Introduction

Let $L$ be a positive-definite even integral lattice. The root system of $L$ is $$R(L)=\{x\in L:(x,x)=2\}.$$ When the roots span the ambient real vector space, the root system is a finite simply-laced root system and therefore decomposes uniquely as $$R(L)=\bigoplus_{X\in\mathcal A} X^{m_X},$$ where $$\mathcal A= \{A_1,A_2,\ldots\} \cup \{D_4,D_5,\ldots\} \cup \{E_6,E_7,E_8\}.$$

The purpose of this paper is to study the extent to which low-order metric information determines the multiplicity vector $$\mathbf m=(m_X)_{X\in\mathcal A}.$$

For a root system $R$, let $N_k(R)$ denote the number of ordered orthogonal $k$-frames of roots: $$N_k(R) = \#\left\{ (r_1,\ldots,r_k)\in R^k: (r_i,r_j)=2\delta_{ij} \right\}.$$ Define the exponential frame generating function $$\begin{equation} F_R(t) = \sum_{k\geq 0}\frac{N_k(R)}{k!}t^k. \label{eq:frame-generating-function} \end{equation}$$

For an orthogonal direct sum, $$R=R_1\oplus R_2,$$ one has $$F_R(t)=F_{R_1}(t)F_{R_2}(t).$$ Consequently, if $$R=\bigoplus_X X^{m_X},$$ then $$\begin{equation} F_R(t)=\prod_X F_X(t)^{m_X}. \label{eq:multiplicative-frame} \end{equation}$$

The key observation of this paper is that taking the formal logarithm turns this multiplicative relation into an additive one.

Logarithmic Frame Linearization

Formal logarithmic moments

Write $$F_X(t) = 1+a_1(X)t+a_2(X)t^2+a_3(X)t^3+a_4(X)t^4+O(t^5).$$ Define $$\begin{equation} \log F_X(t) = \sum_{k\geq1}c_k(X)t^k. \label{eq:log-definition} \end{equation}$$

The coefficients $c_k(X)$ are universal polynomial expressions in the frame coefficients $a_j(X)$.

Additivity

The logarithm of [eq:multiplicative-frame] gives $$\begin{equation} \log F_R(t) = \sum_X m_X\log F_X(t). \end{equation}$$ Therefore $$\begin{equation} [t^k]\log F_R(t) = \sum_Xm_Xc_k(X). \label{eq:additive-log-moments} \end{equation}$$

Define the truncated logarithmic frame map $$\begin{equation} \Lambda_4(R) = \left( [t]\log F_R,\, [t^2]\log F_R,\, [t^3]\log F_R,\, [t^4]\log F_R \right) \in\mathbb Q^4. \label{eq:lambda4} \end{equation}$$

Let $$\mathbf c(X) = \begin{pmatrix} c_1(X)\\ c_2(X)\\ c_3(X)\\ c_4(X) \end{pmatrix}.$$ Then $$\begin{equation} \boxed{ \Lambda_4(R) = \sum_Xm_X\mathbf c(X). } \label{eq:linear-map} \end{equation}$$

Thus the original nonlinear convolution problem becomes an exact linear moment problem.

Explicit Classical Logarithmic Moments

The $A_n$ family

For $A_n$, the number of ordered orthogonal $k$-frames is $$\begin{equation} N_k(A_n) = \frac{(n+1)^{\underline{2k}}}{k!}, \end{equation}$$ where $$x^{\underline r} = x(x-1)\cdots(x-r+1).$$

Consequently, $$\begin{equation} F_{A_n}(t) = \sum_{k\geq0} \frac{(n+1)^{\underline{2k}}}{k!}t^k. \end{equation}$$

Applying Proposition 1 gives:

The $D_n$ family

For $D_n$ one has $$\begin{align} F_{D_n}(t) ={}& 1 +2n^{\underline2}t +\left(2n^{\underline2}+2n^{\underline4}\right)t^2 \\ &+ \left( 4n^{\underline4} +\frac43n^{\underline6} \right)t^3 \\ &+ \left( 2n^{\underline4} +4n^{\underline6} +\frac23n^{\underline8} \right)t^4 +O(t^5). \end{align}$$

Exceptional components

Direct evaluation gives $$\begin{align} \mathbf c(E_6) &= (72,-1512,50976,-2011824), \\ \mathbf c(E_7) &= (126,-4158,223272,-14196924), \\ \mathbf c(E_8) &= (240,-13680,1281600,-143445600). \end{align}$$

The Vandermonde Factorization

The polynomial structure of the classical families has a stronger consequence than mere linear independence.

The Rank-Augmented Moment Map

For reconstruction at fixed total rank, it is natural to adjoin the rank coordinate to the four logarithmic moments.

Define $$\begin{equation} \mathbf v(X) = \begin{pmatrix} \operatorname{rank}(X)\\ c_1(X)\\ c_2(X)\\ c_3(X)\\ c_4(X) \end{pmatrix} \in\mathbb Q^5. \end{equation}$$

For $$R=\bigoplus_X X^{m_X},$$ one has $$\begin{equation} \sum_Xm_X\mathbf v(X) = \begin{pmatrix} \operatorname{rank}(R)\\ \Lambda_4(R) \end{pmatrix}. \label{eq:rank-augmented} \end{equation}$$

ADE Configuration Spaces

Full ADE convention

For a positive integer $n$, define $$\mathcal R_n^{\mathrm{Full}}$$ to be the finite set of all multisets of irreducible simply-laced ADE components having total rank $n$.

Thus the component registry contains $$A_1,\ldots,A_n, \qquad D_4,\ldots,D_n, \qquad E_6,E_7,E_8$$ whenever the relevant rank is at most $n$.

Niemeier-restricted convention

For comparison, let $$\mathcal R_{24}^{\mathrm{Niem}}$$ denote the configurations obtained using only those component types that actually occur in the rooted Niemeier root systems.

This distinction is important: the unrestricted ADE configuration space contains many rank-$24$ root systems which do not occur as the root system of a Niemeier lattice.

Classical $A$-only convention

Finally, define $$\mathcal R_n^A$$ to be the set of configurations consisting only of $A$-components. Its cardinality is the ordinary partition number $$|\mathcal R_n^A|=p(n).$$

Finite Rank-24 and Rank-32 Rigidity Theorems

We now state the principal finite computational result.

Machine-Checkable Certificate

The finite theorem admits a direct machine-checkable certificate.

Exact Reconstruction of Niemeier Root Systems

The finite theorem immediately applies to the rooted Niemeier systems.

Let $$N$$ be a rooted Niemeier lattice of rank $24$. Its root system is an ADE configuration $$R(N)=\bigoplus_X X^{m_X}.$$

Since $\Lambda_4$ is injective on the full rank-$24$ ADE configuration space, the root multiplicity vector is uniquely determined by $$\Lambda_4(R(N)).$$

The Root Layer and the Gluing Layer

Let $$R=R(L)$$ be the root lattice of a root-generated even unimodular lattice $L$.

The reconstruction problem naturally decomposes as $$\begin{equation} \boxed{ \mathcal D_4(L) \longrightarrow R(L) \longrightarrow (A_R,q_R) \longrightarrow C \longrightarrow L. } \label{eq:two-stage-reconstruction} \end{equation}$$

Here $$A_R=R^*/R$$ is the discriminant group and $$q_R:A_R\to\mathbb Q/2\mathbb Z$$ is its discriminant quadratic form.

An even unimodular overlattice corresponds to an appropriate isotropic subgroup $$C\subset A_R$$ with respect to $q_R$.

Thus the reconstruction has two conceptually different stages.

Stage I: Dynkin recovery

The logarithmic frame moments determine the multiplicity vector $$\mathbf m$$ in the finite rank cases certified above.

Stage II: gluing recovery

Once the root lattice is known, one must determine the isotropic gluing data. This generally requires information not contained in the root frame moments.

This distinction prevents the erroneous inference $$\text{root moments} \Longrightarrow \text{complete unimodular lattice}.$$

The correct architecture is $$\text{root moments} \Longrightarrow \text{root lattice},$$ followed by $$\text{higher Fourier data} \Longrightarrow \text{gluing information}.$$

The Diophantine Kernel Problem

The finite computations motivate the following general formulation.

Let $$\mathbf v(X) = \left( \operatorname{rank}(X),c_1(X),c_2(X),c_3(X),c_4(X) \right)^{\mathsf T}.$$

Suppose two ADE configurations $$R=\bigoplus_X X^{m_X}, \qquad R'=\bigoplus_X X^{m'_X}$$ have the same rank and the same four logarithmic moments.

Then $$\sum_X(m_X-m'_X)\mathbf v(X)=0.$$

Setting $$z_X=m_X-m'_X$$ gives the integer relation $$\begin{equation} \sum_Xz_X\mathbf v(X)=0. \label{eq:diophantine-kernel} \end{equation}$$

However, the infinite component registry contains infinitely many columns in a five-dimensional vector space. Therefore one cannot demand that the entire infinite collection of column vectors be linearly independent. The relevant question is instead whether a relation of the form [eq:diophantine-kernel] can be realized as the difference of two nonnegative multiplicity vectors having the same total rank.

This is the precise mixed-family Diophantine problem.

Universal Four-Moment ADE Rigidity

The finite computations lead to the principal conjecture of the paper.

Theorem 8 proves this conjecture for $$n=24,\qquad n=32.$$

Convex Geometry and Moment Curves

The formulas of Propositions 2 and 3 exhibit a degree progression $$\deg_n c_k(X)=k+1, \qquad 1\leq k\leq4,$$ for both classical families.

After dividing out the natural positive factors $$n(n+1)$$ for $A_n$ and $$2n(n-1)$$ for $D_n$, one obtains polynomial evaluation vectors whose degrees increase successively from $0$ through $3$.

This explains the appearance of Vandermonde determinants.

It is tempting to describe these vectors as “strictly convex moment curves.” The rigorous content needed here, however, is the Vandermonde factorization itself. In particular, the present paper does not rely on an informal appeal to convexity to establish mixed-family injectivity.

Algorithmic Reconstruction

For a fixed rank $n$, reconstruction from logarithmic moments can be formulated as an integer feasibility problem.

Let $$C_n = \left( \mathbf c(X) \right)_{X\in\mathcal A,\ \operatorname{rank}(X)\leq n}.$$ Given a target signature $$\mathbf b\in\mathbb Q^4,$$ we seek $$\mathbf m\in\mathbb Z_{\geq0}^{|\mathcal A_n|}$$ such that $$\begin{align} C_n\mathbf m&=\mathbf b, \\ \sum_Xm_X\operatorname{rank}(X)&=n. \end{align}$$

Equivalently, $$\begin{equation} \begin{pmatrix} \operatorname{rank}(X) \end{pmatrix}_X \mathbf m=n, \qquad C_n\mathbf m=\mathbf b. \end{equation}$$

For fixed $n$, this is a finite exact integer problem.

The exhaustive computation used in this paper does not depend on floating point tolerances. Every coefficient is represented as an element of $\mathbb Q$, and equality of signatures is exact.

Exact Computational Verification

The following program implements the finite enumeration and exact four-moment computation.

from fractions import Fraction


def fall_frac(n, m):
    result = Fraction(1, 1)
    for i in range(m):
        result *= Fraction(n - i, 1)
    return result


def get_A_moments_exact(n):
    a1 = fall_frac(n + 1, 2)
    a2 = fall_frac(n + 1, 4) / 2
    a3 = fall_frac(n + 1, 6) / 6
    a4 = fall_frac(n + 1, 8) / 24

    c1 = a1
    c2 = a2 - a1**2 / 2
    c3 = a3 - a1 * a2 + a1**3 / 3
    c4 = (
        a4
        - a1 * a3
        - a2**2 / 2
        + a1**2 * a2
        - a1**4 / 4
    )

    return (c1, c2, c3, c4)


def get_D_moments_exact(n):
    a1 = 2 * fall_frac(n, 2)
    a2 = (
        2 * fall_frac(n, 2)
        + 2 * fall_frac(n, 4)
    )
    a3 = (
        4 * fall_frac(n, 4)
        + Fraction(4, 3) * fall_frac(n, 6)
    )
    a4 = (
        2 * fall_frac(n, 4)
        + 4 * fall_frac(n, 6)
        + Fraction(2, 3) * fall_frac(n, 8)
    )

    c1 = a1
    c2 = a2 - a1**2 / 2
    c3 = a3 - a1 * a2 + a1**3 / 3
    c4 = (
        a4
        - a1 * a3
        - a2**2 / 2
        + a1**2 * a2
        - a1**4 / 4
    )

    return (c1, c2, c3, c4)


# ------------------------------------------------------------
# Component registry
# ------------------------------------------------------------

components = {}

for n in range(1, 33):
    components[f"A{n}"] = (
        n,
        get_A_moments_exact(n)
    )

for n in range(4, 33):
    components[f"D{n}"] = (
        n,
        get_D_moments_exact(n)
    )

components["E6"] = (
    6,
    (
        Fraction(72),
        Fraction(-1512),
        Fraction(50976),
        Fraction(-2011824),
    )
)

components["E7"] = (
    7,
    (
        Fraction(126),
        Fraction(-4158),
        Fraction(223272),
        Fraction(-14196924),
    )
)

components["E8"] = (
    8,
    (
        Fraction(240),
        Fraction(-13680),
        Fraction(1281600),
        Fraction(-143445600),
    )
)


# ------------------------------------------------------------
# Exhaustive ADE multiset enumeration
# ------------------------------------------------------------

def enumerate_partitions(target_rank, component_list):
    result = []

    def backtrack(index, current_rank, multiplicities):

        if current_rank == target_rank:
            result.append(dict(multiplicities))
            return

        if index == len(component_list):
            return

        if current_rank > target_rank:
            return

        component = component_list[index]
        rank = components[component][0]

        max_multiplicity = (
            target_rank - current_rank
        ) // rank

        for multiplicity in range(
            max_multiplicity, -1, -1
        ):

            if multiplicity > 0:
                multiplicities[component] = multiplicity

            backtrack(
                index + 1,
                current_rank + multiplicity * rank,
                multiplicities
            )

            if multiplicity > 0:
                del multiplicities[component]

    backtrack(0, 0, {})
    return result


# ------------------------------------------------------------
# Exact Lambda_4 computation
# ------------------------------------------------------------

def compute_Lambda4_exact(partition):
    moments = [
        Fraction(0),
        Fraction(0),
        Fraction(0),
        Fraction(0)
    ]

    for component, multiplicity in partition.items():

        rank, c = components[component]

        for k in range(4):
            moments[k] += multiplicity * c[k]

    return tuple(moments)


# ------------------------------------------------------------
# Exhaustive collision test
# ------------------------------------------------------------

for rank in [24, 32]:

    component_list = [
        component
        for component, (component_rank, _) in components.items()
        if component_rank <= rank
    ]

    configurations = enumerate_partitions(
        rank,
        component_list
    )

    signatures = {
        compute_Lambda4_exact(configuration)
        for configuration in configurations
    }

    print(
        f"Rank {rank}: "
        f"|R_{rank}| = {len(configurations)}, "
        f"distinct Lambda_4 = {len(signatures)}"
    )

    assert len(signatures) == len(configurations)

    print(
        f"Rank {rank}: ZERO COLLISIONS."
    )

The Finite Rigidity Certificate

The computational output can be summarized as follows.

============================================================
          FOUR-MOMENT ADE RIGIDITY CERTIFICATE
============================================================

RANK 24

Total ADE configurations:       10,458
Distinct Lambda_4 signatures:  10,458
Collisions:                         0
Status:                         CERTIFIED INJECTIVE


RANK 32

Total ADE configurations:       98,981
Distinct Lambda_4 signatures:  98,981
Collisions:                         0
Status:                         CERTIFIED INJECTIVE

============================================================

The certificate is reproducible from Listing [lst:verification].

Relation to Siegel Theta Series

For a lattice $L$ of rank $n$, the degree-$g$ Siegel theta series is $$\begin{equation} \Theta_L^{(g)}(Z) = \sum_{X\in L^g} \exp\left( \pi i\operatorname{tr}(X^{\mathsf T}XZ) \right). \end{equation}$$

A Fourier coefficient indexed by $$T\in\operatorname{Sym}_g^*(\mathbb Z)_{\geq0}$$ counts vectors $$(x_1,\ldots,x_g)\in L^g$$ whose Gram matrix is prescribed by $T$.

In particular, $$T=I_g$$ counts ordered orthogonal $g$-frames of roots when the diagonal entries are $2$.

Thus $$a(I_g,\Theta_L^{(g)})$$ is a natural genus-$g$ observable attached to the root system.

The frame generating function studied in this paper therefore extracts a particularly transparent family of Fourier coefficients.

From Root Moments to Genus Four

The finite rank-$24$ theorem provides a precise algebraic explanation for the success of low-order frame observables in the Niemeier problem.

For a rooted Niemeier lattice $N$, $$R(N) = \bigoplus_X X^{m_X}.$$ The four logarithmic frame moments determine $$(m_X)_X$$ within the full rank-$24$ ADE configuration space.

Therefore the genus-four root-frame data contain enough information to recover the complete Dynkin decomposition.

This complements the direct orthogonal-frame separation theorem for the 24 Niemeier lattices: the former reconstructs the root system through linearized moments, while the latter can be viewed as an explicit Fourier-coefficient separation mechanism.

Why Spherical Designs Are Not Automatically Genus Collapse

A separate issue arises for rootless extremal lattices.

Suppose a shell $$X\subset S^{n-1}$$ is a spherical $t$-design. Then harmonic polynomial averages of degree at most $t$ agree with the corresponding spherical averages.

This is a one-vector statement.

A degree-$g$ Siegel coefficient, however, concerns tuples $$(x_1,\ldots,x_g)$$ and their complete joint Gram matrix $$\left((x_i,x_j)\right)_{i,j}.$$

Consequently, a spherical design property does not by itself imply that all genus-$g$ theta coefficients collapse.

To obtain such a conclusion one needs an additional factorization or representation-theoretic statement controlling the relevant multivariate harmonic tensors.

This distinction is essential for higher-rank conjectures.

The Design-to-Genus Principle

The preceding observation motivates the following formulation.

Extremal Lattices and the Higher-Genus Program

For an extremal even unimodular lattice of rank $n$, the minimum norm is constrained by the modular-form bound.

This suggests a hierarchy in which increasingly strong shell design properties may delay the first possible genus of separation.

The motivating predictions are $$k^*(24)=4,$$ together with the proposed higher-rank tests $$k^*(48)\stackrel{?}{=}6, \qquad k^*(72)\stackrel{?}{=}8.$$

These statements are deliberately presented as conjectural research targets rather than consequences of the finite ADE theorem.

The Linear Dimension Curve

Let $$V_g = \operatorname{span}_{\mathbb C} \left\{ \Theta_N^{(g)}: N\in\mathcal N_{24} \right\}.$$ Define $$d(g)=\dim_{\mathbb C}V_g.$$

The low-genus values relevant to the present program are $$d(1)=2, \qquad d(2)=3, \qquad d(3)=4,$$ while the full independence problem reaches dimension $24$ by genus $12$.

The intermediate sequence $$d(4),d(5),\ldots,d(11)$$ is therefore a natural computational and modular-form problem.

A complete determination of $$d(1),d(2),\ldots,d(12)$$ would give a detailed picture of how the 24 Niemeier theta series acquire independent degrees of freedom as the genus increases.

Metric Decks

For a lattice $L$, define its degree-$g$ metric deck schematically by $$\mathcal D_g(L) = \left\{ \operatorname{Gram}(x_1,\ldots,x_g): (x_1,\ldots,x_g)\in L^g \right\},$$ with multiplicities when required.

The central reconstruction question is then

$$\begin{equation} \mathcal D_g(L) \stackrel{?}{\Longrightarrow} [L]. \end{equation}$$

The logarithmic frame map provides a low-dimensional projection: $$\mathcal D_g(L) \longrightarrow \Lambda_g(L).$$

The genus threshold can therefore be regarded as the first $g$ for which the available Gram-pattern observables separate the relevant isometry classes.

The Commutant Observable Algebra

Let $$G_L=\operatorname{Aut}(L).$$ Consider the tensor representation $$L^{\otimes g}.$$ Its commutant algebra is $$\begin{equation} \mathcal C_g(L) = \operatorname{End}_{G_L} \left( L^{\otimes g} \right). \label{eq:commutant} \end{equation}$$

The genus-$g$ Gram observables generate a distinguished subalgebra $$\mathcal G_g(L)\subseteq\mathcal C_g(L).$$

This leads to the conceptual formulation $$\begin{equation} \boxed{ g_0(L) = \min \left\{ g: \mathcal G_g(L) \text{ separates the relevant }G_L\text{-orbits} \right\}. } \label{eq:commutant-depth} \end{equation}$$

The quantity $g_0(L)$ is a representation-theoretic analogue of the minimal separating genus.

This viewpoint suggests that genus thresholds should ultimately be expressible through the growth of invariant tensors rather than through isolated Fourier coefficients.

Eight Problems for the Next Stage

The results above lead to the following research program.

Conclusion

The principal contribution of this paper is the conversion of an apparently nonlinear root-system reconstruction problem into an exact linear moment problem.

The chain of ideas is $$\boxed{ F_R(t) = \prod_XF_X(t)^{m_X} }$$ followed by $$\boxed{ \log F_R(t) = \sum_Xm_X\log F_X(t) }$$ and hence $$\boxed{ \Lambda_4(R) = \sum_Xm_X\mathbf c(X). }$$

The explicit $A_n$ and $D_n$ formulas reveal a Vandermonde structure, which explains the strong rigidity of the classical families.

The decisive finite result is that exact exhaustive computation finds no four-moment collisions among the full ADE configuration spaces in ranks $24$ and $32$: $$|\mathcal R_{24}^{\mathrm{Full}}| = |\Lambda_4(\mathcal R_{24}^{\mathrm{Full}})| = 10\,458,$$ and $$|\mathcal R_{32}^{\mathrm{Full}}| = |\Lambda_4(\mathcal R_{32}^{\mathrm{Full}})| = 98\,981.$$

These are machine-checkable finite theorems.

At the same time, the paper deliberately distinguishes what is proved from what remains conjectural. In particular, universal four-moment injectivity in arbitrary rank, genus-four recovery of arbitrary gluing data, and the proposed extremal design-to-genus hierarchy remain open.

The resulting architecture is

$$\boxed{ \text{metric deck} \longrightarrow \text{logarithmic moments} \longrightarrow \text{root system} \longrightarrow \text{discriminant form} \longrightarrow \text{gluing} \longrightarrow \text{lattice}. }$$

This provides a common framework in which finite root combinatorics, Siegel modular forms, discriminant theory, spherical designs, and representation-theoretic invariant algebras become different layers of a single reconstruction problem.