@danielsimonjr/mathts-functions 0.57.0 → 0.58.0

package/dist/typed/algebra.d.ts

@@ -218,11 +218,14 @@ 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)'`.
+ * 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** get the tractable subset (see
  * {@link factorMultivariate}): integer-content + common-monomial extraction

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,47 @@
+/**
+ * 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;
+//# 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;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"}

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/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"}

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

@@ -0,0 +1,36 @@
+/**
+ * Univariate polynomial factorization over ℤ — the top-level Zassenhaus
+ * pipeline that ties together the factorization engine modules.
+ *
+ * Pipeline:
+ *   1. Strip integer content and sign (constant prefix).
+ *   2. Yun square-free decomposition (`squareFreeDecompose`).
+ *   3. For each square-free primitive part `g` (possibly non-monic):
+ *      pick a prime `p` with `p ∤ lc(g)` and image square-free mod p (fewest
+ *      modular factors among the first candidates), factor `g` mod p, choose
+ *      `k` with `p^k` large enough (Landau–Mignotte, with the extra leading
+ *      coefficient factor), build the monic integer associate of `g` mod p^k,
+ *      Hensel-lift the mod-p factors, then recombine subsets by exact division
+ *      over ℤ (the leading-coefficient method for non-monic `g`).
+ *   4. Emit each irreducible factor with the multiplicity of its square-free
+ *      level; sort deterministically.
+ *
+ * Part of the univariate factorization engine
+ * (`functions/src/typed/factorization/`) — `bigint`-only by design.
+ */
+import { type IntPoly } from './integer-poly.js';
+/** Result of factoring an integer polynomial: a constant times irreducibles. */
+export type Factorization = {
+    constant: bigint;
+    factors: Array<{
+        poly: IntPoly;
+        mult: number;
+    }>;
+};
+/**
+ * Full univariate factorization of `f` over ℤ into a constant times
+ * irreducible primitive factors with multiplicities. Trivial inputs (zero,
+ * constant, degree ≤ 1) short-circuit.
+ */
+export declare function factorUnivariateZ(f: IntPoly): Factorization;
+//# sourceMappingURL=zassenhaus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zassenhaus.d.ts","sourceRoot":"","sources":["../../../src/typed/factorization/zassenhaus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAaL,KAAK,OAAO,EACb,MAAM,mBAAmB,CAAC;AAK3B,gFAAgF;AAChF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjD,CAAC;AA2NF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,GAAG,aAAa,CA4B3D"}

package/package.json

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