@@ -376,6 +376,24 @@ improper fraction is declined before the first division rather than after the la
 | `"(1 - b*x^2)^3/(c*(1 - b*x^2) + a*d*x^2)^3".ToEntity().Integrate("x")` | no answer within a minute | the antiderivative |
 | `"(a + b*x)^(5/2)/(c + d*x)^4".ToEntity().Integrate("x")` | `integral(...)` | the antiderivative |
 
+### A decline is held at the depth it was made at
+
+**Answers where there were none.** The integrator remembers what it has worked out, declines
+included, and a rule may answer the question asked and the level or two below it and decline the
+same integrand deeper. A decline made at depth three was held under a key that told the question
+asked from the rest and nothing more, and was served at depth two: the search for
+`1/(x^(3/2) (a + c x^4))` declines the root's substitution `2/(w^2 (a + c w^8))` at depth three and
+asks it again at depth two, and the integral was declined. The memo is kept per thread, so a decline
+made deeper in one integral was served the same way to the next. A decline is held at the depth it
+was made at now, and an answer at every depth
+([#718](https://github.com/asc-community/AngouriMath/issues/718)).
+
+| Input | Was (2.5.0) | Now |
+|---|---|---|
+| `"1/(x^(3/2)*(a + c*x^4))".ToEntity().Integrate("x")` | `integral(...)` | the antiderivative |
+| `"1/((a + b/x^3)*x^5)".ToEntity().Integrate("x")` | `integral(...)` | the antiderivative |
+| `"1/(x^(7/2)*(a + b*x^2 + c*x^4))".ToEntity().Integrate("x")` | `integral(...)` | the antiderivative |
+
 ### The Hermite reduction's system is solved in one order whatever the spelling
 
 **Faster, and not a different value.** The reduction of a rational integrand with a repeated factor
 
@@ -237,17 +237,23 @@ private static Entity Normalized(Entity expr, Entity.Variable x) =>
         /// simplifying and a change count is therefore never still.
         /// </para>
         /// <para>
-        /// <b>A decline is held with the scope it was made in.</b> Five rules answer only the
-        /// question asked (<see cref="AnsweringTheQuestionAsked"/>) and decline the same
-        /// integrand one level down, so a <see langword="null"/> computed at depth two says
-        /// nothing about depth one — and once held without the scope it was served to the
-        /// top-level ask: <c>sec(x)^3</c>, tried and declined inside another rule's search, then
-        /// asked for directly and declined from the cache in two milliseconds. The key carries
-        /// the scope, and a lookup takes a decline only from its own scope and an answer from
-        /// either, since an antiderivative that was found is right wherever it is asked for.
+        /// <b>A decline is held with the scope it was made in.</b> Rules answer only the question
+        /// asked (<see cref="AnsweringTheQuestionAsked"/>), or it and one or two levels below it
+        /// (<see cref="AnsweringTheQuestionAskedOrOneBelow"/>,
+        /// <see cref="AnsweringTheQuestionAskedOrTwoBelow"/>), and decline the same integrand
+        /// deeper, so a <see langword="null"/> computed at one depth says nothing about a
+        /// shallower one. Held without the scope it was served there: <c>sec(x)^3</c>, tried and
+        /// declined inside another rule's search, then asked for directly and declined from the
+        /// cache in two milliseconds. And held with the top told only from the rest, a decline at
+        /// depth three was served at depth two: the search for <c>1/(x^(3/2) (a + c x^4))</c>
+        /// declines the root's substitution <c>2/(w^2 (a + c w^8))</c> at depth three and asks it
+        /// again at depth two, and the integral was declined. The key carries the depth as far as
+        /// a scope reaches, <see cref="ScopeDepth"/>, and a lookup takes a decline only from its
+        /// own depth and an answer from any, since an antiderivative that was found is right
+        /// wherever it is asked for.
         /// </para>
         /// </remarks>
-        [System.ThreadStatic] private static Dictionary<(Entity, Entity.Variable, bool, bool), Entity?>? answered;
+        [System.ThreadStatic] private static Dictionary<(Entity, Entity.Variable, bool, int), Entity?>? answered;
 
         /// <summary>The settings <see cref="answered"/> was filled under.</summary>
         [System.ThreadStatic] private static object?[]? answeredUnder;
@@ -346,6 +352,17 @@ private static Entity Normalized(Entity expr, Entity.Variable x) =>
         /// </summary>
         internal static bool AnsweringTheQuestionAskedOrTwoBelow => descentDepth <= 3;
 
+        /// <summary>
+        /// The depth as far as a scope tells one depth from another: 1 for the question asked, 2
+        /// and 3 for the levels <see cref="AnsweringTheQuestionAskedOrOneBelow"/> and
+        /// <see cref="AnsweringTheQuestionAskedOrTwoBelow"/> reach, and 4 for every level past
+        /// them, where every scoped rule declines alike.
+        /// </summary>
+        private static int ScopeDepth => System.Math.Min(descentDepth, DeepestScope);
+
+        /// <summary>The deepest <see cref="ScopeDepth"/>.</summary>
+        private const int DeepestScope = 4;
+
         /// <summary>
         /// <paramref name="expr"/> integrated as a question in its own right rather than as a
         /// step in the search for the current one: the term of a sum asked at the top is asked at
@@ -485,7 +502,7 @@ private static Entity Normalized(Entity expr, Entity.Variable x) =>
             // would otherwise be answered with, without the rule ever being reached to say that a
             // second pass could answer it.
             if (answer is not null && memo is not null && stamp is not null && SettingsState.StillHolds(stamp))
-                memo[(Normalized(expr, x), x, integrateByParts, true)] = answer;
+                memo[(Normalized(expr, x), x, integrateByParts, 1)] = answer;
             return answer;
         }
 
@@ -549,12 +566,13 @@ private static Entity Normalized(Entity expr, Entity.Variable x) =>
             var into = answered;
             var stamp = answeredUnder;
 
-            var key = (expr, x, integrateByParts, AnsweringTheQuestionAsked);
+            var depth = ScopeDepth;
+            var key = (expr, x, integrateByParts, depth);
             if (into.TryGetValue(key, out var already))
                 return already;
-            var otherScope = (expr, x, integrateByParts, !AnsweringTheQuestionAsked);
-            if (into.TryGetValue(otherScope, out var elsewhere) && elsewhere is not null)
-                return elsewhere;
+            for (var other = 1; other <= DeepestScope; other++)
+                if (other != depth && into.TryGetValue((expr, x, integrateByParts, other), out var elsewhere) && elsewhere is not null)
+                    return elsewhere;
 
             // Whether the descent ran out *inside this computation*, which is the only truncation
             // that says anything about this key. The flag is one per thread, so it is cleared
 
@@ -5,6 +5,7 @@
 // Website: https://am.angouri.org.
 //
 
+using System;
 using AngouriMath.Extensions;
 using Xunit;
 
@@ -44,5 +45,39 @@ public void AnIntegrandDeclinedInsideAnotherSearchIsStillAnsweredWhenAsked()
             var asked = "cos(x)^(-3)".ToEntity().Integrate("x");
             Assert.DoesNotContain("integral(", asked.Stringize());
         }
+
+        /// <summary>
+        /// The same two levels further down, inside one integral's own search. A rule may answer
+        /// the question asked and one or two levels below it and decline the same integrand
+        /// deeper. The search for <c>1/(x^(3/2) (a + c x^4))</c> declines the root's substitution
+        /// <c>2/(w^2 (a + c w^8))</c> at depth three and asks it again at depth two, and the
+        /// decline was held under a key that told the top from the rest and nothing more, so it
+        /// was served there and the integral was declined.
+        /// </summary>
+        /// <remarks>
+        /// Checked by differentiating back with <c>a = 2.3</c>, <c>b = 0.7</c>, <c>c = 1.3</c>,
+        /// for positive <c>x</c>, where the half powers are real.
+        /// </remarks>
+        [Theory]
+        [InlineData("1/(x^(3/2)*(a + c*x^4))")]
+        [InlineData("1/(x^(5/2)*(a + c*x^4))")]
+        [InlineData("1/((a + b/x^3)*x^5)")]
+        [InlineData("1/(x^(7/2)*(a + b*x^2 + c*x^4))")]
+        public void AnIntegrandDeclinedThreeBelowIsStillAnsweredTwoBelow(string integrand)
+        {
+            var integral = integrand.ToEntity().Integrate("x");
+            Assert.DoesNotContain("integral(", integral.Stringize());
+            Entity Pinned(Entity e) => e.Substitute("a", 2.3).Substitute("b", 0.7).Substitute("c", 1.3);
+            var derivative = Pinned(integral.Substitute("C", 0)).Differentiate("x");
+            var original = Pinned(integrand.ToEntity());
+            foreach (var at in new[] { 0.4, 0.9, 1.7 })
+            {
+                var got = derivative.Substitute("x", at).EvalNumerical();
+                var want = original.Substitute("x", at).EvalNumerical();
+                Assert.True(Math.Abs((double)(got - want).RealPart) + Math.Abs((double)(got - want).ImaginaryPart)
+                            < 1e-9 * Math.Max(1, Math.Abs((double)want.RealPart)),
+                    $"d/dx of the antiderivative of {integrand} is {got} at x = {at}, where the integrand is {want}");
+            }
+        }
     }
 }