@@ -83,6 +83,21 @@ powers of `c + d x` itself were read before ([#233](https://github.com/asc-commu
 | `"e^(k/(c+d*x))/(a+b*x)".ToEntity().Integrate("x")` | `integral(...)` | two `Ei`, of `k/(c + d x)` and of `k/(c + d x) - k b/(a d - b c)` |
 | `"f^(c/(a+b*x)^2)*x^4".ToEntity().Integrate("x")` | `integral(...)` | 1,262 characters, the error function and powers of `1/(a + b x)` |
 
+### An integrand under a condition free of x is integrated under the condition
+
+**Answers where there were none.** A condition with no x in it holds for every x or for none, so the integral of
+`f provided C` is the integral of f, provided C. `(x^2 sin(x)) provided not k = 0` was declined where `x^2 sin(x)` is
+answered, and so was `(1/((a + b x) 3 x)) provided not d = 0`. Inner simplification writes such a condition at the top
+of the questions rules hand on: `d^0` is `1 provided not d = 0`. Before this change master integrated
+`(1/x) provided a > 0` to `ln(x/a)`, which has a value where `a < 0` and the integrand has none; it is
+`ln(x) provided a > 0` ([#233](https://github.com/asc-community/AngouriMath/issues/233)).
+
+| Input | Was (2.5.0) | Now |
+|---|---|---|
+| `"(x^2*sin(x)) provided not k = 0".ToEntity().Integrate("x")` | `integral(...)` | 72 characters |
+| `"(1/((a+b*x)*3*x)) provided not d = 0".ToEntity().Integrate("x")` | `integral(...)` | 289 characters |
+| `"(1/x) provided a > 0".ToEntity().Integrate("x")` | `integral(...)` | 26 characters, `(ln(x) provided a > 0) + C` |
+
 ### A transcendental function of one shifted linear is integrated in the linear
 
 **Answers where there were none.** Rubi's 2.3 `F^(a + b/(c + d x)^3)/(c + d x)^19` and 3.4 `ln(c (d + e/(f + g x)^3)^q)`
 
@@ -684,6 +684,17 @@ internal static bool ASumOverRootsWouldAnswer
         private static Entity? ComputeIndefiniteIntegralUncached(Entity expr, Entity.Variable x, bool integrateByParts)
         {
             if (!expr.ContainsNode(x)) return expr * x; // base case, handle here
+            // A condition with no x in it holds for every x or for none, so the integral of `f provided C`
+            // is the integral of f, provided C. Inner simplification writes one at the top of a question a
+            // rule hands on -- `d^0` is `1 provided not d = 0` -- and no rule below reads it: AJ's kept
+            // spelling of `1/((c + d x)(a + b (c + d x)^3))` lost eight rows to that. The same question,
+            // so that a rule scoped to the one asked still reads it. Only the question asked: below it, the
+            // partial fractions of Rubi's 1.2.3.2 `(d f + e f x)/(a + b (d + e x)^2 + c (d + e x)^4)` hand on a
+            // piece with `provided not e = 0` that answered took 0.9 GB, for the answer the rest gives anyway.
+            if (expr is Entity.Providedf(var underTheCondition, var condition) && !condition.ContainsNode(x) && AnsweringTheQuestionAsked)
+                return ComputeAsTheSameQuestion(underTheCondition, x, integrateByParts) is { } underIt
+                    ? new Entity.Providedf(underIt, condition)
+                    : null;
             if ((IntegralPatterns.TryStandardIntegrals(expr, x)) is { } answer) return answer;
             // The flag has to be handed on. Every one of these recurses, and a solver that
             // dropped it re-enabled integration by parts one level below the call that
 
@@ -0,0 +1,56 @@
+//
+// 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 condition with no x in it holds for every x or for none, so the integral of <c>f provided C</c>
+    /// is the integral of f, provided C. <c>(x^2 sin(x)) provided not k = 0</c> was declined where
+    /// <c>x^2 sin(x)</c> is answered, and inner simplification writes such a condition at the top of
+    /// the questions rules hand on: <c>d^0</c> is <c>1 provided not d = 0</c>.
+    /// <a href="https://github.com/asc-community/AngouriMath/issues/233">#233</a>
+    /// </summary>
+    [Trait("Area", "Calculus")]
+    public sealed class AConditionFreeOfTheVariableIntegralTest
+    {
+        [Theory]
+        [InlineData("(x^2*sin(x)) provided not k = 0", "not k = 0")]
+        [InlineData("(1/((a + b*x)*3*x)) provided not d = 0", "not d = 0")]
+        [InlineData("(1/x) provided a > 0", "a > 0")]
+        public void IsAnsweredUnderTheCondition(string integrand, string condition)
+        {
+            var integral = integrand.ToEntity().Integrate("x");
+            var text = integral.Stringize();
+            Assert.DoesNotContain("integral(", text);
+            Assert.Contains($"provided {condition}", text);
+            Entity Pinned(Entity e) => e.Substitute("a", 1.3).Substitute("b", 0.7).Substitute("d", 0.9).Substitute("k", 0.4);
+            var derivative = Pinned(integral.Substitute("C", 0)).Differentiate("x");
+            var original = Pinned(integrand.ToEntity());
+            foreach (var at in new[] { 0.3, 0.8, 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}");
+            }
+        }
+
+        /// <summary>Where the condition fails the integrand has no value, and neither has the answer.</summary>
+        [Fact]
+        public void HasNoValueWhereTheConditionFails()
+        {
+            var integral = "(1/x) provided a > 0".ToEntity().Integrate("x").Substitute("C", 0);
+            Assert.True(integral.Substitute("a", -1).Substitute("x", 2).EvalNumerical().IsNaN);
+        }
+    }
+}