@danielsimonjr/mathts-functions 0.58.0 → 0.60.0

package/dist/typed/algebra.d.ts

@@ -227,12 +227,20 @@ export declare function expand(expr: string): string;
  * `factor('x^4+3*x^2+2')` → `'(x^2 + 1)*(x^2 + 2)'`. Polynomials irreducible
  * over ℚ (`x^4 + 1`, `x^2 + x + 1`) are returned unchanged.
  *
- * **Multivariate polynomials** get the tractable subset (see
- * {@link factorMultivariate}): integer-content + common-monomial extraction
- * and monomial difference-of-squares — `x^2*y + x*y^2 → 'x*y*(x + y)'`,
- * `4*x^2 - 9*y^2 → '(2*x - 3*y)*(2*x + 3*y)'`. Full multivariate factorization
- * into irreducible factors (Wang/Zassenhaus/EEZ) is OUT OF SCOPE and returns
- * the partially-factored or unchanged expression rather than a wrong answer.
+ * **Multivariate polynomials** (`n ≥ 2` variables, integer coefficients) are
+ * factored **completely over ℤ/ℚ** into irreducible factors. A fast path (see
+ * {@link factorMultivariate}) handles the common cases byte-for-byte — integer
+ * content, common-monomial extraction, monomial difference-of-squares
+ * (`x^2*y + x*y^2 → 'x*y*(1*y + 1*x)'`, `4*x^2 - 9*y^2 → '(2*x - 3*y)*(2*x + 3*y)'`).
+ * Anything the fast path leaves whole or only partially factored is routed
+ * through the Kronecker-substitution engine ({@link factorMultivariateString}),
+ * which reduces to the univariate ℤ engine and recombines by exact division
+ * (`x^2 + 3*x*y + 4*x + 2*y^2 + 5*y + 3 → (1*x + 1*y + 1)*(1*x + 2*y + 3)`). The
+ * engine declines (and the caller keeps the fast-path/legacy output) beyond a
+ * substituted-degree cap; irreducible multivariate polynomials (`x^2 + y^2`) are
+ * returned unchanged. Wang/EEZ is a future performance upgrade, not a
+ * capability gap. Because the engine confirms every factor by division, it never
+ * emits a wrong factorization.
  *
  * Everything else (no rational root, no common factor) falls back to the
  * original common-integer-factor extraction below.

package/dist/typed/algebra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algebra.d.ts","sourceRoot":"","sources":["../../src/typed/algebra.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAsBH,KAAK,GAAG,GAAG,MAAM,CAAC;AAkJlB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,GAAG,GAAG,GAAG,CAOrD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAO1D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAgB1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,GAAE,MAAU,GAAG,MAAM,EAAE,CAUjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAgBhE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAShE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAGrE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAGtE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAI/C;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAE1D;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAqClD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,GAAE,MAAU,GAAG,MAAM,EAAE,CAclE;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAUhD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAU7E;AA4ND;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA+C3C;AAgGD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkF3C;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CA2D9D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAyF3C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqC7C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA+D1C;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO/C;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQ/C;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAS9C;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK9C;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAMzE;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAc3C;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKlD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO/C;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQhD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAwBjD;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAKrD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CA6BtE;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAmEhF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOnD;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,GAAG,CAgCvD;AAMD;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CxB,CAAC"}
+{"version":3,"file":"algebra.d.ts","sourceRoot":"","sources":["../../src/typed/algebra.ts"],"names":[],"mappings":"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"}

package/dist/typed/factorization/index.d.ts

@@ -44,4 +44,29 @@ export declare function renderFactor(poly: IntPoly, v: string): string;
  * order.
  */
 export declare function factorPolynomialUnivariate(expr: string, v: string): string | null;
+/**
+ * Factor a MULTIVARIATE (`n ≥ 2` variable) integer polynomial given as an
+ * expression string, completely over ℤ/ℚ via the Kronecker-substitution engine
+ * ({@link factorMultivariateKronecker}), rendered to a string matching
+ * `factor()`'s multivariate conventions.
+ *
+ * Returns `null` when the input is not an integer multivariate polynomial in
+ * `vars` (parse failure, non-integer coefficients, single variable, constant,
+ * or the degree cap is exceeded — the engine declines) OR when the
+ * factorization is not worth substituting for the caller's current output.
+ *
+ * The "worth it" threshold is `minFactors` (default 2): a result is returned
+ * only when it has at least `minFactors` irreducible POLYNOMIAL factors.
+ *   - Default (the caller's fast path already declined): require ≥ 2 factors —
+ *     a genuine multi-factor factorization. A single polynomial factor (an
+ *     irreducible, or a bare integer-content extraction like `2·(3x + 2y)`) is
+ *     declined so the caller's legacy content-extraction path keeps its exact
+ *     byte output; the Kronecker rendering's monomial order differs and must not
+ *     override that contract.
+ *   - Provided (the caller's fast path produced a partial factorization with
+ *     `minFactors − 1` irreducible factors): return a result ONLY if it has at
+ *     least `minFactors` factors, i.e. the engine strictly refined a reducible
+ *     cofactor the fast path left whole.
+ */
+export declare function factorMultivariateString(expr: string, vars: string[], minFactors?: number): string | null;
 //# sourceMappingURL=index.d.ts.map

package/dist/typed/factorization/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/typed/factorization/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAU,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAsBzD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAoBvE;AA8CD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA0BjF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/typed/factorization/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAU,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAwBzD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAoBvE;AA8CD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA0BjF;AAmBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EAAE,EACd,UAAU,SAAI,GACb,MAAM,GAAG,IAAI,CAQf"}

package/dist/typed/factorization/kronecker-factor.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Multivariate factorization over ℤ via Kronecker substitution (Layer 2 v1).
+ *
+ * The orchestration ties three shipped pieces together:
+ *   1. Kronecker substitution (`kronecker.ts`) collapses an `n ≥ 2` variable
+ *      integer polynomial to a single univariate image whose monomials are in
+ *      bijection with the original's (mixed-radix place values).
+ *   2. The univariate Zassenhaus engine (`zassenhaus.ts`) factors that image
+ *      into irreducibles over ℤ.
+ *   3. Subset recombination lifts each univariate irreducible (or product of
+ *      several) back to a multivariate candidate and confirms it by EXACT
+ *      multivariate division (`multiExactDivide`) — division is the sole
+ *      arbiter, so no unverified factor is ever emitted.
+ *
+ * Correctness follows because (a) every true multivariate factor's image is a
+ * subset of the univariate factors, so recombination is complete up to the
+ * caps, and (b) division confirms each candidate, so recombination is sound.
+ *
+ * Two caps bound the work (each logs, never returns a silently wrong answer):
+ *   - `KRONECKER_MAX_DEGREE` on the substituted univariate degree
+ *     (`∏(degᵢ+1) − 1`), the Kronecker analogue of Layer 1's factor-count cap.
+ *   - `MAX_MODULAR_FACTORS` on the univariate factor-pool size, matching
+ *     Layer 1's recombination cap.
+ *
+ * `bigint`-only, matching the rest of the factorization engine.
+ */
+import { type MultiPoly } from './multi-poly.js';
+/** Complete multivariate factorization: `p = constant · ∏ factorsᵢ^multᵢ`. */
+export type MultiFactorization = {
+    constant: bigint;
+    factors: Array<{
+        poly: MultiPoly;
+        mult: number;
+    }>;
+};
+/**
+ * Factors a multivariate (`n ≥ 2` variables) integer polynomial completely
+ * over ℤ into irreducible factors with multiplicity, via Kronecker
+ * substitution onto the Layer 1 univariate engine.
+ *
+ * Returns `null` (declines) when it cannot help — a single variable, the zero
+ * or a constant polynomial, or the substituted degree exceeding the cap — so
+ * the caller keeps its existing behavior. On success the constant carries the
+ * signed integer content and every factor has a positive leading term under
+ * the canonical (degree-lex) monomial order.
+ */
+export declare function factorMultivariateKronecker(p: MultiPoly): MultiFactorization | null;
+//# sourceMappingURL=kronecker-factor.d.ts.map

package/dist/typed/factorization/kronecker-factor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kronecker-factor.d.ts","sourceRoot":"","sources":["../../../src/typed/factorization/kronecker-factor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAUL,KAAK,SAAS,EACf,MAAM,iBAAiB,CAAC;AAKzB,8EAA8E;AAC9E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACnD,CAAC;AA4GF;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,SAAS,GAAG,kBAAkB,GAAG,IAAI,CA0HnF"}

package/dist/typed/factorization/kronecker.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Kronecker substitution: reduces a multivariate integer polynomial to a
+ * univariate one so it can be factored by the Layer 1 univariate engine
+ * (`zassenhaus.ts`), then inverts the map to recover multivariate
+ * candidates.
+ *
+ * The substitution maps `x_k ↦ x^{bases[k]}`, where `bases[0] = 1` and
+ * `bases[k] = ∏_{i<k} (degreeIn(p, i) + 1)`. Every monomial
+ * `∏_i x_i^{e_i}` then lands at the distinct univariate degree
+ * `Σ_i e_i · bases[i]` — distinct because the bases form the place values of
+ * a mixed-radix numeral system with radix `degreeIn(p, i) + 1` at position
+ * `i`, so no two exponent vectors bounded by the original per-variable
+ * degrees can collide. This is what makes the map invertible via
+ * {@link backSubstitute}.
+ *
+ * `bigint`-only per the Layer 2 factorization engine's constraints; the
+ * univariate degree used as an array index is a `Number`, guarded against
+ * exceeding `Number.MAX_SAFE_INTEGER` before conversion.
+ */
+import { type MultiPoly } from './multi-poly.js';
+import { type IntPoly } from './integer-poly.js';
+/**
+ * One substitution base per variable of `p`: `bases[0] = 1`,
+ * `bases[k] = ∏_{i<k} (degreeIn(p, i) + 1)`.
+ */
+export declare function substitutionBases(p: MultiPoly): bigint[];
+/**
+ * The univariate degree that the substitution `x_k ↦ x^{bases[k]}` sends
+ * `p`'s highest-degree corner monomial to: `Σ_i degreeIn(p, i) · bases[i]`.
+ * Callers use this (as a `bigint`) to enforce a degree cap BEFORE calling
+ * {@link substitute}, which throws if this bound exceeds
+ * `Number.MAX_SAFE_INTEGER`.
+ */
+export declare function substitutedDegree(p: MultiPoly, bases: bigint[]): bigint;
+/**
+ * Applies the Kronecker substitution `x_k ↦ x^{bases[k]}` to `p`, producing
+ * the univariate image as a dense `IntPoly`. Each term's coefficient is
+ * placed at univariate degree `Σ_i e_i · bases[i]` (summed with any other
+ * term landing at the same degree, though the mixed-radix construction of
+ * `bases` guarantees that never happens for exponents within `p`'s own
+ * degrees).
+ *
+ * Throws `RangeError` if the maximum possible substituted degree exceeds
+ * `Number.MAX_SAFE_INTEGER` (the array index cannot represent it exactly).
+ * Callers should apply the `KRONECKER_MAX_DEGREE` cap via
+ * {@link substitutedDegree} before calling this, so this throw is a defensive
+ * backstop, not the primary cap enforcement.
+ */
+export declare function substitute(p: MultiPoly, bases: bigint[]): IntPoly;
+/**
+ * Inverts {@link substitute}: recovers the `MultiPoly` whose Kronecker image
+ * is `u`, given the same `bases` and the ORIGINAL polynomial's per-variable
+ * degree bounds `degBounds`.
+ *
+ * Each nonzero univariate coefficient at degree `e` is decomposed by
+ * mixed-radix division — radix `degBounds[i] + 1` at position `i` — into an
+ * exponent vector. If `e` doesn't fit within the mixed-radix system sized by
+ * `degBounds` (a nonzero remainder after the top digit), the decomposition is
+ * an out-of-range carry: `e` cannot correspond to a genuine exponent vector
+ * bounded by `degBounds`, so this returns `null` rather than a bogus
+ * `MultiPoly`. This is the guard that rejects spurious univariate factors
+ * during Kronecker recombination.
+ */
+export declare function backSubstitute(u: IntPoly, bases: bigint[], degBounds: number[], vars: string[]): MultiPoly | null;
+//# sourceMappingURL=kronecker.d.ts.map

package/dist/typed/factorization/kronecker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kronecker.d.ts","sourceRoot":"","sources":["../../../src/typed/factorization/kronecker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAA8B,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC7E,OAAO,EAAQ,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,EAAE,CAWxD;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAQvE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAmBjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,OAAO,EACV,KAAK,EAAE,MAAM,EAAE,EACf,SAAS,EAAE,MAAM,EAAE,EACnB,IAAI,EAAE,MAAM,EAAE,GACb,SAAS,GAAG,IAAI,CAsBlB"}

package/dist/typed/factorization/multi-poly.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Sparse multivariate polynomial arithmetic over ℤ, backed by a
+ * `Map<string, bigint>` keyed by an encoded exponent vector.
+ *
+ * Convention: a `MultiPoly` fixes an ordered variable list `vars`; every
+ * exponent vector has `vars.length` entries, one per variable in that order.
+ * `terms` maps `key(exponents)` to the (always nonzero) coefficient — zero
+ * coefficients are pruned on every construction/operation, so the zero
+ * polynomial is represented by an empty map.
+ *
+ * This module is part of the multivariate factorization engine
+ * (`functions/src/typed/factorization/`, Layer 2) and is `bigint`-only by
+ * design, matching the univariate engine in `integer-poly.ts`.
+ */
+/** Sparse multivariate polynomial over ℤ. */
+export interface MultiPoly {
+    /** Ordered variable names; every exponent vector has this length. */
+    vars: string[];
+    /** Exponent-vector key -> nonzero coefficient. */
+    terms: Map<string, bigint>;
+}
+/** Encodes an exponent vector as a stable map key (comma-joined). */
+export declare function key(exps: number[]): string;
+/** Decodes a `key()`-encoded exponent vector back into numbers. */
+export declare function unkey(k: string): number[];
+/** The zero polynomial over `vars`. */
+export declare function zeroPoly(vars: string[]): MultiPoly;
+/** The constant polynomial `c` over `vars` (zero exponents throughout). */
+export declare function constPoly(vars: string[], c: bigint): MultiPoly;
+/**
+ * Builds a `MultiPoly` over `vars` from `(exponents, coefficient)` entries.
+ * Entries sharing an exponent vector are summed; zero coefficients (after
+ * summing) are pruned.
+ */
+export declare function fromTerms(vars: string[], entries: Array<[number[], bigint]>): MultiPoly;
+/** The degree of `p` in the variable at `varIndex` (max exponent across terms; -1 if zero). */
+export declare function degreeIn(p: MultiPoly, varIndex: number): number;
+/** The total degree of `p` (max sum of exponents across terms; -1 if zero). */
+export declare function totalDegree(p: MultiPoly): number;
+/** True iff `p` has no nonzero terms. */
+export declare function isZero(p: MultiPoly): boolean;
+/** Structural equality: same `vars` (in order) and the same term map. */
+export declare function equals(a: MultiPoly, b: MultiPoly): boolean;
+/** `a + b` (both over the same `vars`). */
+export declare function addMP(a: MultiPoly, b: MultiPoly): MultiPoly;
+/** `a - b` (both over the same `vars`). */
+export declare function subMP(a: MultiPoly, b: MultiPoly): MultiPoly;
+/** `a * b` (both over the same `vars`), via distributed convolution. */
+export declare function mulMP(a: MultiPoly, b: MultiPoly): MultiPoly;
+/** `p * k` for a scalar `k: bigint`. */
+export declare function scalarMulMP(p: MultiPoly, k: bigint): MultiPoly;
+/** `-p`. */
+export declare function negMP(p: MultiPoly): MultiPoly;
+/**
+ * Total monomial order used for canonicalizing multivariate polynomials:
+ * degree-lex — higher total degree first, then lexicographic comparison of
+ * the exponent vector (earlier variables weighted higher). Returns a
+ * negative number if `expsA` sorts before `expsB` (i.e. `expsA` is the
+ * "larger"/leading monomial), positive if after, 0 if equal.
+ */
+export declare function canonicalCompare(expsA: number[], expsB: number[]): number;
+/**
+ * The leading term of `p` under `canonicalCompare`: the term whose exponent
+ * vector sorts first. Returns `null` for the zero polynomial.
+ */
+export declare function leadingTerm(p: MultiPoly): {
+    exps: number[];
+    coeff: bigint;
+} | null;
+/** Non-negative gcd of all coefficients of `p` (0 for the zero polynomial). */
+export declare function integerContentMP(p: MultiPoly): bigint;
+/**
+ * Primitive part of `p`: divide out `integerContentMP(p)`, then flip sign
+ * so the leading term (under `canonicalCompare`) has a positive
+ * coefficient. The zero polynomial maps to itself.
+ */
+export declare function primitivePartMP(p: MultiPoly): MultiPoly;
+/**
+ * Multivariate polynomial long division: returns the quotient `a / b` iff
+ * `b` divides `a` **exactly** over ℤ, else `null`.
+ *
+ * Repeatedly takes the `canonicalCompare`-leading term of the current
+ * remainder and attempts to cancel it against `b`'s leading term: the
+ * exponent vector must dominate `b`'s leading exponents component-wise, and
+ * the coefficient must divide `b`'s leading coefficient exactly in ℤ (bigint
+ * `%` gives an exact `0` remainder regardless of operand signs). Any failure
+ * of either condition means the division is not exact — this function is the
+ * recombination correctness arbiter and must never round or approximate.
+ */
+export declare function multiExactDivide(a: MultiPoly, b: MultiPoly): MultiPoly | null;
+/**
+ * Parses `expr` over `vars` via algebra's exact `polyFromExpression`, then
+ * lifts it to a bigint-backed {@link MultiPoly} — but only if EVERY
+ * coefficient is an exact integer. Returns `null` on any non-integer
+ * coefficient or if parsing throws (unknown symbol, non-integer exponent,
+ * non-constant divisor, etc.).
+ */
+export declare function fromAlgebraExpr(expr: string, vars: string[]): MultiPoly | null;
+/**
+ * Renders `p` back to an expression string in the SAME format as
+ * `polynomial-ideal.polyToString` (term order, `*`/`^` spacing, `+ -`
+ * collapsing, `1*x` unit-coefficient style) — but rendered directly from
+ * `bigint` coefficients so values above 2^53 stay exact. Routing through
+ * `polyToString` would require `Number(v)`, which silently rounds.
+ */
+export declare function toAlgebraString(p: MultiPoly): string;
+//# sourceMappingURL=multi-poly.d.ts.map

package/dist/typed/factorization/multi-poly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-poly.d.ts","sourceRoot":"","sources":["../../../src/typed/factorization/multi-poly.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,6CAA6C;AAC7C,MAAM,WAAW,SAAS;IACxB,qEAAqE;IACrE,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,kDAAkD;IAClD,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5B;AAED,qEAAqE;AACrE,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAE1C;AAED,mEAAmE;AACnE,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAKzC;AAED,uCAAuC;AACvC,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAS,CAElD;AAED,2EAA2E;AAC3E,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAM9D;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAgBvF;AAED,+FAA+F;AAC/F,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAS/D;AAED,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,CAUhD;AAED,yCAAyC;AACzC,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAE5C;AAED,yEAAyE;AACzE,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,OAAO,CAU1D;AAED,2CAA2C;AAC3C,wBAAgB,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS,CAW3D;AAED,2CAA2C;AAC3C,wBAAgB,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS,CAE3D;AAED,wEAAwE;AACxE,wBAAgB,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS,CAqB3D;AAED,wCAAwC;AACxC,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAQ9D;AAED,YAAY;AACZ,wBAAgB,KAAK,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,CAM7C;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAYzE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,GAAG;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CASlF;AAED,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,CAMrD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,CAevD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI,CA+B7E;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,IAAI,CAmB9E;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,CAcpD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.58.0",
+  "version": "0.60.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",