toric/README.md

metadata

license: gpl-3.0
task_categories:
  - other
pretty_name: toric — FRST + vex Calabi–Yau phases from the Kreuzer–Skarke list
tags:
  - physics
  - string-theory
  - calabi-yau
  - mathematics
  - toric-geometry
  - kreuzer-skarke
  - triangulations
size_categories:
  - 100M<n<1B
configs:
  - config_name: polytopes
    data_files:
      - split: polytope_catalog
        path: toric/polytope_catalog/h11_*/data-*.parquet
  - config_name: frst
    data_files:
      - split: catalog
        path: toric/frst/catalog/h11_*/data-*.parquet
  - config_name: vex
    data_files:
      - split: catalog
        path: toric/vex/catalog/h11_*/data-*.parquet

toric — FRST + vex Calabi–Yau phases from the Kreuzer–Skarke list

Distinct Calabi–Yau threefold phases from triangulations of 4D reflexive polytopes, precomputed for use with stringforge.

FRST and vex phases are built from the same Kreuzer–Skarke polytopes, so they ship as one sub-dataset with a shared polytope layer and per-mode phase layers (mode ∈ {"frst","vex"}). The polytope geometry is stored once; the shared polytope_catalog carries both phase counts. One sub-dataset of the larger cy-database repository; for shared conventions (lazy access, cache modes, schema versioning) see the umbrella card.

Two modes

• frst — inequivalent CY phases = distinct CYTools cy()-classes among the Fine, Regular, Star Triangulations of a polytope (FRST-class technology [arXiv:2310.06820] on NTFE FRSTs [arXiv:2309.10855]). $h^{1,1}\in \{1,\dots ,12\}h^\{1,1\}\backslash in\backslash \{1,\backslash dots,12\backslash \}$ (staged).
• vex — phases from fine, regular, non-star triangulations ("vex"), deduplicated by identical in-basis $(\kappa ,c_2)(\backslash kappa,c\_2)$ (Wall classes) [arXiv:2512.14817]. The resulting toric varieties are non-weak-Fano; their anticanonical hypersurfaces are smooth and birational to the FRST ones. $h^{1,1}\in \{2,\dots ,7\}h^\{1,1\}\backslash in\backslash \{2,\backslash dots,7\backslash \}$. Every vex polytope is an FRST polytope (vex ⊆ frst), so vex attaches to a subset of the shared polytopes.

Each phase is identified by (mode, h11, ks_id, triang_id) and carries ${\kappa }_{ijk}\backslash kappa\_\{ijk\}$, $c_{2}c\_2$, the triangulation heights, and a diffeomorphism fingerprint wall_hash. Each polytope (shared) carries its vertices, CY basis, GLSM charge matrix, favourability flags, and both modes' counts.

What is published right now

The dataset is released in stages by $h^{1,1}h^\{1,1\}$; a bucket appears only once it is complete and has passed the validation gate below. manifest.json is authoritative — each bucket carries complete: true only when its polytope coverage matches the ks_id_map.

mode	published	phases	staged (not yet uploaded)
frst	$h^{1,1}=1\dots 12h^\{1,1\}\; =\; 1\backslash ldots12$ — 3,764,169 polytopes	3,250,469,154	—
vex	$h^{1,1}=2\dots 7h^\{1,1\}\; =\; 2\backslash ldots7$ — 63,199 polytopes	3,497,945	—

Counts per $h^{1,1}h^\{1,1\}$

$h^{1,1}h^\{1,1\}$	polytopes	frst phases	vex phases
1	5	5	—
2	36	36	4
3	244	275	141
4	1,197	1,774	2,536
5	4,990	11,847	34,066
6	17,101	75,571	350,454
7	50,376	475,409	3,110,744
8	128,165	2,877,486	—
9	285,929	16,750,698	—
10	568,078	93,719,914	—
11	1,022,264	505,406,669	—
12	1,685,784	2,631,149,470	—
total	3,764,169	3,250,469,154	3,497,945

An em-dash means the mode does not exist at that $h^{1,1}h^\{1,1\}$: vex is built only for $h^{1,1}=2\dots 7h^\{1,1\}\; =\; 2\backslash ldots7$.

Do not infer absence of a polytope from absence of a bucket. Query manifest.json (or query_polytopes(h11=…)) before concluding that something is missing.

Identifiers

• ks_id — 0-based index of the polytope in the Kreuzer–Skarke emission order, cytools.fetch_polytopes(h11=N, lattice="N"). Reproducible; the cross-dataset key together with polytope_hash.
• triang_id — the phase index within a polytope, 0 … n_{mode}_classes-1, assigned as the deterministic rank under a total order (canonical in-basis $\kappa \backslash kappa$, then $c_{2}c\_2$, then heights). Regenerable. FRST and vex index independently.
• phase_id — "{mode}:{h11}:{ks_id}:{triang_id}".
• polytope_hash — sha256(repr(normal_form)) of the polytope; lattice-automorphism-canonical. Bridges frst↔vex↔tdf by content.
• wall_hash — sha256 of the Wall data (h11, h12, canonical in-basis κ, canonical in-basis c₂). A necessary diffeomorphism pre-filter (Wall 1966) in the fixed cy_basis (see below).

Conventions (read before using the geometry)

• Toric schema_version: 3 (non-favorable unfolding). schema.json carries the full changelog; stringforge refuses a bucket whose version it does not understand.

• Normalized storage (unfolded divisors, 0-indexed). $\kappa \backslash kappa$/\(c_2\) are stored out-of-basis over the unfolded divisor list — one entry per irreducible component of each prime toric divisor — at positions 0 … oob_dim-1, with oob_dim = $h^{1,1}+4h^\{1,1\}+4$. For a favorable polytope every divisor is irreducible, so this is exactly the prime toric list and oob_dim = basis_dim + 4 (position $ii$ ↔ divisor label $i+1i+1$). For FRST the interior/origin point is dropped and its $c_{2}c\_2$ preserved as the scalar c2_origin (null for vex). The in-basis form is recovered by slicing to cy_basis — helper in_basis_from_stored(coo, c2, cy_basis).

• cy_basis spans $H^{1,1}(X)H^\{1,1\}(X)$; its first basis_dim entries are the deterministic GLSM sub-basis — Polytope(vertices, deterministic_glsm_basis=True).glsm_basis(), re-expressed as 0-indexed positions. That prefix is what indexes the rows of glsm_charge_matrix; any remaining entries are the extra components of reducible divisors and occur only for non-favorable polytopes. The flag makes the choice reproducible across machines, so the same basis — and hence the same in-basis $\kappa \backslash kappa$/\(c_2\), wall_hash and triang_id — can be reconstructed from the stored vertices. The build recomputes it rather than carrying it over from intermediate files. Checked by sampled recompute in every bucket: in-basis $\kappa \backslash kappa$/\(c_2\) match CYTools exactly (audits.sampled_recompute).

• Non-favorable polytopes are included, flagged (fav_N=False, basis_dim < h11), and complete. A prime toric divisor interior to a 2-face of ${\mathrm{\Delta }}^{\ast }\backslash Delta^*$ with genus $gg$ is reducible on $XX$: it splits into $g+1g+1$ irreducible components [arXiv:1712.04946], so $h^{1,1}(X)>h^{1,1}(V)h^\{1,1\}(X)\; >\; h^\{1,1\}(V)$. Their $\kappa \backslash kappa$/\(c_2\) are stored over the unfolded divisor list and therefore span all of $H^{1,1}(X)H^\{1,1\}(X)$, in the same format as the favorable case — favorable is the degenerate case where every n_components is 1. One exception. The split assumes a reducible divisor is $g+1g+1$ pairwise-disjoint smooth rational surfaces, which forces $\chi ({\mathcal{O}}_D)=\kappa (D,D,D)\mathrm{/}6+(c_2\text{\hspace{0.17em}⁣}\cdot \text{\hspace{0.17em}⁣}D)\mathrm{/}12=g+1\backslash chi(\backslash mathcal\{O\}\_D)\; =\; \backslash kappa(D,D,D)/6\; +\; (c\_2\backslash !\backslash cdot\backslash !D)/12\; =\; g+1$. It held in every FRST phase measured (1,351 sampled across $h^{1,1}=5\dots 10h^\{1,1\}=5\backslash ldots10$) and fails for 17,461 of 34,079 non-favorable vex phases, which keep the ambient truncation instead; the other 16,618 are unfolded. FRST is unfolded throughout. Why it fails is an open question — $\chi ({\mathcal{O}}_D)\backslash chi(\backslash mathcal\{O\}\_D)$ alone cannot distinguish components meeting along curves, fewer than $g+1g+1$ components in a non-star model, or components with $\chi \mathrm{\ne }1\backslash chi\; \backslash neq\; 1$. Determine completeness per phase from the geometry, not from oob_dim: len(c2) == sum(n_components) means unfolded, len(c2) == len(n_components) means ambient. oob_dim and the favourability flags are stored once per polytope and are shared by both modes, so they are neither per-phase nor per-mode. CYPhase.covers_full_h11 does exactly this check.

• wall_hash semantics: comparable across frst/vex when the bases agree; it omits torsion and is not a full diffeomorphism invariant. For a non-favorable polytope the two modes are not comparable: FRST hashes the rank-\(h^{1,1}\) unfolded Wall data, while a vex phase left ambient hashes the rank-basis_dim data, so they can never collide. Full identification (GL\((h^{1,1},\mathbb Z)\) acting jointly on $(\kappa ,c_2)(\backslash kappa,c\_2)$) is the deferred small-ICY step.

Quick start

The consumer class ToricCYDatabase (query(mode, …), query_polytopes(…), O(1) load(mode, …, in_basis=), shared get_polytope(…)) and the per-phase object CYPhase ship with stringforge; they read the sharded layout (below) directly:

from stringforge import CYPhase, ToricCYDatabase
db   = ToricCYDatabase.from_local("…/cy-database")      # local build; the dir with toric/, or toric/
pcat = db.query_polytopes(h11=4)                        # shared: n_frst_classes AND n_vex_classes
cp   = db.query("frst", h11=4)                          # per-FRST-phase (thin) catalog
geom = db.load("frst", h11=4, ks_id=0, triang_id=0, in_basis=True)   # O(1) via the _ksid_index
phase = CYPhase.from_database(db, mode="frst", h11=4, ks_id=1, triang_id=0)   # -> ToricCYPhase
kappa = phase.intersection_numbers(in_basis=True)       # stored; no CYTools import

Note that ks_id is unique only within one h11, so all four of (mode, h11, ks_id, triang_id) are needed to name a phase. Access is currently local only; lazy download of the sharded layout from the Hub is not yet implemented.

To read the Parquet directly, use a per-h11 dataset over the sharded parts (they are large — always filter, and at h11≥10 never load a whole catalog):

import pyarrow.dataset as pds
ds = pds.dataset("…/toric/frst/catalog/h11_4")          # data-*.parquet + _metadata
df = ds.to_table(filter=pds.field("fav_N") == True).to_pandas()

Sub-dataset layout (sharded per h11)

toric/
    README.md   schema.json   manifest.json   provenance.json
    polytope_catalog/h11_{N}/data-*.parquet   ← ONE row/polytope (shared): meta + FRST counts
    polytope/h11_{N}/data-*.parquet           ← ONE copy: vertices, cy_basis, glsm_charge_matrix, polytope_hash
    polytope_vex_counts/h11_{N}/data-*.parquet← ks_id, n_vex, n_vex_classes   (h11=2..7; joined on read)
    frst/catalog/h11_{N}/data-*.parquet       ← thin per-FRST-phase rows
    frst/geom/h11_{N}/data-*.parquet          ← heights, intnums_coo_{i,j,k,v}, c2, c2_origin
    vex/catalog/h11_{N}/ …   vex/geom/h11_{N}/ …    (h11 = 2..7)

Each split dir also has _ksid_index.parquet (ks_id → (part, row0, n) for O(1) point lookups) and a pyarrow _metadata (for efficient dataset scans). Parts are immutable (streaming build); h11=12 has thousands of parts per split. Each part is written with ~25k-row row groups, so a single record is fetched by reading only its row group — locally, or via HTTP range reads remotely (e.g. pyarrow.parquet.ParquetFile(url, filesystem=HfFileSystem())) — not the whole part/file.

Schemas

• polytope_catalog/ (shared, per polytope): h11, ks_id, h12, polytope_hash, fav_N, fav_M, trilayer, n_rigids, n_rigids_dual, FRST counts n_frsts, n_ntfe_frsts:Int64 (nullable; present for $h^{1,1}\ge 10h^\{1,1\}\backslash ge\; 10$), n_frst_classes, oob_dim (the unfolded divisor count, $h^{1,1}+4h^\{1,1\}+4$), basis_dim (< $h^{1,1}h^\{1,1\}$ iff non-favorable).
• polytope_vex_counts/ (per vex polytope): ks_id, n_vex, n_vex_classes. query_polytopes left-joins this onto polytope_catalog by ks_id (null where a polytope has no vex).
• {mode}/catalog/ (thin, per phase): h11, ks_id, triang_id, h12, fav_N, fav_M, trilayer, wall_hash:binary(32) (raw sha256 digest — .hex() for the string form), geom_shard_id, geom_row_index. polytope_hash is not stored (join via ks_id); phase_id is derived ("{mode}:{h11}:{ks_id}:{triang_id}").
• {mode}/geom/ (per phase): h11, ks_id, triang_id, heights:list<float> (verbatim; vex may be non-integer), intnums_coo_{i,j,k}:list<int16> + intnums_coo_v:list<int64> (0-indexed positions into the unfolded divisor list), c2:list<int32> (length oob_dim; shorter — the ambient length — for a vex phase left ambient), c2_origin:Int64 (dropped origin $c_{2}c\_2$; null for vex).
• polytope/ (shared): h11, ks_id, polytope_hash, vertices, cy_basis (0-indexed positions into the unfolded divisor list; length $h^{1,1}h^\{1,1\}$), n_components (components per prime toric divisor; all 1 iff favorable), glsm_charge_matrix.

Bucketed by $h^{1,1}h^\{1,1\}$ (phase count explodes — frst h11=12 ≈ 2.4 B phases); zstd compression. Scale caveat: at h11≥10 use point lookups (ks_id) or filtered scans; an unfiltered whole-h11 query returns billions of rows.

Provenance & reproducibility

provenance.json records the exact CYTools version + install path + git SHA (if available), Python, numpy, pandas, pyarrow versions, and experimental_features: true (vex vector_config and non-favorable CY construction use CYTools experimental features). ks_id is the Kreuzer–Skarke emission order, map-verified (ks_id_collection). Every phase is self-verifying: rebuild the triangulation from the stored heights via CYTools (FRST → CalabiYau via .cy(); vex → a toric Fan via p.vc().triangulate(heights)) and re-derive $\kappa \backslash kappa$/\(c_2\)/wall_hash. Cite the frozen HuggingFace revision used.

Citation

FRST classes: arXiv:2310.06820; NTFE FRSTs: arXiv:2309.10855; vex triangulations: arXiv:2512.14817; CYTools: arXiv:2211.03823; Kreuzer–Skarke: hep-th/0002240.