/**
 * 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