README.md

---
license: gpl-3.0
task_categories:
  - other
pretty_name: cy-database — Calabi–Yau geometries for string-compactification workflows
tags:
  - physics
  - string-theory
  - flux-compactifications
  - calabi-yau
  - mathematics
  - mirror-symmetry
size_categories:
  - 1M<n<10M
---

# `cy-database` — Calabi–Yau geometries for string-compactification workflows

Precomputed Calabi–Yau threefold data, organised as a family of **sub-datasets**, accessed through the [`stringforge`](https://github.com/AndreasSchachner/stringforge) infrastructure package. Each sub-dataset covers one class of Calabi–Yau constructions and is keyed by a class-specific identifier system.

This top-level card describes the conventions, layout, and loading interface that are common to all sub-datasets. Each sub-dataset has its own card with construction-specific details.

## Available sub-datasets

| Sub-dataset | Construction class | Identifier | Status | Card |
|---|---|---|---|---|
| [`tdf/`](./tdf/) | Trilayer, double favourable toric hypersurfaces from the Kreuzer–Skarke list | `(ks_id, triang_id)` | Available | [TDF card](./tdf/README.md) |
| [`cicy/`](./cicy/) | Complete-intersection Calabi–Yau threefolds | `cicy_id` | Available | [CICY card](./cicy/README.md) |
| [`kklt/`](./kklt/) | Curated KKLT index over `tdf/` (one-face-divisor conifold classes) | `(ks_id, coni_class_id, coni_id)` | Available | [KKLT card](./kklt/README.md) |
| [`toric/`](./toric/) | All Calabi–Yau phases from triangulations of the Kreuzer–Skarke polytopes, in two modes — FRST classes and VEX (Wall) classes | `(mode, h11, ks_id, triang_id)` | Available, \\(h^{1,1}=1\ldots10\\); \\(h^{1,1}=11,12\\) staged | [toric card](./toric/README.md) |

`toric/` is much the largest sub-dataset — **113,913,015** FRST phases over 1,056,121 polytopes, plus
**3,497,945** VEX phases — and is the one that differs structurally from the others: see
[Where `toric/` differs](#where-toric-differs) before using it.

## Quick start

```bash
pip install stringforge
```

```python
from stringforge import CYDatabase, TDFDatabase, CICYDatabase, LCSDatabase, KKLTDatabase

# 1.  Pure I/O on the TDF sub-dataset (no JAXVacua import)
db = TDFDatabase()                                # downloads catalogue only (~10 MB)
df = db.query(h11=2, has_conifolds=True)          # catalogue-level filter, no shard I/O

# 2.  Same as 1, but in mirror convention and producing JAXVacua model objects
lcs = LCSDatabase(dataset="tdf")                  # mirror-convention wrapper
tree = lcs.load(                                  # returns a jaxvacua.lcs.lcs_tree
    ks_id=int(df.iloc[0]["ks_id"]),
    triang_id=int(df.iloc[0]["triang_id"]),
    h12=int(df.iloc[0]["h12"]),                   # h12 in mirror convention
    include_gv=True,
    include_conifolds=True,
)

# 3.  Plain CICY access
cicy = CICYDatabase()
cicy_df = cicy.query(h11=3)

# 4.  Curated KKLT index (logical links into TDF; no geometry duplication)
kklt = KKLTDatabase()
polys = kklt.query_polytopes(Q_min=100)

# 5.  Toric CY phases (FRST / VEX). Local build only -- see "Where toric/ differs".
from stringforge import ToricCYDatabase
toric = ToricCYDatabase.from_local("/path/to/cy-database")   # the dir holding toric/, or toric/
pcat  = toric.query_polytopes(h11=4, fav_N=True)             # shared polytope layer
frst  = toric.query("frst", h11=4, ks_id=1)                  # phases of one polytope
geom  = toric.load("frst", h11=4, ks_id=1, triang_id=0, in_basis=True)
```

The `LCSDatabase` class is the recommended entry point for JAXVacua workflows: it operates in the mirror convention used by `lcs_tree` / `FluxVacuaFinder` and exposes `load_model(...)` to construct a fully initialised `FluxVacuaFinder` in one call.

## Repository layout

```
aschachner/cy-database/
    README.md                       ← this file (umbrella card)

    tdf/                            ← Trilayer, Double Favourable toric models
        README.md                   ← TDF card
        catalog.parquet
        conifold_catalog.parquet
        schema.json
        manifest.json
        lcs_data/h11_{N}/
        gv/h11_{N}/
        conifolds/h11_{N}/
        polytope/
        extra/

    cicy/                           ← Complete-intersection threefolds
        README.md                   ← CICY card
        catalog.parquet
        schema.json
        manifest.json
        lcs_data/h11_{N}/
        gv/

    kklt/                           ← Curated KKLT index over tdf/
        README.md                   ← KKLT card
        catalog.parquet                       ← polytope-grain
        conifold_class_catalog.parquet        ← class-grain
        conifold_catalog.parquet              ← conifold-grain (with TDF link)
        schema.json
        gv/h11_{N}/

    toric/                          ← FRST + VEX phases of the Kreuzer–Skarke polytopes
        README.md                   ← toric card
        schema.json                           ← NOTE: no monolithic catalog.parquet
        manifest.json
        polytope_catalog/h11_{N}/             ← shared polytope layer, + both modes' counts
        polytope/h11_{N}/                     ← vertices, GLSM basis, charge matrix
        polytope_vex_counts/h11_{N}/
        frst/catalog/h11_{N}/                 ← thin per-phase catalogue, sharded
        frst/geom/h11_{N}/                    ← heights, kappa (COO), c2
        vex/catalog/h11_{N}/
        vex/geom/h11_{N}/
```

## Shared design

All sub-datasets follow the same conventions.

### Format

- **Apache Parquet** shards for all bulk data.
- One small `catalog.parquet` per sub-dataset, serving as the lazy-download entry point. KKLT additionally carries a class-grain and a conifold-grain catalogue.

### Lazy, on-demand access

The [`stringforge.cy_io.CYDatabase`](https://github.com/AndreasSchachner/stringforge/blob/main/stringforge/cy_io.py) class downloads only the files required by a given query:

- `db.query(...)` → catalogue only (~10 MB).
- `db.load(...)` → catalogue + the specific shard(s) needed for one model.
- `db.load_batch(...)` → catalogue + shards for a batch of models.

Constructing a database object performs **no** network access; the first query downloads the catalogue, and only subsequent model-loading steps download shard files.

### Cache modes

- `cache_mode="persistent"` (default): shards are cached in memory (LRU) and on disk. Optimal for repeated access.
- `cache_mode="none"`: shards are downloaded, the requested row is read, and the file is deleted immediately. Ideal for scanning millions of models without filling local disk.

### Offline mode

For HPC clusters without outbound network access, set `offline=True`. All data is served from the local cache; any missing shard raises `FileNotFoundError` instead of triggering a network call. The common pattern is to *warm* the cache on a login node and *replay* on worker nodes.

### Schema versioning

Each sub-dataset carries a `schema.json` file with an integer `schema_version`. `CYDatabase` checks it against the client library's `stringforge.SCHEMA_VERSION` and raises a clear `SchemaVersionError` on incompatibility.
`toric/` is versioned independently against `stringforge.toric_normalize.TORIC_SCHEMA_VERSION`, because its layout evolves separately from the monolithic sub-datasets.

### Bucketing by $h^{1,1}$

Where row sizes scale strongly with $h^{1,1}$ (e.g. triple intersection tensors are $O(h^3)$), data is sub-bucketed by $h^{1,1}$ (directories named `h11_{N}/`). This keeps small-$h^{1,1}$ users from downloading large-$h^{1,1}$ data, and vice versa. Flat splits (small, uniform rows) are not bucketed.

### Adaptive shard sizing

For large buckets (e.g. conifolds at high $h^{1,1}$ with millions of rows), shard sizes are chosen adaptively to target ≈ 30 files per bucket, clamped to $[500,\; 50\,000]$ rows. See each sub-dataset's card for specifics.

### Mirror convention

Catalogues store **`h11`** and **`h12`** in *catalogue convention* (typically small `h11`, large `h12`). JAXVacua works in the *mirror convention* (the two are swapped). Use [`stringforge.lcs_database.LCSDatabase`](https://github.com/AndreasSchachner/stringforge/blob/main/stringforge/lcs_database.py) — which inherits from `CYDatabase` — when working with mirror-convention models; it transparently swaps the two columns at the boundary.


## Where `toric/` differs

`toric/` holds over \\(10^{8}\\) phases, which forces two departures from the shared design above.
Both are visible in the API, so read this before treating it like `tdf/` or `cicy/`.

| | `tdf/`, `cicy/`, `kklt/` | `toric/` |
|---|---|---|
| Catalogue | one `catalog.parquet` | **sharded** `{mode}/catalog/h11_{N}/data-*.parquet` — there is no whole-catalogue file, and no way to load one |
| Access | lazy download from the Hub | **local build only** — `ToricCYDatabase.from_local(...)`; lazy per-shard download is not yet implemented |
| Reader | `TDFDatabase` / `CICYDatabase` / `KKLTDatabase` | `ToricCYDatabase` |
| Key | `(ks_id, triang_id)` or `cicy_id` | `(mode, h11, ks_id, triang_id)` — all four |

Two consequences worth stating plainly:

- **`ks_id` is unique only *within* one \\(h^{1,1}\\).** It is the Kreuzer–Skarke emission order, so the
  same `ks_id` names a different polytope at each \\(h^{1,1}\\). An identifier without `h11` is ambiguous,
  and `CYPhase.from_database` raises rather than guessing.
- **`mode` selects the equivalence, and the two are not nested as phases.** `frst` counts distinct
  CYTools `cy()`-classes of *fine* star triangulations; `vex` counts Wall classes — equal in-basis
  \\((\kappa, c_2)\\) — of *not-necessarily-fine* ones. Every VEX polytope is also an FRST polytope
  (`vex ⊆ frst` **as sets of polytopes**, which is why the polytope layer is shared), but that is *not*
  a containment on phases: the non-fine family is larger, so a polytope routinely has more VEX classes
  than FRST classes.

Because attribute queries stream one shard with predicate pushdown and point lookups go through the
per-\\(h^{1,1}\\) `_ksid_index`, neither operation ever materialises a whole bucket — but you must always
pass `h11`, and at \\(h^{1,1} \ge 10\\) you should never ask for an unfiltered catalogue.

## Geometry objects: `CYPhase`

Alongside the database readers, `stringforge` exposes a small class family that wraps **one geometry**
as an object. It serves the stored data immediately and only materialises CYTools when you ask for
something that genuinely needs it, so `import cytools` never happens on the fast path.

The base class carries exactly the **Wall data** \\((h^{1,1}, h^{2,1}, \kappa, c_2)\\) — by Wall's
theorem (*Invent. Math.* **1** (1966) 355), together with torsion, that fixes the diffeomorphism type
of a smooth simply-connected threefold. Construction-specific material lives in the subclasses.

```python
from stringforge import CYPhase, ToricCYDatabase

db = ToricCYDatabase.from_local("/path/to/cy-database")

# from_database dispatches on the sub-dataset and returns a ToricCYPhase.
# All four of (mode, h11, ks_id, triang_id) are required.
phase = CYPhase.from_database(db, mode="frst", h11=4, ks_id=1, triang_id=0)

phase.hodge_numbers                          # (h11, h21)
phase.euler_characteristic                   # 2 * (h11 - h21)
phase.intersection_numbers(in_basis=True)    # kappa, COO rows (i, j, k, value)
phase.second_chern_class(in_basis=True)      # c2
phase.wall_hash.hex()                        # diffeomorphism pre-filter

# CYTools only from here on, materialised once and cached
cy = phase.to_cytools()                      # CalabiYau for frst, Fan for vex
phase.kahler_cone(version="cup")
phase.gv_invariants(max_deg=3)               # a degree cutoff is required by CYTools
phase.to_lcs_tree()                          # bridge to JAXVacua
assert phase.verify()                        # stored values == a fresh CYTools recompute
```

`in_basis=True` slices the stored prime-toric form to the GLSM basis. The stored form is
**out-of-basis**, indexed by prime toric divisors, so `in_basis=False` (the default) returns a longer
vector — `oob_dim = basis_dim + 4` entries — and `to_dense()` likewise expands to `oob_dim`.

Two cases refuse rather than return something misleading:

- **Non-favorable polytopes** (`fav_N=False`): the GLSM basis spans a proper subspace of
  \\(H^{1,1}(X)\\), so `basis_is_complete` is `False`, in-basis quantities describe only the toric part
  and warn when accessed, and `full_intersection_numbers()` / `full_second_chern_class()` raise.
- **VEX phases**: a not-necessarily-fine triangulation has no `cy()`, so `to_cytools()` returns a
  CYTools `Fan` and the `CalabiYau`-only features — GV invariants, `mori_cone(version="cap")`,
  `kahler_cone(version="cup")`, `to_lcs_tree()` — raise `NotImplementedError`.

CICY geometries load the same way. They live in the `lcs_data` split rather than a catalogue, so they
come through `LCSDatabase`, and the loader un-swaps the stored mirror convention (see the
[CICY card](./cicy/README.md)) so that `h11`, `h12` and `chi` mean the same thing as they do for a
toric phase:

```python
from stringforge import CICYPhase, LCSDatabase

quintic = CICYPhase.from_database(LCSDatabase(dataset="cicy"), cicy_id=7890)
quintic.hodge_numbers            # (1, 101)
quintic.euler_characteristic     # -200
quintic.basis_is_complete        # True only for the 4,511 Kaehler-favourable rows
```

`CICYPhase` deliberately exposes **no** `wall_hash`: that sub-dataset records no basis identification,
so a CICY `wall_hash` would not be comparable to anything.


## Loading without `stringforge`

All sub-datasets are plain Parquet and can be read with any compatible tool:

```python
import pandas as pd
from huggingface_hub import hf_hub_download

catalog_path = hf_hub_download(
    repo_id="aschachner/cy-database",
    filename="tdf/catalog.parquet",
    repo_type="dataset",
)
catalog = pd.read_parquet(catalog_path)
```

Each catalogue contains `(shard_id, row_index)` pointers into the sub-dataset's data splits, so you can resolve individual rows by path construction. See each sub-dataset card for the catalogue schema and resolved path templates.

## Versioning and rebuilds

Builds are incremental: unchanged models (tracked by SHA-256 hash of their source files) are skipped, and only new or changed models are appended. Major layout changes bump `SCHEMA_VERSION` in [`stringforge/cy_io.py`](https://github.com/AndreasSchachner/stringforge/blob/main/stringforge/cy_io.py).

## Scope and limitations

- Data is **precomputed**; not all fields are present for every model. Use `has_gv=True`, `has_conifolds=True`, etc. to filter in `query()`.
- Catalogues use pandas nullable `Int64` for optional shard pointers; consumers that do not support nullable integers should cast or drop missing rows.
- Sub-datasets are independent: different constructions live in separate top-level directories and use different identifier schemes.

## Citation

If you use this dataset, please cite:

```bibtex
@article{XXX
}
```

Application papers include [arXiv:2307.15749](https://arxiv.org/abs/2307.15749), [arXiv:2308.15525](https://arxiv.org/abs/2308.15525), and [arXiv:2501.03984](https://arxiv.org/abs/2501.03984).

Each sub-dataset card lists additional references specific to its construction.

## Licence

GPL-3.0, matching the [`stringforge`](https://github.com/AndreasSchachner/stringforge) and [`jaxvacua`](https://github.com/AndreasSchachner/jaxvacua) libraries.

## Contact

Issues, questions, and contributions: <https://github.com/AndreasSchachner/stringforge/issues>.