Drop the implicit List<Entity> conversion that made three params overloads uncallable

Entity had implicit conversions to itself from both Entity[] and List<Entity>, each
building a FiniteSet. The List one meant a list also converted to a single Entity,
so for any member with both an IEnumerable<Entity> overload and a params Entity[]
overload the params form became applicable in its expanded form, neither candidate
was better, and the call did not compile:

    var equations = new List<Entity> { "x - 1", "y - 2" };
    new EquationSystem(equations);   // error CS0121
    new FiniteSet(equations);        // error CS0121
    MathS.Equations(equations);      // error CS0121

Not three defects -- one conversion breaking every params Entity[] overload in the
library, including any added later. A sweep of all 2602 members in PublicApi.txt for
the IEnumerable<T>/T[] overload pattern found exactly these three, and each was
confirmed by compiling the call in isolation. The array, IEnumerable<Entity> and
variadic forms always compiled; only a concrete List<Entity> broke, which is how it
reached a 2.0 preview unnoticed.

The Entity[] conversion is kept. An array binds to the params overload in its normal
form by an identity conversion, which wins outright, so it never had the ambiguity.

The new test compiling is the regression guard: restore the conversion and the test
project stops building. Sources/.editorconfig gets a per-file header section for it,
since Tests/UnitTests/Common still carries the 2022 template.

Verified: 6055 C# tests and 130 F# tests pass, the library, F# wrapper and Utils
build clean, and all ten call shapes in the ambiguity matrix now compile.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: Rafael-SOWNet

BREAKING-CHANGES.md

@@ -57,6 +57,7 @@ read first.
 | loud | `MathS.Quantum.IsNormalised` | the British spelling | `MathS.Quantum.IsNormalized` |
 | loud | the target frameworks | `net7.0;netstandard2.0` | `netstandard2.0;net8.0;net10.0` |
 | **silent** | `abs(x) = c` for a negative `c` | a set of non-solutions | the empty set |
+| loud | implicit `List<Entity>` to `Entity` | made a `FiniteSet`, and made three `params` overloads uncallable | removed |
 
 ---
 
@@ -99,6 +100,51 @@ the built assemblies: present in `net8.0` and `net10.0`, absent from `netstandar
 
 ## Types and members
 
+### The implicit conversion from `List<Entity>` is removed
+
+`Entity` had two implicit conversions from a collection, both building a `FiniteSet`:
+
+```csharp
+public static implicit operator Entity(Entity[] elements);
+public static implicit operator Entity(List<Entity> elements);   // removed
+```
+
+The second one made three public members impossible to call with a `List<Entity>`:
+
+```csharp
+var equations = new List<Entity> { "x - 1", "y - 2" };
+new EquationSystem(equations);        // error CS0121: the call is ambiguous
+new FiniteSet(equations);             // error CS0121
+MathS.Equations(equations);           // error CS0121
+```
+
+Each of those has both an `IEnumerable<Entity>` overload and a `params Entity[]` overload. With
+the conversion in place a `List<Entity>` also converts to a single `Entity`, so the `params`
+overload becomes applicable in its expanded form, neither candidate is better than the other,
+and the call does not compile. The array, `IEnumerable<Entity>`, and variadic forms were always
+fine — only a concrete `List<Entity>` broke, which is why it survived to a 2.0 preview.
+
+This was not three separate defects. One conversion made *every* `params Entity[]` overload in
+the library uncallable with a list, including any added later.
+
+**What breaks.** Assigning a list where an `Entity` is expected:
+
+```csharp
+Entity set = new List<Entity> { 1, 2, 3 };   // no longer compiles
+```
+
+Write one of these instead:
+
+```csharp
+Entity set = new FiniteSet(new List<Entity> { 1, 2, 3 });
+Entity set = new List<Entity> { 1, 2, 3 }.ToSet();
+Entity set = new Entity[] { 1, 2, 3 };       // the array conversion is unchanged
+```
+
+The `Entity[]` conversion is kept: an array argument binds to the `params` overload in its normal
+form by an identity conversion, which beats the alternatives outright, so it never produced the
+ambiguity.
+
 ### `Minusf`'s two operands exchanged names
 
 In `a - b`, `a` is the minuend and `b` is the subtrahend. The record declared them the other way

Sources/.editorconfig

@@ -24,6 +24,9 @@ file_header_template=\nCopyright (c) 2019-2026 Angouri.\nAngouriMath is licensed
 [Tests/UnitTests/Core/Transformations/*.cs]
 file_header_template=\nCopyright (c) 2019-2026 Angouri.\nAngouriMath is licensed under MIT.\nDetails: https://github.com/asc-community/AngouriMath/blob/master/LICENSE.md.\nWebsite: https://am.angouri.org.\n
 
+[Tests/UnitTests/Common/ListArgumentOverloadTest.cs]
+file_header_template=\nCopyright (c) 2019-2026 Angouri.\nAngouriMath is licensed under MIT.\nDetails: https://github.com/asc-community/AngouriMath/blob/master/LICENSE.md.\nWebsite: https://am.angouri.org.\n
+
 # A new file in a directory whose other files predate it, so the section is on the file
 # rather than the folder.
 [AngouriMath/Core/Entity/Continuous/Entity.Continuous.{Floors,Rounding}.Classes.cs]

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

@@ -83,7 +83,6 @@ public bool Contains(Entity entity)
         public static implicit operator Entity(Domain domain) => Set.SpecialSet.Create(domain);
         public static implicit operator Entity((Entity left, Entity right) interval) => new Interval(interval.left, true, interval.right, true);
         public static implicit operator Entity(Entity[] elements) => new FiniteSet(elements);
-        public static implicit operator Entity(List<Entity> elements) => new FiniteSet((IEnumerable<Entity>)elements);
 #pragma warning restore CS1591
 
     }

Sources/Tests/UnitTests/Common/ListArgumentOverloadTest.cs

@@ -0,0 +1,72 @@
+//
+// 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.Collections.Generic;
+using AngouriMath;
+using AngouriMath.Core;
+using Xunit;
+
+namespace AngouriMath.Tests.Common
+{
+    /// <summary>
+    /// Every member here takes both an <see cref="IEnumerable{T}"/> and a <c>params Entity[]</c>.
+    /// While <c>Entity</c> also had an implicit conversion from <c>List&lt;Entity&gt;</c>, a list
+    /// argument matched the params overload in its expanded form as well, neither candidate was
+    /// better than the other, and none of these calls compiled -- CS0121. The conversion is gone;
+    /// this file failing to compile is what says it has not come back.
+    /// </summary>
+    [Trait("Area", "Common")]
+    public sealed class ListArgumentOverloadTest
+    {
+        static List<Entity> Equations => new() { "x - 1", "y - 2" };
+
+        [Fact]
+        public void EquationSystemTakesAList()
+        {
+            var solutions = new EquationSystem(Equations).Solve("x", "y");
+            Assert.NotNull(solutions);
+            Assert.Equal(1, solutions.RowCount);
+            Assert.Equal(2, solutions.ColumnCount);
+        }
+
+        [Fact]
+        public void MathSEquationsTakesAList()
+        {
+            var solutions = MathS.Equations(Equations).Solve("x", "y");
+            Assert.NotNull(solutions);
+            Assert.Equal(1, solutions.RowCount);
+        }
+
+        [Fact]
+        public void FiniteSetTakesAList()
+        {
+            var set = new Entity.Set.FiniteSet(new List<Entity> { 1, 2, 3 });
+            Assert.Equal(3, set.Count);
+        }
+
+        /// <summary>The array and variadic forms were never ambiguous, and must stay that way.</summary>
+        [Fact]
+        public void ArrayAndVariadicFormsStillBind()
+        {
+            Entity[] equations = { "x - 1", "y - 2" };
+            Assert.NotNull(new EquationSystem(equations).Solve("x", "y"));
+            Assert.NotNull(new EquationSystem("x - 1", "y - 2").Solve("x", "y"));
+            Assert.Equal(3, new Entity.Set.FiniteSet(1, 2, 3).Count);
+        }
+
+        /// <summary>
+        /// The conversion from an array is deliberately kept, so an array in an
+        /// <c>Entity</c> position is still a set.
+        /// </summary>
+        [Fact]
+        public void ArrayStillConvertsToASet()
+        {
+            Entity set = new Entity[] { 1, 2, 3 };
+            Assert.Equal(new Entity.Set.FiniteSet(1, 2, 3), set);
+        }
+    }
+}

Sources/Tests/UnitTests/Common/PublicApi.txt

@@ -2132,7 +2132,6 @@ AngouriMath.Entity.op_Implicit(PeterO.Numbers.EInteger) : AngouriMath.Entity
 AngouriMath.Entity.op_Implicit(PeterO.Numbers.ERational) : AngouriMath.Entity
 AngouriMath.Entity.op_Implicit(System.Boolean) : AngouriMath.Entity
 AngouriMath.Entity.op_Implicit(System.Byte) : AngouriMath.Entity
-AngouriMath.Entity.op_Implicit(System.Collections.Generic.List<AngouriMath.Entity>) : AngouriMath.Entity
 AngouriMath.Entity.op_Implicit(System.Decimal) : AngouriMath.Entity
 AngouriMath.Entity.op_Implicit(System.Double) : AngouriMath.Entity
 AngouriMath.Entity.op_Implicit(System.Int16) : AngouriMath.Entity