From c145d6aceff4f5d13f3a461ce42b0db626a7c574 Mon Sep 17 00:00:00 2001 From: Brandon Schneider Date: Thu, 7 May 2026 03:42:35 -0500 Subject: [PATCH] ingest: GCCL-GEC full compression architecture spec MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Geometric-Cognitive Compression Law / Glyph Eigen Codec. 9 archive components: D (decompressor), 𝔊 (GlyphBook), Χ (ChiralityBook), Τ (TypeBook), 𝕌 (EigenBook), Γ (packet stream), Θ (params), Ε (residuals), R (audit). 7-field packet: γᵢ (glyph), χᵢ (chirality), κᵢ (coordinate), τᵢ (type), UᵢΛᵢaᵢ (eigen descriptor), θᵢ (params), εᵢ (residual). 5 model families: Wiki structural, same-referent, arithmetic/date, fractal/generator, eigenfield. 5 implementation phases: toy codec → arithmetic → same-referent → eigen descriptors → PUA glyph acceleration. 7 stack integrations mapped (density field, S3C shells, OAC, hypercube→rhomboid, FAMM, erans, radius-ratio). 10 keeper phrases. Core rule: glyph ≠ symbol; glyph = callable kernel. --- 4-Infrastructure/shim/ingest_gccl_gec_spec.py | 357 ++++++++++++++++++ 1 file changed, 357 insertions(+) create mode 100644 4-Infrastructure/shim/ingest_gccl_gec_spec.py diff --git a/4-Infrastructure/shim/ingest_gccl_gec_spec.py b/4-Infrastructure/shim/ingest_gccl_gec_spec.py new file mode 100644 index 00000000..7e0dad12 --- /dev/null +++ b/4-Infrastructure/shim/ingest_gccl_gec_spec.py @@ -0,0 +1,357 @@ +#!/usr/bin/env python3 +""" +Ingest: GCCL-GEC Spec — Full Compression Architecture +====================================================== +Geometric-Cognitive Compression Law / Glyph Eigen Codec +Byte-exact compression via lawful callable glyph kernels. +""" + +import json, time +from pathlib import Path + +RESEARCH_STACK = Path("/home/allaun/Documents/Research Stack") + +GCCL_GEC = { + "id": "gccl-gec-spec-v1", + "source": "USER formal spec — complete compression architecture", + "title": "GCCL-GEC: Geometric-Cognitive Compression Law / Glyph Eigen Codec — Full Specification", + "date": "2026-05-07", + + "purpose": ( + "Compress a byte corpus by finding the smallest lawful executable " + "glyph/eigen/manifold program that reconstructs the exact original bytes. " + "Do not store the text. Store the cheapest lawful generator of the byte projection." + ), + + "archive_structure": { + "formula": "A = D ⊕ 𝔊 ⊕ Χ ⊕ Τ ⊕ 𝕌 ⊕ Γ ⊕ Θ ⊕ Ε ⊕ R", + "components": { + "D": {"name": "Deterministic Decompressor", "role": "Loads profile, interprets packets, emits exact bytes"}, + "𝔊": {"name": "GlyphBook", "role": "Maps printable codepoints to callable reconstruction kernels"}, + "Χ": {"name": "ChiralityBook", "role": "Maps chirality vectors to law-axes for each glyph"}, + "Τ": {"name": "TypeBook", "role": "Maps datatype witnesses to structural generative laws"}, + "𝕌": {"name": "EigenBook", "role": "Stores reusable eigenbasis/spectrum/coefficient descriptors"}, + "Γ": {"name": "Glyph Packet Stream", "role": "Atomic compression units — not characters, but kernel invocations"}, + "Θ": {"name": "Parameter Stream", "role": "Side-stream of integer/arithmetic-coded payload data"}, + "Ε": {"name": "Residual Stream", "role": "Exact byte repair — honesty layer where speculative compressors die"}, + "R": {"name": "Receipt/Checksum/Audit", "role": "SHA256 verification + audit trail"} + }, + "compact_equation": "C = Π_B(Bind_GCCL(𝔊, Χ, Τ, 𝕌, Γ, Θ, Ε))", + "compact_meaning": "Corpus = byte projection of GCCL-bound kernel composition" + }, + + "fundamental_packet": { + "formula": "Γᵢ = γᵢ ⊗ χᵢ ⊗ κᵢ ⊗ τᵢ ⊗ UᵢΛᵢaᵢ ⊗ θᵢ ⊗ εᵢ", + "fields": { + "γᵢ": {"name": "visible_glyph", "domain": "emoji / math symbol / PUA codepoint / Unicode printable", "meaning": "Invokes a specific reconstruction kernel"}, + "χᵢ": {"name": "chirality_vector", "domain": "⟨G_geo, G_comp, G_load, G_spec, G_topo, G_arith⟩", "meaning": "Which law-axis the glyph operates on"}, + "κᵢ": {"name": "local_context / manifold_coordinate", "domain": "position in n-D semantic manifold", "meaning": "Where in the field this packet applies"}, + "τᵢ": {"name": "datatype_witness", "domain": "TypeBook entry", "meaning": "Structural law to import (biography, math article, citation graph...)"}, + "UᵢΛᵢaᵢ": {"name": "eigen_descriptor", "domain": "EigenBook entry", "meaning": "Reusable geometric basis + spectrum + sparse coefficients"}, + "θᵢ": {"name": "parameters", "domain": "side-stream encoded integers", "meaning": "Mode selectors, eigenbook indices, residual class tags"}, + "εᵢ": {"name": "residual", "domain": "byte repair data", "meaning": "Exact correction to generated prediction"} + }, + "core_rule": "glyph ≠ symbol. glyph = callable compression kernel." + }, + + "chirality_book": { + "description": "Same glyph means different lawful things depending on chirality vector.", + "vector_axes": { + "G_geo": "geometric primitive", + "G_comp": "mathematics article/domain macro", + "G_spec": "eigenbasis selector", + "G_topo": "incidence/angle graph operator", + "G_arith": "numeric constraint kernel", + "G_load": "expensive/fallback region marker" + }, + "example": { + "📐_geo": "geometric primitive", + "📐_comp": "mathematics article/domain macro", + "📐_spec": "eigenbasis selector", + "📐_topo": "incidence/angle graph operator", + "📐_arith": "numeric constraint kernel", + "📐_load": "expensive/fallback region marker" + }, + "power": "Finite glyph set becomes combinatorially huge through chirality rotation" + }, + + "type_book": { + "core_rule": "The datatype is the engine. UTF-8 is only the exhaust.", + "example_types": [ + "WikiArticle", + "WikiArticle", + "WikiArticle", + "Infobox", + "CitationGraph", + "SectionTree", + "HistoricalTimeline", + "BranchTaxonomy", + "TableMatrix", + "SameReferentCluster", + "FormulaRegion", + "ListRegion", + "MarkupRegion" + ], + "compression_mass": "WikiArticle already implies title, lead, infobox, birth/death fields, occupation, chronology, categories, citation patterns, linking conventions. The datatype itself carries structure.", + "value": "A type imports generative structure without storing every instance explicitly." + }, + + "eigen_book": { + "formula": "Gᵢ = ⟨τᵢ, Uᵢ, Λᵢ, aᵢ, εᵢ⟩", + "components": { + "τᵢ": "manifold/type class", + "Uᵢ": "eigenbasis / local frame (column vectors)", + "Λᵢ": "eigenvalue spectrum / scale-pressure", + "aᵢ": "sparse coefficients (activation weights)", + "εᵢ": "residual bytes (perturbation from ideal eigenstate)" + }, + "example_math_article": { + "U": ["u_definition", "u_taxonomy", "u_history", "u_notation", "u_application", "u_philosophy", "u_reference"], + "meaning": "A mathematics page ≈ sparse activation of these eigenmodes + residual repair" + }, + "keeper": "A wiki page is a sparse eigenstate of a typed reconstruction manifold, plus apology bytes." + }, + + "parameter_encoding": { + "channels": [ + "side streams", + "variation selectors", + "combining marks", + "PUA suffixes", + "integer-coded payloads", + "arithmetic-coded payloads" + ], + "example": "📐︖︉︚ → MathDomainKernel(mode=22, eigenbook=9, residual_class=26)", + "rule": "Decompressor reads codepoints, not what fonts display." + }, + + "residual_stream": { + "role": "The most important honesty layer.", + "core_rule": "Decode(generative_model) ⊕ ε = exact original bytes", + "forms": [ + "literal patch", + "XOR patch", + "edit script", + "structural diff", + "entropy-coded correction", + "markup repair", + "serialization repair" + ], + "diagnostic": "ρ = |ε| / |raw_span|. ρ < 0.1 = excellent. ρ ≈ 0.5 = maybe useful. ρ ≈ 1.0 = generator failed." + }, + + "gccl_gain_test": { + "formula": "ΔGCL(Γᵢ) = ΔG_geo + ΔG_comp + ΔG_spec + ΔG_topo + ΔG_arith - G_load - L(εᵢ) - L(θᵢ) - amortized_decoder_cost", + "accept_rule": "ΔGCL(Γᵢ) > 0", + "practical_form": "gain(Γᵢ) = literal_cost(span) - encoded_cost(γᵢ, χᵢ, κᵢ, τᵢ, UΛa, θᵢ, εᵢ)", + "principle": "No vibes. No 'semantic compression' handwaving. Only: shorter, deterministic, byte-exact, auditable." + }, + + "decode_pipeline": [ + "Load decompressor profile D", + "Load GlyphBook 𝔊", + "Load ChiralityBook Χ", + "Load TypeBook Τ", + "Load EigenBook 𝕌", + "Read region index I", + "For each Γᵢ: resolve glyph γᵢ, chirality χᵢ, type τᵢ, eigen descriptor UᵢΛᵢaᵢ, parameters θᵢ", + "Generate predicted byte span ŝᵢ", + "Apply residual εᵢ", + "Emit exact span sᵢ", + "Concatenate spans", + "Verify checksum / receipt" + ], + + "encode_pipeline": [ + "Segment corpus into candidate spans (pages, sections, infoboxes, tables, citations, formulas, markup regions)", + "Infer candidate types τ", + "Fit candidate geometric model (choose U, Λ, a)", + "Choose glyph kernel γ and chirality χ", + "Generate predicted bytes", + "Compute residual ε", + "Score: gain = literal_cost - encoded_cost", + "Keep candidates with gain > 0", + "Solve covering problem: choose packet set Γ* covering C with minimum total cost", + "Emit archive", + "Decode immediately and verify exact byte equality" + ], + + "model_families": { + "A_Wiki_structural": { + "kernels": ["WikiArticle", "Infobox", "SectionTree", "CitationGraph", "CategoryList", "InternalLinkGraph", "ReferenceList", "TableMatrix"], + "value": "Highest practical value. Structural redundancy in encyclopedic corpora is massive." + }, + "B_Same_referent": { + "kernels": ["SameReferentVariation", "EntityAliasCluster", "PronounEpithetChain"], + "value": "Handles elegant-variation / synonym-heavy text where literal repetition is low." + }, + "C_Arithmetic_date": { + "kernels": ["Year", "DateInterval", "Coordinate", "PopulationTable", "UnitExpression", "Ranking", "Ordinal"], + "value": "Numbers are dense but highly structured. Very reliable wins." + }, + "D_Fractal_generator": { + "kernels": ["Mandelbrot", "L-system", "CellularAutomaton", "ProceduralImage", "ParametricCurve"], + "value": "Only useful if byte projection matches generator closely. SVG serialization cost usually dominates." + }, + "E_Eigenfield": { + "kernels": ["ArticleEigenfield", "CitationEigenfield", "MarkupEigenfield", "SemanticDensityField"], + "value": "Region-level reconstruction. Connects to density-field encoding theory." + } + }, + + "stress_test_lesson": { + "mandelbrot_svg": "generator cost ≈ tiny, serialized artifact cost ≈ huge", + "conclusion": "z ↦ z² + c generates the image, but not the exact SVG file. Residual = ε_serialize.", + "best_diagnostic": "ρ = |ε| / |raw_span|" + }, + + "implementation_phases": { + "Phase_1": { + "name": "Byte-exact toy codec", + "scope": "GlyphBook + TypeBook + ResidualStream", + "kernels": ["CitationGraphKernel", "InfoboxKernel", "SectionTreeKernel"], + "goal": "generated_span + residual = original_span" + }, + "Phase_2": { + "name": "Add arithmetic/date kernels", + "scope": "Years, dates, coordinates, measurements, rankings, table values", + "value": "Reliable wins on dense numeric data" + }, + "Phase_3": { + "name": "Add same-referent variation", + "scope": "EntityClusterKernel, AliasEmitter, CoreferenceSurfaceFormKernel", + "value": "Attacks low-repetition text" + }, + "Phase_4": { + "name": "Add eigen descriptors", + "scope": "UΛa for region classes", + "caution": "Only after above works. Use as descriptor reuse, not magic semantic compression." + }, + "Phase_5": { + "name": "Add PUA glyph acceleration", + "rule": "promotion_gain = repeated_invocation_savings - glyph_definition_cost. Promote only if positive." + } + }, + + "prototype_archive": { + "magic": "GEC1", + "struct_fields": ["decoder_profile", "glyphbook", "typebook", "packets", "params", "residuals", "sha256"], + "packet_fields": ["glyph_id: u32", "chirality: u8", "type_id: u16", "region_start: u64", "region_len: u32", "eigen_id: Option", "param_ref", "residual_ref"], + "decode_invariant": "sha256(decode(archive)) == sha256(original)" + }, + + "stack_integration": { + "density_field_encoding": { + "role": "REGION-LEVEL MODEL FAMILY E. The density field IS an eigenfield kernel.", + "mapping": "ρ(x⃗) = SemanticDensityField kernel. Topological skeleton = GlyphBook + EigenBook. Perturbation = ResidualStream." + }, + "s3c_shells": { + "role": "LOCAL COORDINATE κᵢ. Shell index k = semantic distance from peak (e.g., article title). a = intra-cluster angular position.", + "mapping": "κᵢ encoded as S3C shell coordinates: cheap integer manifold position." + }, + "oac": { + "role": "GLYPH KERNEL LAZINESS. A glyph is a callable kernel stored in the OAC. It only materializes when touched by the decoder pipeline.", + "mapping": "GlyphBook = library of OAC touch-manifestable kernels. Chirality = which touch interpretation." + }, + "hypercube_rhomboid": { + "role": "MANIFOLD GEOMETRY OF THE PACKET STREAM. UTF-8 is orthogonal hypercube (independent byte positions). GCCL-GEC is sheared hyper-rhomboid: each packet's meaning depends on neighboring packets through chirality and type context.", + "mapping": "Shear matrix learned from corpus: eigenvectors = principal semantic directions. Packets lean into each other." + }, + "famm_delay_lines": { + "role": "TEMPORAL SEQUENCING OF PACKET STREAM. FAMM preshaped delays impose decode order through the packet stream.", + "mapping": "Delay profile = path integral through packet dependencies. Fast regions = high structural redundancy (predictable). Slow regions = high residual density (needs more context)." + }, + "erans_entropy": { + "role": "RESIDUAL AND PARAMETER STREAM CODING. After glyph prediction, residual bytes and parameters are entropy-coded via enumerative rANS.", + "mapping": "Histogram of residuals is exact; erans enumerative coding is optimal for exact histograms." + }, + "radius_ratio_motif": { + "role": "LOCAL ADMISSIBILITY QUANTIZER FOR PACKET SELECTION. Given a local feature ratio ρ, the radius-ratio rule selects the smallest stable coordination motif (kernel).", + "mapping": "Local scale ratio → admissible kernel class (WikiArticle, Infobox, CitationGraph...) + residual. Same move: continuous witness → finite motif alphabet." + } + }, + + "keeper_phrases": [ + "Do not store the text. Store the cheapest lawful generator of the byte projection.", + "glyph ≠ symbol. glyph = callable compression kernel.", + "The datatype is the engine. UTF-8 is only the exhaust.", + "A wiki page is a sparse eigenstate of a typed reconstruction manifold, plus apology bytes.", + "Never trust a glyph until the residual gets smaller.", + "No vibes. No 'semantic compression' handwaving. Only: shorter, deterministic, byte-exact, auditable.", + "ρ = |ε| / |raw_span|. This is the only number that matters.", + "The decompressor reads codepoints, not what fonts display.", + "A finite glyph set becomes combinatorially huge because each glyph can rotate through many law-axes.", + "The Morse-Smale complex is the topological skeleton of meaning. GCCL-GEC is the lawful engine that navigates it." + ], + + "metadata": { + "ingested_at": time.time(), + "tags": [ + "gccl-gec", "compression-architecture", "glyph-eigen-codec", + "byte-exact-compression", "callable-kernel", "chirality-book", + "type-book", "eigen-book", "residual-stream", "gain-test", + "hutter-prize", "density-field", "s3c-shells", "oac", + "hypercube-rhomboid", "famm", "erans", "radius-ratio", + "geometric-compression" + ] + } +} + + +def ingest(): + germane_dir = RESEARCH_STACK / "shared-data/data/germane/research" + germane_dir.mkdir(parents=True, exist_ok=True) + + out_path = germane_dir / "gccl_gec_spec_v1.json" + with open(out_path, 'w') as f: + json.dump(GCCL_GEC, f, indent=2) + + print(f"✓ Ingested: {out_path}") + + index_path = germane_dir / "research_ingestion_index.json" + index = [] + if index_path.exists(): + with open(index_path) as f: + index = json.load(f) + + index.append({ + "id": GCCL_GEC["id"], + "title": GCCL_GEC["title"], + "date": GCCL_GEC["date"], + "source": GCCL_GEC["source"], + "ingested_at": GCCL_GEC["metadata"]["ingested_at"], + "tags": GCCL_GEC["metadata"]["tags"], + }) + + with open(index_path, 'w') as f: + json.dump(index, f, indent=2) + + print(f"✓ Index: {len(index)} entries") + + print(f"\nArchive components (9):") + for k, v in GCCL_GEC["archive_structure"]["components"].items(): + print(f" {k} = {v['name']}: {v['role'][:60]}...") + + print(f"\nPacket fields (7):") + for field, props in GCCL_GEC["fundamental_packet"]["fields"].items(): + print(f" {field} → {props['name']}: {props['meaning'][:50]}...") + + print(f"\nModel families (5):") + for fam, data in GCCL_GEC["model_families"].items(): + print(f" {fam}: {len(data['kernels'])} kernels — {data['value'][:50]}...") + + print(f"\nStack integration (7):") + for module, mapping in GCCL_GEC["stack_integration"].items(): + print(f" ↔ {module}: {mapping['role'][:65]}...") + + print(f"\nImplementation phases (5):") + for phase, data in GCCL_GEC["implementation_phases"].items(): + print(f" {phase}: {data['name']} — {data.get('goal', data.get('value', data.get('scope', '')))[:50]}...") + + print(f"\nKeeper phrases ({len(GCCL_GEC['keeper_phrases'])}):") + for p in GCCL_GEC["keeper_phrases"]: + print(f" → {p}") + + +if __name__ == "__main__": + ingest()