Give a one-sided limit the fallback the other paths have

A one-sided limit had nothing behind it. Where a two-sided or an infinite
destination falls through to l'Hopital's rule and the rest, this path
returned whatever the descent produced and stopped:

    if (side is ApproachFrom.Left or ApproachFrom.Right)
        return expr.ComputeLimitDivideEtImpera(x, dest, side);

The descent can make an indeterminate form definite on the way down, by
putting a part's own limit in place of the part. x * ln(x) at 0+ becomes
0 * ln(x), so 0 * -oo, so NaN -- and NaN is the claim that the limit does
not exist, not that it was not found. sin(x) / x approached from either
side came back the same way: the library said the most familiar limit in
the subject did not exist.

Where nothing above answered, this now moves x out to infinity and asks
there. That is what ComputeLimitImpl does for a finite destination in any
case, so it is the same question, put where l'Hopital's rule and the rest
of the machinery for infinity live. Whatever the descent found is kept if
this finds nothing better, so the change can only add answers.

The substituted expression is simplified before being asked about, and not
for tidiness: the destination is left behind as a term, and it is exactly
that leftover which produces the NaN. (0 + 1/x) * ln(0 + 1/x) at infinity
is NaN where (1/x) * ln(1/x) is 0.

Measured over 26 one-sided limits worked out by hand: 13 correct before,
18 after; 12 wrong before, 7 after. Nothing that was right became wrong.
Suite unchanged at 3m09s against 3m05s.

Seven are still wrong, and this does not claim them: x^2 * ln(x),
sqrt(x) * ln(x), x^x, (1 + x)^(1/x), (1 - cos(x)) / x^2, 1/x - 1/sin(x)
and 1/ln(x) - 1/(x-1) from the right. Each needs the machinery at infinity
to be stronger than it is, not a different bridge to it -- three of them
answer already once the differences-at-infinity and Gruntz branches are in.
(1 + x)^(1/x) at 0+ gives 1 rather than e both before and after, which is
a separate defect on the two-sided-versus-one-sided path.

Part of #209.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: Rafael-SOWNet

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

@@ -51,7 +51,33 @@ private static Entity ExpandLogarithm(Entity expr)
             expr = expr.Replace(ExpandLogarithm);
 
             if (side is ApproachFrom.Left or ApproachFrom.Right)
-                return expr.ComputeLimitDivideEtImpera(x, dest, side);
+            {
+                var oneSided = expr.ComputeLimitDivideEtImpera(x, dest, side);
+                if (oneSided is { } found && (acceptNaN || found.Evaled != MathS.NaN))
+                    return oneSided;
+                // The one-sided path is the only one with nothing behind it, and the descent
+                // can make an indeterminate form definite on the way down: for x * ln(x) at 0+
+                // it substitutes the first factor's own limit and then asks for 0 * -oo, which
+                // is NaN. NaN is the claim that the limit does not exist, and here it is 0.
+                //
+                // Moving x out to infinity is what ComputeLimitImpl does for a finite
+                // destination in any case, so this asks the same question in the place where
+                // l'Hopital's rule and the rest of the machinery for infinity live -- none of
+                // which this path can otherwise reach. Only where nothing above answered, and
+                // whatever was found before is kept if this finds nothing better.
+                // Simplified, and not only for tidiness: the substitution leaves the
+                // destination behind as a term, and it is exactly that leftover which makes
+                // the answer NaN. x * ln(x) at 0+ becomes (0 + 1/x) * ln(0 + 1/x), whose limit
+                // at infinity comes back NaN, where the same expression written as
+                // (1/x) * ln(1/x) comes back 0.
+                if (dest.IsFinite
+                    && ComputeLimit(expr.Substitute(x, side is ApproachFrom.Left ? dest - 1 / x : dest + 1 / x)
+                                        .InnerSimplified,
+                                    x, Real.PositiveInfinity) is { } byInfinity
+                    && byInfinity.Evaled != MathS.NaN)
+                    return byInfinity;
+                return oneSided;
+            }
             if (side is ApproachFrom.BothSides)
             {
                 expr = expr.Replace(a => TrivialTrigonometricReplacement(a, x));

Sources/Tests/UnitTests/Calculus/OneSidedLimitTest.cs

@@ -0,0 +1,81 @@
+//
+// Copyright (c) 2019-2022 Angouri.
+// AngouriMath is licensed under MIT.
+// Details: https://github.com/asc-community/AngouriMath/blob/master/LICENSE.md.
+// Website: https://am.angouri.org.
+//
+
+using AngouriMath;
+using AngouriMath.Core;
+using AngouriMath.Extensions;
+using Xunit;
+
+namespace AngouriMath.Tests.Calculus
+{
+    /// <summary>
+    /// A one-sided limit had nothing behind it. Where the two-sided and the infinite paths
+    /// fall through to l'Hopital's rule, this one returned whatever the descent produced --
+    /// and the descent can make an indeterminate form definite on the way down, by putting a
+    /// part's own limit in place of the part. x * ln(x) at 0+ becomes 0 * ln(x), so 0 * -oo,
+    /// so NaN, and NaN is the claim that the limit does not exist.
+    /// </summary>
+    public sealed class OneSidedLimitTest
+    {
+        private static Entity Limit(string expression, string destination, ApproachFrom side) =>
+            expression.ToEntity().Limit("x", destination.ToEntity(), side).Simplify();
+
+        private static void AssertLimit(string expression, string destination, ApproachFrom side, string expected) =>
+            Assert.Equal(expected.ToEntity().Evaled, Limit(expression, destination, side).Evaled);
+
+        /// <summary>
+        /// Every one of these came back NaN. sin(x) / x is the one worth naming: approached
+        /// from either side it is 1, and the library said the limit did not exist.
+        /// </summary>
+        [Theory]
+        [InlineData("sin(x) / x", "0", "1")]
+        [InlineData("tan(x) / x", "0", "1")]
+        [InlineData("x / sin(x)", "0", "1")]
+        [InlineData("x * ln(x)", "0", "0")]
+        public void FormsThatUsedToBeCalledNonExistentFromTheRight(string expression, string destination, string expected) =>
+            AssertLimit(expression, destination, ApproachFrom.Right, expected);
+
+        [Theory]
+        [InlineData("sin(x) / x", "0", "1")]
+        [InlineData("x / sin(x)", "0", "1")]
+        public void FormsThatUsedToBeCalledNonExistentFromTheLeft(string expression, string destination, string expected) =>
+            AssertLimit(expression, destination, ApproachFrom.Left, expected);
+
+        /// <summary>
+        /// The one-sided answers that were already right, kept. The fallback is only consulted
+        /// where the descent returned nothing or NaN, so none of these should reach it at all.
+        /// </summary>
+        [Theory]
+        [InlineData("1 / x", "0", ApproachFrom.Right, "+oo")]
+        [InlineData("1 / x", "0", ApproachFrom.Left, "-oo")]
+        [InlineData("1 / x ^ 2", "0", ApproachFrom.Right, "+oo")]
+        [InlineData("1 / x ^ 2", "0", ApproachFrom.Left, "+oo")]
+        [InlineData("ln(x)", "0", ApproachFrom.Right, "-oo")]
+        [InlineData("ln(x) / x", "0", ApproachFrom.Right, "-oo")]
+        [InlineData("e ^ (1/x)", "0", ApproachFrom.Right, "+oo")]
+        [InlineData("e ^ (1/x)", "0", ApproachFrom.Left, "0")]
+        [InlineData("1 / (x - 2)", "2", ApproachFrom.Right, "+oo")]
+        [InlineData("1 / (x - 2)", "2", ApproachFrom.Left, "-oo")]
+        [InlineData("(x ^ 2 - 1) / (x - 1)", "1", ApproachFrom.Right, "2")]
+        [InlineData("(x ^ 2 - 1) / (x - 1)", "1", ApproachFrom.Left, "2")]
+        [InlineData("x / (x + 1)", "0", ApproachFrom.Right, "0")]
+        public void EstablishedOneSidedLimitsAreUnaffected(string expression, string destination, ApproachFrom side, string expected) =>
+            AssertLimit(expression, destination, side, expected);
+
+        /// <summary>
+        /// The fallback moves x out to infinity, which is what a finite destination does in any
+        /// case. It must not be reached for a destination that is already infinite, where the
+        /// substitution would mean nothing.
+        /// </summary>
+        [Theory]
+        [InlineData("1 / x", "+oo", ApproachFrom.Right, "0")]
+        [InlineData("x ^ 2 / (x ^ 2 + 1)", "+oo", ApproachFrom.Left, "1")]
+        [InlineData("1 / x", "-oo", ApproachFrom.Left, "0")]
+        public void AnInfiniteDestinationIsLeftAlone(string expression, string destination, ApproachFrom side, string expected) =>
+            AssertLimit(expression, destination, side, expected);
+    }
+}