import { CellComplex } from '../geometry/cell-complex.js';
import { type ExactValue } from '../coxeter/exact.js';
/** Which real embedding of Z[phi] is used to obtain a point in R^4. */
export type PhiEmbedding = 'parallel' | 'perpendicular';
/** The two norm-2 icosian shells whose union is the E8 root system. */
export type E8RootShell = 'unit' | 'conjugate';
/** Exact provenance classes of the folded E8 root-polytope edges. */
export type E8EdgeClass = 'parallel-skeleton' | 'perpendicular-skeleton' | 'chord' | 'strut';
/** Four doubled quaternion coordinates in Z[phi]. The represented point is q = coords / 2. */
export type DoubledIcosian = readonly [ExactValue, ExactValue, ExactValue, ExactValue];
/** A standard E8 coordinate vector multiplied by two, so every entry is integral. */
export type DoubledE8Vector = readonly [
    bigint,
    bigint,
    bigint,
    bigint,
    bigint,
    bigint,
    bigint,
    bigint
];
/**
 * Exact base change from `[a0..a3,b0..b3]` of a doubled icosian to a
 * doubled standard E8 coordinate vector. The inverse matrix is stored as
 * integer numerators over the common denominator two.
 */
export interface E8BaseChange {
    readonly icosianToInteger: ReadonlyArray<ReadonlyArray<bigint>>;
    readonly integerToIcosianNumerators: ReadonlyArray<ReadonlyArray<bigint>>;
    readonly integerToIcosianDenominator: 2n;
}
export interface IcosianE8Data {
    /** The 240 exact roots: 120 unit icosians followed by (1-phi) times those 120. */
    readonly roots: readonly DoubledIcosian[];
    /** Shell provenance, parallel to `roots`. */
    readonly shells: readonly E8RootShell[];
    /** Both Galois readings of the same exact roots, packed as 240 points in R^4. */
    readonly parallelPositions: Float64Array;
    readonly perpendicularPositions: Float64Array;
    /** Metric-nearest pairs of both 600-cell shells in the parallel embedding. */
    readonly parallelMetricSkeletonEdges: Uint32Array;
    /** Metric-nearest pairs of both 600-cell shells in the perpendicular embedding. */
    readonly perpendicularMetricSkeletonEdges: Uint32Array;
    /** All 6720 minimal-distance pairs. */
    readonly edges: Uint32Array;
    /** 720 E8 edges that are metric shell edges in the parallel embedding. */
    readonly parallelSkeletonEdges: Uint32Array;
    /** 720 E8 edges that are metric shell edges in the perpendicular embedding. */
    readonly perpendicularSkeletonEdges: Uint32Array;
    /** The remaining 2400 in-shell E8 edges, which are chords in both embeddings. */
    readonly chordEdges: Uint32Array;
    /** The 2880 edges joining the two shells. */
    readonly strutEdges: Uint32Array;
}
export declare const e8BaseChange: E8BaseChange;
/** Map a doubled icosian exactly into the standard doubled E8 coordinate model. */
export declare function icosianToE8Integer(root: DoubledIcosian): DoubledE8Vector;
/**
 * Map a standard doubled E8 lattice vector into doubled icosian
 * coordinates. Throws when the supplied integer vector is outside the E8
 * parity lattice and would require half-integral icosian coefficients.
 */
export declare function e8IntegerToIcosian(vector: DoubledE8Vector): DoubledIcosian;
/** The canonical 240 standard E8 roots in doubled integer coordinates. */
export declare function e8IntegerRoots(): readonly DoubledE8Vector[];
/**
 * The 2,160 norm-4 vectors of E8 in doubled standard coordinates.
 *
 * The integer coset contributes the axis vectors `(±4,0^7)` and the
 * four-coordinate vectors `(±2)^4`; the half-integer coset contributes
 * `(±3,±1^7)` subject to the E8 parity condition.
 */
export declare function e8IntegerSecondShell(): readonly DoubledE8Vector[];
/**
 * Every standard E8 lattice vector with quadratic norm at most `maxNorm`.
 * The bound is spherical in E8, so complete Weyl/H4 orbits are never clipped
 * by an arbitrary coordinate box.
 */
export declare function e8IntegerVectorsThroughNorm(maxNorm: number): readonly DoubledE8Vector[];
/** Evaluate a Z[phi] value in either of its two real embeddings. */
export declare function evaluatePhi(value: ExactValue, embedding?: PhiEmbedding): number;
/** Exact quaternionic norm of a doubled icosian (four times the norm of the represented q). */
export declare function doubledIcosianNorm(root: DoubledIcosian): ExactValue;
/** The integral E8 quadratic form Q(q) = 2(a+b), accounting for doubled storage. */
export declare function e8QuadraticNorm(root: DoubledIcosian): bigint;
/** The integral bilinear form polarizing `e8QuadraticNorm`. */
export declare function e8InnerProduct(left: DoubledIcosian, right: DoubledIcosian): bigint;
/**
 * The E8 roots in the icosian model, with exact folded-edge provenance.
 *
 * The construction never classifies an edge by a floating threshold. E8
 * adjacency is the exact condition B(x,y)=1; the two in-shell classes are
 * separated by their exact Z[phi] quaternion inner products.
 */
export declare function icosianE8Data(): IcosianE8Data;
export interface FoldedE8ShellOptions {
    /** Which Galois embedding supplies the R^4 positions. Default `parallel`. */
    embedding?: PhiEmbedding;
    /** Uniform scale applied after embedding. Default 1. */
    scale?: number;
}
/**
 * The two folded 600-cell vertex sets with their metric skeletons.
 *
 * @param options - Galois embedding and uniform output scale.
 */
export declare function createFoldedE8Shells(options?: FoldedE8ShellOptions): CellComplex;
/**
 * The same 240 E8 roots reached as an exact orbit of one simple root in
 * the rank-8 Coxeter representation. This is the integer model; use
 * `icosianE8Data` when the H4 folding and its two embeddings are needed.
 */
export declare function e8RootOrbit(): readonly ExactValue[][];
export interface FoldedE8Options {
    /** Which Galois embedding supplies the R^4 positions. Default `parallel`. */
    embedding?: PhiEmbedding;
    /** Exact edge classes to include. Default all three. */
    edgeClasses?: readonly E8EdgeClass[];
    /** Uniform scale applied after embedding. Default 1. */
    scale?: number;
}
/**
 * A 4D renderable view of the E8 root polytope under the H4 folding.
 * This is a view of the 8D root system, not a claim that E8 is 4D.
 *
 * @param options - Galois embedding, included edge classes, and output scale.
 */
export declare function createFoldedE8Roots(options?: FoldedE8Options): CellComplex;
//# sourceMappingURL=e8.d.ts.map