---
license: gpl-3.0
task_categories:
  - other
pretty_name: TDF — Trilayer, Double Favourable Calabi–Yau database
tags:
  - physics
  - string-theory
  - flux-compactifications
  - calabi-yau
  - mathematics
  - toric-geometry
  - kreuzer-skarke
size_categories:
  - 1M<n<10M
configs:
  - config_name: tdf
    data_files:
      - split: catalog
        path: tdf/catalog.parquet
      - split: conifold_catalog
        path: tdf/conifold_catalog.parquet
---

# TDF — Trilayer, Double Favourable Calabi–Yau database

**Toric Calabi–Yau threefold hypersurfaces from the Kreuzer–Skarke list, precomputed for use with [`stringforge`](https://github.com/AndreasSchachner/stringforge) and [`jaxvacua`](https://github.com/AndreasSchachner/jaxvacua).**

This is one sub-dataset of the larger [`cy-database`](../) repository. For shared conventions (lazy access, cache modes, offline mode, schema versioning, mirror convention) see the [umbrella card](../README.md).

## Scope

TDF covers Calabi–Yau threefolds $X$ realised as **trilayer, double favourable** anti-canonical hypersurfaces in toric varieties from the Kreuzer–Skarke list [[arXiv:hep-th/0002240](https://arxiv.org/abs/hep-th/0002240)]. Each model is uniquely identified by

- `ks_id` — the Kreuzer–Skarke 4D reflexive-polytope identifier;
- `triang_id` — the triangulation identifier within that polytope (different triangulations generally give rise to different Calabi–Yau geometries).

For each model the dataset provides (when computed):

- **Topological data**: triple intersection numbers $\kappa_{ijk}$, second Chern class $c_2$, Euler characteristic $\chi$, Hodge numbers $h^{1,1}$ and $h^{2,1}$, Kähler-cone generators and hyperplanes.
- **Gopakumar–Vafa invariants** $n_q^0$ (and Gromov–Witten data where available).
- **Conifold data**: conifold curves, GV invariants of shrinking cycles, integer basis-change matrices.
- **Polytope data**: lattice points of the reflexive polytope.
- **Extra properties**: the D3 tadpole $\chi/24$ and miscellaneous precomputed fields.

Hodge ranges span $h^{1,1},\, h^{2,1} \in \{1,\, \dots,\, \sim 500\}$.

## Quick start

```bash
pip install stringforge
```

### Pure I/O (no JAXVacua)

```python
from stringforge import TDFDatabase

db = TDFDatabase()                              # downloads catalogue only (~10 MB)
df = db.query(h11=2, has_conifolds=True)        # catalogue-level filter, no shard I/O

# Inspect a single polytope's lattice points without loading the geometry
poly = db.get_polytope(ks_id=int(df.iloc[0]["ks_id"]), h11=2)
```

### Model loading in mirror convention (recommended for JAXVacua)

```python
from stringforge import LCSDatabase

lcs = LCSDatabase(dataset="tdf")                # mirror-convention wrapper
df = lcs.query(h12=2, has_conifolds=True)       # h12 in mirror convention

tree = lcs.load(
    ks_id    = int(df.iloc[0]["ks_id"]),
    triang_id= int(df.iloc[0]["triang_id"]),
    h11      = int(df.iloc[0]["h11"]),          # mirror h11
    h12      = int(df.iloc[0]["h12"]),          # mirror h12
    include_gv        = True,
    include_conifolds = True,
)

# Or construct a fully initialised FluxVacuaFinder directly
finder = lcs.load_model(
    ks_id    = int(df.iloc[0]["ks_id"]),
    triang_id= int(df.iloc[0]["triang_id"]),
    include_gv        = True,
    include_conifolds = True,
    maximum_degree    = 2,
)
```

### Streaming batches without local-disk accumulation

```python
from stringforge import LCSDatabase

lcs_lean = LCSDatabase(dataset="tdf", cache_mode="none")
for tree in lcs_lean.iter_batch(h11=2, include_gv=True):
    ...
```

A full walkthrough — including offline mode, batched loading, and vacua persistence — is in the [`stringforge` documentation](https://github.com/AndreasSchachner/stringforge/tree/main/documentation/source/tutorials).

## Sub-dataset layout

```
tdf/
    README.md                       ← this file
    catalog.parquet                 ← main index, ~10 MB
    conifold_catalog.parquet        ← per-conifold sub-catalogue
    schema.json                     ← schema version + description
    manifest.json                   ← incremental-build manifest

    lcs_data/h11_{N}/               ← geometry data, sharded by h^{1,1}
        data-00000.parquet
        data-00001.parquet
        ...
    gv/h11_{N}/                     ← Gopakumar–Vafa invariants, sharded by h^{1,1}
        data-00000.parquet
        ...
    conifolds/h11_{N}/              ← conifold-limit data, sharded by h^{1,1}
        data-00000.parquet
        ...
    polytope/                       ← reflexive polytope data (one row per ks_id)
        data-00000.parquet
        ...
    extra/                          ← miscellaneous precomputed fields
        data-00000.parquet
        ...
```

### Why $h^{1,1}$-bucketed?

The row size for `lcs_data`, `gv`, and `conifolds` scales strongly with $h^{1,1}$: intersection-number tensors are $O(h^3)$, GV charge vectors have length $h$, conifold curves are $h$-vectors. Placing small- and large-$h^{1,1}$ rows in the same Parquet file would force fixed-width columns sized for the largest entry, wasting space and I/O.

Bucketing by $h^{1,1}$ also means a query like `db.load_batch(h11=3)` pulls only the `h11_3` sub-directories — small-$h^{1,1}$ users never need to download large-$h^{1,1}$ shards.

The `polytope` and `extra` splits are flat (not $h^{1,1}$-bucketed) because their rows are small and uniform.

### Shard sizing

Shard sizes are adaptive per (split, $h^{1,1}$) bucket, targeting ≈ 30 shards per bucket, clamped to $[500,\; 50\,000]$ rows. Without this, `conifolds/h11_{10}/` with millions of rows would explode into thousands of tiny files.

## Catalogue schema

The main `catalog.parquet` is the entry point. One row per $(\text{ks\_id},\, \text{triang\_id})$ pair, with shard pointers into the data splits.

| Column | Type | Description |
|---|---|---|
| `ks_id` | `int64` | Kreuzer–Skarke polytope identifier |
| `triang_id` | `int64` | Triangulation identifier within the polytope |
| `h11` | `int64` | Hodge number $h^{1,1}(X)$ (catalogue convention) |
| `h12` | `int64` | Hodge number $h^{2,1}(X)$ (catalogue convention) |
| `chi` | `int64` | Euler characteristic $\chi(X) = 2\,(h^{1,1} - h^{2,1})$ |
| `lcs_shard_id` | `int64` | Shard index in `lcs_data/h11_{h11}/` |
| `lcs_row_index` | `int64` | Row within that shard |
| `gv_shard_id` | `Int64` (nullable) | Shard index in `gv/h11_{h11}/` — null if GV data unavailable |
| `gv_row_index` | `Int64` (nullable) | Row within that shard |
| `has_gv` | `bool` | Whether GV data is present |
| `n_conifolds` | `int64` | Number of conifold limits available |
| `conifold_shard_id` | `Int64` (nullable) | First shard index in `conifolds/h11_{h11}/` — null if `n_conifolds == 0` |
| `polytope_shard_id` | `int64` | Shard index in `polytope/` (shared across triangulations of the same `ks_id`) |
| `polytope_row_index` | `int64` | Row within that shard |
| `D3_tadpole` | `int64` | $\chi/24$ |

A smaller `conifold_catalog.parquet` lists one row per $(\text{ks\_id},\, \text{triang\_id},\, \text{conifold\_id})$ triple, with columns `ks_id`, `triang_id`, `conifold_id`, `h11`, `h12`, `ncf`, `conifold_curve`, `conifold_shard_id`, `conifold_row_index`.

> **Mirror convention.** The catalogue exposes Hodge numbers in *catalogue convention* (typically small `h11`, large `h12`). Use `stringforge.LCSDatabase(dataset="tdf")` for the *mirror* convention used by `jaxvacua.lcs.lcs_tree`; it swaps the two columns at the boundary.

## Data splits

### `lcs_data/h11_{N}/`

One row per model. Contains the topological data needed to build the Kähler cone and the LCS prepotential.

| Column | Description |
|---|---|
| `ks_id`, `triang_id`, `h11`, `h12`, `chi` | Identity |
| `intnums` | Triple intersection numbers $\kappa_{ijk}$ of the mirror (dense tensor) |
| `c2` | Second Chern class $c_{2,i}$ |
| `generators_kahler_cone` | Kähler-cone generators |
| `rays_kahler_cone`, `tip_of_stretched_kahler_cone` | Kähler-cone geometry |
| `hyperplanes` | Hyperplane constraints defining the cone |

### `gv/h11_{N}/`

Gopakumar–Vafa invariants, one row per model that has GV data.

| Column | Description |
|---|---|
| `ks_id`, `triang_id`, `h11`, `h12` | Identity |
| `GVs`, `GWs` | Dictionaries of GV and GW invariants keyed by effective-curve charge |
| `grading_vector` | Grading vector used during the computation |

### `conifolds/h11_{N}/`

One row per $(\text{ks\_id},\, \text{triang\_id},\, \text{conifold\_id})$ triple.

| Column | Description |
|---|---|
| `ks_id`, `triang_id`, `h11`, `h12`, `conifold_id` | Identity |
| `ncf` | GV invariant of the shrinking curve |
| `conifold_curve` | Charge vector $c \in \mathbb{Z}^{h^{1,1}}$ of the shrinking cycle |
| `basis_change` | Integer basis rotation matrix placing the conifold modulus first |

### `polytope/`

One row per `ks_id` (shared across all triangulations of that polytope).

| Column | Description |
|---|---|
| `ks_id` | Identity |
| `polytope_points` | Lattice points of the reflexive polytope (2D integer array) |

### `extra/`

Miscellaneous scalar fields that vary per model.

| Column | Description |
|---|---|
| `ks_id`, `triang_id`, `h11`, `h12` | Identity |
| `chi` | Euler characteristic |
| `D3_tadpole` | $\chi/24$ |
| ... | Additional precomputed properties |

## Loading without `stringforge`

Plain Parquet access with `pandas` + `huggingface_hub`:

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

# Download only the catalogue
catalog_path = hf_hub_download(
    repo_id   = "aschachner/cy-database",
    filename  = "tdf/catalog.parquet",
    repo_type = "dataset",
)
catalog = pd.read_parquet(catalog_path)

# Resolve a specific model's geometry shard
row = catalog.query("ks_id == 716 and triang_id == 1").iloc[0]
lcs_path = hf_hub_download(
    repo_id   = "aschachner/cy-database",
    filename  = f"tdf/lcs_data/h11_{int(row['h11'])}/data-{int(row['lcs_shard_id']):05d}.parquet",
    repo_type = "dataset",
)
lcs = pd.read_parquet(lcs_path)
model_row = lcs.iloc[int(row["lcs_row_index"])]
```

`stringforge.TDFDatabase` (pure I/O) and `stringforge.LCSDatabase(dataset="tdf")` (JAXVacua-compatible model loading) wrap this pattern with a consistent API, caching, mirror-convention handling, and filtering.

## Scope and limitations specific to TDF

- Only **trilayer, double favourable** toric hypersurfaces are included. Other toric and non-toric constructions live in separate sub-datasets (e.g. [`cicy/`](../cicy/)).
- GV invariants are precomputed only for a subset of models — use `has_gv=True` in queries to filter.
- Conifold data is present only for models with at least one conifold limit — use `has_conifolds=True` in queries.

## Building / updating

Produced from a local collection of per-model pickle files by the `build_tdf_database` notebook under [`stringforge/private/database/`](https://github.com/AndreasSchachner/stringforge/tree/main/private/database). Builds are incremental: models already in the manifest (by content hash) are skipped; only new or changed models are appended to the existing shards.

## Additional references

For citation, licence, and contact details, see the [umbrella `cy-database` card](../README.md).