@@ -6998,6 +6998,27 @@ written back is the argument's, which is that of `x` only for a positive slope a
 | `"asec(x)^2/(x*sqrt(x^2 - 1))".ToEntity().Integrate("x")` | `integral(...)` | the same |
 | `"asec(x + 3)^2/((x + 3)*sqrt((x + 3)^2 - 1))".ToEntity().Integrate("x")` | `integral(...)` | right for `x > -2` and for `x < -4` |
 
+### `x^(4k - 1) (a + b arcsec(c x))/sqrt(1 - c^4 x^4)` and the arccosecant's are integrated on both sides of `|c x| = 1`
+
+**Answers where there were none.** Rubi's 5.5.1 and 5.6.1 `x^(4k - 1) (a + b arcsec(c x))/sqrt(1 - c^4 x^4)`
+and the arccosecant's were declined by 2.5.0, and on the unreleased master answered for `|c x| > 1` only. By
+parts leaves a root of `1 - 1/(c x)^2`, which is written apart as `sqrt((c x)^2 - 1)/|c x|`, and the antiderivative
+of what that leaves came back `provided (c x)^2 - 1 >= 0`, a condition the step dropped: for `|c x| < 1`, where the
+integrand is complex, the answer's derivative was the integrand's negative. `sqrt(1 - u^2)/sqrt(u - 1)` is
+`sqrt(-(1 + u))` for `u > 1` and its negative for `-1 < u < 1`, so with `sgn((c x)^2 - 1)` in front the antiderivative
+holds on both sides, as Rubi's does with `sqrt(1 - c^2 x^2)/(c x sqrt(1 - 1/(c^2 x^2)))`. The sign is checked at two
+points of every interval between its roots, and goes in front only where the integrand has no value at them, here
+`0/0`; where no sign is found the condition is kept, and the answer says where it holds. The same holds of
+`x^3 (a + b arcsec(c x)) sqrt(1 - c^4 x^4)` and its kin, also declined by 2.5.0
+([#233](https://github.com/asc-community/AngouriMath/issues/233)).
+
+| Input | Was (2.5.0) | Now |
+|---|---|---|
+| `"x^3*(a + b*arcsec(c*x))/sqrt(1 - c^4*x^4)".ToEntity().Integrate("x")` | `integral(...)` | 322 characters, for `c^2 x^2 < 1` and `> 1`; 298 for `c^2 x^2 > 1` only on the unreleased master |
+| `"x^7*(a + b*arcsec(c*x))/sqrt(1 - c^4*x^4)".ToEntity().Integrate("x")` | `integral(...)` | 678 characters, the same; 654 on the unreleased master |
+| `"x^11*(a + b*arcsec(c*x))/sqrt(1 - c^4*x^4)".ToEntity().Integrate("x")` | `integral(...)` | 1,211 characters, the same; 1,187 on the unreleased master |
+| `"x^3*(a + b*arccsc(c*x))/sqrt(1 - c^4*x^4)".ToEntity().Integrate("x")` | `integral(...)` | 321 characters, the same; 297 on the unreleased master |
+
 ### A perfect square in a power of the variable is read as one
 
 `sqrt(a^2 + 2 a b x^2 + b^2 x^4) sqrt(c + e x + d x^2)` was left unevaluated. The radicand is
 
@@ -32323,6 +32323,19 @@ private static bool NotRealAt(Entity expr, Entity.Variable x, double at)
             foreach (var pair in signs)
                 if (pair.Value % 2 == 1 && extended is { })
                     extended = MathS.Signum(pair.Key) * extended;
+            // Bare drops the conditions the simplification attaches, a denominator nonzero, and
+            // with them one of another kind, that the antiderivative holds on part of the line
+            // only: the root of `1 - 1/x^2` written apart is `sqrt(x^2 - 1)/|x|`, and the
+            // remainder parts leaves from Rubi's `x^3 arcsec(x)/sqrt(1 - x^4)` written so comes
+            // back `provided x^2 - 1 >= 0`. Returned bare it was taken for an antiderivative on
+            // `|x| < 1` as well, where its derivative is the integrand's negative.
+            if (tookAPowerOfX && extended is { } && TheRestrictionsOnTheVariable(forPositive, x) is { Count: > 0 } restrictions)
+            {
+                var (offIt, stillUnder) = OffItsRestrictions(expr, extended, restrictions, byParity: !(wholePowersOfX && everyPowerOfXFromAFactor), x);
+                extended = offIt;
+                if (stillUnder is { })
+                    assumed = assumed == Entity.Boolean.True ? stillUnder : assumed & stillUnder;
+            }
             return extended?.Provided(assumed);
 
             // What is set free under the root is a polynomial of degree four at most: the
@@ -32480,6 +32493,120 @@ Entity PowerOfAPositive(Entity positive, Number.Rational exponent)
             }
         }
 
+        /// <summary>
+        /// The conjuncts of the condition <paramref name="answer"/> is given under that confine
+        /// <paramref name="x"/> to part of the real line, its inequalities in <paramref name="x"/>:
+        /// not those the simplification attaches, a denominator nonzero, which leave out points.
+        /// </summary>
+        private static List<Entity> TheRestrictionsOnTheVariable(Entity answer, Entity.Variable x)
+            => answer.InnerSimplified is Providedf(_, var condition)
+                ? Andf.LinearChildren(condition).Where(conjunct => conjunct is Greaterf or GreaterOrEqualf or Lessf or LessOrEqualf && conjunct.ContainsNode(x)).Distinct().ToList()
+                : new List<Entity>();
+
+        /// <summary>
+        /// <paramref name="answer"/>, an antiderivative of <paramref name="integrand"/> where
+        /// <paramref name="restrictions"/> hold, as one wherever the integrand has a value, with the
+        /// condition it still holds under, <see langword="null"/> where it needs none: as it is
+        /// where it holds on every interval between the roots of the restrictions, with the sign
+        /// of the one restriction in front where that is what it is off it, and under the
+        /// restrictions otherwise. <paramref name="byParity"/> where <paramref name="answer"/> is
+        /// the antiderivative for positive x written in |x|.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// <c>sqrt(1 - u^2)/sqrt(u - 1)</c> is <c>sqrt(-(1 + u))</c> for <c>u &gt; 1</c> and its
+        /// negative for <c>-1 &lt; u &lt; 1</c>, where the root below the bar is imaginary, so an
+        /// antiderivative found through the one is the negative of one off it, and
+        /// <c>sgn(u - 1) F</c> holds on both sides. Rubi writes that sign as
+        /// <c>sqrt(1 - c^2 x^2)/(c x sqrt(1 - 1/(c^2 x^2)))</c>, which is <c>i sgn(c x) sgn(c^2 x^2 - 1)</c>.
+        /// Only where the integrand has no value at the restriction's roots, which then part its
+        /// domain: where it has one, an antiderivative is continuous there and <c>sgn(P) F</c> is not.
+        /// </para>
+        /// <para>
+        /// Decided at two points of every interval between the real roots of the restrictions and
+        /// of x, comparing complex values, every other symbol pinned to an exact rational so that
+        /// the roots are exact. An interval where the two cannot be compared does not hold. The
+        /// derivative is compared with each <c>(P^(1/n))^n</c> in the answer written <c>P</c>, which
+        /// is the same number on every branch: <c>(sqrt(x^2 - 1))^2</c> under a root, inside
+        /// <c>(-1, 1)</c>, is an interval about the negative axis that the evaluation cannot place
+        /// on either side of the cut.
+        /// https://github.com/asc-community/AngouriMath/issues/233
+        /// </para>
+        /// </remarks>
+        private static (Entity Answer, Entity? Condition) OffItsRestrictions(Entity integrand, Entity answer, List<Entity> restrictions, bool byParity, Entity.Variable x)
+        {
+            Entity Written(Entity inX) => byParity ? inX.Substitute(x, MathS.Abs(x)) : inX;
+            var condition = restrictions.Select(Written).Aggregate((left, right) => left & right);
+            // What each restriction says is positive, or not negative.
+            var positives = restrictions.Select(restriction => restriction switch
+            {
+                Greaterf(var left, var right) => left - right,
+                GreaterOrEqualf(var left, var right) => left - right,
+                Lessf(var left, var right) => right - left,
+                LessOrEqualf(var left, var right) => right - left,
+                _ => restriction
+            }).Select(positive => positive.Expand().InnerSimplified).Distinct().ToList();
+            var parameters = integrand.Vars.Concat(answer.Vars).Concat(positives.SelectMany(positive => positive.Vars))
+                .Where(v => v != x).Distinct().ToList();
+            Entity Pinned(Entity e)
+            {
+                for (var i = 0; i < parameters.Count; i++)
+                    e = e.Substitute(parameters[i], Number.Rational.Create((i % 3) switch { 0 => 137, 1 => 271, _ => 83 } + 100 * i, 100));
+                return e;
+            }
+            // The real roots of x and of each restriction, exact.
+            var bases = new List<Entity> { x };
+            foreach (var positive in positives)
+            {
+                var pinned = Pinned(positive).InnerSimplified;
+                bases.Add(pinned);
+                if (byParity)
+                    bases.Add(pinned.Substitute(x, -x).InnerSimplified);
+            }
+            var realRoots = new List<(Entity Root, double At, bool OfARestriction)>();
+            for (var index = 0; index < bases.Count; index++)
+            {
+                var polynomial = bases[index];
+                if (!TreeAnalyzer.TryGetPolynomial(polynomial, x, out _) || MathS.SolveEquation(polynomial, x) is not Set.FiniteSet solutions)
+                    return (answer, condition);
+                foreach (var solution in solutions.Elements)
+                {
+                    if (solution.Evaled is not Number.Complex { IsFinite: true } value)
+                        return (answer, condition);
+                    if (value.ImaginaryPart.EDecimal.IsZero)
+                        realRoots.Add((solution, (double)value.RealPart, index > 0));
+                }
+            }
+            var at = realRoots.Select(root => root.At).Distinct().OrderBy(root => root).ToList();
+            var intervals = new List<double[]> { new[] { at[0] - 1, at[0] - 2 }, new[] { at[at.Count - 1] + 1, at[at.Count - 1] + 2 } };
+            for (var i = 0; i + 1 < at.Count; i++)
+                if (at[i + 1] - at[i] > 1e-9)
+                    intervals.Add(new[] { at[i] + (at[i + 1] - at[i]) / 3, at[i] + 2 * (at[i + 1] - at[i]) / 3 });
+            var points = intervals.Select(pair => pair.Select(point => point.ToString("0.0###########", System.Globalization.CultureInfo.InvariantCulture)).ToArray()).ToList();
+            var pinnedIntegrand = Pinned(integrand);
+            bool Holds(Entity candidate)
+            {
+                using var _ = MathS.Settings.DowncastingEnabled.Set(false);
+                var derivative = Functions.PartialFractions.Bare(Pinned(candidate))
+                    .Replace(node => node is Powf(Powf(var radicand, Number.Rational root), Number.Integer power)
+                        && root.ERational.Numerator.Equals(EInteger.One) && root.ERational.Denominator.Equals(power.EInteger) ? radicand : node)
+                    .Differentiate(x);
+                return points.All(pair => Functions.PartialFractions.HoldsAtSampledPoints(derivative, pinnedIntegrand, x, pair));
+            }
+            if (Holds(answer))
+                return (answer, null);
+            if (positives.Count == 1)
+            {
+                var signed = MathS.Signum(Written(positives[0])) * answer;
+                // The integrand without a value at each real root of the restriction: 0/0 there.
+                var partsTheDomain = realRoots.Where(root => root.OfARestriction)
+                    .All(root => pinnedIntegrand.Substitute(x, root.Root).Evaled is Number.Complex { IsFinite: false });
+                if (partsTheDomain && Holds(signed))
+                    return (signed, null);
+            }
+            return (answer, condition);
+        }
+
         /// <summary>
         /// Whether the polynomial <paramref name="expr"/> in <paramref name="x"/> is positive at
         /// every real <paramref name="x"/> but possibly zero once its parameters are real: every
 
@@ -0,0 +1,86 @@
+//
+// 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 System.Linq;
+using AngouriMath.Extensions;
+using Xunit;
+
+namespace AngouriMath.Tests.Calculus
+{
+    /// <summary>
+    /// <c>x^(4k - 1) (a + b arcsec(c x))/sqrt(1 - c^4 x^4)</c> and the arccosecant's, by parts: the
+    /// remainder holds a root of <c>1 - 1/(c x)^2</c>, which is written apart as
+    /// <c>sqrt((c x)^2 - 1)/|c x|</c>, and what the chain answers for it holds for
+    /// <c>|c x| &gt;= 1</c> only. Returned without that condition, the answer was wrong for
+    /// <c>|c x| &lt; 1</c>, where the integrand is complex; off it, it is the negative of one, and
+    /// <c>sgn((c x)^2 - 1)</c> in front makes it one on both sides. Rubi's 5.5.1 and 5.6.1.
+    /// <a href="https://github.com/asc-community/AngouriMath/issues/233">#233</a>
+    /// </summary>
+    [Trait("Area", "Calculus")]
+    public sealed class AQuotientWrittenApartBeyondItsRestrictionIntegralTest
+    {
+        [Theory]
+        [InlineData("x^3*(a + b*arcsec(c*x))/sqrt(1 - c^4*x^4)")]
+        [InlineData("x^7*(a + b*arcsec(c*x))/sqrt(1 - c^4*x^4)")]
+        [InlineData("x^11*(a + b*arcsec(c*x))/sqrt(1 - c^4*x^4)")]
+        [InlineData("x^3*(a + b*arccsc(c*x))/sqrt(1 - c^4*x^4)")]
+        [InlineData("x^7*(a + b*arccsc(c*x))/sqrt(1 - c^4*x^4)")]
+        [InlineData("x^11*(a + b*arccsc(c*x))/sqrt(1 - c^4*x^4)")]
+        // And with the root above the bar, which parts leaves the same root of 1 - 1/(c x)^2 beside.
+        [InlineData("x^3*(a + b*arcsec(c*x))*sqrt(1 - c^4*x^4)")]
+        [InlineData("x^3*(a + b*arccsc(c*x))*sqrt(1 - c^4*x^4)")]
+        public void HoldsOnBothSidesOfTheUnitModulus(string integrand)
+        {
+            var integral = integrand.ToEntity().Integrate("x");
+            var text = integral.Stringize();
+            Assert.DoesNotContain("integral(", text);
+            Assert.DoesNotContain("provided", text);
+            // c = 1/2 puts |c x| = 1 at x = 2, and c = -13/10 at |x| = 10/13, a negative c.
+            Compare(integrand, integral, c: 0.5, inside: new[] { -1.7, -0.9, -0.3, 0.4, 1.1, 1.9 }, outside: new[] { -3.3, -2.2, 2.3, 4.1 });
+            Compare(integrand, integral, c: -1.3, inside: new[] { -0.7, -0.35, 0.2, 0.6 }, outside: new[] { -2.1, -0.9, 0.85, 1.7 });
+        }
+
+        [Theory]
+        [InlineData("x^3*(a + b*arcsec(c*x))/sqrt(1 - c^4*x^4)")]
+        [InlineData("x^3*(a + b*arccsc(c*x))/sqrt(1 - c^4*x^4)")]
+        public void TheIntegrandHasNoValueWhereTheSignTurns(string integrand)
+        {
+            // At |c x| = 1 the integrand is 0/0, so the domain parts there and a sign that turns
+            // there leaves an antiderivative on each side: Rubi's has the same factor,
+            // sqrt(1 - c^2 x^2)/(c x sqrt(1 - 1/(c^2 x^2))).
+            var original = integrand.ToEntity().Substitute("a", 1.3).Substitute("b", 0.6).Substitute("c", 0.5);
+            Assert.True(original.Substitute("x", 2).EvalNumerical().IsNaN);
+            Assert.True(original.Substitute("x", -2).EvalNumerical().IsNaN);
+        }
+
+        private static void Compare(string integrand, Entity integral, double c, double[] inside, double[] outside)
+        {
+            Entity Pinned(Entity e) => e.Substitute("a", 1.3).Substitute("b", 0.6).Substitute("c", c);
+            // Pinned before the differentiation, so that sgn((c x)^2 - 1)' is zero off its roots.
+            var derivative = Pinned(integral.Substitute("C", 0)).Differentiate("x");
+            var original = Pinned(integrand.ToEntity());
+            foreach (var at in inside)
+                Assert.True(Math.Abs(c * at) < 1, $"{at} is not inside for c = {c}");
+            foreach (var at in outside)
+                Assert.True(Math.Abs(c * at) > 1, $"{at} is not outside for c = {c}");
+            // In decimals, as the integrator's own checks compare: downcast to rationals, the
+            // integrand at c = -1.3, x = 0.2 has no value in the legacy evaluation.
+            using var _ = MathS.Settings.DowncastingEnabled.Set(false);
+            foreach (var at in inside.Concat(outside))
+            {
+                var want = original.Substitute("x", at).EvalNumerical();
+                var got = derivative.Substitute("x", at).EvalNumerical();
+                // The integrand is complex on both sides: compared as complex values.
+                Assert.False(want.IsNaN, $"the integrand {integrand} has no value at x = {at}, c = {c}");
+                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}, c = {c}, where the integrand is {want}");
+            }
+        }
+    }
+}