cicy/README.md

---
license: gpl-3.0
task_categories:
  - other
pretty_name: CICY — Complete-intersection Calabi–Yau threefold database
tags:
  - physics
  - string-theory
  - flux-compactifications
  - calabi-yau
  - complete-intersection
  - mathematics
size_categories:
  - 1K<n<10K
configs:
  - config_name: cicy
    data_files:
      - split: catalog
        path: cicy/catalog.parquet
---

# CICY — Complete-intersection Calabi–Yau threefold database

**Complete-intersection Calabi–Yau (CICY) threefolds, 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

CICY covers the 7\,890 complete-intersection Calabi–Yau threefolds first classified by Candelas et al., realised as the vanishing locus of a set of homogeneous polynomials inside a product of complex projective spaces. Each model is uniquely identified by

- `cicy_id` — the integer index in the CICY list, with $1 \le \text{cicy\_id} \le 7\,890$.

For each model the dataset provides (when computed):

- **Topological data**: triple intersection numbers $\kappa_{ijk}$ (stored in coordinate / "COO" form), second Chern class $c_2$, $a$-matrix, Hodge numbers $h^{1,1}$ and $h^{2,1}$, Euler characteristic $\chi$, Kähler-cone generators and rays, Mori-cone rays, hyperplane constraints, and an integer basis change to a tractable working basis.
- **Gopakumar–Vafa invariants** $n_q^0$ in sparse form (`gv_charges`, `gv_invariants`) together with the grading vector used during the computation.
- **Extra data**: per-model auxiliary fields stored as a dictionary column (`extra_data`).

The current catalogue contains **7\,406 models** with Hodge ranges $h^{1,1} \in \{0,\, \dots,\, 101\}$ and $h^{2,1} \in \{0,\, \dots,\, 19\}$ in catalogue convention (equivalently, $h^{1,1} \in \{0,\, \dots,\, 19\}$ and $h^{2,1} \in \{0,\, \dots,\, 101\}$ in mirror convention). Of these, **4\,511 models** carry precomputed GV invariants.

## Quick start

```bash
pip install stringforge
```

### Pure I/O (no JAXVacua)

```python
from stringforge import CICYDatabase

db = CICYDatabase()                                # downloads catalogue only
df = db.query(h11=3)                               # catalogue-level filter
print(df.head())
```

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

```python
from stringforge import LCSDatabase

lcs = LCSDatabase(dataset="cicy")                  # mirror-convention wrapper
df  = lcs.query(h12=3, has_gv=True)                # h12 in mirror convention

tree = lcs.load(
    cicy_id    = int(df.iloc[0]["cicy_id"]),
    include_gv = True,
)

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

### Streaming batches without local-disk accumulation

```python
from stringforge import LCSDatabase

lcs_lean = LCSDatabase(dataset="cicy", cache_mode="none")
for tree in lcs_lean.iter_batch(h12=3, include_gv=True):
    ...
```

## Sub-dataset layout

```
cicy/
    README.md                       ← this file
    catalog.parquet                 ← main index, one row per cicy_id
    schema.json                     ← schema version + description
    manifest.json                   ← incremental-build manifest

    lcs_data/h11_{N}/               ← geometry data, sharded by h^{1,1}
        data-00000.parquet
        ...
    gv/                             ← Gopakumar–Vafa invariants (flat split)
        data-00000.parquet
        ...
```

Unlike the [TDF sub-dataset](../tdf/), CICY does **not** carry per-conifold or polytope splits: the construction is a complete intersection in an ambient projective product, so reflexive-polytope data and shrinking-curve / conifold metadata are not part of the standard model identity.

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

The `lcs_data` split is bucketed by $h^{1,1}$ because the per-row sizes (intersection-number tensors $O(h^3)$, $a$-matrices $O(h^2)$, GV charge vectors $O(h)$) scale strongly with the rank. Bucketing keeps fixed-width Parquet columns at the size appropriate for each rank, and lets `db.load_batch(h11=k)` pull only the `h11_k/` directory.

The `gv` split is *flat* (not $h^{1,1}$-bucketed) because GV invariants are stored in sparse coordinate form, so each row's size is determined by the number of effective curves rather than by $h$.

## Catalogue schema

The main `catalog.parquet` is the entry point. One row per `cicy_id`, with shard pointers into the data splits.

| Column | Type | Description |
|---|---|---|
| `cicy_id` | `int64` | CICY list index, $1 \le \text{cicy\_id} \le 7\,890$ |
| `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` (nullable) | Shard index in `lcs_data/h11_{h11}/` |
| `lcs_row_index` | `Int64` (nullable) | Row within that shard |
| `gv_shard_id` | `Int64` (nullable) | Shard index in `gv/` — null if GV data unavailable |
| `gv_row_index` | `Int64` (nullable) | Row within that shard |
| `has_gv` | `bool` | Whether GV data is present |

> **Mirror convention.** The catalogue exposes Hodge numbers in *catalogue convention*. Use `stringforge.LCSDatabase(dataset="cicy")` 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 |
|---|---|
| `cicy_id`, `h11`, `h12`, `chi` | Identity |
| `intnums_coo_i`, `intnums_coo_j`, `intnums_coo_k`, `intnums_coo_v` | Triple intersection numbers $\kappa_{ijk}$ in coordinate (COO) sparse form |
| `c2` | Second Chern class $c_{2,i}$ |
| `a_matrix` | Symmetrised second-derivative matrix $a_{ij}$ entering the LCS prepotential |
| `hyperplanes` | Hyperplane constraints defining the Kähler cone |
| `kahler_generators` | Kähler-cone generators in the working basis |
| `kahler_rays` | Rays of the Kähler cone |
| `mori_rays` | Rays of the Mori cone |
| `basis_change` | Integer change-of-basis matrix to the working basis |
| `extra_data` | Per-model auxiliary fields, stored as a dictionary column |

### `gv/`

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

| Column | Description |
|---|---|
| `cicy_id`, `h11`, `h12` | Identity |
| `gv_charges` | Array of effective-curve charge vectors $q \in \mathbb{Z}^{h^{1,1}}$ |
| `gv_invariants` | Array of integer GV invariants $n_q^0$, aligned with `gv_charges` |
| `grading_vector` | Grading vector used during the computation |

## 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  = "cicy/catalog.parquet",
    repo_type = "dataset",
)
catalog = pd.read_parquet(catalog_path)

# Resolve one model's geometry shard
row = catalog.query("cicy_id == 7884").iloc[0]
lcs_path = hf_hub_download(
    repo_id   = "aschachner/cy-database",
    filename  = f"cicy/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.CICYDatabase` (pure I/O) and `stringforge.LCSDatabase(dataset="cicy")` (JAXVacua-compatible model loading) wrap this pattern with a consistent API, caching, mirror-convention handling, and filtering.

## Scope and limitations specific to CICY

- Models are stored in the working basis defined by `basis_change`; downstream code that needs the original CICY-list basis should apply the inverse rotation.
- GV invariants are precomputed only for a subset of models — use `has_gv=True` in queries to filter.
- CICY threefolds in the standard list **do not carry conifold or polytope metadata**: this dataset has no `conifold_catalog.parquet`, no `conifolds/` split, and no `polytope/` split. Conifold-aware workflows should use the [TDF sub-dataset](../tdf/).
- The catalogue currently lists **7\,406** models out of the canonical 7\,890; missing entries reflect ongoing computation of the topological data and will be back-filled in incremental rebuilds.

## Building / updating

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

## References

- P. Candelas, A. M. Dale, C. A. Lütken, R. Schimmrigk, *Complete Intersection Calabi–Yau Manifolds*, Nucl. Phys. B 298 (1988) 493.

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