UOR Atlas Explorer
LexLean · examples/uor-atlas · E8 at scale 2

The UOR Atlas, moving

The Atlas is 48 of E8's 120 root classes, cut into four blocks of 12. Everything here is computed in your browser from the 120 class representatives and 8 simple roots stored in the kernel-checked source, then compared with the theorems that source proves.

240 roots projected onto E8's Coxeter plane: eight rings of 30. Each class is a root together with its negative, drawn on opposite sides of the centre.

Selected class

Current instance

Edges from a block to each block, per class (D19)

The orbit

Starting from the canonical instance A0, the eight simple reflections reach every Atlas instance. The breadth-first map below counts how many instances sit at each reflection distance from A0. Its total is the census, and the orbit–stabilizer theorem turns the census into the size of the gauge group.

Mapping the orbit…
348,364,800 ÷ ? = ?

348,364,800 is the order of W(E8)/{±1} acting on the 120 classes (Group.T59). Dividing by the number of instances gives the order of the subgroup that maps A0 to itself: the gauge group (gaugeOrderW0).

Adjacency, reordered

Rows and columns are the 120 classes, with the current instance first, block by block, then the 72 classes outside it. A filled cell means the two classes are not orthogonal.

Each 12×12 square on the diagonal has 8 cells per row filled: a block is a D4. The square pairing a block with its frame partner is empty, because the two blocks are orthogonal. Every other off-diagonal square has 6 per row, so each instance class sees 8 + 6 + 6 = 20 neighbours inside. Reflect the instance in Dynamics and this picture stays the same.

The gauge square

A reflection word that carries A0 back onto its own 48 classes is a gauge transformation. There are 4,608 of them, and they move the four blocks in only eight ways. Put the blocks at the corners of a square with the two frames as its diagonals: the sides are the block pairs joined by 6 edges per class, the diagonals are the orthogonal pairs, and the eight arrangements are exactly the symmetries of that square.

Each sample is a random element of the reflection group followed by the shortest path back to A0 in the orbit map. A gauge loop run in Dynamics is counted here too.

Five scales

The source nests the instance in a tower: block 0 inside the frame it forms with block 3, inside the 48-class instance, with the 72 outside classes as its residue and all 120 classes on top. Give each class x the projector Px onto its line. At every scale three readings agree. The −4 eigenvectors of the adjacency are exactly the linear relations among the projectors (Scales.S14), so the projectors span n − m(−4) of the 36 dimensions of symmetric 8×8 matrices. An adjacency eigenvalue λ is an eigenvalue 1 + λ/4 of the projectors' Gram matrix (S37). And the projectors of each scale above the block add up to a multiple of the identity (S17).

Orthogonal frames

Eight mutually orthogonal classes form an orthogonal 8-frame: an orthonormal basis of the ambient space, up to sign. Every class lies in 135 of them (Scales.S25). The current instance contains 36, and its 48 classes split into 6 disjoint ones; the residue splits into 9 (S7, S11). Together the two splits cut all 120 classes into 15 orthonormal bases, which is why the instance's projectors add up to 6·I and the residue's to 9·I.

Inside a block

A block is 12 classes whose 24 roots form a D4. Its classes fall into three parts of four. Classes in the same part are orthogonal, and every class is adjacent to all eight classes in the other two parts (Scales.S1, S29). So the block's graph is three groups of four with every edge between groups.

Block of the current instance

Choose one part as a basis r1, r2, r3, r4. Every other class of the block is ½(±r1 ± r2 ± r3 ± r4), read off by Parseval from its four inner products (Census.recon_of_parseval, Blocks.Recon). The 16 sign patterns, taken up to an overall sign, give 8 classes. Patterns with an even number of minus signs make up one remaining part and odd patterns the other.

Basis

Triality

The reflection words that carry a block onto itself permute its three parts. Sampling them shows all six permutations: the symmetries of a block realize every rearrangement of its parts, the triality of D4. There are 348,364,800 ÷ 3,150 = 110,592 such symmetries. Each sample is a random element of the reflection group followed by the shortest path back to the block, using a map of all 3,150 blocks.

Mapping the 3,150 blocks…

Blocks from four classes

The census finds every block from four mutually orthogonal classes. Take the four, together with every class adjacent to all four of them. When that set has 12 classes it is a block (Census.block_of_quad), and its classes are exactly the roots in the span of the four (mem_quadSet_iff_inSpan). Every block arises this way (block_has_orthogonal_quad). Most orthogonal quads have no common neighbour at all and span no other root.

How instances meet

Compare the current instance with all 75,600 instances. Two instances share no block, exactly one frame (two blocks), or all four blocks. They never share exactly one or three blocks, because a shared block brings its orthogonal partner with it. The distribution is the same from every instance, because the reflection group carries any instance to any other. Click a bar to walk to an instance with that overlap.

no shared blockone shared framethe instance itself

Completing a frame

The frame made of blocks 0 and 3 lies in exactly 96 instances. Their other halves are 96 different frames built from the 96 classes outside it, and each of those classes appears in exactly 24 of them. The matrix shows the incidence: classes down the side, completions across, with the current completion in the first column.

The group, level by level

The source certifies its group orders with stabilizer chains (Group.autChain, stabChain, kerChain). Fix a base point and count its orbit, pass to the subgroup that fixes that point, and repeat. The order is the product of the orbit lengths. The page rebuilds each chain from the source's own base points with a randomized Schreier–Sims run. A partial chain can only undercount, so reaching the proved order confirms it.

Waiting for the orbit map…

The Atlas at a prime

The Places layer looks at E8 one prime at a time. At a prime p, a rational number is integral when p does not divide its denominator. Every root has integer coordinates in the basis of the eight simple roots (Places.V65c), and the Gram matrix of that basis has determinant 1 with an integer inverse (Roots.T58x, Places.gramInvRows), so E8 equals its own dual at every prime (Places.T58, T67). Each class gets an address at every prime, the addresses are all different (T75, V71), and reflections carry addresses to addresses (V75).

Residues at p = 2

a root class (120)a nonzero non-root vector (135)instance classes, by blockneighbours of the selected class

Rows and columns read the simple coordinates mod 2: coordinates 5–8 choose the row, 1–4 the column. Tap a cell to select its class.

Mod 2, E8 becomes the 256 vectors of F₂⁸, and its quadratic form becomes a form q with values 0 and 1. The 120 classes land on exactly the 120 vectors with q = 1, and two classes are neighbours exactly when their mod-2 inner product is 1. A reflection becomes the map x ↦ x + B(x, r)·r. Move the instance in Dynamics and its 48 cells move across this grid.

This residue picture is computed on the page. The source works with the localization at p itself; reducing mod p is one step further.

Reflect, then reduce

The Functor layer proves that the reflection group acts compatibly with every localization (Functor.F3, F6, T79): reflecting and then passing to the prime gives the same result as passing to the prime and then reflecting. The square below runs this on the selected class.

Prime
Reflection

One object

4,608 arrows between any two 75,600 instances thin quotient the Atlas one object, a zero object

Take the instances as objects and the elements of the reflection group carrying one to another as arrows. This is the action groupoid of the source (D23). Between any two instances there are exactly 4,608 arrows (T35), and the gauge group acts on each arrow set freely and transitively (T40, T42). So no instance is initial (T36): there is never a single preferred way to get from one to another.

Collapse every arrow set to one arrow. Then every instance is a zero object (T45), and the skeleton has exactly one object (T37, T63a). That object is the Atlas (D27). The walks in Dynamics are arrows of the groupoid: a gauge loop is one of A0's 4,608 endomorphisms, and walking home composes arrows back to the base point.

Why eight

The Glue module builds a lattice in every dimension n: the even-sum integer vectors Dn, glued to the shifted copy Dn + ½·(1,…,1). It proves which of these behave like E8. The glued set is closed under addition only when 2 divides n, its inner products are integers only when 4 divides n, and its norms are even only when 8 divides n (Glue.T57a–c). The glue vector ½·(1,…,1) has norm n/4, so it is a root, with norm 2, only at n = 8 (T84, T85). That is where the glue coset contributes roots of its own, and the root system becomes E8.

The eight parameters

The source fixes its numbers before any geometry (Parameters.T1–T4). The last column counts the same number in the structure on this page.

Checked against the kernel

Each row pairs a theorem in the Atlas source with the same quantity recomputed on this page. Rows marked live follow the current instance.

StatementTheoremProvedComputed here