@@ -28,6 +28,8 @@ read first.
 | **Silent** | `MathS.Abs("x").WithCodomain(Domain.Any).Stringize()`, and every node widened to `Any` from a narrower default | `abs(x)` — reads back as `Real`, losing the widening | `domain(abs(x), Any)` |
 | **Silent** | `"domain(1/2, CC)".ToEntity()`, and every quotient of two integer literals annotated with the codomain its node type does not default to | `1/2` — the annotation dropped, equal to the unannotated literal | `1/2` carrying `Codomain = Complex`, which prints and reads back as `domain(1/2, CC)` |
 | | `"a in (a / 3; 3a)".ToEntity().Simplify()`, and every denominator but 2 | `a in (a / 3; 3 * a)` — left as written | `a > 0` |
+| | `MathS.Matrix(...).Determinant` on a symbolic matrix of polynomials | `a * d + -b * c`, Laplace's nested expansion | `a * d - b * c`, expanded — the same value, no larger |
+| | the same on a numeric matrix past 10x10 | did not return | 11x11 in 2 ms, 30x30 in 22 ms |
 | | `"a in (a / 2; 0)".ToEntity().Simplify()`, and every interval demanding both signs | left as written | `False provided a in RR` |
 | | `new Entity[0].SumAll()`, and `Sumf.Sum` on an empty list | `AngouriBugException: At least 1 child required` | `0` |
 | | `new Entity[0].MultiplyAll()`, and `Mulf.Multiply` on an empty list | `AngouriBugException` | `1` |
@@ -848,6 +850,57 @@ together because the first is what makes the second free: the guard alone cost t
 that were being answered by coincidence, and the collection restores them along with the rest of the
 family ([#1056](https://github.com/asc-community/AngouriMath/issues/1056)).
 
+### The determinant is computed by fraction-free elimination where it can be
+
+`Matrix.Determinant` expanded by Laplace, which is `O(n!)`. For a fully symbolic matrix that is
+optimal — the determinant genuinely has `n!` terms, and no algorithm returns it smaller in expanded
+form. For a numeric one it is pure waste: the answer is a single number and `O(n^3)` work suffices.
+
+Bareiss' fraction-free elimination now runs wherever the entries are polynomials over the rationals,
+and Laplace answers everything else. What decides it is not the size but whether the entries can be
+read, settled per matrix by trying.
+
+**The ceiling this removes**, both arms built from source on one machine:
+
+| | before | now |
+|---|---|---|
+| numeric 8×8 | 382 ms | under 1 ms |
+| numeric 10×10 | 14 415 ms | 2 ms |
+| numeric 11×11 | did not return in four minutes | 2 ms |
+| numeric 12×12 | did not return | 3 ms |
+| numeric 20×20 | did not return | 11 ms |
+| numeric 30×30 | did not return | 22 ms |
+
+**The printed form of a symbolic determinant changes**, because an elimination produces an expanded
+polynomial where Laplace produces a nested expansion. The value is the same and the expression is no
+larger in any case measured:
+
+| | before | now |
+|---|---|---|
+| `"[[a, b], [c, d]]"` | `a * d + -b * c` | `a * d - b * c` |
+| `"[[x, 1, 0], [1, x, 1], [0, 1, x]]"` | `x * (x ^ 2 + -1) + -x` | `x ^ 3 - 2 * x` |
+| `"[[a, b, 1], [c, d, 2], [1, 2, 3]]"` | `a * (d * 3 + -4) + -b * (c * 3 + -2) + c * 2 + -d` | `3 * a * d - 4 * a - 3 * b * c + 2 * b + 2 * c - d` |
+| `"[[x, 1], [1, x]]"` | `x ^ 2 + -1` | unchanged |
+| `"[[1/2, 1/3], [1/4, 1/5]]"` | `1/60` | unchanged |
+
+**No condition is introduced, and that is the point.** An ordinary Gaussian elimination leaves its
+pivots as literal divisions, so its answer is undefined wherever a pivot vanishes — at points where
+the determinant is perfectly well defined. That was
+[#992](https://github.com/asc-community/AngouriMath/issues/992), and it is why Laplace was chosen.
+Bareiss divides as well, but each division is by the *previous* pivot and is exact: the quotient is a
+determinant of a minor, so it is back in the ring. Here it is exact **and checked** — the arithmetic
+happens in `MultivariatePolynomial`, which has no quotients to leave behind, and a division that does
+not come out returns null and sends the caller to Laplace.
+
+**What is declined**, and answered by Laplace exactly as before: an entry that is not a polynomial
+over the rationals (`sin(x)`, `1 / x`, `2 ^ x`), a matrix in more than eight indeterminates, and a
+matrix mentioning `e` or `pi` — a constant is a value rather than an indeterminate, and this ring
+cannot hold one.
+
+The two algorithms were compared on 300 generated matrices where both apply, as a difference
+simplified to zero rather than as trees, with **no disagreements**
+([#999](https://github.com/asc-community/AngouriMath/issues/999)).
+
 ### A fold over an empty sequence answers instead of throwing
 
 A fold over a monoid has an identity, so the empty sum is `0` and the empty product is `1` — which
 
@@ -51,6 +51,15 @@ file_header_template=\nCopyright (c) 2019-2026 Angouri.\nAngouriMath is licensed
 [AngouriMath/Functions/Algebra/Polynomials/KroneckerFactorization.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
 
+[AngouriMath/Functions/Algebra/Polynomials/FractionFreeDeterminant.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
+
+[AngouriMath/Functions/Algebra/Polynomials/PolynomialDeterminant.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/Algebra/Polynomials/FractionFreeDeterminantTest.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
+
 [AngouriMath/Functions/Algebra/Groebner/*.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
 
 
@@ -270,23 +270,37 @@ public Entity AsScalar()
             this);
             private LazyPropertyA<Matrix> t;
 
-            // We do not need to use Gaussian elimination here
-            // since we anyway get N! memory use.
-            // Gaussian elimination is also not merely no cheaper, it is wrong here:
-            // it leaves the pivots as literal divisions, so the expression it returns
-            // is undefined wherever a pivot vanishes -- at points where the
-            // determinant itself is perfectly well defined. The determinant of a
-            // matrix over a commutative ring is a polynomial in its entries, and
-            // Laplace expansion never divides, so there is nothing to exclude.
+            // Two algorithms, and which one runs is decided by the entries rather than by the
+            // size. Bareiss' fraction-free elimination is O(n^3) and Laplace expansion is
+            // O(n!), so Bareiss is tried first -- but it needs entries it can read as
+            // polynomials over the rationals, and it says so by declining rather than by
+            // guessing. https://github.com/asc-community/AngouriMath/issues/999
+            //
+            // *Ordinary* Gaussian elimination is not merely no cheaper than Laplace, it is
+            // wrong here: it leaves the pivots as literal divisions, so the expression it
+            // returns is undefined wherever a pivot vanishes -- at points where the
+            // determinant itself is perfectly well defined. The determinant of a matrix over a
+            // commutative ring is a polynomial in its entries, and neither Laplace nor Bareiss
+            // ever leaves a quotient, so there is nothing to exclude either way.
             // https://github.com/asc-community/AngouriMath/issues/992
             /// <summary>
-            /// Finds the symbolical determinant via Laplace's method
+            /// The determinant, by fraction-free elimination where the entries are polynomials
+            /// over the rationals and by Laplace expansion otherwise.
             /// </summary>
+            /// <remarks>
+            /// Both are exact and neither divides in a way that could exclude a point, so the
+            /// two agree wherever both apply; which one ran is a fact about cost, not about the
+            /// answer. Laplace is optimal for a fully symbolic matrix, whose determinant
+            /// genuinely has n! terms.
+            /// </remarks>
             public Entity? Determinant => determinant.GetValue(
-                static @this => 
+                static @this =>
                 {
-                    if (!@this.IsSquare) 
+                    if (!@this.IsSquare)
                         return null;
+                    if (Functions.PolynomialDeterminant.Of(@this.RowCount, (r, c) => @this[r, c])
+                        is { } byElimination)
+                        return byElimination.InnerSimplified;
                     return @this.InnerMatrix.DeterminantLaplace().InnerSimplified;
                 },
                 this
 
@@ -0,0 +1,127 @@
+//
+// 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 AngouriMath.Core.Multithreading;
+using PeterO.Numbers;
+
+namespace AngouriMath.Functions
+{
+    /// <summary>
+    /// Bareiss' fraction-free elimination: the determinant of a square matrix over an
+    /// integral domain, in <c>O(n^3)</c> ring operations and without ever leaving the ring.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Ordinary Gaussian elimination divides by the pivot, so over a ring of polynomials it
+    /// produces quotients — and an expression built from them is undefined wherever a pivot
+    /// vanishes, at points where the determinant itself is perfectly well defined. That is
+    /// what <a href="https://github.com/asc-community/AngouriMath/issues/992">#992</a> was
+    /// about, and why <see cref="Entity.Matrix.Determinant"/> used Laplace expansion rather
+    /// than elimination.
+    /// </para>
+    /// <para>
+    /// Bareiss divides too, and the divisions are the point: each entry is divided by the
+    /// <em>previous</em> pivot, and that division is <b>exact</b> — the quotient is a
+    /// determinant of a minor and therefore back in the ring. So the intermediate entries do
+    /// not swell the way Gaussian elimination's do, and nothing is ever left as a quotient to
+    /// exclude a point.
+    /// </para>
+    /// <para>
+    /// <b>Exactness is a fact about the ring, and is checked here anyway.</b>
+    /// <see cref="MultivariatePolynomial.DivideExact(MultivariatePolynomial, int)"/> returns
+    /// null rather than a remainder, so a division that does not come out — because the term
+    /// ceiling was reached, or because an assumption above is wrong — stops the elimination
+    /// instead of producing an answer that is quietly not the determinant. Every caller reads
+    /// null as "use another method", never as "there is no determinant".
+    /// </para>
+    /// <para>
+    /// Split out of <see cref="PolynomialResultant"/>, where it was written for the Sylvester
+    /// matrix. Shared rather than written twice, deliberately: a sign convention or an
+    /// off-by-one in an elimination is a wrong answer that looks entirely plausible, and one
+    /// implementation exercised by two callers is tested by both.
+    /// <a href="https://github.com/asc-community/AngouriMath/issues/999">#999</a>
+    /// </para>
+    /// </remarks>
+    internal static class FractionFreeDeterminant
+    {
+        [ConstantField] private static readonly ERational MinusOne = ERational.One.Negate();
+
+        /// <summary>
+        /// The determinant of <paramref name="matrix"/>, or <see langword="null"/> where the
+        /// elimination could not finish within <paramref name="maxWork"/> or a division came
+        /// back inexact.
+        /// </summary>
+        /// <param name="matrix">
+        /// Square, and <b>modified in place</b> — the caller owns it and must not need it
+        /// afterwards. Elimination is destructive, and copying here would hide the cost of the
+        /// one thing this exists to make cheap.
+        /// </param>
+        /// <param name="variableCount">
+        /// How many variables the entries are over, needed to build the zero and the one of the
+        /// same ring. Not derivable from the entries, since a matrix may be all constants.
+        /// </param>
+        /// <param name="maxWork">
+        /// A ceiling on term-pair multiplications, charged <em>before</em> each multiplication
+        /// rather than after, so that the budget cannot be overshot by the one step that was
+        /// going to be the most expensive of them.
+        /// </param>
+        internal static MultivariatePolynomial? Of(
+            MultivariatePolynomial[][] matrix, int variableCount, long maxWork)
+        {
+            var size = matrix.Length;
+            if (size == 0)
+                return MultivariatePolynomial.One(variableCount);
+
+            var zero = MultivariatePolynomial.Zero(variableCount);
+            var negated = false;
+            var work = 0L;
+            var previous = MultivariatePolynomial.One(variableCount);
+
+            for (var pivot = 0; pivot + 1 < size; pivot++)
+            {
+                MultithreadingFunctional.ExitIfCancelled();
+                if (matrix[pivot][pivot].IsZero)
+                {
+                    var replacement = -1;
+                    for (var row = pivot + 1; row < size && replacement < 0; row++)
+                        if (!matrix[row][pivot].IsZero)
+                            replacement = row;
+                    // Nothing below the pivot to bring up means the column is a combination
+                    // of the ones before it, so the matrix is singular and its determinant
+                    // is zero. That is an answer, not a failure.
+                    if (replacement < 0)
+                        return zero;
+                    (matrix[pivot], matrix[replacement]) = (matrix[replacement], matrix[pivot]);
+                    negated = !negated;
+                }
+                var head = matrix[pivot][pivot];
+                for (var row = pivot + 1; row < size; row++)
+                {
+                    MultithreadingFunctional.ExitIfCancelled();
+                    var leading = matrix[row][pivot];
+                    for (var column = pivot + 1; column < size; column++)
+                    {
+                        work += (long)head.TermCount * matrix[row][column].TermCount
+                            + (long)leading.TermCount * matrix[pivot][column].TermCount;
+                        if (work > maxWork)
+                            return null;
+                        if (head.Multiply(matrix[row][column]) is not { } kept
+                            || leading.Multiply(matrix[pivot][column]) is not { } removed
+                            || kept.Subtract(removed).DivideExact(previous) is not { } reduced)
+                            return null;
+                        matrix[row][column] = reduced;
+                    }
+                    matrix[row][pivot] = zero;
+                }
+                previous = head;
+            }
+
+            var determinant = matrix[size - 1][size - 1];
+            return negated ? determinant.ScaleBy(MinusOne) : determinant;
+        }
+    }
+}