Skip to content

Speculative Lattices

enumeratio edited this page Nov 16, 2026 · 3 revisions

Lattices

Speculative. A proposal, not adopted.

IsLattice and FindStat's Lattices statistics on the Poset carrier: phase 4 of Posets, after #1354 (the carrier and its first statistics). Lattices(n), the collection, is not here; it restricts Posets(n) and waits for it.

"Measured" means I ran it in Python (stdlib) against the crawl (~/Playground/@enumeratio/findstat-crawl) or against posets I generated. "Assumed" means reasoned, not run. Nothing here has been compiled or interpreted through compute-engine; no Epsil was run.

Summary

  • The crawl has 34 Lattices statistics. I recommend 23 (18 that read only the order, joins and meets, 5 that enumerate subsets as a bitmask), leave out 11 (linear algebra, congruences and tolerances, sublattice families, isomorphism, algebra with no code).
  • Every recommended statistic agrees with every crawl row the crawl holds for it (up to n = 668 for the four with large lattices) under an independent reading, and with every row up to a stated n cap under a second, Epsil-shaped reading that uses only lower covers, the flat strict order and flat join and meet tables. One statistic's title disagrees with its rows: St000550 (below).
  • IsLattice is: no elements, or exactly one minimal element and every pair has a join. Measured equal to "every pair has a join and a meet" on all 96,428 naturally labeled posets through n = 7. A lattice's bottom is element 1 and its top element n, which every definition uses.
  • The snapshot as #1354 sets it (Lattices through 6 elements) is not enough as wired: the sweep's standard cap is per carrier (5), so the standard run compares only the 10 lattices with at most 5 elements, and St001719 is constant (1) on them and St000550 and St000551 have identical values. Through 6 (25 lattices) fixes both; through 7 (78 lattices) is the margin. See "The snapshot".

IsLattice

Definition. IsLattice(P), for a Poset, is true when P has no elements, or when P has exactly one minimal element and every pair of elements has a join. A pair has a join when it has a least upper bound. In a natural labeling the only candidate is the least-labeled common upper bound m, and the pair has a join exactly when m is below every common upper bound.

Why joins and a bottom, not both sides. In a finite poset with a bottom, every pair has a join exactly when every pair has a meet: the meet of a and b is the join of their common lower bounds, a non-empty set because it holds the bottom. So the one-sided test is complete once the bottom is checked, and costs half the work of the two-sided one. Joins alone are not enough: a poset with a top and every pair joined need not have meets (the V turned upside down). Measured over naturally labeled posets with n = 1..7 elements (1, 2, 7, 40, 357, 4,824, 96,428; counts confirmed):

n posets joins and meets one minimal and joins joins only
4 40 2 2 7
5 357 7 7 39
6 4,824 39 39 320
7 96,428 320 320 3,637

The two correct definitions agree on every poset; "joins only" overcounts. Counted up to isomorphism (least relabeling code), the lattices are 1, 1, 2, 5, 15, 53 for n = 2..7, the known counts, and all 25,183 crawl rows (all 34 statistics) are lattices: none fails the test.

The empty poset. IsLattice(Poset([])) is true: nothing is unjoined. The crawl lists the empty lattice (([],0)) for St001754 and St001990, so FindStat counts it. The guard answers it before the lattice test, as withPoset does.

Cost. One pass for the minimal element (each entry past the first has a lower cover), then for each of n² pairs the common upper bounds (n reads of below) and a test that the least one is below the rest (n more): about 2n³ reads, 1,024 at n = 8. It needs below, so it sits inside withRelation. Measured on the Epsil-shaped reading: agrees with the bitmask definition on every naturally labeled poset through n = 6 (4,824 at n = 6, 0 disagreements).

Where it sits.

  • IsLattice is a predicate head on poset in the posets/ area (Is…). The statistics machinery's Definition has an optional result type for answers that are not numbers; whether it carries a boolean, and how an area declares a predicate that is not a statistic, is not checked (open question 1).
  • A guard helper beside withPoset: withLattice(body, otherwise = 0) is withPoset of If(IsLattice(_x), body, <declines>). The empty poset answers otherwise first. How a definition declines (leaves the call unevaluated, not NaN and not 0) was probed first and is open (question 1): a definition's own else branch cannot do it.
  • Two further helpers bind flat n² tables once, as withRelation binds below: withJoins (joins, entry (a − 1)·n + b is the least element above both: the least z with a ≤ z and b ≤ z) and withMeets (meets: the greatest z below both). No sort is needed: the least label among upper bounds is the join in a natural labeling, and Min over If(cond, z, n + 1) picks it without a filter. Cost n³ each. They are valid only after the guard.

The crosscheck. findstat/src/objects.ts already has "Lattices": "Poset" in COLLECTION_CARRIER (#1354), so the reader reads a lattice's spelling as a Poset and the statistic runs on it. Every crawl object is a lattice (measured), so no statistic is evaluated off its domain and skipped stays []; there is no row for a non-lattice to disagree with. A lattice statistic's findstat-data.ts row is { head, on: "Poset", findstat: [id], values }. One consequence of keying by carrier: see "The snapshot".

The 34 statistics and their buckets

Rows are the crawl's; "complete" means every lattice of that size is present (1, 1, 1, 1, 2, 5, 15, 53, 222 for n = 0..8, measured as the union of spellings over all 34 statistics, equal to the known counts). n = 9 has 905 distinct spellings of 1,078 lattices, so it is partial everywhere.

Id Title (short) Sage Rows Complete through Bucket
550 modular elements yes 78 7 a
551 left modular elements yes 656 7 (+ some to 499) a
1613 log2 of the center size yes 1,200 8 a
1615 join-prime elements yes 1,200 8 a
1616 neutral elements yes 1,200 8 a
1617 dimension of the space of valuations yes 1,200 8 d (linear algebra)
1618 size of the Frattini sublattice yes 1,200 8 c (family of sublattices)
1619 non-isomorphic sublattices yes 1,200 8 e (isomorphism)
1620 sublattices yes 1,200 8 c
1621 atoms yes 78 7 a
1622 join-irreducibles yes 554 7 (+ some to 64) a
1623 doubly irreducibles yes 78 7 a
1624 breadth yes 78 7 c (bitmask over join subsets)
1625 Möbius invariant yes 78 7 b
1626 maximal proper sublattices yes 78 7 c (family of sublattices)
1630 global dimension of the incidence algebra no 76 3..7 d
1651 Frankl number yes 586 2..7 (+ some to 64) a
1666 non-isomorphic subposets that are lattices yes 1,200 8 e
1677 non-degenerate subsets with meet 0 yes 1,200 8 c
1679 subsets with meet 0 yes 1,200 8 c
1681 minimal subsets with meet 0 yes 1,200 8 c
1719 shortest chains of small intervals yes 1,200 8 a (DP fold)
1720 minimal length of a chain of small intervals yes 2,050 8 (+ some to 668) a
1754 tolerances no 26 n = 0..6 c (bits over pairs)
1820 image of the pop stack operator yes 1,200 8 a
1833 linear intervals yes 1,200 8 a
1845 join-irreducibles minus rank yes 1,200 8 a
1846 elements without a complement yes 1,200 8 a
1875 simple modules, projective dimension at most 1 no 76 3..7 d
1876 2-regular simple modules no 60 none (3..4) d
1877 injective modules, projective dimension 2 no 76 3..7 d
1878 projective dimension of the minimum's simple no 76 3..7 d
1881 factors as a Cartesian product yes 1,200 8 a (center)
1990 zero divisors yes 79 0..7 a

Bucket counts: (a) 17, (b) 1, (c) 8, (d) 6, (e) 2 = 34. The design page counted 18 meet/join-local, 1 Möbius, 8 sublattice enumeration, 5 algebraic and 2 isomorphism. Differences: breadth (St001624) needs a bitmask, so it is (c) here; St001881 moves from sublattice enumeration to (a), because its rows equal max(1, St001613) on all 1,200 (measured) and a direct product's factors are the central elements; St001617 (linear algebra) joins the algebraic six and St001754 (subsets of pairs) the enumerations.

Reach of a bitmask over elements at n ≤ 8 (the standard run reaches 5..7, the deep run 7):

  • 1624 breadth, 1677, 1679, 1681, 1620: yes. One mask per subset (256 at n = 8, 512 at n = 9), a meet or join fold of n steps for the first four, a closure test over pairs for 1620. Modeled at 100% agreement in Python.
  • 1618 Frattini and 1626 maximal proper sublattices: modeled at 100% through n = 9 (1,200 and 78 rows) but they need the family of sublattice masks and a maximality test of every one against all others, a mask-subset test with no bit operations. Reachable at n ≤ 7 and clumsy; left out.
  • 1754 tolerances: the unknowns are subsets of pairs, 2^15 at n = 6 and 2^28 at n = 8. Modeled at 100% for n ≤ 6 (26 rows), the only rows there are; not reachable at n = 8 and no row beyond 6. Left out.
  • 1619, 1666: need to decide isomorphism of the sublattices or subposets. Left out until IsIsomorphicPoset exists.
  • 1617: nullity of a rational matrix (Birkhoff: the number of projective-prime-interval classes of the modular quotient). Modeled at 100% by exact Gaussian elimination over Q with v(bottom) = 0 (n ≤ 9). No row reduction in the core. Left out.
  • 1630, 1875..1878: homological algebra of the incidence algebra; no Sage code. Left out.

The recommended statistics

All values are on the lattices: 1-chain, 2-chain, 3-chain, B2 ([[],[1],[1],[2,3]], the diamond), N5 (the pentagon [[],[1],[1],[3],[2,4]]), M3 ([[],[1],[1],[1],[2,3,4]]). Agreement is the Python reading against all crawl rows, under the independent reading (readings.py) and the Epsil-shaped one (fast.py, with its n cap). "Needs" lists what the Epsil definition reads beyond _x.

Head names are checked with git ls-files | grep '/reference/<Name>/index.md' on origin/main and against the reference dirs #1354 adds; "free" means neither has it.

Tier 1: order, joins and meets

Id Head Reading that matches the rows Needs 1-ch, 2-ch, 3-ch, B2, N5, M3 Rows agree (readings / Epsil-shaped)
550 ModularElementCount (free) elements a with a ∧ (y ∨ z) = (a ∧ y) ∨ z for every y and every z ≤ a. Not the title's "(x, y) and (y, x) are modular pairs" joins, meets, below 1, 2, 3, 4, 4, 5 78/78 (all, n ≤ 7) / 78/78
551 LeftModularElementCount (free) a with (y ∨ a) ∧ z = y ∨ (a ∧ z) for every y ≤ z joins, meets, below 1, 2, 3, 4, 4, 5 656/656 (n ≤ 499) / 532/532 (n ≤ 20)
1613 LatticeCenterRank (free; CenterSize is taken) log2 of the center, the center being the neutral elements that have a complement; as the central elements that cover no other non-bottom central element joins, meets; neutral test below 0, 1, 1, 2, 1, 1 1,200/1,200 (n ≤ 9) / 1,200/1,200
1615 JoinPrimeCount (free) non-bottom a with a ≤ p ∨ q ⇒ a ≤ p or a ≤ q for all p, q; the top counts joins, below 0, 1, 2, 2, 2, 0 1,200/1,200 / 1,200/1,200
1616 NeutralElementCount (free) e such that for all p, q and each of the 3 ways to pick r from {e, p, q} (the others u, v): (u ∨ v) ∧ r = (u ∧ r) ∨ (v ∧ r) and the dual joins, meets 1, 2, 3, 4, 2, 2 1,200/1,200 / 1,200/1,200
1621 AtomCount (free) entries whose only lower cover is 1 _x only 0, 1, 1, 2, 2, 3 78/78 / 78/78
1622 JoinIrreducibleCount (free) entries with exactly one lower cover _x only 0, 1, 2, 2, 3, 3 554/554 (n ≤ 64) / 553/553 (n ≤ 32)
1623 DoublyIrreducibleCount (free) exactly one lower cover and exactly one upper cover _x, upperCoverCount (as #1354) 0, 0, 1, 2, 3, 3 78/78 / 78/78
1625 MoebiusInvariant (free) μ(1, n): the last entry of the Möbius row of element 1 (the PR's moebiusRow, one row not n) below, Möbius recurrence 1, −1, 0, 1, 1, 2 78/78 / 78/78
1651 FranklNumber (free) max over join-irreducible x of `n − 2· [x, n] `; no value on the 1-element lattice (no join-irreducible, no row) below
1719 ShortestSmallIntervalChainCount (free) chains 1 = e₀ < … < eₖ = n with the fewest elements in which each eᵢ₊₁ is a join of upper covers of eᵢ: j > e is such a step iff the upper covers of e below j join to j; count by a fold from the top over (elements, chains) joins, below 1, 1, 1, 1, 1, 1 1,200/1,200 / 1,200/1,200 (n ≤ 9)
1720 ShortestSmallIntervalChainSize (free) the elements on that chain, both ends counted (1-chain: 1): iterate e ← join of the upper covers of e from 1 to n; the title says "length" joins 1, 2, 3, 2, 2, 2 2,050/2,050 (n ≤ 668) / 1,741/1,741 (n ≤ 30)
1820 PopStackImageSize (free; PopStackSortingPasses is a permutation statistic) distinct values of x ∧ (meet of x's lower covers), the empty meet being x meets 1, 1, 2, 1, 2, 1 1,200/1,200 / 1,200/1,200
1833 LinearIntervalCount (free) pairs x ≤ y (including x = y) whose interval is a chain below 1, 3, 6, 8, 12, 11 1,200/1,200 / 1,200/1,200
1845 JoinIrreducibleCountMinusRank (free) join-irreducibles less the length of the longest chain (PosetRank's reading) _x, chain sizes as #1354 0, 0, 0, 0, 0, 1 1,200/1,200 / 1,200/1,200
1846 UncomplementedElementCount (free) x with no y having x ∧ y = 1 and x ∨ y = n joins, meets 0, 0, 1, 0, 0, 0 1,200/1,200 / 1,200/1,200
1881 DirectFactorCount (free) `max(1, log2 center ): the center is a Boolean lattice 2^kandLis a product ofkdirectly indecomposable lattices;St001881 = max(1, St001613)` on all 1,200 rows as 1613
1990 ZeroDivisorCount (free) non-bottom a with some non-bottom b and a ∧ b = bottom; the empty lattice gives 0 (its row exists) meets 0, 0, 0, 2, 3, 3 79/79 (n ≤ 7, includes the n = 0 row) / 79/79

Tier 2: a bitmask over the elements

Subsets are bitmasks folded through Mod and Divide as PosetWidth and AntichainCount do in #1354. Cheap at the sizes the sweep reaches, grows as 2^n.

Id Head Reading that matches the rows Needs 1-ch, 2-ch, 3-ch, B2, N5, M3 Rows agree (readings / Epsil-shaped, n cap)
1620 SublatticeCount (free) subsets closed under join and meet, the empty set included (1-chain: 2) joins, meets, masks 2, 4, 8, 13, 23, 20 1,200/1,200 (n ≤ 9) / 300/300 (n ≤ 8)
1624 LatticeBreadth (Breadth is taken) the most elements in a join-irredundant subset (no element can be dropped without changing the join), at least 1; the same value over subsets of join-irreducibles only (78/78) joins, masks 1, 1, 1, 2, 2, 2 78/78 / 78/78 (all rows are n ≤ 7)
1677 NondegenerateBottomMeetSubsetCount (free) non-empty subsets with neither bottom nor top and meet bottom meets, masks 0, 0, 0, 1, 3, 4 1,200/1,200 / 300/300
1679 BottomMeetSubsetCount (free) non-empty subsets with meet bottom; equals 2^(n−1) + 2·St001677 for n ≥ 2 (all 1,199 rows) meets, masks 1, 2, 4, 10, 22, 24 1,200/1,200 / 300/300
1681 MinimalBottomMeetSubsetCount (free) subsets with meet bottom, none smaller; "meet bottom" is upward closed, so dropping one element tests every proper subset meets, masks 1, 1, 1, 2, 3, 4 1,200/1,200 / 300/300

Neutral and central elements: St001616 and St001613 agree with all 1,200 rows under the identity form (the Epsil-shaped reading) and under the literal definition ("the sublattice generated by e, x, y is distributive for all x, y", by closure) in readings.py.

Quirks that the records should say, since rows beat titles:

  • St000550: title and description say "modular pair both ways"; the rows say the one-sided law above. The title's reading agrees with 39 of 78 rows (the smallest miss: the pentagon, title reading 3, row 4). The rows also differ from St000551 on 28 of 78 objects.
  • St001720 counts elements, not steps (the 1-chain is 1, the 2-chain 2), as ShortestMaximalChainSize in #1354.
  • St001620 includes the empty sublattice; St001833 includes the trivial intervals; St001615 counts the top and not the bottom; St001624 is at least 1 on the one-element lattice.
  • St001651 has no row on the one-element lattice, so it is undefined there (decline), not 0.

Left out, and why

Id Reason
1617 Nullity of a rational linear system. Modeled 1,200/1,200 by elimination over Q; needs a rank, which the core has no way to write.
1618, 1626 Family of sublattice masks plus maximality of each against the others; modeled 1,200/1,200 and 78/78. Clumsy at n = 8; wait for a subset-family vocabulary.
1619, 1666 Isomorphism classes of sublattices or subposets; second slice (IsIsomorphicPoset). Not modeled.
1754 Subsets of pairs (2^28 at n = 8); modeled 26/26, rows only to n = 6.
1630, 1875, 1876, 1877, 1878 Incidence algebra homological invariants, no Sage code; St001876's rows list only some lattices per size.

Hazards

  • Declining off the domain. Probed: a definition cannot return "unevaluated" (question 1). The fallback is not 0; the ways on are listed there.
  • The empty lattice. It is a lattice here (vacuous). Counts then give 0; MoebiusInvariant, FranklNumber, the two small-interval statistics and LatticeBreadth have no natural value on it, and FindStat has no row for them there. Recommendation: they decline on the empty poset; only ZeroDivisorCount has a row (0).
  • Natural labeling carries the load. Bottom is 1, top is n, and a join is the least-labeled upper bound. This is why no sort is needed, and it is only valid for a naturally labeled value (the carrier's valid, the reader). A definition run on a non-natural list would be wrong; the guard checks the unique minimal element only.
  • Two samples for the records. #1354's sample [[],[],[1],[1,2]] is not a lattice (two minimal elements), so a lattice record's example would show an unevaluated call. A lattice sample is needed (the pentagon [[],[1],[1],[3],[2,4]]: 550 and 551 are 4, the Frankl number 1, 1620 is 23); whether SAMPLES takes two entries for one carrier is not checked.
  • Cost, unmeasured through compute-engine. withJoins and withMeets are n³ each; the neutral test is n³ identity checks over n² (e, p, q) triples with 3 permutations; 1616 and 1613 are the heaviest of tier 1. Tier 2 is 2^n. The standard run reaches the lattices of 7 elements at most (below); the deep run's crawl has rows to n = 9 and, for four statistics, to hundreds of elements, which the cap keeps out.
  • A snapshot of 78 lattices is not a proof. It is every lattice through 7, which includes N5, M3 and the first non-modular, non-distributive, non-complemented cases, but the counts that need 8 elements to vary (LatticeBreadth of 3 is B3, 8 elements) are checked only in a deep run with the crawl.
  • n = 9 is partial (905 of 1,078 spellings), for every statistic; the deep cap of 7 never reaches it.
  • The unique-minimal check is not a naturally-labeled check. A poset whose labeling is not natural fails isPoset in the reader tests, so it never reaches a statistic from the crawl.

The snapshot

#1354 keeps every Lattices row through 6 elements (OBJECT_WISE_THROUGH, Lattices: 6). That is 25 distinct lattices (1, 1, 1, 2, 5, 15 for n = 1..6; 26 with the empty lattice that two statistics list). But OBJECT_WISE.Poset = { standard: 5, deep: 7 } caps by carrier, and these statistics are on Poset, so the standard run compares only lattices with at most 5 elements: 10 lattices. Measured on the recommended statistics:

Through Lattices Statistics constant Statistics with identical value vectors Rows added (23 statistics) Added size, as statistics.json indents
5 (the standard run) 10 St001719 (always 1) St000550 and St000551 230 about 9 KB
6 (the snapshot) 25 none none 575 about 29 KB
7 (the deep cap) 78 none none 1,794 about 111 KB

Weakest even at 6: St001719 (2 values), St001624, St001881, St001845 (2 to 3 values), because they first vary at n = 4 to 6. Through 7, St001719 has 3 values. The file is 949 KB today.

Recommendation: key the cap by FindStat collection, not carrier (the item already carries collection), with Lattices at least 6 in the standard run and 7 in a deep run, and keep the snapshot through 7. If the standard run's cost of 78 lattices times 23 statistics is too much, take 6 and accept two statistics that first vary at 6 (St000550 vs St000551, St001719) being checked on a single lattice class each.

Questions for the owner

All are decided as recommended (Dean, 2026-11-15), and the probe of question 1 has since come back: the decline it assumed cannot be written, so how a statistic declines is open again.

  1. How does a lattice statistic decline, and how is IsLattice declared? Decided: probe before any statistic is written; IsLattice as an area definition with result: "boolean". The probe (the builder's first step, 2026-11-15):
    • The predicate works. A definition with result: "boolean" is declared (poset) -> boolean and gave True and False on two posets. Not checked: what a boolean head does in the carrier's statistics table, the generated entries, the compile guard and the coverage tests.
    • A definition cannot decline. applyDefinition (combinatorics/src/statistics/declare.ts) always replaces the call with the definition's value. An else branch of Nothing or Undefined becomes the answer; Hold of the call stays as a Hold; the head's own call recurses without end or fails to type. The compiled route is no obstacle: it falls back to the interpreter when it throws.
    • Open (Dean's call). The lane stopped here with no commits. The ways on:
      • (a) A placeholder value (Undefined or Nothing) as the answer off the domain. No change to the machinery. It is an answer, not a decline, and a sum or Max over the values of a collection then meets it.
      • (b) A sentinel the machinery reads. The definition's else branch is a designated value and the head's evaluate leaves the call when it sees it. One file, and the lane's recommendation. The body's type becomes a number or the sentinel, which is the If(cond, z, sentinel) shape this page already doubts will compile to typed code, and the thirty-odd files that call applyDefinition directly (tests, the finder, the area scripts) see the sentinel as a value.
      • (c) A Lattice carrier. Against answer 7 (one carrier, two domains), and FindStat's Lattices rows are read as Poset values.
      • (d) The domain as data. A definition carries a predicate over the subject (where: IsLattice(_x), with a size condition where a statistic has no value on the smallest lattices). One helper, called by the head and by the carrier's statistics table, evaluates it first and leaves the call when it is false. The body stays a number on its domain and compiles as the poset statistics do; the record can print the domain, and the crosscheck and the finder can read it. It touches more: the Definition type, the two call sites in declare.ts, the entries generator, and the build's compile cross-check, which must take its subjects from the domain. Not checked: that cross-check's sampling.
    • Lean: (d), then (b). (b) is the smaller change and unblocks the lane as written; (d) keeps the compiled route out of the question and makes the domain something the page and the tools can read, which the next partial statistics (a graph statistic on connected graphs only) will want too.
  2. Is the empty poset a lattice? Decided: yes. FindStat's rows say it is (([],0) for St001754, St001990), the definition is vacuous, and the guard order is unchanged. Counts give 0; statistics with no natural value decline.
  3. Cap the sweep by collection? Decided: yes, Lattices 7 deep, 6 or 7 standard, with the snapshot through 7. Why: with the carrier's cap of 5 the standard run holds St001719 to one value and cannot tell St000550 from St000551 (measured above).
  4. Slice size. Decided: all 23, tier 2 last so it can drop without touching tier 1. Why: tier 1 is where the verification is strongest and the cost lowest, tier 2 is 2^n but needs nothing new. If compile or standard-run time of tier 2 is too high at n = 7, ship tier 1 and keep tier 2 for the next batch.
  5. Names. Decided: LatticeCenterRank (the rows count the rank of the Boolean center; the title says binary logarithm of its size) and LatticeBreadth (Breadth is a permutation statistic). Why: bare names where free, prefixed only for Breadth, and CenterSize is taken. Alternatives: CenterBinaryLogarithm; BreadthOfLattice.
  6. ZeroDivisorCount bare or prefixed? Decided: bare. Free today; a ring statistic with the same name would take the prefix then, as GraphLeafCount did.
  7. A separate area file? Decided: posets/src/statistics.lattices.ts, LATTICE_STATISTICS, joined into the area's list, with its own record domain: "Lattice statistics". Why: one carrier, two domains; the Poset carrier record and Lattices(n) stay untouched, and Lattices(n), a restriction of Posets(n), waits for that collection (out of scope here).
  8. A Lattice protocol bridge (GreatestLowerBound and LeastUpperBound on a Poset): out of scope; the joins and meets here are tables, not those heads.

Measured versus assumed

Measured (Python, stdlib, one run at a time, each under a minute): the 34 statistics, titles and Sage-code presence; rows per size and the union of spellings per size (1, 1, 1, 1, 2, 5, 15, 53, 222, and 905 of 1,078); that all 25,183 rows relabel to a natural, transitively reduced poset and form a lattice; the readings of 27 statistics against every crawl row (all agree except the title of St000550); the Epsil-shaped readings of 23 against the rows (all agree, with an n cap where noted); the alternative reading for St000550 (78/78); the identities St001679 = 2^(n−1) + 2·St001677, St001881 = max(1, St001613); breadth over join-irreducibles only; IsLattice three ways on 96,428 posets with the counts of lattices up to isomorphism; the Epsil-shaped IsLattice on all posets through 6; per-statistic distinct values on the lattices through 5, 6 and 7; snapshot sizes; the head-name collision checks; and that the sweep caps Poset objects by carrier (read from #1354's crosscheck-sweep.ts).

Probed in the repository (the lattice lane, 2026-11-15): IsLattice can be a predicate with a boolean result; a definition cannot decline (question 1).

Assumed or unverified: that any of this compiles; that Min and Max over If(cond, z, sentinel) map compile to the typed list shape that withRelation did; cost in compute-engine; that the entries generator takes a second sample; the estimate that 78 lattices times 23 statistics fits the standard run; FindStat's own Sage rank() for St001845 (I matched the rows with longest chain length, not Sage's code); the names (LatticeCenterRank in particular); that no ring statistic will want ZeroDivisorCount; the 1-element and empty values for the statistics that have no row there.

Home

Project

Working

Design: every design page, by subject

Clone this wiki locally