@@ -1098,6 +1098,35 @@ in Rubi's 1.1.3.4 come out shorter as well, and those that took two seconds take
 | `"1/(x^8*(a + b*x^3)*(c + d*x^3))".ToEntity().Integrate("x")` | `integral(...)` | 1,217 characters |
 | `"1/(x^6*(a + b*x^4)*(c + d*x^4))".ToEntity().Integrate("x")` | `integral(...)` | 795 characters |
 
+### A polynomial beside a logarithm of a power of a quotient of linears, and a logarithm over a power of a linear, are integrated shorter
+
+**Answers where there were none, shorter and sooner than on the unreleased master.** `(a g + b g x)^4 (A + B ln(e ((a + b x)/(c + d x))^n))`
+was declined, and so were the other three below, from Rubi's 3.2.1 and 3.2.2, a polynomial beside the same logarithm.
+By parts, `integral P F` is `S F - integral S F'` with `S = integral P`, and `F'` is now read with the power of the
+quotient written apart, `B n (b/(a + b x) - d/(c + d x))`, which is exact since `(Q^n)'/Q^n = n Q'/Q`. Taken whole, the
+derivative was two terms over `(c + d x)^2 (a + b x)`, and the unreleased master divided each remainder by that cubic
+with its coefficients simplified: 4,063 characters in seventeen seconds for the first, where it is 1,560 in two
+([#233](https://github.com/asc-community/AngouriMath/issues/233)).
+
+Over a power of a linear, `integral F/(f + g x)^k` by parts leaves partial fractions over `f + g x`, and the one at
+the pole the antiderivative was matched to is a zero over a constant, which the inner simplification writes
+`0 provided c != 0`. Written in `u = f + g x`, that condition stood at the top of the question, the substitution
+search spent seconds declining it, and the fractions were then integrated one by one in x. The question in u is now
+asked without it, the generic case: `(A + B ln(e (a + b x)/(c + d x)))/(f + g x)^5`, declined by 2.5.0, is 10,605
+characters in under a second, where the unreleased master wrote 11,215 in eight. The same holds over powers of a
+linear in Rubi's 3.1.4 and 3.3, which come out shorter too.
+
+| Input | Was (2.5.0) | Now |
+|---|---|---|
+| `"(a*g+b*g*x)^4*(A+B*ln(k*((a+b*x)/(c+d*x))^n))".ToEntity().Integrate("x")` | `integral(...)` | 1,560 characters |
+| `"(f+g*x)^3*(A+B*ln(k*((a+b*x)/(c+d*x))^n))".ToEntity().Integrate("x")` | `integral(...)` | 1,766 characters |
+| `"(a*g+b*g*x)*(A+B*ln(k*((a+b*x)/(c+d*x))^n))".ToEntity().Integrate("x")` | `integral(...)` | 465 characters |
+| `"(a*g+b*g*x)^3*(c*j+d*j*x)*(A+B*ln(k*((a+b*x)/(c+d*x))^n))".ToEntity().Integrate("x")` | `integral(...)` | 2,292 characters |
+| `"(A+B*ln(k*(a+b*x)/(c+d*x)))/(f+g*x)^5".ToEntity().Integrate("x")` | `integral(...)` | 10,605 characters |
+| `"(A+B*ln(k*(a+b*x)/(c+d*x)))/(f+g*x)^4".ToEntity().Integrate("x")` | `integral(...)` | 6,284 characters |
+| `"(a+b*ln(c*(d+h*x)^n))/(f+g*x)^4".ToEntity().Integrate("x")` | `integral(...)` | 565 characters |
+| `"(a+b*ln(c*x^n))/(d+h*x)^4".ToEntity().Integrate("x")` | `integral(...)` | 266 characters |
+
 ### A secant or cosecant power of a logarithm beside the power two below it is integrated as the derivative of a product
 
 **Answers where there were none.** `-(1 + b^2 n^2) sec(a + b ln(c x^n)) + 2 b^2 n^2 sec(a + b ln(c x^n))^3` was
 
@@ -16148,12 +16148,40 @@ node is Powf(var @base, var power) && @base.ContainsNode(u)
             if (inU.ContainsNode(x))
                 return null;
             // dx = du/d.
-            if (Integration.ComputeAsAQuestionOfItsOwn((inU / slope).InnerSimplified, u, integrateByParts) is not { } answer)
+            var question = (inU / slope).InnerSimplified;
+            // A zero over a constant among partial fractions over the linear -- what a pole whose
+            // residue vanishes leaves -- is written `0 provided c != 0` by the inner simplification,
+            // and the condition rises to the top of the question in u, where only the substitution
+            // search reads a question: it spent seven seconds declining the remainder by parts of
+            // Rubi's `(A + B ln(e (a + b x)/(c + d x)))/(f + g x)^5` for it, and the sum was then
+            // integrated term by term in x, in a longer answer. The condition says only that a
+            // constant is not zero, which the generic case takes, so the question is asked without
+            // it. Not beside a polynomial term, which in u integrates to a multiple of the linear
+            // where in x it is one of x, the longer spelling.
+            if (question is Providedf(var unconditioned, var condition) && IsANonzeroCondition(condition, u)
+                && expr is Sumf or Minusf && Sumf.LinearChildren(expr).Any(IsAZeroOverAConstant)
+                && Sumf.LinearChildren(expr).All(term => IsAZeroOverAConstant(term) || term.ContainsNode(x) && !TreeAnalyzer.TryGetPolynomial(term, x, out _)))
+                question = unconditioned;
+            if (Integration.ComputeAsAQuestionOfItsOwn(question, u, integrateByParts) is not { } answer)
                 return null;
             var back = answer.Substitute(u, linear);
             return back.Nodes.Any(node => node == MathS.NaN) ? null : back;
+
+            bool IsAZeroOverAConstant(Entity term) => term is Divf(var zero, var constant) && zero == Number.Integer.Zero && !constant.ContainsNode(x);
         }
 
+        /// <summary>
+        /// Whether <paramref name="condition"/> says only that constants are not zero:
+        /// <c>not c = 0</c> with <c>c</c> free of <paramref name="u"/>, or a conjunction of such.
+        /// </summary>
+        private static bool IsANonzeroCondition(Entity condition, Entity.Variable u) => condition switch
+        {
+            Andf(var left, var right) => IsANonzeroCondition(left, u) && IsANonzeroCondition(right, u),
+            Notf(Equalsf(var left, var right)) => !left.ContainsNode(u) && !right.ContainsNode(u)
+                && (right.Evaled is Number.Complex { IsZero: true } || left.Evaled is Number.Complex { IsZero: true }),
+            _ => false,
+        };
+
         /// <summary>
         /// A polynomial times powers of error functions of one shifted linear, written in
         /// <c>u = a + b x</c>: <c>x erf(a + b x)^2</c> is <c>(u - a) erf(u)^2/b^2</c>, which by parts
@@ -28508,7 +28536,25 @@ private static Entity WithLogarithmArgumentsOverOneBar(Entity expr, Entity.Varia
         {
             if (!Integration.AnsweringTheQuestionAskedOrOneBelow)
                 return null;
-            expr = WithNegativePowersOfProductsApart(expr);
+            // The reciprocal of a product read as the quotient it is, where written apart it hides
+            // a linear. The constant-over-a-product branch of SolveAsPolynomialTerm hands
+            // `1/((a/b + x)^3 (A + B ln(...)))` on as its power -1, and that power written apart
+            // over one bar is `((a + b x)^3)^(-1) b^3`, a power of a power, from which no linear is
+            // read: declined, the substitution search spent five to forty seconds on it and
+            // declined it too, and the quotient one level up was then answered here at once. Read
+            // as that quotient it is answered as that quotient is, in the same words. A reciprocal
+            // that written apart is read, `((a + b x)(c + d x) L^2)^(-1)`, is read so, as before.
+            var readFromTheReciprocal = false;
+            var apart = WithNegativePowersOfProductsApart(expr);
+            if (expr is Powf(Mulf reciprocal, Number.Integer { EInteger: var minusOne }) && minusOne.Equals(EInteger.FromInt32(-1))
+                && FactorsOfTheIntegrand(apart).Any(pair => pair.Factor is Powf(Powf(var nested, _), _) && nested.ContainsNode(x)
+                    && !nested.Nodes.Any(node => node is Logf)))
+            {
+                expr = Number.Integer.One / reciprocal;
+                readFromTheReciprocal = true;
+                apart = WithNegativePowersOfProductsApart(expr);
+            }
+            expr = apart;
             // The logarithm's argument: a product of constants and powers of two linears with
             // opposite exponents.
             Entity? logarithm = null;
@@ -28622,6 +28668,14 @@ private static Entity WithLogarithmArgumentsOverOneBar(Entity expr, Entity.Varia
             }
             if (logarithmsFactor is null || aPolynomialBesideTheLogarithm)
                 return null;
+            // Read from the reciprocal, a power of t beside the logarithm's alone is left where it
+            // went before: the substitution search after this rule answers it through the
+            // logarithm, writing `e^((A + B ln(k t))/B)/t` as the `k e^(A/B)` it is -- Rubi's
+            // `1/((a g + b g x)^2 (A + B ln(e (a + b x)/(c + d x))))` in 129 characters, where
+            // this writes 231.
+            if (readFromTheReciprocal && powerOfDenominator.Evaled is Number.Complex { IsZero: true }
+                && powerOfT.Evaled is not Number.Complex { IsZero: true })
+                return null;
             Entity above = constantInFront * logarithmsFactor, below = Number.Integer.One;
             foreach (var (@base, power) in new[] { (t, Functions.PartialFractions.Bare(powerOfT.Simplify())), (denominatorInT, Functions.PartialFractions.Bare(powerOfDenominator.Simplify())) })
             {
@@ -28761,11 +28815,14 @@ static bool AreEqualAsPolynomials(Entity left, Entity right)
             Entity? differentiated = null;
             Entity writtenPower = Number.Integer.One;
             Entity rational = Number.Integer.One;
+            var aPolynomialBeside = true;
             foreach (var (factor, underneath) in FactorsOfTheIntegrand(expr))
             {
                 if (!factor.ContainsNode(x) || IsARationalFunction(factor, x))
                 {
                     rational = underneath ? rational / factor : rational * factor;
+                    if (factor.ContainsNode(x) && (underneath || factor is Powf(_, var exponentOfFactor) && exponentOfFactor.Evaled is not Number.Integer { EInteger.Sign: >= 0 }))
+                        aPolynomialBeside = false;
                     continue;
                 }
                 if (differentiated is not null)
@@ -28793,8 +28850,16 @@ static bool AreEqualAsPolynomials(Entity left, Entity right)
             // And term by term, each term of the sum differentiated on its own: simplified
             // whole, `b/(a + b x) - d/(c + d x)` is brought over one bar, and the pieces below
             // then hold a quadratic with symbols in it.
+            // And beside a polynomial, a power of a quotient with x on both sides written apart as
+            // well: `ln(e ((a + b x)/(c + d x))^n)` as written differentiates to two terms each
+            // over `(c + d x)^2 (a + b x)`, and the long division of every remainder by that
+            // cubic, its symbolic coefficients simplified, took Rubi's
+            // `(a g + b g x)^4 (A + B ln(e ((a + b x)/(c + d x))^n))` seventeen seconds and an
+            // answer of 4,063 characters, where the spelling `e (a + b x)^n/(c + d x)^n` takes a
+            // third of a second. Beside a polynomial only: over `(f + g x)^5` the remainders
+            // written so took one second to six.
             var derivativeTerms = new List<Entity>();
-            foreach (var term in TermsDistributed(WithLogarithmsOfProductsApart(differentiated, x)))
+            foreach (var term in TermsDistributed(WithLogarithmsOfProductsApart(differentiated, x, powersOfQuotientsApart: aPolynomialBeside)))
             {
                 var termDerivative = Functions.PartialFractions.Bare(term.Differentiate(x).InnerSimplified);
                 if (termDerivative == Number.Integer.Zero || termDerivative.Evaled is Number.Complex { IsZero: true })
@@ -29067,22 +29132,38 @@ private static List<Entity> TermsDistributed(Entity expr)
         /// as the sum of the logarithms of the factors holding <paramref name="x"/>, each
         /// times its power, and the constant factors dropped. Equal to the original up to a
         /// constant on each interval where both are defined, which is all a derivative sees.
+        /// With <paramref name="powersOfQuotientsApart"/>, a power of a quotient of two factors
+        /// holding <paramref name="x"/> is written apart too, each side's logarithm times the
+        /// power: <c>ln(e ((a + b x)/(c + d x))^n)</c> is <c>n ln(a + b x) - n ln(c + d x)</c>,
+        /// whose derivative is the same, since <c>(Q^n)'/Q^n = n Q'/Q</c>.
         /// </summary>
-        private static Entity WithLogarithmsOfProductsApart(Entity expr, Entity.Variable x)
+        private static Entity WithLogarithmsOfProductsApart(Entity expr, Entity.Variable x, bool powersOfQuotientsApart)
             => expr.Replace(node =>
             {
                 if (node is not Logf(var @base, var argument) || @base != MathS.e || !argument.ContainsNode(x) || argument is not (Mulf or Divf or Powf))
                     return node;
                 Entity sum = Number.Integer.Zero;
                 foreach (var (factor, underneath) in FactorsOfTheIntegrand(argument))
+                    Add(factor, underneath, Number.Integer.One);
+                return sum;
+
+                void Add(Entity factor, bool underneath, Entity outer)
                 {
                     if (!factor.ContainsNode(x))
-                        continue;
+                        return;
                     var (inner, power) = factor is Powf(var b, var p) && !p.ContainsNode(x) ? (b, p) : (factor, (Entity)Number.Integer.One);
+                    if (outer != Number.Integer.One)
+                        power = power == Number.Integer.One ? outer : outer * power;
+                    if (powersOfQuotientsApart && power != Number.Integer.One
+                        && inner is Divf(var numerator, var denominator) && numerator.ContainsNode(x) && denominator.ContainsNode(x))
+                    {
+                        foreach (var (innerFactor, innerUnderneath) in FactorsOfTheIntegrand(inner))
+                            Add(innerFactor, underneath != innerUnderneath, power);
+                        return;
+                    }
                     var term = power == Number.Integer.One ? MathS.Ln(inner) : power * MathS.Ln(inner);
                     sum = underneath ? sum - term : sum + term;
                 }
-                return sum;
             });
 
         /// <summary>
 
@@ -0,0 +1,71 @@
+//
+// 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>
+    /// Powers of linears beside a power of <c>A + B ln(k ((a + b x)/(c + d x))^n)</c>, Rubi's 3.2.1,
+    /// on the three readings that sent them past the corpus's budget: the reciprocal of a product
+    /// handed on as its power -1, which written apart hid its linear under a power of a power; the
+    /// logarithm of a power of the quotient, whose derivative was taken whole and brought every
+    /// remainder over a cubic; and a remainder over a power of a third linear, whose zero term put
+    /// a condition on the constants at the top of the question in that linear. Answered and
+    /// differentiated back.
+    /// <a href="https://github.com/asc-community/AngouriMath/issues/233">#233</a>
+    /// </summary>
+    [Trait("Area", "Calculus")]
+    public sealed class PowersOfLinearsBesideALogarithmOfTheirQuotientIntegralTest
+    {
+        [Theory]
+        [InlineData("1/((a*g + b*g*x)^3*(A + B*ln(k*(a + b*x)/(c + d*x))))")]
+        [InlineData("1/((a*g + b*g*x)^3*(A + B*ln(k*((a + b*x)/(c + d*x))^n))^2)")]
+        [InlineData("1/((c*g + d*g*x)^2*(A + B*ln(k*((a + b*x)/(c + d*x))^n))^2)")]
+        [InlineData("1/((a*g + b*g*x)^2*(A + B*ln(k*(c + d*x)/(a + b*x)))^2)")]
+        [InlineData("1/((a*g + b*g*x)^3*(A + B*ln(k*(c + d*x)^2/(a + b*x)^2))^2)")]
+        public void TheReciprocalReadAsTheQuotient(string integrand) => AnsweredAndDifferentiatedBack(integrand);
+
+        [Theory]
+        [InlineData("(a*g + b*g*x)^4*(A + B*ln(k*((a + b*x)/(c + d*x))^n))")]
+        [InlineData("(c*g + d*g*x)^4*(A + B*ln(k*((a + b*x)/(c + d*x))^n))")]
+        [InlineData("(f + g*x)^3*(A + B*ln(k*((a + b*x)/(c + d*x))^n))")]
+        public void TheLogarithmOfAPowerOfTheQuotientDifferentiatedApart(string integrand) => AnsweredAndDifferentiatedBack(integrand);
+
+        [Theory]
+        [InlineData("(A + B*ln(k*(a + b*x)/(c + d*x)))/(f + g*x)^5")]
+        [InlineData("(A + B*ln(k*(a + b*x)^2/(c + d*x)^2))/(f + g*x)^4")]
+        [InlineData("(a + b*ln(c*x^n))/(d + h*x)^4")]
+        public void ARemainderOverAPowerOfALinearAskedWithoutTheConditionOfAZeroTerm(string integrand) => AnsweredAndDifferentiatedBack(integrand);
+
+        private static void AnsweredAndDifferentiatedBack(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)
+                .Substitute("f", 0.9).Substitute("g", 1.1).Substitute("h", 0.5).Substitute("A", 0.6).Substitute("B", 0.8).Substitute("k", 1.7).Substitute("n", 1.4);
+            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.8, 1.3, 1.9, 2.9 })
+            {
+                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}");
+        }
+    }
+}