---
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) |

## 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)
```

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}/
```

## 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.

### 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.

## 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
}
```

## 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>.