Do not simplify x in {1} to false

Author: Happypig375

Sources/AngouriMath/Convenience/MathS.cs

@@ -3324,7 +3324,7 @@ public static (Variable, Variable, Variable, Variable, Variable) Var(string name
 
         // Undefined
         /// <summary>
-        /// That is both undefined and indeterminite
+        /// NaN represents both "undefined" and "indeterminate".
         /// Any operation on NaN returns NaN
         /// </summary>
         /// <example>

Sources/AngouriMath/Core/Entity/Continuous/Entity.Continuous.Complex.Definition.cs

@@ -71,11 +71,6 @@ private protected Complex(Real? real, Real? imaginary) =>
                 /// </summary>
                 public new bool IsZero => RealPart.EDecimal.IsZero && ImaginaryPart.EDecimal.IsZero;
 
-                /// <summary>
-                /// Checks whether the given number is undefined
-                /// </summary>
-                public bool IsNaN => this == Real.NaN;
-
                 /// <summary>
                 /// Creates an instance of Complex
                 /// </summary>

Sources/AngouriMath/Core/Entity/Continuous/Entity.Continuous.Real.Definition.cs

@@ -28,7 +28,7 @@ public partial record Real : Complex, System.IComparable<Real>
                 private protected Real(EDecimal @decimal) : base(null, null) => EDecimal = @decimal;
 
                 /// <summary>
-                /// The PeterO number representation in decimal
+                /// The PeterO number representation in <see cref="PeterO.Numbers.EDecimal"/>
                 /// </summary>
                 public EDecimal EDecimal { get; }
 

Sources/AngouriMath/Core/Entity/Continuous/Number/Operators.cs

@@ -373,6 +373,8 @@ static Complex BinaryIntPow(Complex num, EInteger val)
                 if (@base is Real { EDecimal: { IsNegative: false } realBase } && power is Real { EDecimal: var realPower })
                     return realBase.Pow(realPower, context);
                 // From https://source.dot.net/#System.Runtime.Numerics/System/Numerics/Complex.cs,7dc9c2ee4f99814a
+                // NOTE: System.Numerics.Complex.Pow(0, System.Numerics.Complex(-2, 1)) gives 0 + 0i despite being mathematically undefined
+                // NOTE: System.Numerics.Complex.Pow(0, 0) gives 1 + 0i despite being mathematically undefined
                 var baseReal = @base.RealPart.EDecimal;
                 var baseImaginary = @base.ImaginaryPart.EDecimal;
                 var powerReal = power.RealPart.EDecimal;

Sources/AngouriMath/Core/Entity/Entity.Definition.cs

@@ -705,5 +705,10 @@ public IReadOnlyList<Variable> Vars
         /// </code>
         /// </example>
         public bool IsConstantLeaf => this is Boolean or Number or Set.SpecialSet;
+
+        /// <summary>
+        /// Checks whether this entity represents the undefined value (<see cref="MathS.NaN"/>).
+        /// </summary>
+        public bool IsNaN => this == Real.NaN;
     }
 }

Sources/AngouriMath/Core/Entity/Omni/Entity.Omni.Classes.cs

@@ -14,6 +14,7 @@
 using HonkSharp.Laziness;
 using Complex = AngouriMath.Entity.Number.Complex;
 using System.Linq.Expressions;
+using System.Diagnostics.CodeAnalysis;
 
 namespace AngouriMath
 {
@@ -53,7 +54,7 @@ public FiniteSet Apply(Func<Entity, Entity> func)
                         var changed = func(el);
                         if (!ReferenceEquals(changed, el))
                             hasAnythingChanged = true;
-                        newElements.Add(changed);
+                        if (changed != MathS.NaN) newElements.Add(changed);
                     }
                     if (hasAnythingChanged)
                         return newElements.ToFiniteSet();
@@ -123,31 +124,26 @@ internal static FiniteSet Unite(FiniteSet A, FiniteSet B)
                     => new FiniteSet(A.Elements.Concat(B.Elements));
 
                 // It could be written with one chain request, but readability > one line
-                internal static FiniteSet Subtract(FiniteSet A, FiniteSet B)
+                internal static bool TryFullSubtract(FiniteSet A, FiniteSet B, [NotNullWhen(true)] out FiniteSet? resultSet)
                 {
+                    var constantSets = A.Vars.Count == 0 && B.Vars.Count == 0;
                     var dict = BuildDictionaryFromElements(A.Elements, noCheck: true);
                     foreach (var el in B)
-                        dict.Remove(el.Evaled);
-                    return new FiniteSet(dict.Values, noCheck: true); // we didn't add anything
-                }
-
-                internal static FiniteSet Intersect(FiniteSet A, FiniteSet B)
-                {
-                    var dict = BuildDictionaryFromElements(A.Elements, noCheck: true);
-                    foreach (var el in A.elements)
-                        if (!B.Contains(el.Key))
-                            dict.Remove(el.Key);
-                    return new FiniteSet(dict.Values, noCheck: true); // we didn't add anything
+                        if (!dict.Remove(el.Evaled) && !constantSets) { resultSet = null; return false; }
+                    resultSet = new FiniteSet(dict.Values, noCheck: true); // we didn't add anything
+                    return true;
                 }
 
                 /// <inheritdoc/>
                 public override bool TryContains(Entity entity, out bool contains)
                 {
+                    if (IsSetEmpty) { contains = false; return true; } // a in {} is unambiguously false
                     contains = elements.ContainsKey(entity.Evaled);
-                    // a in { 2, 3 } is false
-                    // 4 in { a, 3 } is false
-                    // TODO: should we return false when there are symbolic expressions?
-                    return true;
+                    // x in { x, 2 } and 2 in { x, 2 } are both unambiguously true
+                    if (contains) return true;
+                    // however, 1 in { x, 2 }, y in { x, 2 } are both unknown
+                    // meanwhile, 2 in { 1, 3 } is unambiguously false
+                    return entity.Vars.Count == 0 && elements.Keys.All(el => el.Vars.Count == 0);
                 }
 
                 /// <inheritdoc/>
@@ -168,7 +164,7 @@ public bool Equals(FiniteSet? other)
                     if (other.Count != Count)
                         return false;
                     foreach (var pair in elements)
-                        if (!other.Contains(pair.Key))
+                        if (!other.TryContains(pair.Key, out var contains) || !contains)
                             return false;
                     return true;
                 }
@@ -653,13 +649,9 @@ public override Entity Replace(Func<Entity, Entity> func)
                 public override bool TryContains(Entity entity, out bool contains)
                 {
                     contains = false;
-                    if (Left is not Set left || Right is not Set right)
-                        return false;
-                    if (left.TryContains(entity, out var leftContains) && right.TryContains(entity, out var rightContains))
-                    {
-                        contains = leftContains || rightContains;
-                        return true;
-                    }
+                    if (Left is not Set left || Right is not Set right) return false;
+                    if (left.TryContains(entity, out contains) && contains) return true;
+                    if (right.TryContains(entity, out contains)) return true;
                     return false;
                 }
 

Sources/AngouriMath/Core/Entity/Omni/Entity.Omni.Definition.cs

@@ -22,13 +22,12 @@ public Entity In(Entity supSet)
             => new Inf(this, supSet);
 
         /// <summary>
-        /// Creates a node of a expression assuming some condition
+        /// Creates a node of a expression assuming some condition. If the condition is the true node, the node itself is returned.
         /// </summary>
         /// <param name="that">
         /// A condition under which a given expression (this) is valid.
         /// </param>
         /// <returns>A node</returns>
-        public Entity Provided(Entity that)
-            => new Providedf(this, that);
+        public Entity Provided(Entity that) => that == Boolean.True ? this : new Providedf(this, that);
     }
 }

Sources/AngouriMath/Core/Entity/Omni/Sets/SetOperators.Intersection.cs

@@ -14,8 +14,6 @@ internal static partial class SetOperators
     {
         internal static Set IntersectFiniteSetAndSet(FiniteSet finite, Set set)
         {
-            if (set is FiniteSet another)
-                return FiniteSet.Intersect(finite, another);
             var fsb = new FiniteSetBuilder();
             var amb = new FiniteSetBuilder();
             foreach (var elem in finite)

Sources/AngouriMath/Core/Entity/Omni/Sets/SetOperators.SetSubtraction.cs

@@ -14,8 +14,8 @@ internal static partial class SetOperators
     {
         internal static Set SetSubtractSetAndFiniteSet(Set set, FiniteSet finite)
         {
-            if (set is FiniteSet another)
-                return FiniteSet.Subtract(another, finite);
+            if (set is FiniteSet another && FiniteSet.TryFullSubtract(another, finite, out var result))
+                return result;
             var fsb = new FiniteSetBuilder(finite);
             foreach (var el in finite)
                 if (set.TryContains(el, out var contains) && !contains)

Sources/AngouriMath/Functions/Continuous/Differentiation.cs

@@ -136,7 +136,7 @@ partial record Powf
             /// <inheritdoc/>
             protected override Entity InnerDifferentiate(Variable variable) =>
                 Exponent == Integer.One
-                ? Base.InnerDifferentiate(variable).WithCondition(Base.DomainCondition) // don't create x^0 which is undefined for x=0
+                ? Base.InnerDifferentiate(variable).Provided(Base.DomainCondition) // don't create x^0 which is undefined for x=0
                 : Exponent is Number exp
                 ? exp * Base.Pow(exp - 1) * Base.InnerDifferentiate(variable)
                 : Base is Number