---
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`](https://github.com/AndreasSchachner/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](../README.md).

## 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](https://arxiv.org/abs/2310.06820)] on NTFE FRSTs [[arXiv:2309.10855](https://arxiv.org/abs/2309.10855)]). \\(h^{1,1}\in\{1,\dots,12\}\\) (staged).
- **`vex`** — phases from **fine, regular, non-star** triangulations ("vex"), deduplicated by identical in-basis \\((\kappa,c_2)\\) (Wall classes) [[arXiv:2512.14817](https://arxiv.org/abs/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\}\\). **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}\\), \\(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}\\)**; 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\ldots12\\) — 3,764,169 polytopes | **3,250,469,154** | — |
| `vex` | \\(h^{1,1} = 2\ldots7\\) — 63,199 polytopes | **3,497,945** | — |

### Counts per \\(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}\\): `vex` is built only for
\\(h^{1,1} = 2\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\\), then \\(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\\)/\\(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}+4\\). For a **favorable** polytope every divisor is irreducible, so this is exactly the prime toric list and `oob_dim = basis_dim + 4` (position \\(i\\) ↔ divisor label \\(i+1\\)). For FRST the interior/origin point is dropped and its \\(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)\\); 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\\)/\\(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\\)/\\(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 \\(\Delta^*\\) with genus \\(g\\) is reducible on \\(X\\): it splits into \\(g+1\\) irreducible components [[arXiv:1712.04946](https://arxiv.org/abs/1712.04946)], so \\(h^{1,1}(X) > h^{1,1}(V)\\). Their \\(\kappa\\)/\\(c_2\\) are stored over the **unfolded** divisor list and therefore span **all** of \\(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+1\\) pairwise-disjoint smooth rational surfaces, which forces \\(\chi(\mathcal{O}_D) = \kappa(D,D,D)/6 + (c_2\!\cdot\!D)/12 = g+1\\). It held in every FRST phase measured (1,351 sampled across \\(h^{1,1}=5\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)\\) alone cannot distinguish components meeting along curves, fewer than \\(g+1\\) components in a non-star model, or components with \\(\chi \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)\\)) 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:

```python
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):

```python
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 10\\)), `n_frst_classes`, `oob_dim` (the **unfolded** divisor count, \\(h^{1,1}+4\\)), `basis_dim` (< \\(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\\); `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}\\)), `n_components` (components per prime toric
  divisor; all 1 iff favorable), `glsm_charge_matrix`.

Bucketed by \\(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\\)/\\(c_2\\)/`wall_hash`. Cite the frozen
HuggingFace revision used.

## Citation

FRST classes: [arXiv:2310.06820](https://arxiv.org/abs/2310.06820); NTFE FRSTs: [arXiv:2309.10855](https://arxiv.org/abs/2309.10855); vex triangulations: [arXiv:2512.14817](https://arxiv.org/abs/2512.14817); CYTools: [arXiv:2211.03823](https://arxiv.org/abs/2211.03823); Kreuzer–Skarke: [hep-th/0002240](https://arxiv.org/abs/hep-th/0002240).