@@ -493,6 +493,20 @@ It is written out again in the precision asked for now
 | `Rational.Create(128, 12167)`'s `EDecimal`, read at the default precision and then under 300 digits | 100 digits | 300 digits |
 | `sqrt(46) * 128/12167` evaluated under 300 digits, with that rational | relative error `4.7e-101` | correct to 300 digits |
 
+### An antiderivative is not inner-simplified where that would multiply it
+
+**Shorter answers, where 2.5.0 gave none.** `Integrate` inner-simplifies the antiderivative before returning it, which drops a branch whose
+guard is decidably false. A sum of piecewises whose conditions differ as written is combined case by case there. Rubi's
+1.1.2.2 `x^19/(a + b x^2)^10` was answered in 11,811 characters, and the combination came to 5,051,391: ten piecewises of
+four arms each. The corpus spent seventeen seconds differentiating that back. Where the simplification makes an answer
+more than four times larger, the answer is returned as it was found
+([#718](https://github.com/asc-community/AngouriMath/issues/718)).
+
+| Input | Was (2.5.0) | Now |
+|---|---|---|
+| `"x^19/(a+b*x^2)^10".ToEntity().Integrate("x")` | `integral(...)` | 11,815 characters, where before this change master gave 5,051,391 |
+| `"x^7/(a+b*x^2)^4".ToEntity().Integrate("x")` | `integral(...)` | 3,269 characters, where before this change master gave 20,387 |
+
 ### A polynomial over a power of a linear beside `a + b ln(c x^n)` is integrated by parts against its antiderivative vanishing at zero
 
 **Answers where there were none.** Rubi's 3.1.4 `x^5 (a + b ln(c x^n))/(d + e x)^7` was declined, and on unreleased
 
@@ -1053,8 +1053,20 @@ private sealed class IntegrationTransformation : Transformation
             protected override Entity? ApplyCore(Entity input)
                 => MathS.Settings.DowncastingEnabled.Value ? Integrate(input) : IntegrateExactly(input);
 
+            /// <remarks>
+            /// Inner-simplified, which drops a branch whose guard is decidably false; but not where that
+            /// multiplies the answer: a sum of piecewises whose conditions differ as written is combined case
+            /// by case, and the 11,811 characters `x^19/(a + b x^2)^10` is answered in came to 5,051,391,
+            /// ten piecewises of four arms each, which the corpus spent seventeen seconds differentiating back.
+            /// </remarks>
             private Entity? Integrate(Entity input)
-                => Functions.Algebra.Integration.ComputeIndefiniteIntegral(input.InnerSimplified, variable)?.InnerSimplified;
+                => Functions.Algebra.Integration.ComputeIndefiniteIntegral(input.InnerSimplified, variable) is { } antiderivative
+                   && antiderivative.InnerSimplified is var simplified
+                    ? simplified.Complexity > LargestGrowthBySimplifying * antiderivative.Complexity ? antiderivative : simplified
+                    : null;
+
+            /// <summary>How many times larger the inner simplification of an answer may make it.</summary>
+            private const int LargestGrowthBySimplifying = 4;
 
             /// <summary>See <see cref="ReadExactly"/>.</summary>
             private Entity? IntegrateExactly(Entity input)
 
@@ -0,0 +1,48 @@
+//
+// 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;
+using AngouriMath.Extensions;
+using Xunit;
+
+namespace AngouriMath.Tests.Calculus
+{
+    /// <summary>
+    /// An antiderivative is inner-simplified before it is returned, but not where that multiplies it:
+    /// Rubi's 1.1.2.2 <c>x^19/(a + b x^2)^10</c> was answered in 11,811 characters, a sum of ten piecewises
+    /// of four arms each whose conditions differ as written, and combined case by case it came to
+    /// 5,051,391, which the corpus spent seventeen seconds differentiating back.
+    /// <a href="https://github.com/asc-community/AngouriMath/issues/718">#718</a>
+    /// </summary>
+    [Trait("Area", "Calculus")]
+    public sealed class AnAntiderivativeItsSimplificationWouldMultiplyIntegralTest
+    {
+        [Theory]
+        // Rubi 1.1.2.2:208.
+        [InlineData("x^19/(a + b*x^2)^10", 50_000)]
+        [InlineData("x^7/(a + b*x^2)^4", 10_000)]
+        public void IsReturnedAtTheSizeItWasFound(string integrand, int mostCharacters)
+        {
+            var integral = integrand.ToEntity().Integrate("x");
+            var text = integral.Stringize();
+            Assert.DoesNotContain("integral(", text);
+            Assert.True(text.Length < mostCharacters, $"{integrand} came back in {text.Length} characters");
+            Entity Pinned(Entity e) => e.Substitute("a", 1.3).Substitute("b", 0.7);
+            var derivative = Pinned(integral.Substitute("C", 0)).Differentiate("x");
+            var original = Pinned(integrand.ToEntity());
+            foreach (var at in new[] { -2.2, -0.9, 0.3, 1.4, 2.1 })
+            {
+                var want = original.Substitute("x", at).EvalNumerical();
+                var got = derivative.Substitute("x", at).EvalNumerical();
+                Assert.False(got.IsNaN, $"d/dx of the antiderivative of {integrand} has no value at x = {at}, where the integrand is {want}");
+                Assert.True(Math.Abs((double)(got - want).RealPart) + Math.Abs((double)(got - want).ImaginaryPart)
+                            < 1e-9 * Math.Max(1, Math.Abs((double)want.RealPart) + Math.Abs((double)want.ImaginaryPart)),
+                    $"d/dx of the antiderivative of {integrand} is {got} at x = {at}, where the integrand is {want}");
+            }
+        }
+    }
+}