@danielsimonjr/mathts-functions 0.57.0 → 0.59.0

package/dist/typed/algebra.d.ts

@@ -218,18 +218,29 @@ export declare function expand(expr: string): string;
  * Factor an expression string.
  *
  * **Univariate polynomials** (a single variable, integer coefficients,
- * degree ≥ 2) are factored over ℚ via the rational-root theorem: candidate
- * roots ±(divisors of the constant term)/(divisors of the leading
- * coefficient) are tested, each confirmed root's linear factor is divided
- * out exactly, and any irreducible remainder is left as-is:
- * `factor('x^2-1')` → `'(x - 1)*(x + 1)'`.
- *
- * **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.
+ * degree ≥ 2) are factored **completely over ℤ/ℚ** into irreducible factors
+ * with multiplicity. Rational linear roots are extracted first (rational-root
+ * theorem); any higher-degree remainder — and any polynomial with no rational
+ * root — is routed through the Zassenhaus engine
+ * ({@link factorPolynomialUnivariate}): `factor('x^2-1')` → `'(x - 1)*(x + 1)'`,
+ * `factor('x^4-1')` → `'(x - 1)*(x + 1)*(x^2 + 1)'`,
+ * `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** (`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":"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"}
+{"version":3,"file":"algebra.d.ts","sourceRoot":"","sources":["../../src/typed/algebra.ts"],"names":[],"mappings":"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"}

package/dist/typed/factorization/finite-field.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Dense univariate polynomial arithmetic over the finite field 𝔽_p, backed
+ * by the same `bigint[]` representation as `integer-poly.ts` (index =
+ * degree). Every coefficient produced by an operation in this module is
+ * kept reduced into the canonical range `[0, p)` and trimmed so the
+ * highest-degree entry (if any) is nonzero.
+ *
+ * This module is part of the univariate factorization engine
+ * (`functions/src/typed/factorization/`) and is `bigint`-only by design.
+ */
+import { type IntPoly } from './integer-poly.js';
+export type { IntPoly } from './integer-poly.js';
+/**
+ * Reduces every coefficient of `a` into `[0, p)`, then trims trailing
+ * (highest-degree) zero coefficients. Does not mutate the input.
+ */
+export declare function reduceModP(a: IntPoly, p: bigint): IntPoly;
+/** `a + b` over 𝔽_p, coefficients reduced into `[0, p)`. */
+export declare function addP(a: IntPoly, b: IntPoly, p: bigint): IntPoly;
+/** `a - b` over 𝔽_p, coefficients reduced into `[0, p)`. */
+export declare function subP(a: IntPoly, b: IntPoly, p: bigint): IntPoly;
+/** `a * b` over 𝔽_p via schoolbook convolution, coefficients in `[0, p)`. */
+export declare function mulP(a: IntPoly, b: IntPoly, p: bigint): IntPoly;
+/**
+ * Modular inverse of a scalar `a` modulo prime `p`, via the extended
+ * Euclidean algorithm. Returns a value in `[1, p)`. Throws if `a ≡ 0 (mod p)`
+ * (no inverse exists).
+ */
+export declare function invModP(a: bigint, p: bigint): bigint;
+/**
+ * Scales `a` so its leading coefficient becomes 1 (multiplies by
+ * `invModP(lc(a), p)`). Returns `[]` unchanged for the zero polynomial.
+ */
+export declare function makeMonicP(a: IntPoly, p: bigint): IntPoly;
+/**
+ * Polynomial division over 𝔽_p: `a = q*b + r` with `deg(r) < deg(b)`.
+ * `b` must be nonzero. Coefficients of `q` and `r` are reduced into `[0, p)`.
+ */
+export declare function divmodP(a: IntPoly, b: IntPoly, p: bigint): {
+    q: IntPoly;
+    r: IntPoly;
+};
+/**
+ * Monic gcd of `a` and `b` over 𝔽_p via the Euclidean algorithm. Returns
+ * `[]` (zero polynomial) only when both inputs are zero; otherwise the
+ * result is monic (leading coefficient 1).
+ */
+export declare function gcdP(a: IntPoly, b: IntPoly, p: bigint): IntPoly;
+/**
+ * `base^e mod (mod, p)`: modular exponentiation of `base` by non-negative
+ * bigint `e`, reducing modulo the polynomial `mod` (via `divmodP`) and
+ * modulo `p` at each step, using square-and-multiply. `e` must be >= 0.
+ */
+export declare function powModPolyP(base: IntPoly, e: bigint, mod: IntPoly, p: bigint): IntPoly;
+/**
+ * Distinct-degree factorization of a monic, square-free polynomial `f` over
+ * 𝔽_p. Returns the distinct-degree decomposition: each entry's `prod` is the
+ * product of ALL monic irreducible factors of `f` that have degree exactly
+ * `deg`. Uses the standard algorithm built on `x^(p^i) mod f` computed via
+ * `powModPolyP`, peeling off `gcd(v, x^(p^i) - x)` at each step and shrinking
+ * the working polynomial `v` as factors are removed.
+ *
+ * Precondition: `f` is monic and square-free over 𝔽_p. The empty array is
+ * returned for a constant (degree ≤ 0) input.
+ */
+export declare function distinctDegreeFactor(f: IntPoly, p: bigint): Array<{
+    deg: number;
+    prod: IntPoly;
+}>;
+/**
+ * Equal-degree factorization (Cantor–Zassenhaus): given a monic, square-free
+ * `f` that is a product of degree-`d` irreducibles over 𝔽_p, returns those
+ * monic irreducible factors. The candidate polynomials are enumerated
+ * deterministically (see `trialPolys`), so the factorization is reproducible.
+ */
+export declare function equalDegreeFactor(f: IntPoly, d: number, p: bigint): IntPoly[];
+/**
+ * Full factorization of a square-free monic polynomial `f` over 𝔽_p into its
+ * monic irreducible factors: distinct-degree decomposition followed by
+ * Cantor–Zassenhaus equal-degree splitting of each degree class. Constant
+ * (degree ≤ 0) inputs yield the empty array; a linear input yields itself.
+ */
+export declare function factorModP(f: IntPoly, p: bigint): IntPoly[];
+//# sourceMappingURL=finite-field.d.ts.map

package/dist/typed/factorization/finite-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finite-field.d.ts","sourceRoot":"","sources":["../../../src/typed/factorization/finite-field.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAA4B,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE3E,YAAY,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAQjD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,6DAA6D;AAC7D,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAS/D;AAED,6DAA6D;AAC7D,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAS/D;AAED,8EAA8E;AAC9E,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAe/D;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAiBpD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAOzD;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,OAAO,CAAC;IAAC,CAAC,EAAE,OAAO,CAAA;CAAE,CAqBrF;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAe/D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAetF;AAKD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,CAyBjG;AAyED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,EAAE,CAI7E;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,EAAE,CAoB3D"}

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

@@ -0,0 +1,38 @@
+/**
+ * Multifactor Hensel lifting for the univariate factorization engine
+ * (`functions/src/typed/factorization/`).
+ *
+ * Given a MONIC integer polynomial `f` and its MONIC irreducible factors over
+ * 𝔽_p (whose product is ≡ f mod p), lift that factorization to a factorization
+ * modulo `p^k` whose product is ≡ f (mod p^k), with each lifted factor still
+ * ≡ its input factor (mod p). The target modulus `p^k` is chosen by the caller
+ * so that `p^k ≥ 2·landauMignotte(f)+1`, i.e. large enough that the true
+ * integer factors of `f` are uniquely recovered by symmetric reduction.
+ *
+ * Strategy: LINEAR (iterated) two-factor Hensel lifting from `p^i` to `p^{i+1}`
+ * up to `p^k`, combined with a recursive FACTOR TREE for more than two factors.
+ * Bézout cofactors `s, t` with `s·g + t·h ≡ 1 (mod p)` are computed once per
+ * two-factor split via the extended Euclidean algorithm over 𝔽_p; because the
+ * per-step diophantine correction is solved only mod p, the fixed mod-p
+ * cofactors remain valid at every lifting step (the standard property of linear
+ * Hensel lifting — see Geddes/Czapor/Labahn §6.4 or von zur Gathen & Gerhard
+ * §15). All factors are monic and `f` is monic, so the lifted factors stay
+ * monic and no leading-coefficient imposition is required.
+ *
+ * `bigint`-only by design: float64 loses correctness once `p^k > 2^53`.
+ */
+import { type IntPoly } from './integer-poly.js';
+/**
+ * Multifactor Hensel lift. Lifts the mod-`p` factorization `factorsModP` of the
+ * monic integer polynomial `f` (with `∏ factorsModP ≡ f mod p`) to monic
+ * integer factors whose product is `≡ f (mod targetPk)` and each of which is
+ * `≡ its input factor (mod p)`. Coefficients are returned in the symmetric
+ * range modulo `targetPk = p^k` (via `modSymmetric`).
+ *
+ * More than two factors are handled by a recursive factor tree: `factorsModP`
+ * is split into two halves, the two half-products are lifted together by
+ * `henselLiftTwo`, and each lifted half is recursively split into its own
+ * factors.
+ */
+export declare function henselLift(f: IntPoly, factorsModP: IntPoly[], p: bigint, targetPk: bigint): IntPoly[];
+//# sourceMappingURL=hensel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hensel.d.ts","sourceRoot":"","sources":["../../../src/typed/factorization/hensel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAQL,KAAK,OAAO,EACb,MAAM,mBAAmB,CAAC;AA8H3B;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,OAAO,EACV,WAAW,EAAE,OAAO,EAAE,EACtB,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,MAAM,GACf,OAAO,EAAE,CAmBX"}

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

@@ -0,0 +1,72 @@
+/**
+ * Public entry point of the univariate factorization engine: parse an
+ * expression string into an integer polynomial, run the Zassenhaus pipeline
+ * (`factorUnivariateZ`), and render the irreducible factorization back to a
+ * string that matches `algebra.ts`'s `factor()` output conventions.
+ *
+ * This module is deliberately self-contained (it does not import `algebra.ts`)
+ * so wiring it into `factor()` introduces no import cycle. It reuses the shared
+ * polynomial parser from `../polynomial-ideal.js` and the `bigint` engine from
+ * this directory.
+ *
+ * Part of the univariate factorization engine
+ * (`functions/src/typed/factorization/`).
+ */
+import { type IntPoly } from './integer-poly.js';
+/**
+ * Render a dense integer-coefficient univariate polynomial as a bare (no outer
+ * parentheses) human-readable string with the repo's spacing/`*`/`^` style and
+ * unit coefficients elided: `[1,0,1] → "x^2 + 1"`, `[-1,0,2] → "2*x^2 - 1"`.
+ * Coefficients are rounded for display; zero terms are omitted. Exported so
+ * `algebra.ts` can render an unfactorable higher-degree remainder consistently.
+ */
+export declare function cleanUnivariatePoly(coeffs: number[], v: string): string;
+/**
+ * Render one irreducible factor: linears via {@link renderLinearFactor},
+ * higher via {@link renderIntPoly} (bigint-native — see its doc comment for
+ * why this must not go through `Number()`) wrapped in parentheses. Exported
+ * for direct unit testing of the bigint-fidelity path.
+ */
+export declare function renderFactor(poly: IntPoly, v: string): string;
+/**
+ * Factor a univariate integer polynomial given as an expression string into
+ * its irreducible factors over ℤ/ℚ, rendered to a `*`-joined string matching
+ * `factor()`'s conventions (constant prefix when ≠ 1, degree-1 factors via the
+ * linear formatter, degree ≥ 2 factors wrapped in parentheses, repeated factors
+ * for multiplicity > 1).
+ *
+ * Returns `null` when the input is not an integer polynomial in `v` (parse
+ * failure, another variable, non-integer coefficients, degree < 1) OR when the
+ * polynomial is already irreducible over ℚ (a single primitive factor with
+ * multiplicity 1) — in that "nothing gained" case the caller keeps its existing
+ * behavior (leaving the expression whole / doing plain content extraction).
+ * Factor order is `factorUnivariateZ`'s deterministic (degree, coefficients)
+ * 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

@@ -0,0 +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;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/integer-poly.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Dense univariate polynomial arithmetic over ℤ, backed by `bigint[]`.
+ *
+ * Convention: index = degree (coefficient of x^i lives at index i).
+ * `[]` denotes the zero polynomial. After `trim`, the last entry (highest
+ * degree) is guaranteed nonzero. `degree([])` is -1 by convention.
+ *
+ * This module is part of the univariate factorization engine
+ * (`functions/src/typed/factorization/`) and is `bigint`-only by design:
+ * float64 loses correctness once coefficients exceed 2^53 during Hensel
+ * lifting to p^k.
+ */
+/** Dense polynomial over ℤ: index i holds the coefficient of x^i. */
+export type IntPoly = bigint[];
+/**
+ * Removes trailing (highest-degree) zero coefficients so the last entry
+ * (if any) is nonzero. Does not mutate the input.
+ */
+export declare function trim(p: IntPoly): IntPoly;
+/** Degree of `p`; the zero polynomial has degree -1 by convention. */
+export declare function degree(p: IntPoly): number;
+/** Leading coefficient of `p` (0n for the zero polynomial). */
+export declare function lc(p: IntPoly): bigint;
+/** True iff `p` is the zero polynomial (ignoring trailing zero padding). */
+export declare function isZero(p: IntPoly): boolean;
+/** `a + b`, trimmed. */
+export declare function add(a: IntPoly, b: IntPoly): IntPoly;
+/** `a - b`, trimmed. */
+export declare function sub(a: IntPoly, b: IntPoly): IntPoly;
+/** `-a`, trimmed. */
+export declare function neg(a: IntPoly): IntPoly;
+/** `a * b` via the schoolbook convolution, trimmed. */
+export declare function mul(a: IntPoly, b: IntPoly): IntPoly;
+/** `p * k` for a scalar `k: bigint`, trimmed. */
+export declare function scalarMul(p: IntPoly, k: bigint): IntPoly;
+/** Structural equality after trimming (so trailing-zero padding is ignored). */
+export declare function equals(a: IntPoly, b: IntPoly): boolean;
+/** Evaluates `p(x)` at a bigint `x` via Horner's method. */
+export declare function evaluate(p: IntPoly, x: bigint): bigint;
+/** Non-negative gcd of two bigints (gcd(0,0) = 0). */
+export declare function bigintGcd(a: bigint, b: bigint): bigint;
+/** Content of `p`: the non-negative gcd of its (trimmed) coefficients. */
+export declare function content(p: IntPoly): bigint;
+/**
+ * Primitive part of `p`: divide out the content, then flip sign so the
+ * leading coefficient is positive. The zero polynomial maps to itself.
+ */
+export declare function primitivePart(p: IntPoly): IntPoly;
+/**
+ * Exact polynomial quotient `a / b` over ℤ: performs schoolbook long division
+ * and returns the quotient only if the remainder is exactly zero AND every
+ * intermediate coefficient division was integral (no rounding). Returns
+ * `null` whenever `b` does not divide `a` exactly over ℤ. This is the
+ * recombination correctness test used by subset factor-recombination —
+ * it must never silently round.
+ */
+export declare function exactDivide(a: IntPoly, b: IntPoly): IntPoly | null;
+/** Formal derivative `p'` over ℤ: coefficient i*p[i] at index i-1. */
+export declare function derivative(p: IntPoly): IntPoly;
+/**
+ * Gcd of two polynomials over ℤ via the Euclidean pseudo-remainder sequence
+ * (stays in ℤ throughout via pseudo-division), returned as a primitive
+ * polynomial with positive leading coefficient. `gcd(0, b) = primitivePart(b)`
+ * and symmetrically for `gcd(a, 0)`; `gcd(0,0) = []`.
+ */
+export declare function polyGcdZ(a: IntPoly, b: IntPoly): IntPoly;
+/**
+ * Landau–Mignotte coefficient bound: any integer factor of `p` has all
+ * coefficients bounded in absolute value by this quantity. Uses the
+ * generous form `ceil(sqrt(deg+1) * 2^deg * |lc(p)|)`, computed entirely
+ * with bigint integer arithmetic (integer sqrt rounded UP so the bound
+ * stays safe/over-estimating). Always positive.
+ */
+export declare function landauMignotte(p: IntPoly): bigint;
+/**
+ * Reduces every coefficient of `p` into the symmetric residue range
+ * `(-m/2, m/2]` modulo `m`. `m` must be a positive modulus. Coefficient
+ * count is preserved (no trailing-zero trim) — a coefficient that reduces
+ * to 0 mod `m` stays as an explicit 0 at its original index.
+ */
+export declare function modSymmetric(p: IntPoly, m: bigint): IntPoly;
+//# sourceMappingURL=integer-poly.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integer-poly.d.ts","sourceRoot":"","sources":["../../../src/typed/factorization/integer-poly.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,qEAAqE;AACrE,MAAM,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC;AAE/B;;;GAGG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAMxC;AAED,sEAAsE;AACtE,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAGzC;AAED,+DAA+D;AAC/D,wBAAgB,EAAE,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAGrC;AAED,4EAA4E;AAC5E,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAE1C;AAED,wBAAwB;AACxB,wBAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CASnD;AAED,wBAAwB;AACxB,wBAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CASnD;AAED,qBAAqB;AACrB,wBAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAEvC;AAED,uDAAuD;AACvD,wBAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAenD;AAED,iDAAiD;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,gFAAgF;AAChF,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAQtD;AAED,4DAA4D;AAC5D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAOtD;AAED,sDAAsD;AACtD,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAStD;AAED,0EAA0E;AAC1E,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAO1C;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAYjD;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAmClE;AAED,sEAAsE;AACtE,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAU9C;AAyBD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAkBxD;AAmBD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAejD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAa3D"}

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/dist/typed/factorization/square-free.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Yun's square-free decomposition over ℤ.
+ *
+ * Given a nonzero integer polynomial `f`, decomposes `primitivePart(f)` into
+ * pairwise-coprime square-free factors with multiplicities such that
+ * `primitivePart(f) = ∏ factorᵢ^multᵢ` (up to sign — each returned `factor`
+ * is normalized to have a positive leading coefficient via `primitivePart`).
+ *
+ * This is the classical characteristic-0 algorithm (valid over any field of
+ * characteristic 0, hence over ℤ via `polyGcdZ`/`exactDivide`): let
+ * `g = gcd(f, f')`, `c = f/g`, `w = f'/g`. Then repeatedly peel off the
+ * square-free part at multiplicity `i` via `y = gcd(c, w)`,
+ * `factor = c/y`, `c = y`, `w = w/y - factor'`.
+ *
+ * Part of the univariate factorization engine
+ * (`functions/src/typed/factorization/`) — bigint-only.
+ */
+import { type IntPoly } from './integer-poly.js';
+/** One square-free factor of the input, with its multiplicity in the input. */
+export interface SquareFreeFactor {
+    factor: IntPoly;
+    mult: number;
+}
+/**
+ * Yun square-free decomposition of `f` over ℤ. `f` must be nonzero (may be
+ * non-primitive; the content is discarded — decomposition operates on
+ * `primitivePart(f)`). Trivial degree-0 (constant) factors are never
+ * included in the output.
+ *
+ * Recurrence (standard Yun, char 0): with `g = gcd(f, f')`,
+ * `b0 = f/g`, `c0 = f'/g`, `d0 = c0 - b0'`. At each step `i = 1, 2, …`
+ * (while `deg(b) > 0`): `aᵢ = gcd(b, d)` is the square-free factor of
+ * multiplicity `i` (possibly a unit, i.e. degree 0, meaning multiplicity `i`
+ * is absent); `b ← b/aᵢ`, `c ← d/aᵢ`, `d ← c - b'` for the next round.
+ */
+export declare function squareFreeDecompose(f: IntPoly): SquareFreeFactor[];
+//# sourceMappingURL=square-free.d.ts.map

package/dist/typed/factorization/square-free.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"square-free.d.ts","sourceRoot":"","sources":["../../../src/typed/factorization/square-free.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAOL,KAAK,OAAO,EACb,MAAM,mBAAmB,CAAC;AAE3B,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,OAAO,GAAG,gBAAgB,EAAE,CAkClE"}