Split a power of x beside blocks to a power only where its pieces are read (#2000)

SolveAsPolynomialTerm writes 1/P as P^(-1) and asks it a level down, and
deeper still SolveByLinearRadicalSubstitution reached
IntegrateOverBlocksInAPowerOfX with besideAPowerOfX at descent 3. The pieces
over a block to a power are read only by IntegrateOverAPowerOfXBesideABlock,
which runs at the question asked or one below, so at descent 3 every piece
went round the whole search, about sixteen levels deep, before it was
declined, and the 1/P spelling one level up then answered in 80 ms. The
split now declines there, where a block is to a power past the first; with
every block to the first power the pieces are read at any depth, and stay.

Twelve of Rubi's 1.1.2.4 rows that took 5-16 s (542-544, 550-552, 562-564,
570-572) allocate 3-14 times less, 542 from 11.9 GB to 0.97, with the same
answers, character for character; 303 solved rows of 1.1.2.x and 1.1.3.x
answer as before, none allocating more.

Part of #233.


Claude-Session: https://claude.ai/code/session_012sonx8iAspMiwRwokT1Ura

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

Author: Rafael-SOWNet

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

@@ -2882,6 +2882,17 @@ private static Entity WithTheDenominatorInPowersOf(Entity value, IReadOnlyList<E
                 return null;
             if (besideAPowerOfX && (powerOfX == 0 || blocks.Count < 2 || powerOfX > MaximumPowerOfXOverABlock))
                 return null;
+            // Beside a power of x with a block to a power, only where the pieces over that power
+            // are read: each is a power of x over one block, asked at this level, and
+            // IntegrateOverAPowerOfXBesideABlock, which reads a block to a power, answers the
+            // question asked or one below it. Deeper, the pieces went round the whole search to be
+            // declined: `1/(x^(3/2) (a + b x^2) (c + d x^2)^2)` reaches this split twice, at the
+            // level where it is answered and a level further down, through the reciprocal
+            // SolveAsPolynomialTerm writes, where it spent six of its seven seconds. Blocks to the
+            // first power are read at any depth, and `1/(x^(5/2) (a + b x^2)(c + d x^2))` is
+            // answered through the deeper split with a thirtieth of the allocation it takes without it.
+            if (besideAPowerOfX && !Integration.AnsweringTheQuestionAskedOrOneBelow && blocks.Any(block => block.Power > 1))
+                return null;
             // n, the greatest common divisor of every power the blocks hold.
             var n = EInteger.Zero;
             foreach (var (polynomial, _) in blocks)

Sources/Tests/UnitTests/Calculus/APowerOfXBesideBlocksIsSplitWhereThePiecesAreReadIntegralTest.cs

@@ -0,0 +1,59 @@
+//
+// 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>
+    /// A half-odd power of x below two blocks in <c>x^2</c>, one of them to a power, as Rubi's 1.1.2.4
+    /// writes it. Under <c>t = sqrt(x)</c> it is a power of t beside two blocks in <c>t^4</c>, which the
+    /// split beside a power of x answers where its pieces over the power are read, at the question
+    /// asked or one below it. It was answered there, after a second pass through the same split a
+    /// level further down, where those pieces are not read and each went round the whole search to be
+    /// declined: seven seconds of <c>1/(x^(3/2) (a + b x^2) (c + d x^2)^2)</c> were six of that. With
+    /// both blocks to the first power the deeper split is read and still taken.
+    /// <a href="https://github.com/asc-community/AngouriMath/issues/233">#233</a>
+    /// </summary>
+    [Trait("Area", "Calculus")]
+    public sealed class APowerOfXBesideBlocksIsSplitWhereThePiecesAreReadIntegralTest
+    {
+        [Theory]
+        [InlineData("1/(x^(3/2)*(a + b*x^2)*(c + d*x^2)^2)")]
+        [InlineData("1/(x^(5/2)*(a + b*x^2)*(c + d*x^2)^2)")]
+        [InlineData("1/(x^(7/2)*(a + b*x^2)*(c + d*x^2)^2)")]
+        [InlineData("1/(x^(3/2)*(a + b*x^2)*(c + d*x^2)^3)")]
+        [InlineData("1/(x^(5/2)*(a + b*x^2)*(c + d*x^2)^3)")]
+        [InlineData("1/(x^(7/2)*(a + b*x^2)*(c + d*x^2)^3)")]
+        [InlineData("1/(x^(3/2)*(a + b*x^2)^2*(c + d*x^2)^2)")]
+        [InlineData("1/(x^(5/2)*(a + b*x^2)*(c + d*x^2))")]
+        public void DifferentiatesBack(string integrand)
+        {
+            var integral = integrand.ToEntity().Integrate("x");
+            var text = integral.Stringize();
+            Assert.DoesNotContain("integral(", text);
+            Entity Pinned(Entity e) => e.Substitute("a", 1.3).Substitute("b", 0.7).Substitute("c", 0.4).Substitute("d", 0.3);
+            var derivative = Pinned(integral.Substitute("C", 0)).Differentiate("x");
+            var original = Pinned(integrand.ToEntity());
+            var compared = 0;
+            foreach (var at in new[] { 0.3, 0.6, 0.9, 1.3, 1.8, 2.4 })
+            {
+                var want = original.Substitute("x", at).EvalNumerical();
+                var got = derivative.Substitute("x", at).EvalNumerical();
+                if (want.IsNaN)
+                    continue;
+                compared++;
+                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}");
+            }
+            Assert.True(compared >= 5, $"only {compared} points could be compared for {integrand}");
+        }
+    }
+}