Keep a sum of piecewise answers a sum where their cases do not line up (#1882)

* Keep a sum of piecewises a sum where their cases do not line up

An answer's sum of two piecewises was combined case by case into one
piecewise with every case of one against every case of the other. It
stays a sum where that combination has more cases than the two together,
counted after the unreachable ones are gone; and a sum holding a
piecewise is not copied into another's cases. Integrands are normalised
with the old combination, so the search sees what it saw before.

Fixes #1874

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012sonx8iAspMiwRwokT1Ura

* Record the answers a sum of piecewises shortens

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012sonx8iAspMiwRwokT1Ura

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: Rafael-SOWNet

BREAKING-CHANGES.md

@@ -560,24 +560,38 @@ same answer as on the unreleased master, in 1.4 seconds rather than 30
 **Answers where there were none.** `sqrt(a + b x + c x^2)/((d + k x)(f + g x)^2)` was declined: with no quadratic
 below the bar, powers of linears were left to Euler's substitution, which writes the root of a symbolic leading
 coefficient into every coefficient and does not finish. They are taken apart over the linears now where the
-integrand has a symbol in it, each piece closed beside the root. The answers are large because each piece's cases,
-by the sign of the radicand at its pole and of `c`, multiply in the sum
-([#1874](https://github.com/asc-community/AngouriMath/issues/1874)): the fourth row is 27 cases of about 3,000
-characters each ([#718](https://github.com/asc-community/AngouriMath/issues/718)).
-
-| Input | Was (2.5.0) | Now |
-|---|---|---|
-| `"sqrt(a + b*x + c*x^2)/((d + k*x)*(f + g*x)^2)".ToEntity().Integrate("x")` | `integral(...)` | 12,694 characters |
-| `"sqrt(a + b*x + c*x^2)/((d + k*x)*(f + g*x)^3)".ToEntity().Integrate("x")` | `integral(...)` | 20,029 characters |
-| `"sqrt(a + b*x + c*x^2)/((d + k*x)*(f + g*x)^4)".ToEntity().Integrate("x")` | `integral(...)` | 29,203 characters |
-| `"(a + b*x + c*x^2)^(3/2)/((d + k*x)*(f + g*x)^3)".ToEntity().Integrate("x")` | `integral(...)` | 79,744 characters |
-| `"1/((d + k*x)*(f + g*x)^2*sqrt(a + b*x + c*x^2))".ToEntity().Integrate("x")` | `integral(...)` | 11,335 characters |
-| `"1/((d + k*x)*(f + g*x)^3*sqrt(a + b*x + c*x^2))".ToEntity().Integrate("x")` | `integral(...)` | 18,103 characters |
-| `"sqrt(a + b*x^2 + c*x^4)/(x^3*(d + k*x^2))".ToEntity().Integrate("x")` | `integral(...)` | 5,902 characters |
-| `"(a + b*x^2 + c*x^4)^(3/2)/(x^3*(d + k*x^2))".ToEntity().Integrate("x")` | `integral(...)` | 27,184 characters |
-| `"1/(x^3*(d + k*x^2)*sqrt(a + b*x^2 + c*x^4))".ToEntity().Integrate("x")` | `integral(...)` | 5,515 characters |
-| `"asec(a + b*x)/x^4".ToEntity().Integrate("x")` | `integral(...)` | 11,873 characters |
-| `"acsc(a + b*x)/x^4".ToEntity().Integrate("x")` | `integral(...)` | 11,864 characters |
+integrand has a symbol in it, each piece closed beside the root, and the pieces' answers are a sum of their piecewises
+([#718](https://github.com/asc-community/AngouriMath/issues/718)).
+
+| Input | Was (2.5.0) | Now |
+|---|---|---|
+| `"sqrt(a + b*x + c*x^2)/((d + k*x)*(f + g*x)^2)".ToEntity().Integrate("x")` | `integral(...)` | 4,421 characters |
+| `"sqrt(a + b*x + c*x^2)/((d + k*x)*(f + g*x)^3)".ToEntity().Integrate("x")` | `integral(...)` | 7,052 characters |
+| `"sqrt(a + b*x + c*x^2)/((d + k*x)*(f + g*x)^4)".ToEntity().Integrate("x")` | `integral(...)` | 10,281 characters |
+| `"(a + b*x + c*x^2)^(3/2)/((d + k*x)*(f + g*x)^3)".ToEntity().Integrate("x")` | `integral(...)` | 9,304 characters |
+| `"1/((d + k*x)*(f + g*x)^2*sqrt(a + b*x + c*x^2))".ToEntity().Integrate("x")` | `integral(...)` | 3,989 characters |
+| `"1/((d + k*x)*(f + g*x)^3*sqrt(a + b*x + c*x^2))".ToEntity().Integrate("x")` | `integral(...)` | 6,416 characters |
+| `"sqrt(a + b*x^2 + c*x^4)/(x^3*(d + k*x^2))".ToEntity().Integrate("x")` | `integral(...)` | 2,063 characters |
+| `"(a + b*x^2 + c*x^4)^(3/2)/(x^3*(d + k*x^2))".ToEntity().Integrate("x")` | `integral(...)` | 3,100 characters |
+| `"1/(x^3*(d + k*x^2)*sqrt(a + b*x^2 + c*x^4))".ToEntity().Integrate("x")` | `integral(...)` | 1,933 characters |
+| `"asec(a + b*x)/x^4".ToEntity().Integrate("x")` | `integral(...)` | 4,073 characters |
+| `"acsc(a + b*x)/x^4".ToEntity().Integrate("x")` | `integral(...)` | 4,072 characters |
+
+### A sum of two piecewise answers whose cases do not line up stays a sum
+
+**Shorter answers, and answers where there were none.** An antiderivative made of terms that each split
+on the signs of their constants was combined into one piecewise listing every case of one term against
+every case of the other. It stays a sum of the terms' piecewises now wherever combining them would
+give more cases than they have between them. `1/(b x^2 + m) - 1/(sqrt(a + b x^2) (b x^2 + m))` was nine
+cases; `(A + B x)(d + k x)^(7/2)/(b x + c x^2)^3` came to seven million characters on the unreleased
+master and is answered in two seconds now
+([#1874](https://github.com/asc-community/AngouriMath/issues/1874)).
+
+| Input | Was (2.5.0) | Now |
+|---|---|---|
+| `"1/(b*x^2 + m) - 1/(sqrt(a + b*x^2)*(b*x^2 + m))".ToEntity().Integrate("x")` | `integral(...)` | 975 characters |
+| `"(A + B*x)*(d + k*x)^(7/2)/(b*x + c*x^2)^3".ToEntity().Integrate("x")` | `integral(...)` | 15,079 characters |
+| `"(A + B*x)/((d + k*x)^(5/2)*(b*x + c*x^2)^3)".ToEntity().Integrate("x")` | `integral(...)` | 17,637 characters |
 
 ### A trinomial the numerator holds is divided out of a power of it
 

Sources/AngouriMath/Functions/Continuous/Integration/Integration.Definition.cs

@@ -189,7 +189,7 @@ internal static partial class Integration
         /// </para>
         /// </remarks>
         private static Entity Normalized(Entity expr, Entity.Variable x) =>
-            expr.Replace(Patterns.GatherPowersOfOneBase).Replace(node => IndefiniteIntegralSolver.GatherSignsAndModuli(node, x))
+            WithItsPiecewiseSumsCombined(expr.Replace(Patterns.GatherPowersOfOneBase).Replace(node => IndefiniteIntegralSolver.GatherSignsAndModuli(node, x))
                 // A whole power of a fractional power is the power of the product of the
                 // exponents, exact for every base: `((c^2 x^2 + 1)^(-1/2))^2` is
                 // `(c^2 x^2 + 1)^(-1)`, and left as a square of a root it was handed to Euler's
@@ -209,7 +209,36 @@ private static Entity Normalized(Entity expr, Entity.Variable x) =>
                 // `1/(a + b x^2 + c x^4)` is answered.
                 .Replace(node => node is Entity.Powf(var zeroth, Entity.Number.Integer { IsZero: true }) && zeroth.ContainsNode(x)
                     ? Entity.Number.Integer.One
-                    : node);
+                    : node));
+
+        /// <summary>
+        /// <paramref name="expr"/> with every sum of piecewises in it combined case by case, as
+        /// the evaluator did before an answer's sum of piecewises was left a sum: an integrand
+        /// is searched as the one piecewise, and taken apart term by term it was searched once a
+        /// term. The sums are written anew, so that no simplification of them is remembered from
+        /// outside the scope.
+        /// https://github.com/asc-community/AngouriMath/issues/1874
+        /// </summary>
+        private static Entity WithItsPiecewiseSumsCombined(Entity expr)
+        {
+            if (!expr.Nodes.Any(node => node is Entity.Sumf or Entity.Minusf && node.DirectChildren.Any(child => child is Entity.Piecewise)))
+                return expr;
+            var combining = Entity.CombinesEveryPiecewiseSum;
+            Entity.CombinesEveryPiecewiseSum = true;
+            try
+            {
+                return expr.Replace(node => node switch
+                {
+                    Entity.Sumf(var augend, var addend) => new Entity.Sumf(augend, addend),
+                    Entity.Minusf(var minuend, var subtrahend) => new Entity.Minusf(minuend, subtrahend),
+                    _ => node
+                }).InnerSimplified;
+            }
+            finally
+            {
+                Entity.CombinesEveryPiecewiseSum = combining;
+            }
+        }
 
         /// <summary>
         /// The integrals already answered under the settings in force, so that the same question

Sources/AngouriMath/Functions/Evaluation/Evaluation.Classes.cs

@@ -162,6 +162,10 @@ Entity ops(Entity a, Entity b)
                 (Providedf a, var b) => ExpandOnTwoArguments(a.Expression, b, operation, defaultCtor, isExact).Provided(a.Predicate),
                 (var a, Providedf b) => ExpandOnTwoArguments(a, b.Expression, operation, defaultCtor, isExact).Provided(b.Predicate),
                 (Piecewise a, Piecewise b) => CombinedCaseByCase(a, b, operation, defaultCtor, isExact),
+                // A sum already holding a piecewise is not copied into each case of another: it
+                // stays beside it, as CombinedCaseByCase leaves two piecewises that do not combine.
+                (Piecewise a, var b) when this is Sumf or Minusf && !CombinesEveryPiecewiseSum && b.Nodes.Any(node => node is Piecewise) => defaultCtor(this, left, right),
+                (var a, Piecewise b) when this is Sumf or Minusf && !CombinesEveryPiecewiseSum && a.Nodes.Any(node => node is Piecewise) => defaultCtor(this, left, right),
                 (Piecewise a, var b) => a.ApplyToValues(a => ops(a, b)),
                 (var a, Piecewise b) => b.ApplyToValues(b => ops(a, b)),
                 (Matrix a, Matrix b) => a.InnerMatrix.Shape == b.InnerMatrix.Shape ? a.Elementwise(b, ops) : defaultCtor(this, left, right),
@@ -177,6 +181,17 @@ Entity ops(Entity a, Entity b)
             };
         }
 
+        /// <summary>
+        /// Set while the integrator normalises an integrand: a sum of piecewises in one is combined
+        /// case by case whatever the count, as before
+        /// <a href="https://github.com/asc-community/AngouriMath/issues/1874">#1874</a>. An
+        /// integrand holding the cases of an answer -- what parts leaves, `u' v` with `v` an
+        /// antiderivative -- is searched as one piecewise, where kept a sum it was taken apart
+        /// term by term and every term searched: `(a + b atanh(c x^2))^2/x^5` went from 19
+        /// seconds to 134. Answers stay sums.
+        /// </summary>
+        [ThreadStatic] internal static bool CombinesEveryPiecewiseSum;
+
         /// <summary>
         /// A piecewise combined with a piecewise, case by case: every case of one against every
         /// case of the other, under the conjunction of their predicates.
@@ -227,7 +242,19 @@ private Entity CombinedCaseByCase(Piecewise a, Piecewise b,
             for (var i = 0; i < pairs.Count; i++)
                 if (keep[i])
                     cases.Add((ExpandOnTwoArguments(pairs[i].First.Expression, pairs[i].Second.Expression, operation, defaultCtor, isExact), pairs[i].Predicate).ToProvided());
-            return MathS.Piecewise(cases);
+            var combined = MathS.Piecewise(cases);
+            // A sum or a difference is combined only where the cases line up: where they do not,
+            // every case of one against every case of the other is the product of the two counts,
+            // and the two piecewises as written say the same in the sum of them. Counted once the
+            // cases no value reaches are gone, since a sum over `k < a` for each k is one case per
+            // k after that and the product before it. The antiderivative of
+            // `1/(b x^2 + m) - 1/(sqrt(a + b x^2) (b x^2 + m))` was nine cases in 3,685
+            // characters, where its two terms are 287 and 685.
+            // https://github.com/asc-community/AngouriMath/issues/1874
+            if (this is Sumf or Minusf && !CombinesEveryPiecewiseSum && combined.InnerSimplified(isExact) is var simplified
+                && (simplified is Piecewise piecewise ? piecewise.Cases.Count() : 1) > a.Cases.Count() + b.Cases.Count())
+                return defaultCtor(this, a, b);
+            return combined;
         }
 
         /// <summary>

Sources/Tests/UnitTests/Core/APiecewiseSumStaysASumTest.cs

@@ -0,0 +1,60 @@
+//
+// Copyright (c) 2019-2026 Angouri.
+// AngouriMath is licensed under MIT.
+// Details: https://github.com/asc-community/AngouriMath/blob/master/LICENSE.md.
+// Website: https://am.angouri.org.
+//
+
+using System.Linq;
+using AngouriMath.Extensions;
+using Xunit;
+using static AngouriMath.Entity;
+
+namespace AngouriMath.Tests.Core
+{
+    /// <summary>
+    /// A sum of two piecewises whose cases do not line up stays a sum of the two: combined case
+    /// by case it lists every case of one against every case of the other.
+    /// <a href="https://github.com/asc-community/AngouriMath/issues/1874">#1874</a>
+    /// </summary>
+    [Trait("Area", "Core")]
+    public sealed class APiecewiseSumStaysASumTest
+    {
+        private static Entity ThreeSigns(string of, string positive, string zero, string negative)
+            => $"piecewise({positive} provided {of} > 0, {zero} provided {of} = 0, {negative} provided {of} < 0)".ToEntity();
+
+        [Fact]
+        public void CasesOnDifferentQuantitiesStayASum()
+        {
+            var sum = (ThreeSigns("a", "1", "2", "3") + ThreeSigns("b", "x", "y", "z")).InnerSimplified;
+            var asASum = Assert.IsType<Sumf>(sum);
+            Assert.IsType<Piecewise>(asASum.Augend);
+            Assert.IsType<Piecewise>(asASum.Addend);
+        }
+
+        [Fact]
+        public void CasesOnOneQuantityStillCombine()
+        {
+            // The three that agree and the two opposite strict signs: five, not nine.
+            var sum = (ThreeSigns("a", "1", "2", "3") + ThreeSigns("a", "x", "y", "z")).InnerSimplified;
+            Assert.IsType<Piecewise>(sum);
+        }
+
+        [Fact]
+        public void ASumHoldingAPiecewiseIsNotCopiedIntoTheCasesOfAnother()
+        {
+            var sum = (ThreeSigns("a", "1", "2", "3") + ThreeSigns("b", "x", "y", "z") + ThreeSigns("c", "u", "v", "w")).InnerSimplified;
+            Assert.Equal(3, sum.Nodes.Count(node => node is Piecewise));
+        }
+
+        [Fact]
+        public void TheIssuesIntegralIsTheSumOfItsTerms()
+        {
+            Entity one = "1/(b*x^2 + m)";
+            Entity two = "1/(sqrt(a + b*x^2)*(b*x^2 + m))";
+            var whole = (one - two).Integrate("x").Stringize().Length;
+            var apart = one.Integrate("x").Stringize().Length + two.Integrate("x").Stringize().Length;
+            Assert.True(whole <= apart + 16, $"{whole} characters for the difference, {apart} for its terms");
+        }
+    }
+}

Sources/Tests/UnitTests/Core/ContradictoryConjunctionTest.cs

@@ -148,7 +148,8 @@ public void AConstantFactorIsTheSameQuantity()
         [Fact]
         public void OppositeSignsStayWhereALaterCaseDoesNotTestTheQuantity()
         {
-            var sum = "piecewise(1 provided q > 0, 2 provided q < 0, 3 provided p > 0) + piecewise(10 provided q < 0, 20 provided q > 0, 30 provided p > 0)".ToEntity().InnerSimplified;
+            // A product: a sum whose cases do not line up stays a sum of its two piecewises (#1874).
+            var sum = "piecewise(1 provided q > 0, 2 provided q < 0, 3 provided p > 0) * piecewise(10 provided q < 0, 20 provided q > 0, 30 provided p > 0)".ToEntity().InnerSimplified;
             Assert.Contains(Assert.IsType<Piecewise>(sum).Cases, @case => @case.Predicate.ToString().Contains("q > 0") && @case.Predicate.ToString().Contains("q < 0"));
         }