Data, with its
relationships intact.
A database engine for storing measurements together with the structure used to compare them. Explore its representation, query language, implementation and measured tradeoffs.
Part of Davis Geometric’s research in data systems. Read the documentation, inspect the benchmarks, or work through GIGI Builds.
01 / A question of representation
The same amount. A different context.
Two transactions can share a value and still differ in merchant, time and neighborhood. This illustrative construction shows how the chosen representation changes what can be compared; it is not a fraud verdict.
GROUP BY, per question.
The κ values above (4.1 / 0.2) are illustrative — the shape of the computation, not a stored run. Measured κ lives below: the iris insert ack (curvature 0.0882) and the /scan benchmark (zero-config PR-AUC 0.6531).
The verbs are your operations.
HOLONOMY, TRANSPORT, GEODESIC, SPECTRAL — the operations at the top of the GQL grammar are the operations you already compute when you look for topological invariants in a continuous spectrum. Parker, Burby, Marston & Tobias showed that a magnetized plasma’s continuum carries nontrivial topology (arXiv:1909.07910, 2019). GIGI stores equilibria as sections of a fiber bundle over parameter space, so those invariants ride along on every query instead of being recomputed post-hoc.
Every database stores data as points in a container and builds an external index. B-trees, inverted indices, HNSW graphs — auxiliary structures bolted onto flat storage.
GIGI says: the geometry IS the index. Data lives on a fiber bundle. The mathematical structure determines where data lives and how it's found.
Keys live on the base; values live on the fiber. A record is a section. A point query evaluates the section — with the record's curvature riding along. Nothing is bolted on, because there is nothing to bolt on to.
Ask questions SQL cannot form.
GQL speaks the bundle natively. Every verb below is a question about the shape of your data that has no SQL translation — not harder SQL, no SQL. Statements are exact, verified against the parser, and the service answering them is public.
TRANSPORT corpus FROM (token_str='walk') TO (token_str='walked') ON FIBER (f4, f11, f12);
The operator that carries a fiber vector from walk’s frame to walked’s — how meaning rotates between two rows.
SQL can fetch both rows. It has no concept of a path between them.
HOLONOMY corpus ON FIBER (f11, f12) AROUND tense_label;
Walk a closed loop, come back, read the rotation you kept — the curvature trapped inside the cycle.
A JOIN cycle returns rows. It cannot return what the loop did to you.
COVER sensors ON city = 'Moscow' WHERE temp < -25 RANK BY temp DESC FIRST 5;
SELECT-shaped — but ON restricts where you stand (the base) and WHERE filters what you carry (the fiber).
SQL’s WHERE lives in one flat namespace. The bundle splits position from payload.
GEODESIC sensors FROM city='Moscow' TO city='Singapore';
The shortest path under the bundle’s own metric — the hop sequence plus the true geodesic distance.
Recursive CTEs count hops. There is no metric in SQL to minimize.
SPECTRAL sensors FULL LIMIT 5;
The eigenvalues of the database’s own connectivity — λ₁ is its coherence, read off the spectrum.
No SQL engine can be asked how it vibrates.
PERCEIVE sensors ROTATION (0.0, -1.0, 1.0, 0.0) VECTOR (1.0, 0.0) DIM 2;
The same bundle seen from a rotated observer frame — active perception as a first-class query.
A SQL view renames columns. PERCEIVE moves the observer.
FREEENERGY sensors AT 0.5;
F = −τ log Z — the thermodynamic free energy of your data at temperature τ, as one scalar.
No SQL aggregate computes a partition function.
PERSISTENCE cloud ON (x, y) GAP 3;
Cluster births and deaths at every scale — the groups that are topologically real, not named in advance.
GROUP BY demands the key up front. PERSISTENCE discovers how many groups exist.
WASSERSTEIN pop ON income BETWEEN cohort = 0 AND 1;
The earth-mover distance between two entire distributions, as one scalar.
SQL compares averages to averages. This compares shapes to shapes.
FISHER demo ON (age, income);
The Fisher information metric on your data’s statistical manifold — distinguishability, direction by direction.
Covariance is where SQL stops. This is where the geometry starts.
One lookup, four boundaries.
Four published figures, a 770× spread — and the spread is layers, not inconsistency. The same O(1) section evaluation costs different amounts depending on where you stand when you measure it. So we measure it at every boundary and label each one.
Point lookup, by layer. All four are the same O(1) section evaluation measured at different boundaries.
500 ns — the raw in-process figure — is the one canonical headline number on this page. Every other lookup figure you'll meet below names its boundary in the same sentence.
1.5 µs point reads. Flat to a million rows.
Head-to-head against the best embedded engines in the world, on their turf: one machine, 100k synthetic transactions, seed 20260731, byte-reproducible, 1 warmup + 3 timed reps, median. GIGI wins the lanes a database of record actually lives in — point access, durable ingest, built-in anomaly detection — and every number that beat us is on this page too, at full price, because receipts are the house style.
Four rounds — how the numbers were earned.
GIGI measured over HTTP (its real deployment shape); SQLite and DuckDB in-process (theirs) — the asymmetry is disclosed in every results file. Snowflake and Databricks are excluded by their DeWitt-clause terms of service, Cassandra for lacking a local runtime — excluded, not dodged. Four rounds, each audited before publication — starting with a round 1 that was published with its losses unsoftened.
Round 1Losses, unsoftened.
"It's committed anyway, because a benchmark you'd only publish if you won isn't a benchmark."
Two narrow round-1 wins, both scoped: point queries — GIGI over HTTP beat in-process DuckDB, p50 0.354 vs 0.417 ms, despite paying a localhost round trip — while in-process SQLite still won that lane 6.4x, on the scoreboard above. Faster than DuckDB on point lookups. We do not compete on analytical scan throughput — different engine class, different workload. And the anomaly call is zero-config: 5 client lines against 15 lines of SQL that needed a hand-chosen grouping.
Round 2Isolate the transport.
Round 3 + 3bThe fixes, measured.
Round 3 also reported play 1 regressing — 0.7003 → 0.4924 — at full price under honest_regressions. Root cause found in 3b: a hard clip at 6 MAD-units created a tie plateau; the fix is a strictly monotone squash z/(z+6). The scan-lens fix also cost wall time, 317.4 → 501.4 ms, reported as measured.
Round 4The contract correction.
Rounds 1–3 compared 100 durability acknowledgments against 1 and called it an ingest gap. Credit to the founder who pushed until the asymmetry surfaced. Re-run under matched contracts, both directions, engine at main dc22e42.
Audits with teeth
Errors were caught in GIGI's own favor and fixed before publication.
Adversarial fairness audit + reproduction spot-check before the report was written. Verdict, verbatim: "the headline result is brutally anti-gigi and fully reproduced."
The fairness audit FAILED the first artifact: two gigi-favoring defects — a missing txn_id index flattered embedded ingest (134,381 → 116,526 rows/s) — fixed and re-run before the final numbers.
The +58% WAL win was not bought with durability: CRC-32C rewrite byte-equivalent, fsync-identical, durability pins committed before the perf commit.
The auditor counted fsyncs empirically — a temporary atomic counter in Wal::sync: exactly 2 one-ack, exactly 110 many-ack. Counter removed, wal.rs restored byte-identical.
Two lanes, both named, both with a named fix: one-ack bulk load trails SQLite 1.19x (per-record CPU tail — profiled, on the roadmap), and analytical scan throughput belongs to columnar engines (different engine class; the TPC-H section below prices it honestly, and the Q6 columnar fix is diagnosed at ~60–120x in benchmarks/q6_profile). Losing lanes get named fixes, not silence.
Six million real rows, and the caveats first.
Honest caveats, re-verified against the current build. No SIMD — zero intrinsics anywhere in the repo, and the one kernel that would benefit (embedding similarity, VectorMetric::score) compiles to entirely scalar SSE: 57 scalar float ops, 0 packed ones. The whole library emits 0 AVX instructions. No vectorized execution — storage is row-major Vec<Value> tagged enums and aggregation is tuple-at-a-time. No intra-query parallelism, and no join reordering. This is not a claim to beat DuckDB or Velox. It is a claim that the storage-geometry choice and the bitmap join path produce correct results at real data scale with O(n) cost growth.
Two caveats that used to sit in that list were wrong, so they are gone. There is a physical query optimizer, and it is on the hot path for every query below: exact bitmap cardinalities order each AND-predicate smallest-first, OR groups resolve entirely in bitmap space, and LIMIT without ORDER BY terminates the scan early instead of buffering. On 500K rows at 1% selectivity that is worth 75x (index path vs residual scan, identical result sets) and 510x (LIMIT 10 vs full materialization). And reads are parallel — the engine sits behind one RwLock, so N concurrent readers execute on N cores: measured 7.2x at 8 threads, 258K → 1.85M point queries/sec. What serializes is writes, behind a single engine-wide write lock. The TPC-H run below is still single-threaded by design — one query at a time, best of three.
Data: DuckDB TPC-H SF=1 generator — same dbgen algorithm as the official TPC council C toolkit. Six standard tables: 6,001,215 LINEITEM rows, 1.5M ORDERS, 150K CUSTOMERS, 200K PARTS, ~1GB pipe-delimited. Each query ran three times; best wall-clock time reported (standard TPC-H methodology). Single-threaded Rust release build, Windows desktop, fully in-memory.
Publishing the reference range next to the result lets the reader check the work.
Scaling linearity — SF=0.001 → SF=0.01 (expect 10x)
Storage auto-selection
BaseGeometry::Flat with step=1. O(1) point lookup, cache-linear full scan.
Auto-detected at load time — no schema hint required.
Same data, same split, same metric — losses on the page.
GIGI's geometry verbs against sklearn baselines. Every number is mean ± sample std across 5 fixed seeds (20260801–20260805), captured in scripts/sweep_results_multiseed.json. Verdicts use the artifact's own rule: WIN or LOSS only when the signed delta clears max(combined std, 0.005) — else PARITY. Tally over all 27 cells: 11 WIN / 10 PARITY / 6 LOSS — of the 11, four are geometric-arm wins and seven are GIGI's own flat implementations beating sklearn's, which is implementation-quality evidence, not geometry.
Where the geometric method wins
Parity with zero configuration
No delta smaller than its own noise is called a win — ten cells land inside the threshold and are reported as exactly that.
Where flat wins
On a 5,000-record × 17-dimension bundle with no indexed fiber fields, SPECTRAL timed out at 30 s and passed at 180 s; the warm second run took ~120 s — the O(n²) part is the proximity adjacency build, 25M pairwise comparisons. Same run: HOLONOMY >180 s, fail. (CONSISTENCY logged ~120 s there too, but that measured the pre-fix code path — since f912c22 it is a bounded ≤100-record sampled scan.) The dense eigensolver is capped at 4,096 vertices (SPECTRAL_DENSE_MAX_V); past the ceiling, BULK routes to the sparse interior arm — live probe V=4913: converged 32/32, max residual 2.528e-12, 30.2 s wall — whose O(V²) per solve cost (739.69 s at V=8000) is "inherent … and explicitly out of scope to break."
Five capabilities no shipping database has.
Five, each falsifiable, each pointing at the section of this page that carries its evidence. Everything else GIGI does, something else also does — those rows are in the table further down, losses included.
The H¹ = 0 claim, named and falsifiable
When Edge syncs to Stream, the sheaf gluing axiom checks that overlapping data on both sides is consistent. H¹ = 0 means the first Čech cohomology group is trivial — there are no obstructions to gluing. Every local section on the checked cover extends to a global section. This isn't "eventual consistency" — it's a proof, scoped to the cover it checked: since f912c22 the CONSISTENCY verb runs a bounded ≤100-record sampled cover (the honest-cost note above), so H¹ = 0 certifies the sampled cover, not every record by fiat.
The big three, with their headlines intact
Their real strengths, plainly: Druid is fundamentally an event-oriented, immutable, time-series OLAP engine — at clustered scale that is a formidable machine. Cassandra is a write-optimized distributed key-value store that trades read flexibility for write throughput and availability. ELK is a search engine grown into an observability platform with an ecosystem GIGI does not have.
Eleven capabilities, side by side
The old version of this table had a twelfth row; it is gone. Curvature measures variability — it does not forecast, and the page no longer says it does.
"Same speed. But GIGI tells you which results to trust."
"Same availability. But GIGI proves your replicas converged — or tells you where they didn't."
"Same logs. But GIGI detects anomalies without a pipeline, proves consistency without a plugin, and compresses the wire by 35–79% depending on data shape."
"They index data. GIGI understands data. The geometry IS the index."
One range, measured at both ends.
35–79% depending on data shape. Arithmetic and low-cardinality data (sensors, transactions) compresses hardest; free text compresses least. The mechanism: arithmetic fields (timestamps, IDs) are described by start + step — only deviations are stored. Default fields (status="normal" at 94%) are elided entirely. The geometry of the data is the compression.
@start+step —
entire column elided), modal defaults (|value — only
deviations transmitted), and trailing elision (omit trailing
defaults). The Rust encoder detects all three automatically. Events compress most
because timestamps are arithmetic and most fields have strong defaults.
Low K = flat = predictable. High K = curved = variable. Battery (K = 0.01) is 98% constant; pressure (K = 0.12) varies the most. The same K that scores your query confidence decides what the wire can elide.
Fisher's own flowers, under Fisher's own metric.
R. A. Fisher published the iris measurements in 1936; the information-geometry metric that now ranks them is his too. Four geometry verbs — FISHER, WASSERSTEIN, PERSISTENCE, REEB — run against the live server on his 150 rows. These are verbatim captured HTTP/GQL responses from a live run: a demo transcript, not a statistical claim.
It returns 1 when there is no real grouping instead of hallucinating structure — an honest cluster count. The sepal plane genuinely doesn't separate; the verb says so.
Reproduce: scripts/pk_iris_examples.py against a post_kahler_phase1 build · 18 module ground-truth tests + 3 endpoint/GQL integration tests · default no-feature build byte-unchanged.
Every number here has a way to be proven wrong.
The contract of this section: every row has an independent analytic or textbook ground truth, and a stated falsification route — a script you can run whose disagreement would break the claim.
The red-first failures are the point: T5's expander counterexample forced a non-universal-bound disclosure into the docs before the gate went green. A validation suite that has never caught anything is not a validation suite.
Run SQL on the encrypted bundle.
Encryption in GIGI is not a cipher bolted onto storage — it is a private change of coordinates on the fiber. Every gauge-invariant quantity — curvature, confidence, capacity, spectral gap, holonomy, Betti numbers — reads identically on plaintext and ciphertext. So the server answers eleven SQL aggregates on ciphertext at native speed, equality checks are one O(1) hash compare, and invariant queries decrypt zero bytes — pinned by an instrumented decrypt counter that must stay 0.
K = Var/r² is
invariant because Var(αv+β) = α²·Var(v) and range(αv+β) = α·range(v),
so the α cancels. This is the gauge symmetry: the geometry doesn't care about the
coordinate system.
Drag any α or β — the stored values change, K does not. Sample data: eight sensor rows, four numeric fields, all computation in this page.
The full page — live ciphertext demos → The paper on Zenodo
Security maturity, in the module's own words: validation to date is mathematical — every invariance and timing property is pinned by the test suites above; independent cryptographic review is a planned deliverable. Mode-by-mode leakage scope is stated on the full page.
Open format. Open core. Hosted service.
Three products, one engine, one geometry. Source-available — free for non-commercial use; commercial use is licensed.
- Upload JSON → get DHOOM
- Geometric data profiler
- Compression ratio prediction
- Batch + streaming modes
- O(1) read + write
- Real-time subscriptions
- DHOOM wire (35–79% depending on data shape)
- Curvature confidence
- Sheaf-guaranteed consistency
- Holonomy drift detection
- Tiny local engine
- Offline-first
- Sheaf-guaranteed sync
- No conflict resolution needed
docker pull beerosadavis/gigi:latest curl https://gigi-stream.fly.dev/v1/health
Convert and Edge verified reachable in the image at engine commit 49a9eaa · hub.docker.com/r/beerosadavis/gigi · Debian slim runtime · auto-built from GitHub
gigi-stream.fly.dev; Convert and Edge ship in the Docker image.
Contact bee_davis@alumni.brown.edu for
commercial licensing.
Three layers. One geometric framework. Zero Euclidean math in the query path.
Query algebra
vs HNSW / vector databases — the honest scoping
HNSW (Hierarchical Navigable Small World) — the algorithm behind Pinecone, Weaviate, Qdrant — builds an approximate nearest-neighbor graph over high-dimensional embedding vectors. O(log n) query time, probabilistic recall. Designed for unstructured similarity search over learned embeddings.
GIGI does not compete on unstructured embedding workloads. The architectural difference is: HNSW is approximate and works on any vector space; GIGI is exact and works on structured typed schemas with fields, predicates, and joins. For structured data — financial records, IoT sensors, user tables — GIGI's bitmap index delivers exact results with no recall penalty. The TPC-H Q3 benchmark demonstrates this directly: predicate pushdown on the BUILDING market segment reduces a 1.5M-row ORDERS scan to ~30K matching rows with zero approximation and zero probability of missing a result.
The curvature score K is also architecturally different from cosine similarity or a learned vector distance. K measures structural regularity in the local data neighborhood — it is derived from the fiber bundle geometry of the data itself, not from an external model. There is no embedding step.
The math, in five cards
(E, B, F, π) — total space E, base space B (keys), fiber F (schema), projection π. A section σ: B → E is a record. Insert = define a section. Point query = evaluate the section. Both O(1).| defaults, deviations become : overrides, arithmetic base points become @ compression. One math, end to end — 35–79% wire savings depending on data shape.Real code, real theory — not yet product claims.
These are live mathematical directions in the engine. They compile, they have tests, some have theorems — and they are listed here, apart from the capability list, because that is the honest altitude for them.
Where the geometry earns its keep.
Six shapes of problem. The cards argue fit; the numbers live in the evidence sections above, next to their provenance.
Eighteen instruments. One geometry under them.
“A Gi_System is a scientific instrument whose every observable is gauge-invariant, whose every operation is local, and whose every claim is gated by an analytical target with no tunable tolerance.” Plasma stability, drug binding, outbreak surveillance, maritime threat detection, payment reconciliation, flight control — one instrument per field, every one speaking the same geometry GIGI speaks.
The full pattern, system by system, lives on the Halcyon page — where every claim is gated the same way GIGI’s are: analytical target, no tunable tolerance.
Two volumes published. A series of five underway.
The engine ships with a literature. Not marketing PDFs — full-length engineering and mathematics books, built with the same receipts discipline as the code: every number in print traceable to a test, a file, or a live endpoint.
- 509 pages · 7 parts · 18 chapters · appendices A–D · written for engineers who know B-trees and WALs, assuming zero differential geometry
- A 367-entry machine-readable claims ledger — a checker greps the manuscript and fails any numeral that cannot name its source
- 126 hands-on exercises — all online, each chapter with a live GQL console wired to the public engine
- 21 chapter illustrations in 19th-century engraving style
- 520 pages · 25 chapters · 8 parts · 61 figures, every one drawn by code that ships with the book
- 28 equation ladders — numbered climbs from eleventh-grade algebra to Chern classes, one rung per move, no rung skipped
- Every boxed claim labeled on the page: classical (with citation), engine contract (with the named test), or conjecture — no third option
- Passed a mechanical inspection gate the morning it launched — all 520 pages scanned for unsourced numbers and drifted figures — and it prints a published theorem corrected by its own author
Volumes 3–5 are outlined — GIGI Speaks, GIGI Solves: The Clay Seven, GIGI Solves: Beyond the Clay — a planned series of roughly 3,000 pages. Books and engine alike are free for personal use, research, and teaching under PolyForm Noncommercial 1.0.0.
Bee Rosa Davis
Applied mathematician, security engineer, and independent researcher. Gigi is my ballroom house nickname — it means mom. I build production systems grounded in differential geometry. Every product ships with the same identity: S + d² = 1. The math is the product.
Hidden Variable
From a childhood IQ diagnosis to NASA and algorithmic justice.
The Geometry of Sameness
ML and Riemannian manifolds tell the same story.
The Geometry of Medicine
Health as geometric coherence on the Davis Manifold.
The Geometry of Fuel
Davis Law to topological vacuum rectification.
Motion to Be Seen
One Black trans woman's fight for algorithmic justice.
Fly Into The Sun
Consciousness, identity, and the geometry of interstellar travel.