Interactive Relational Normalization & Synthesis Studio Codd 1970 • Bernstein 1976

Derive candidate keys under Armstrong's Axioms, inspect minimal covers, synthesize dependency-preserving lossless-join 3NF relations, decompose BCNF trees, and verify join dependency implication via the deterministic Tableau Chase with spurious tuple counterexamples.

Load Preset:

1. Relational Schema Input Pure discrete evaluator

Heading Attributes (U)

Comma-separated list of attribute names.

Functional Dependencies (F)

One dependency per line: X -> Y.

Custom Components for Chase (Optional)

Leave blank to chase Bernstein's 3NF synthesis, or enter subschemas to test for lossiness.

Candidate Keys

—

Prime Attributes

—

Chase Join Status

—

Normal Form Decision Invariants

Bernstein (1976) 3NF Synthesis (Lossless & Dependency-Preserving)

Run synthesis to generate decomposed relational tables.

Relational Tableau Chase Execution Trace

Step	FD Applied	Rows Equated	Attribute	Symbol Mutation
Awaiting execution...

View Final Tableau Matrix

Generated Relational DDL

-- SQL DDL will appear here after synthesis

Streaming BQNF Delta Repair & Quantile Rebalancing Homological Quotient Repair

Simulate high-throughput Change Data Capture (CDC) events across query boundaries. Observe how Boundary-Quotient Normal Form commutes incremental signed coboundary updates, services destructive extremum deletions via $O(\log K)$ priority-queue cochains, and bisects dynamic dyadic quantile sketches under power-law skew without full table recomputations.

1. Boundary & Stream Config

Declared Query Boundary

Query: SELECT region, SUM(amount), MAX(amount) FROM sales

Filter: WHERE status = 'paid' GROUP BY region;

State: region_extremum_cochain + region_quantile_cochain

Enable Priority-Queue Extremum Cochain (Bypasses $O(N)$ full scans)

Dynamic Dyadic Bisection Thresholds

Split Threshold:

Merge Threshold:

CDC Event Stream (JSON)

CDC Events Processed

—

Extrema Cochain Hits

—

Table Scan Fallbacks

—

Extrema Repair Log (Database Audit Trail)

Op	Amount	Destructive?	Route	Extrema Transition	Fallback Scan
Run simulation to view SQLite execution log.

Dynamic Dyadic $\epsilon$-Quantiles Sketch Histogram

Bucket intervals will be rendered here...

NF-IR Compiler Playground Godbolt-Style Multi-Target Lowering

Inspect the 4-layer compiler intermediate representation. Transform declarative normal form contracts into micro-kernel witness triples $K = (X, F, L)$, optimize via monotone poset subsumption lattices with dead-check elimination (DCE), and lower to executable SQLite triggers, Python guards, and automated counterexample test fixtures.

1. Contract & Invariant Spec

Contract ID

Table Name

Key Field

Heading Fields (U)

Determinant (Collapse Map)

Dependent (Protected Law)

Test Carrier Data (JSON Array)

Layer 2 Poset Subsumption & Dead-Check Elimination

Compile contract to evaluate subsumption ordering...

Executable SQLite DDL with BEFORE INSERT/UPDATE abort triggers

-- SQLite DDL and triggers will be emitted here

Zero-overhead fail-closed Python decorator

# Python guard code will be emitted here

AI Agent Model Context Protocol (MCP) LossLedger Gateway Token Conservation & Cryptographic Audit

Auditable RAG context compression and token truncation. Enforces exact token conservation (source_tokens == retained_tokens + truncated_tokens), emits SHA-256 Merkle-sealed LossLedgers documenting erased attributes, and enforces the epistemic firewall (certified_implies_authorized: false).

1. RAG Context Budgeting Input

Token Budget Ceiling

Maximum allowed tokens in projected prompt context.

Target Retained Fields

Any unlisted source fields (e.g. debug traces, raw embeddings) will be safely erased and recorded in the LossLedger.

Source Chunks (JSON)

Source Tokens

—

Retained Tokens

—

Truncated Tokens

—

Cryptographic SHA-256 Merkle LossLedger Seal

Root Merkle Digest: —

Erased Metadata Fields: —

Token Conservation Law: —

Epistemic Authority Firewall

In accordance with certified_implies_authorized: false, a verified context projection remains strictly unauthorized until validated by an independent policy verifier. This prevents hallucinated or truncated context from automatically triggering irreversible real-world tool execution.

Zero-Friction Developer Adoption: 3 Lines of Python

Integrate relational schema normalization, streaming BQNF delta repair, and intermediate representation guards directly into your database migration pipelines, backend services, and AI agents.

1. Clone & Install in Editable Mode

# Clone repository
git clone https://github.com/dbccpage/simplex-normal-forms.git
cd simplex-normal-forms

# Install editable package
pip install -e .

# Run test suite
python -m pytest tests/ -v

2. Relational Schema Normalization & 3NF Synthesis

from normal_forms.domain.relational import FunctionalDependency, RelationalSchema, check_3nf, chase_join_dependency
from normal_forms.domain.relational_advanced import synthesize_3nf_bernstein

# 1. Declare attributes and functional dependencies
schema = RelationalSchema(
    attributes=frozenset({"order_id", "cust_id", "zip", "amount"}),
    dependencies=frozenset({
        FunctionalDependency.from_str("order_id", "cust_id,amount"),
        FunctionalDependency.from_str("cust_id", "zip")
    })
)

# 2. Synthesize 3NF subschemas (Bernstein 1976)
tables = synthesize_3nf_bernstein(schema)
print("3NF Decomposed Tables:", [sorted(t) for t in tables])

# 3. Verify lossless join via Relational Tableau Chase
chase = chase_join_dependency(schema.attributes, schema.dependencies, tables)
assert chase.is_implied is True, "Lossless join verified!"

3. Lowering Normal-Form Contracts to SQLite Triggers

import sqlite3
from normal_forms.domain.relational import FunctionalDependency
from normal_forms.ir_kernel import lower_fd_to_kernel_spec
from normal_forms.ir_lowering import compile_to_sqlite_triggers, install_and_verify_sqlite_bundle

# 1. Lower BCNF contract to SQLite triggers
spec = lower_fd_to_kernel_spec(
    fd=FunctionalDependency.from_str("dept_id", "manager_id"),
    key_field="employee_id",
    heading=("employee_id", "dept_id", "manager_id", "office"),
    contract_id="nf.classical.bcnf"
)
bundle = compile_to_sqlite_triggers(spec, table_name="employees")

# 2. Install and enforce in SQLite database
conn = sqlite3.connect(":memory:")
ok, err = install_and_verify_sqlite_bundle(conn, bundle, rows=[
    {"employee_id": "1", "dept_id": "D1", "manager_id": "M1", "office": "101"},
    {"employee_id": "2", "dept_id": "D1", "manager_id": "M2", "office": "102"} # Conflicts on dept_id -> manager_id!
])
assert ok is False, "Database trigger blocked invalid insert!"

4. Verifiable AI Context Transport with Merkle LossLedger

from normal_forms.ai import coda_mur_projection, verify_loss_ledger_integrity

@coda_mur_projection(
    source_fields=("chunk_id", "text", "doc_title", "internal_debug_trace"),
    target_fields=("chunk_id", "text", "doc_title"),
    key_field="chunk_id",
    protected_fields=("chunk_id", "doc_title"),
    max_token_budget=30
)
def compress_context(chunks):
    return None # Return None for canonical projection

envelope = compress_context([{"chunk_id": "c1", "text": "...", "doc_title": "T1", "internal_debug_trace": "xyz"}])
assert envelope.token_conservation_commutes is True
print("SHA-256 Merkle LossLedger:", envelope.loss_ledger["merkle_digest"])