Do not answer an exhausted search with the empty set (#1036, #746 tier 4) (#1046)

`Solve` returned an empty `FiniteSet` both for an equation shown to have no roots
and for one every solver declined. The empty set is a positive claim, so the
second was a wrong answer: `x^6 + x*y + 1 = 0` has six roots for every `y` and
came back as `{ }`.

The two exits that mean "nothing settled this" now answer with the equation as a
set builder — the spelling `AnalyticalEquationSolver` already uses for #278 and
#964 — while an equation whose emptiness was established keeps `{ }`. Newton's
method is included: a search from finitely many starting points inside a bounded
region finding nothing is a fact about the search.

A conjunction with an unsettled side is answered as the conjunction. Intersecting
a finite set with a condition keeps the elements whose membership could not be
decided, so `x^6 + x*y + 1 = 0 and x - 1 = 0` would have become `{ 1 }` — one
false claim in place of another, since 1 solves the first only at `y = -2`.

Four theory rows recorded the old answer as correct. Each pinned an equation the
solver gives up on and that has roots, so they move to the new test file with the
honest assertion rather than being loosened.


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

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

Author: Rafael-SOWNet

BREAKING-CHANGES.md

@@ -21,6 +21,9 @@ read first.
 
 | Silent? | What | Was | Is |
 |---|---|---|---|
+| **Silent** | `"x6 + x y + 1 = 0".ToEntity().Solve("x")`, and every equation no solver settles | `{  }` — there are no roots | `{ x : 1 + x ^ 6 + x * y = 0 }` — these are the roots, whichever they are |
+| **Silent** | `"(x - 1) * (x6 + x y + 1) = 0".ToEntity().Solve("x")` | `{ 1 }` | `{ 1 } \/ { x : 1 + x ^ 6 + x * y = 0 }` |
+| **Silent** | `"x6 + x y + 1 = 0 and x - 1 = 0".ToEntity().Solve("x")` | `{  }` | `{ x : x ^ 6 + x * y + 1 = 0 and x - 1 = 0 }` |
 | **Silent** | `"sum(k, k, 1, n)".ToEntity().FreeVariables`, and `product` | `{ k, n }` — the bound index counted as free | `{ n }` |
 | **Silent** | `"integral(t * b, t, 0, 1)".ToEntity().FreeVariables`, and every integral with limits | `{ b, t }` | `{ b }` |
 | | `"x ^ 3 - x > 0".ToEntity().Solve("x")`, and every polynomial inequality of degree three or more | `NotSufficientlySupportedException: Only linear and quadratic polynomial inequalities are supported` | `(-1; 0) \/ (1; +oo)` — the solution set |
@@ -37,6 +40,105 @@ read first.
 | | `Compile` to a nullable integral return type in a NativeAOT app | `AngouriBugException: IsNaN method expected for type System.Double`, which took the process down | the compiled function |
 | **Silent** | an app publishing with `PublishTrimmed` or NativeAOT | `AngouriMath.dll` was copied in whole, being unmarked | it is trimmed with the rest, since the assembly now declares `IsTrimmable` |
 
+### An equation nothing settled is no longer answered with the empty set
+
+`Solve` and `SolveEquation` returned an empty `FiniteSet` for two different things: an equation
+shown to have no roots, and an equation every solver in the chain declined. The empty set is a
+positive claim — *no x satisfies this* — so the second of those was a wrong answer rather than a
+graceful failure ([#1036](https://github.com/asc-community/AngouriMath/issues/1036),
+[#746](https://github.com/asc-community/AngouriMath/issues/746) tier 4).
+
+**Was** — indistinguishable, and false for the second column:
+
+```
+"x6 + x y + 1 = 0".ToEntity().Solve("x")            {  }        six roots for every y
+"sin(x) + x + y = 0".ToEntity().Solve("x")          {  }
+"e^x + x + y = 0".ToEntity().Solve("x")             {  }
+"x6 + x y + 1".ToEntity().SolveEquation("x")        {  }
+"e^x = 0".ToEntity().Solve("x")                     {  }        genuinely none
+"abs(x) = -1".ToEntity().Solve("x")                 {  }        genuinely none
+```
+
+**Is** — the equation itself, as the set of the x that satisfy it. It names the same set and
+asserts of it only what was established:
+
+```
+"x6 + x y + 1 = 0".ToEntity().Solve("x")            { x : 1 + x ^ 6 + x * y = 0 }
+"sin(x) + x + y = 0".ToEntity().Solve("x")          { x : sin(x) + x = -y }
+"e^x + x + y = 0".ToEntity().Solve("x")             { x : e ^ x + x = -y }
+"x6 + x y + 1".ToEntity().SolveEquation("x")        { x : 1 + x ^ 6 + x * y = 0 }
+"e^x = 0".ToEntity().Solve("x")                     {  }        unchanged
+"abs(x) = -1".ToEntity().Solve("x")                 {  }        unchanged
+```
+
+Turning Newton's method off leaves nothing numerical either, and those answers move the same way.
+A search over finitely many starting points inside a bounded region finding nothing is a fact about
+the search:
+
+```
+using var _ = MathS.Settings.AllowNewton.Set(false);
+
+"x5 + 3x + 1 = 0".ToEntity().Solve("x")             was {  }   is { x : x ^ 5 + 3 * x = -1 }
+"sin(x) * x - 3 = 0".ToEntity().Solve("x")          was {  }   is { x : sin(x) * x = 3 }
+
+"x + sqrt(x^0.1 + a) + c".ToEntity().SolveEquation("x")
+    was {  }   is { x : sqrt(a + x ^ (1/10)) + c + x = 0 }
+"(x + 6)^(1/6) + x + x3 + a".ToEntity().SolveEquation("x")
+    was {  }   is { x : (6 + x) ^ (1/6) + x + x ^ 3 = -a }
+"2 ^ (x sin(x)) + 4 ^ (x sin(x)) + c".ToEntity().SolveEquation("x")
+    was {  }
+    is  { x : sin(x) * x = ln(((-1 - sqrt(1 - 4 * c)) / 2) ^ (1 / ln(2)))
+              or sin(x) * x = ln(((-1 + sqrt(1 - 4 * c)) / 2) ^ (1 / ln(2))) }
+```
+
+The last of those is the shape of it: the exponential solver did settle the equation in
+`2 ^ (x sin(x))`, and it was the inversion of `x * sin(x)` that had nothing to say. What comes back
+now is the half that was solved, with the half that was not left standing as a condition.
+
+An answer that is partly settled keeps the part that is, so a product one of whose factors was
+solved comes back as a union rather than as the factor's roots alone:
+
+```
+"(x - 1) * (x6 + x y + 1) = 0".ToEntity().Solve("x")
+    was  { 1 }
+    is   { 1 } \/ { x : 1 + x ^ 6 + x * y = 0 }
+
+"x6 + x y + 1 = 0 or x - 1 = 0".ToEntity().Solve("x")
+    was  { 1 }
+    is   { 1 } \/ { x : 1 + x ^ 6 + x * y = 0 }
+
+"x6 + x y + 1 = 0 implies x - 1 = 0".ToEntity().Solve("x")
+    was  { 1 } \/ BB
+    is   { 1 } \/ (BB \ { x : 1 + x ^ 6 + x * y = 0 })
+```
+
+A conjunction with an unsettled side is answered as the conjunction. Intersecting a finite set with
+a condition keeps the elements whose membership could not be decided, so taking the intersection
+here would have replaced one false claim with another — `{ 1 }` says 1 solves
+`x^6 + x*y + 1 = 0`, and it does so only at `y = -2`:
+
+```
+"x6 + x y + 1 = 0 and x - 1 = 0".ToEntity().Solve("x")
+    was  {  }
+    is   { x : x ^ 6 + x * y + 1 = 0 and x - 1 = 0 }
+```
+
+**What this means for callers.** `Solve` has always been typed `Set` and has always been able to
+return an `Interval`, a `ConditionalSet` or a union; what changes is how often it does. Code that
+casts the result to `FiniteSet`, or that reads an empty result as "no solutions", has to say which
+of the two it means:
+
+```csharp
+var answer = equation.Solve(x);
+if (answer is FiniteSet roots)      { /* these are all of them */ }
+else if (answer.IsSetEmpty)         { /* shown to have none */ }
+else                                { /* not settled, or not finite */ }
+```
+
+Nothing that solved before stops solving, and no equation that was shown to have no roots gains
+any. Solving `x2 - 4 = 0`, `sin(x) = 1/2`, `x2 + 1 = 0` and the system solver's answers are
+unchanged, as is `Solve` on an inequality.
+
 ### A bound index is not a free variable
 
 `FreeVariables` knew about two binders — `Lambda` and the set builder — and about no others. A

Sources/AngouriMath/Convenience/MathS.cs

@@ -5652,7 +5652,9 @@ internal static EDecimal DowncastingTolerance
             }
 
             /// <summary>
-            /// If you only need analytical solutions and an empty set if no analytical solutions were found, disable Newton's method
+            /// If you only need analytical solutions, disable Newton's method. What comes back
+            /// where there are none is the equation itself as a set builder: the empty set
+            /// would say the equation has no roots, which is a claim nothing established.
             /// </summary>
             /// <example>
             /// <code>
@@ -5671,7 +5673,7 @@ internal static EDecimal DowncastingTolerance
             /// { 1.0050669478588620808778841819730587303638458251953125 + 0.93725915669289194820379407246946357190608978271484375i,
             /// ... omitting here most of the output, because it's huge
             /// }
-            /// {  } // nothing was found for 5-degree polynomial without numeric solution
+            /// { x : x ^ 5 + 3 * x = -1 } // no analytical solution was found for this quintic
             /// </code>
             /// </example>
             public static Setting<bool> AllowNewton { get; } = true;

Sources/AngouriMath/Functions/Continuous/Solvers/EquationSolver/AnalyticalEquationSolver.cs

@@ -330,11 +330,43 @@ bool ProductIsDefinedAt(Entity root)
             // TODO: Solve factorials (Needs Lambert W function)
             // https://mathoverflow.net/a/28977
 
-            // if nothing has been found so far
+            // A numerical search that comes back with nothing has not shown there is
+            // nothing to find: Newton's method is started from finitely many points inside
+            // a bounded region, so an empty result is a fact about the search rather than
+            // about the equation. Where it does find roots the answer is theirs, unchanged.
             if (MathS.Settings.AllowNewton && expr.Vars.Count == 1)
-                return expr.SolveNt(x).Select(ent => TryDowncast(expr, x, ent)).ToSet();
+                return expr.SolveNt(x).Select(ent => TryDowncast(expr, x, ent)).ToSet()
+                    is FiniteSet { IsSetEmpty: false } found ? found : Unsolved(expr, x);
 
-            return Enumerable.Empty<Entity>().ToSet();
+            return Unsolved(expr, x);
         }
+
+        /// <summary>
+        /// The answer when every solver above has declined: the equation itself, as the set
+        /// of the <paramref name="x"/> that satisfy it.
+        /// </summary>
+        /// <remarks>
+        /// The empty set is a positive claim -- that no <paramref name="x"/> satisfies
+        /// <paramref name="equation"/> -- and returning it from an exhausted search asserts
+        /// something nothing here established. <c>x^6 + x*y + 1 = 0</c> has six roots for
+        /// every <c>y</c> and was answered <c>{ }</c>. A condition asserts only what was
+        /// established, which is that these are the roots, whichever they are; the set is
+        /// still exactly the solution set, so nothing downstream is told anything false.
+        ///
+        /// The spelling is the one <see cref="StatementSolver.UnsolvedWhereIndependenceIsDenied"/>
+        /// and the <a href="https://github.com/asc-community/AngouriMath/issues/278">#278</a>
+        /// case above already use, rather than a second way of saying the same thing.
+        /// <a href="https://github.com/asc-community/AngouriMath/issues/1036">#1036</a>,
+        /// <a href="https://github.com/asc-community/AngouriMath/issues/746">#746</a>
+        /// </remarks>
+        private static Set Unsolved(Entity equation, Variable x)
+            // Written back as an equation between the two sides where there are two, rather
+            // than as the residual the solvers pass around. A compensated call is handed its
+            // equation unsimplified on purpose, so the difference survives for them to read,
+            // and stating it as it stands leaves the reader `x^5 + 3*x - (-1) = 0` where the
+            // question was whether `x^5 + 3*x` is -1. The two admit the same x.
+            => new ConditionalSet(x, equation is Minusf(var lhs, var rhs)
+                ? lhs.Equalizes(rhs)
+                : equation.Equalizes(0));
     }
 }

Sources/AngouriMath/Functions/Continuous/Solvers/EquationSolver/SolveStatement.cs

@@ -148,6 +148,23 @@ private static EDecimal LargestTerm(Entity substituted)
             return largest;
         }
 
+        /// <summary>
+        /// Where both sides of a conjunction were settled, its solution set is the
+        /// intersection of theirs.
+        /// </summary>
+        /// <remarks>
+        /// Where one of them is a condition nothing settled, it is not: intersecting a
+        /// finite set with one keeps an element whose membership could not be decided, so
+        /// <c>x^6 + x*y + 1 = 0 and x - 1 = 0</c> comes back as <c>{ 1 }</c> — and 1 is a
+        /// root of the first only when <c>y</c> is -2. The conjunction as written asserts
+        /// exactly what is known about it and nothing more.
+        /// <a href="https://github.com/asc-community/AngouriMath/issues/1036">#1036</a>
+        /// </remarks>
+        private static Set Conjunction(Set left, Set right, Entity statement, Variable x)
+            => (left, right) is (ConditionalSet, FiniteSet) or (FiniteSet, ConditionalSet)
+                ? new ConditionalSet(x, statement)
+                : (Set)MathS.Intersection(left, right);
+
         internal static Set Solve(Entity expr, Variable x)
             => expr switch
             {
@@ -161,8 +178,8 @@ internal static Set Solve(Entity expr, Variable x)
 
                 Equalsf => Empty,
 
-                Andf(var left, var right) => 
-                    MathS.Intersection(Solve(left, x), Solve(right, x)),
+                Andf(var left, var right) =>
+                    Conjunction(Solve(left, x), Solve(right, x), expr, x),
                 Orf(var left, var right) => 
                     MathS.Union(Solve(left, x), Solve(right, x)),
                 Impliesf(var left, var right) => 

Sources/AngouriMath/Functions/Continuous/Solvers/Solvers.Definition.cs

@@ -84,7 +84,7 @@ partial record Entity
         /// { 9.08837698687877... }
         /// -----------------
         /// sin(x) * x - 3 = 0
-        /// {  }
+        /// { x : sin(x) * x = 3 }
         /// </code>
         /// </example>
         public Set Solve(Variable var)

Sources/Tests/UnitTests/Algebra/SolveTest/SolveOneEquation.cs

@@ -189,9 +189,6 @@ public void InvertedFunctions(string func, int rootAmount)
         public void CDSolver(string expr, int rootCount, string? verifyRoots) => TestSolver(expr, rootCount, verifyRoots: verifyRoots);
 
         [Theory]
-        [InlineData("x + sqrt(x^0.1 + a) + c", 0)]
-        [InlineData("(x + 6)^(1/6) + x + x3 + a", 0)]
-        [InlineData("sqrt(x + 1) + sqrt(x + 2) + a + x", 0)]
         [InlineData("(x + 1)^(1/3) - x - a", 3)]
         public void FractionedPoly(string expr, int rootCount) => TestSolver(expr, rootCount);
 
@@ -233,7 +230,6 @@ public void InvertedFunctions(string func, int rootAmount)
         [InlineData("4^x - a", 1, "{ log(4, a) }")]
         [InlineData("a^x + (a^2)^x - c", 2)]
         [InlineData("e^x + (e2)^x - 1", 2)]
-        [InlineData("2 ^ (x sin(x)) + 4 ^ (x sin(x)) + c", 0)]
         [InlineData("2^x - 4^x", 1, "{ 0 }")]
         public void TestExponentialSolver(string equation, int rootCount, string? verifyRoots = null)
             => TestSolver(equation, rootCount, verifyRoots: verifyRoots);