One $52 stands where $52 belongs; the other stands alone at the edge of the café's
ground at 3 am. κ isn't about the value — it's the distance between
a value and the ground it stands on.
A database engine where data lives on a fiber bundle. Queries are section
evaluations. Joins are pullbacks. Confidence is curvature.
Patent Pending via DHOOM · U.S. App. No. 64/008,940
Two rows say $52. One is fraud. In a bucket they are the same number
in the same column — comparing a row against "rows like it" means guessing
the right GROUP BY, per question.
GIGI — fiber bundle
the fused ground, drawn: merchant makes territories · time spaces the points
illustrative
The ground is the geometry: the merchant key splits it into territories,
time spaces the points (3:07 stands alone at café's edge), and the arcs are
the ground's own neighbor graph. The amounts never chose their neighbors —
the ground did. Café-3am is judged by café's line (carries ≈ $7 →
κ 4.1); market's $52 by market's (≈ $59 → κ 0.2).
keys = matching values (c1 = c1)→keys = territories + distances on the ground"rows like this" = a GROUP BY you must guess→neighbors already stand beside it$52 = just a number→$52 = a number standing somewheretwo identical rows→two different κ — place tells them apart
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).
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.
Live diagnostic
CHIHIRO
Real-time MHD stability diagnostic. 1D radial CHT spectral gap in under
10 ms. Includes an experimental topology channel that
compares the Cheeger cut against the shear-reversal surface on reversed-shear
equilibria.
Davis, B. R. (2026), The Spectral Geometry of Plasma Confinement: A Davis
Field Equations Framework. Direct δW scan of the n=1 external kink over
20 profiles gives
βN,crit/li = 0.163 ± 0.004
— within ~2% of 1/(2π), consistent with Wesson §6.16.
On the ITER-hybrid reversed-shear profile the Cheeger cut and the
shear-reversal surface coincide within 3% at
βN = 0.5, and decouple by
βN = 1. Stated as a question because that is what it is:
the direct Chern computation that would settle it is scoped, not run.
phase B · a 20-week research program, not a result
The thesis
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.
The language · GQL
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.
The service answering right nowGET gigi-stream.fly.dev/v1/health · probed 2026-08-02
bundles 5,049 · records 13,096,387 · uptime 12.9 days at probeTRANSPORT · HOLONOMY · GEODESIC · PERCEIVE · FREEENERGY parse-verified against the deployed binaryREEB · FISHER · WASSERSTEIN · PERSISTENCE ship at HEAD (1,371 tests) and land with the next deploy — the live transcript below runs them against a local build today
TRANSPORTlive · fly.dev
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.
HOLONOMYlive · fly.dev
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.
COVERlive · fly.dev
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.
GEODESIClive · fly.dev
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.
SPECTRALlive · fly.dev
SPECTRAL sensors FULL LIMIT 5;
The eigenvalues of the database’s own connectivity — λ₁ is its coherence, read off the spectrum.
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.
The HTTP figure is dominated by network and serialization, not by the lookup.
gold rules ∝ log₁₀(latency) — log scale · Independently re-measured in the vs-stores
harness (2026-07-31): embedded p50 1.5 µs / p95 2.4 µs; HTTP p50 353.7 µs — consistent
with the layers above. BENCHMARKS_VS_STORES.md §R2.1
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.
vs SQLite · DuckDB — four rounds
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.
The headlines — where GIGI winsBENCHMARKS_VS_STORES.md R2–R4 · results_round4_ingest_contracts.json · 2026-07-31
point query 37x FASTER than in-process sqlite p50 1.5 µs / p95 2.4 µs, matched shapescaling 45–63x FASTER at every N, 10k → 1M p95 grows 1.12x over two decades vs sqlite's 2.25x — the B-tree shows, the bundle doesn'tdurable ingest 2.36x FASTER than sqlite under real commit contracts — duckdb collapses ~66x on the same contractanomaly PR-AUC 0.6531ZERO-CONFIG — nothing specified but the bundle name; native play 0.7190 ties the expert's hand-tuned SQLover HTTP still beats in-process duckdb on point lookups, 0.354 vs 0.417 ms — paying a network round trip, it wins anyway
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.
ingest LOSES 7.8x to sqlite 78,775 vs 617,285 rows/spoint query LOSES 6.4x to sqlite p50 0.354 vs 0.056 ms — while beating in-process duckdb's 0.417aggregates LOSES 293x to duckdb 2,167.3 ms † vs 7.4 msanomaly LOSES 8.5x on PR-AUC 0.0848 vs 0.7189 — its own thesis task, to 15 lines of SQL† disclosed fallback: the GQL parser rejected stddev() in INTEGRATE — "GQL stddev is a documented lie today" — so INTEGRATE + 12x COVER + client-side stddev ran at full pricecalibration: random-AP floor at 0.5% prevalence ≈ 0.005 — 0.0848 is ~17x above chance, real signal, far below the expert baseline
"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.
Embedded lane + scaling curvesBENCHMARKS_VS_STORES.md §R2 · 2026-07-31
embedded point query p50 1.5 µs / p95 2.4 µs (HTTP p50 353.7 µs — a 236x transport tax)at matched in-process shape the round-1 6.4x point-query loss to sqlite flips to a 37x winscaling 10k/100k/1M embedded 45–63x faster than in-process sqlite at every Nsqlite p95 growth 2.25x (93 → 209 µs) — "the B-tree showing"; log-N lives in the tailGIGI HTTP growth 1.12x over two decades of N — consistent-with-O(1) within noisedisclosed: embedded loop is native Rust timing vs Python's sqlite3 wrapper
Round 3 + 3bThe fixes, measured.
Three fix lanes, same locked protocolresults_round3b_gigi.json · results_round3b_expert.json · branch 19f58c0
WAL fix ingest 116,526 → 184,349 rows/s (+58.2%) sqlite gap 5.3x → 3.3xstddev shipped aggregate 2,167.3 → 167.5 ms cross-checked vs fallback, max rel diff 7.6e-15zero-config /scan PR-AUC 0.0848 → 0.4579 → (3b) 0.6531 — nothing specified but the bundle namenative weighted play 0.7190 — statistically indistinguishable from the expert SQL's 0.7189; parity by this page's own ≥0.005 rule
Regression
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.
Ingest under matched durability contracts · rows/sresults_round4_ingest_contracts.json · 2026-07-31
Contract
GIGI embedded
SQLite
DuckDB
Verdict
One ack — 100k rows, single durable ack
431,697
515,531
276,543
GIGI LOSES to sqlite, 1.19x — reported as measured; beats duckdb 1.56x
Many ack — durable commit every 1,000 rows
197,525
83,785
4,187
GIGI WINS over sqlite, 2.36x; duckdb collapses ~66x from its own one-ack rate
profile: 54.53% of many-ack batch_insert time is fsync — the contract, not the engine ·
remaining 1.19x gap is per-record CPU · bin sweep: zero-config 0.6531 verdict STABLE
(8 bins 0.6647, 16 bins 0.6346, pre-locked ±0.05 criterion); 12 bins is not a
cherry-picked peak, and the sweep reproduced the committed 0.6531 byte-equal
Audits with teeth
Errors were caught in GIGI's own favor and fixed before publication.
Round 1 · reproduction
Adversarial fairness audit + reproduction spot-check before the report was written.
Verdict, verbatim: "the headline result is brutally anti-gigi and
fully reproduced."
Round 2 · FAIL
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.
Round 3 · durability
The +58% WAL win was not bought with durability: CRC-32C rewrite
byte-equivalent, fsync-identical, durability pins committed before
the perf commit.
Round 4 · fsync count
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.
Still slower today
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.
TPC-H · Scale Factor 1
Six million real rows, and the caveats first.
Read this 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.
4 groups — correct for real TPC-H. Synthetic produced 6 (uniform random).
Q14 LINEITEM-to-PART join
7,860
1,309.9
6,001,215
1
promo_revenue validates join correctness — see the receipt below.
Q3 3-way join + bitmap
3,405
454.0
7,651,215
11,619
Bitmap pre-filters ~30K BUILDING customers before any LINEITEM scan.
1,264.7 ns/row on a cache-linear scan is under profiling — the
curvature path costs ~12 ns/record on the same hardware. And Q3
appears faster per-row because the bitmap pre-filter on the BUILDING market segment reduces
the effective scan to matching orders — not all 6M rows. That is
predicate pushdown working as designed, not a measurement error. One denominator
disclosure: Q3's ns/row divides by the 7,501,215 join-path rows
(LINEITEM + ORDERS) — 3,405.8 ms ÷ 7,501,215 = 454.0 ns/row —
while its Rows-scanned column also counts the 150K-customer bitmap pass.
Q14 computes promo_revenue = 100 × Σ(extprice × (1−disc) where part_type LIKE
'PROMO%') / Σ(extprice × (1−disc)) over September 1995 shipments. GIGI result:
16.38%. Published TPC-H reference values for SF=1 fall in the
14–18% range depending on generation seed. This validates the
LINEITEM-to-PART join via key-indexed lookup (pullback join), the date range filter,
and the conditional aggregation.
Publishing the reference range next to the result lets the reader check the work.
Q3 at 12.5x is slightly super-linear — expected for a
three-table join where intermediate result sets also grow with scale factor. All four
queries fall within the linear band.
Storage auto-selection
LINEITEM → Sequential
l_id is dense auto-increment (1..6,001,215). GIGI selects
BaseGeometry::Flat with step=1. O(1) point lookup, cache-linear full scan.
Auto-detected at load time — no schema hint required.
ORDERS → Hashed
o_orderkey has gaps of 1–8 between keys (standard TPC-H sparse keys). GIGI auto-selects
HashMap. O(1) per orderkey lookup. Q3's bitmap join resolves ~30K orderkeys in
O(|BUILDING_customers|), not O(1.5M ORDERS).
The full run was serialized to a DHOOM report — GIGI's own
machine-readable structured format. It encodes the query catalogue, timing results,
scaling linearity proof, and storage geometry annotations.
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.
The representation row is a controlled experiment, not a benchmark comparison: both arms
run one shared EM implementation with identical covariance, init, and convergence — only
the representation changes, so the +0.356 ARI is the isolated
representation effect. sklearn's GMM on the same raw pixels rides along in the artifact
at 0.491 ± 0.063.
re-anchored 2026-08-01: earlier single-run figures for the representation row
(0.594 → 0.708) predate two fixes the artifact verification forced — the spectral head
previously ran a different GMM implementation than the raw arm, and record order was
process-dependent — and are superseded; the label-propagation row's figures survived the
re-run unchanged. Both rows were claim-grade † until this artifact landed (attested in
the /v1/ml catalog and commits 9a17360 / 912f450, no artifact file); they now carry the
same five-seed artifact as every other cell. GIGI's arm exposes no seed parameter — its
std 0.0 is measured per seed, not assumed, and re-verified across fresh server processes
by scripts/multiseed_repro_probe.py.
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.
iris kmeans ARI 0.620 vs 0.618 ± 0.004 iris gmm ARI 0.904 vs 0.826 ± 0.173wine svm acc 0.983 vs 0.983 bcancer knn acc 0.965 vs 0.968bcancer svm acc 0.975 vs 0.974 diabetes ols R² 0.486 vs 0.482pca expl.var wine/bcancer/digits — equal to ≤ 3·10⁻⁶ on all threeanomaly · bcancer-rare PR-AUC /scan 0.539 ± 0.099 vs IsolationForest 0.542 ± 0.078the seeded malignant subsample varies both arms; formerly presented as a single-run win (0.559 vs 0.552) — the multiseed variance dissolves it. Zero configuration on the GIGI side: nothing specified but the bundle name.
Where flat wins
LOSS cells (6) · mean ± std, 5 seedsscripts/sweep_results_multiseed.json · 2026-08-01
Task · dataset
Metric
GIGI
Flat baseline
Note
cluster · digits (gmm)
ARI
0.256 ± 0.000
sklearn GMM 0.491 ± 0.063
largest loss in the sweep; the eigenspace recovery of this same GMM to 0.612 is the representation row above
cluster · digits (kmeans)
ARI
0.454 ± 0.000
sklearn 0.506 ± 0.049
cluster · wine (spectral)
ARI
0.833 ± 0.000
sklearn Spectral 0.880 ± 0.000
a geometric method losing, not a control arm
classify · iris (svm)
accuracy
0.913 ± 0.000
SVC(rbf) 0.967 ± 0.000
regress · diabetes (local_linear)
R²
0.408 ± 0.000
KNN-reg 0.449 ± 0.000
regress · diabetes (gp)
coverage@90%
0.878 ± 0.000
sklearn GP 0.907 ± 0.024
flipped: the single-run snapshot had this as a GIGI win (0.919 vs 0.902); the re-run reports the loss it now is
The catalog's own positioning text concedes "On flat data they tie." The review's flag on
the gp code comment also stands: coverage is cross-conformal and empirically calibrated,
not "guaranteed."
implementation-parity arm — GIGI's own flat implementations vs sklearn's, not geometry:
WINs on wine kmeans (0.915 vs 0.897), wine gmm (0.947 vs 0.884 ± 0.023), iris knn
(0.960 vs 0.953), wine knn (0.972 vs 0.967), digits knn (0.974 vs 0.944), digits svm
(0.958 vs 0.949), MovieLens matrix-factorization RMSE (0.911 vs 0.929 ± 0.006, lower
is better)
Honest cost
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."
The competitive frame
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.
1 · every read
Curvature-based confidence
Every query result annotated with how much to trust it — κ and confidence ride along on the response, updated at insert time.
No distance computation anywhere in the query path — neighborhood comes from the bundle topology, not from embedding into ℝⁿ. Scope: the lookup / range / join path. Opt-in analysis verbs like WASSERSTEIN, PERSISTENCE and SPECTRAL compute the metric quantities they name — that is their job, not the query path's.
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.
Competitive absence · checked against four systemssrc/bin/gigi_stress.rs phase 2 (Consistency H¹ row) + phase 3 (Edge→Stream sync)
None of the four systems checked ships a consistency proof — and two of them, Monte Carlo and Arize, are observability platforms rather than databases, listed because they sell the closest alternative. Snowflake, Databricks, Monte Carlo and Arize all detect problems after the fact; H¹ = 0 proves there are none on the cover it checked. 1,001 operations, verified clean in 0.8 ms.
The big three, with their headlines intact
System
Their headline
GIGI's response
Apache Druid
Sub-second OLAP at trillion-row scale
500 ns lookups — no cluster to coordinate.Topologies differ, so no single multiplier is honest; the layer table above is the receipt. Druid wins clustered ingest — GIGI's O(1) insert never compacts, never reindexes.
Apache Cassandra
Always-on, no single point of failure
Consistency you can prove — not vote on.Sheaf-checked H¹ plus holonomy drift detection: math over consensus protocols, and when replicas diverge, GIGI names the record.
ELK Stack
Full-text search + real-time log visualization
The anomaly detector IS the database.Curvature rides on every query — no pipeline, no plugin, no second system to deploy.
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
Capability
Druid
Cassandra
ELK
GIGI
Point queries
◐
✓
✓
✓ O(1)
Range queries
✓
✗
✓
✓ O(|r|)
Joins
✗
✗
✗
✓ pullback
Aggregation
✓
✗
✓
✓ fiber
Anomaly detection
✗
✗
◐
✓ auto
Confidence scoring
✗
✗
◐
✓ auto
Consistency proof
✗
✗
✗
✓ sheaf
Consistency diagnostics
✗
✗
✗
✓ Čech H¹
Drift detection
✗
✗
✗
✓ holonomy
Connectivity analysis
✗
✗
✗
✓ spectral
Wire compression
✗
✗
✗
✓ DHOOM
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.
vs Druid
"Same speed. But GIGI tells you which results to trust."
vs Cassandra
"Same availability. But GIGI proves your replicas converged — or tells you where they didn't."
vs ELK
"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."
vs all three
"They index data. GIGI understands data. The geometry IS the index."
Wire · DHOOM
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.
The low end of the published range is a measurement on this page, not a disclaimer.
Text-heavy chat data really does compress at 35.7% — that's why
the range starts there.
How DHOOM works
DHOOM detects arithmetic progressions (@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.
dhoom.dev ↗ · U.S. Provisional 64/008,940 · filed 2026-03-18
The symbols
@ arithmetic — timestamps, IDs described by start+step ·
& interning — repeated strings stored once ·
# computed — derivable from other fields ·
| default — modal value, only deviations transmitted ·
! constraint — type constraints validated by the engine ·
: deviation — the interesting data.
battery K = 0.0104 conf 98.98%timestamp K = 0.0833 conf 92.31%humidity K = 0.0851 conf 92.16%temperature K = 0.0883 conf 91.89%pressure K = 0.1249 conf 88.90%
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.
Post-Kähler verbs · live transcript
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.
Ingest returns geometrytheory/reviews/iris_pk_results.json · live server transcript · 127.0.0.1:3142
POST /v1/bundles/iris/insert{ "inserted": 150,"curvature": 0.0882,"confidence": 0.9189 }— the ack itself carries κ; nothing was asked for
FISHER — metric ranks informativenessiris_pk_results.json · g = diag(1/σ², 2/σ²) from L4 Welford variance
FISHER iris ON (sepal_length, sepal_width, …)sepal_width g_μμ 5.299 det 56.16tightestpetal_length g_μμ 0.323 det 0.209loosest— read free from running variance; no extra pass
PERSISTENCE — the honest cluster countiris_pk_results.json · H₀ via MST + elder rule
PERSISTENCE iris ON (petal_length, petal_width) GAP 2 → estimated_clusters: 2longest MST edge1.3038vs second0.3162— a real gapPERSISTENCE iris ON (sepal_length, sepal_width) → estimated_clusters: 1edges0.5385vs0.4123— no real gap
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.
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.
|γ| matches the analytic form at all seven gap ratios Δ/ε ∈ {0, 0.25, 0.5, 1, 2, 5, 100}max rel err 2.9e-4 · integrality deviation 0.0000/0.0002 at endpoints (Chern −1, 0)at Δ=ε the deviation is 0.4472 — a Dirac-string non-integer-Chern signatureflat-bundle negative control: constant 0.2500 — cannot mimic the signaturefalsify: rerun validation_tests_v5.py — any rel_err > 2.9e-4 or a mid-Δ deviation ≠ 0.4472 breaks it
The rest of the index, one line eachVALIDATION.md · verbatim numbers, artifact paths inside
Wu-Yang integrality five integer charges exactly 0.00e+00; non-integer charges correctly FAIL at 0.3333–0.4000results_v2.txtWDVV associativity max associator 0.00e+00 over 27 triples; so(3) negative control 1.0000results_v2.txtBerezin-Toeplitz dev/ħ³ = 0.04115–0.04166 converging on the predicted 1/24 = 0.0417results_v3.txtRiemann-Roch on T² exact at levels n = 1–5; Hodge Betti (1, 2, 1), ‖d₁d₀‖ = 0results_v3.txtPoincaré → sharding TDD gates with honest red-first failures logged (T2, T5, T6) fixed before green theory/poincare_to_sharding/validation/Encryption primitives golden vectors 25/25 PASS — secp256k1, HMAC/HKDF/SHA-256, Shamir, ratchet results_v0_3.txt
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.
GIGI Encrypt · gauge encryption
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.
invariance max |K(enc) − K(plain)| = 1.39×10⁻¹⁷ over 10,000 samples × 36 gauges — machine epsilon is 2.22×10⁻¹⁶zero decrypt PROJECT INVARIANT runs with decrypt counter = 0, asserted by test, whitelist enforced at parse timeaggregates 11 SQL aggregates on ciphertext — SUM AVG MIN MAX VAR STDDEV RANGE MEDIAN QUANTILE ARGMIN ARGMAX — one closed-form client inversionin production since 2026-05-01 the Just Gigi chat store on davisgeometric.com runs OPAQUE mode — we eat what we cookpaper Zenodo 10.5281/zenodo.20438796 · 28 pp · Theorem 3.1 characterizes exactly which aggregates are ciphertext-computable
Why the math holds
Each field value v is mapped to αv + β, where α ≠ 0 and β derive
from a 32-byte cryptographic seed. Curvature 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.
Five modes, graded leakage
Affine for numeric · Isometric O(k) for grouped numeric
(Fisher metric preserved to 10⁻¹⁰) · INDEXED deterministic PRF ·
OPAQUE AES-256-GCM-SIV AEAD (IND-CPA) · PROBABILISTIC —
statistically unlinkable yet still O(1)-queryable via the Davis Identity S + d² = 1.
Each mode's leakage scope is stated on the full page, per mode, in writing.
The cryptographic suite
Curvature-MAC whole-bundle integrity (one 32-byte tag) · an append-only RFC 6962
Merkle holonomy ledger · forward-secret dual-seed key rotation with an RG-flow ratchet ·
BLS12-381 pairing delegation · two post-quantum delegation modes
(ML-KEM-768 and lattice threshold sharing).
Publicly verifiable
A verifier holding only ciphertext recomputes the six-component invariant fingerprint
and checks the prover's claim — sub-millisecond on a 1k-record bundle, no trusted
setup, no key handed over. Rekey is a streaming pass on ciphertext:
0 plaintext bytes materialized, by instrumented counter.
Try the theoremin-page demo · sample sensor rows · recomputed live on every slider move — not a stored measurement
Drag any α or β — the stored values change, K does not. Sample data: eight sensor rows,
four numeric fields, all computation in this page.
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.
Products
Open format. Open core. Hosted service.
Three products, one engine, one geometry. Source-available — free for non-commercial use;
commercial use is licensed.
Ships in the Docker image
GIGI Convert
JSON / CSV / SQL → DHOOM conversion. Local CLI free. API metered. Detects arithmetic, computes defaults, optimizes field ordering automatically.
Upload JSON → get DHOOM
Geometric data profiler
Compression ratio prediction
Batch + streaming modes
LIVE · gigi-stream.fly.dev
GIGI Stream
Real-time geometric database as a service. O(1) reads/writes. DHOOM wire protocol. WebSocket subscriptions. Confidence per result.
O(1) read + write
Real-time subscriptions
DHOOM wire (35–79% depending on data shape)
Curvature confidence
Sheaf-guaranteed consistency
Holonomy drift detection
Ships in the Docker image
GIGI Edge
Local-first GIGI engine for mobile/IoT. Stores locally, syncs to GIGI Stream. Sheaf gluing axiom guarantees correct sync.
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
O(1) means GIGI's cost per query is constant regardless of database size. GIGI Stream is
live at gigi-stream.fly.dev; Convert and Edge ship in the Docker image.
Contact bee_davis@alumni.brown.edu for
commercial licensing.
Architecture · the mathematics
Three layers. One geometric framework. Zero Euclidean math in the query path.
Layer
Name
What lives there
L3
Connection Layer
Parallel transport · Curvature K · C = τ/K confidence · Holonomy (consistency) · Čech cohomology H¹
L2
Sheaf Query Engine
σ(x) point — O(1) · F(U) range — O(|r|) · Pullback join — O(|left|) · Fiber integration
L1
Bundle Store
Base manifold B · Fiber F (schema) · Sections σ (records) · GIGI hash (chart) · Field index topology
Query algebra
SQL
Geometric operation
Complexity
WHERE pk = v
Section evaluation σ(x)
O(1)
WHERE f IN (…)
Sheaf evaluation F(U)
O(|result|)
JOIN ON fk = pk
Pullback bundle f*E₂
O(|left|)
GROUP BY f
Base space partition
O(N)
COUNT / SUM / AVG
Fiber integration
O(|group|)
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
Fiber bundles
(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).
Sheaf axioms
Locality: if two sections agree on every element of an open cover, they are the same section. Gluing: local sections that agree on overlaps combine into a globally correct result. These are mathematical guarantees, not SLA promises. Čech cohomology H¹ ≠ 0 detects when data is inconsistent — and tells you exactly where.
C = τ/K — Davis Field Equation
τ = tolerance budget (acceptable error). K = curvature (local variability). C = τ/K = capacity — the ability to answer confidently. Every query result gets a confidence score from the geometry.
Spectral capacity
The field index graph's Laplacian eigenvalues govern capacity at a deeper level than curvature. λ₁ (spectral gap) bounds mixing time and detects bottleneck structure. Disconnected components have λ₁ = 0 — the spectrum tells you the topology.
Betti numbers
β₀ counts connected components in the field index graph (union-find). β₁ = |E| − |V| + β₀ is the cycle rank — independent loops. β₀ = 1 means all data is reachable; β₁ tells you how topologically rich the structure is.
Wire protocol · DHOOM
GIGI speaks DHOOM natively. The zero section becomes | defaults, deviations become : overrides, arithmetic base points become @ compression. One math, end to end — 35–79% wire savings depending on data shape.
Citations
Full framework: Davis, B. R. (2024). The Geometry of Sameness. Amazon KDP.
Davis, B. R. (2026). The Double Cover Principle. Zenodo.
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.
Partition function
For approximate queries, a Boltzmann distribution over nearby records: P(q|p,τ) = exp(−d/τ) / Z. At τ→0 only the exact match survives (Z=1); at τ→∞ all neighbors contribute equally. C = τ/K recovered as a thermodynamic equation of state.
Entropy & RG flow
Shannon entropy S = −Σ (nᵢ/N) ln(nᵢ/N) over the field-index grouping; coarse-graining at increasing scale produces non-increasing entropy (C-theorem, Thm 3.5). GROUP BY as an RG step — stated here, where it can be studied, rather than sold.
Gauge-invariant migration
ALTER TABLE that provably preserves curvature — schema changes as gauge transformations, with the invariants checked rather than hoped for.
The Double Cover
S + d² = 1 as a completeness bound for queries: S = recall, d = √(1−S); exact queries on a flat connection sit at S = 1, d = 0. (Davis 2026, The Double Cover Principle, Zenodo.)
Helmholtz free energy
F(τ) = −τ · ln Z connects the partition function to thermodynamics. Heat capacity C_V = τ² · ∂²F/∂τ² peaks at structural reorganization — a phase-transition probe for data.
Pullback curvature
When you join two bundles, does the geometry survive? ΔK = K_merged − K_left. A faithful join has ΔK ≈ 0; large ΔK means the foreign-key relationship introduced curvature distortion.
Unified storage/wire math
DHOOM and GIGI share the same fiber bundle, end to end — the storage geometry and the wire format are one object, so what the store knows, the wire can elide.
Use cases
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.
🌡️ IoT / sensor networks
Timestamps are arithmetic. Units are constant. Status is 95% normal. Most sensor fields are derived from structure — and curvature K spikes exactly where they stop being. The database tells you where the interesting data is.
K = anomaly detectorstructure = compression
💰 Financial reconciliation
Pullback joins match transactions across rails in O(|left|). Holonomy around the settlement loop detects breaks: nonzero holonomy = your books don't balance.
Retrieve context in O(1), serialize in DHOOM for fewer tokens on the wire, and let the curvature score tell you which context is reliable before the model sees it.
O(1) retrievalconfidence per result
🌐 Distributed systems
The sheaf gluing axiom mathematically guarantees that range queries across partitions combine into globally correct results. Holonomy detects replica drift.
sheaf gluingholonomy = drift detection
🔍 Semantic search, no vectors
Instead of embedding into ℝⁿ and computing cosine, GIGI uses the intrinsic connection on the data bundle. Zero Euclidean distance computed in the query path.
zero distance opsintrinsic relevance
⚖️ Compliance & audit
Sheaf axioms prove query results are correct — not probabilistically, not eventually, but necessarily. S + d² = 1 quantifies completeness. Show the regulator the math.
provable correctnessS + d² = 1sheaf axioms ≠ SLA
The platform · Gi_Systems
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.
GIGIlive
Geometric query engine. Holonomy, transport, spectral, and Betti verbs over fiber
bundles. On the Halcyon page she appears as one card among eighteen — on this page the
arrow points the other way. DHOOM is her wire format. Halcyon streams its
lattice through her verbs. PRISM reconciles payments on her field equations. Where a
Gi_System needs a database, it runs on GIGI. She is not one of the family;
she is what the family stands on.
HALCYONcurrent
Engineered modification of local inertial response.
PRISMshipped
Multi-rail payment reconciliation via non-invertible geometric embeddings on transaction fiber bundles.
Drug-target binding affinity via geodesic distance on molecular manifolds with ADMET certificates.
DEMETERlive
Unified precision agriculture via C = τ/κ.
GEODESIClive
Cancer biomarker detection through metabolic pathway geometry.
HERALDlive
Viral mutation surveillance and outbreak prediction via sequence manifold curvature.
TESSERAlive
Antimicrobial resistance surveillance via plasmid transfer network geometry.
ICARUSlive
Geometric control substrate for post-linear GNC. Fiber-bundle state, holonomy-gated maneuvers.
SCJlive
Geometry-first vulnerability detection for Windows kernel drivers.
KRAKENlive
Multi-modal maritime threat detection (DAS / sonar / SAR / RF) on a learned Riemannian manifold. 92% TPR at 1% FPR on a 90-day Pacific campaign.
DHOOMlive
Wire format for GIGI. Curvature-aware serialization, 66–84% token savings vs JSON, full round-trip.
GGOGlive
Cryptographically signed birth timestamps for images. The first second only happens once.
HELICITYlive
Geometric economics. Markets on a glassy NP-hard manifold; stagnation as a vanishing spectral gap.
PHAETHONin dev
Grid stability analysis via the Davis Field Equations. Live operator-side spectral diagnostic.
CALCIFERin dev
Geometric derivation of horizon (Hawking) temperature from the Double Cover, without quantum field theory.
DTPin dev
Davis Topological Processor. Curvature, holonomy, and spectral diagnostics for transformer neural networks.
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.
The books
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.
Volume 1 · published · ISBN 9798181715820
GIGI Builds
The fiber-bundle database: a working engineer’s guide from schema to shard
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
The mathematics, taught from eleventh-grade algebra up
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.
The real GIGI
Bee Rosa Davis
Overall Mother of the House of Diwa
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.
MS Digital Forensics Brown University
BA Logic Morehouse College
BA Communication Univ. of the Pacific
35
U.S. provisional applications across the Davis Geometric portfolio · GIGI cites DHOOM · 64/008,940
Products
all on one framework · C = τ/K governs, S + d² = 1 proves
One math
C = τ/K · the Davis Law · S + d² = 1 · the Davis Identity
