Upload README_TDF.md

tdf/README_TDF.md

@@ -0,0 +1,274 @@
+---
+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
+
+Papers that used TDF-class models with `jaxvacua`:
+
+- [arXiv:2307.15749](https://arxiv.org/abs/2307.15749) — $W_0$ distributions.
+- [arXiv:2308.15525](https://arxiv.org/abs/2308.15525) — non-SUSY flux vacua.
+- [arXiv:2501.03984](https://arxiv.org/abs/2501.03984) — deep observations of the Type IIB flux landscape.
+
+For citation, licence, and contact details, see the [umbrella `cy-database` card](../README.md).