Confidential pre-filing demonstration. Enter the PIN you were issued to continue. Access is logged.
Reduction to practiceTEE quote: MOCKdeployed
Not promised. Attested.
Companies promise things: "we keep your health data private,"
"cancel anytime," "no charge until a doctor approves." This site shows
a machine that holds them to it. It turns the promises into rules,
blocks anything that would break them, writes every decision into a
diary nobody can quietly edit, and prints receipts anyone can check
for themselves. Everything below runs live, on made-up data, and you
can press every button.
In filing terms
A privacy policy becomes a ratified commitment set in a formal
language. A gate sits on every egress path and attests, suppresses, or
remediates each event. A tamper-evident ledger scores conduct and
issues certificates a stranger can check without trusting the issuer.
This page runs that loop end to end on synthetic data, and every step
is a glass box: you see the pseudocode listing that executed and the
live values it produced.
Plain English
First time here? Read this part.
Companies make promises all the time. "We keep your health
information private." "Cancel anytime." Right now those promises are
just words on a page. If a company breaks one, nobody finds out until
a lawsuit or a news story, sometimes years later.
This site is a working model of a new invention that turns those
promises into something a computer can enforce and prove. Four ideas
carry the whole thing:
1The promise becomes a rule. The system reads the
company's own policy and turns each promise into a precise rule a
machine can check. The company then signs those rules, the way you
would sign a contract.
2A checkpoint guards the door. Every piece of data
the company tries to send out must pass a checkpoint first. If
sending it would break a signed rule, the checkpoint blocks it, or
cleans it up and sends the safe version. Nothing goes around it.
3Everything lands in a sealed diary. Every decision
is written into a record that cannot be quietly edited. Change even
one old entry and the whole diary visibly breaks. There is a Tamper
button on this page so you can watch that happen.
4The system hands out receipts. It can produce a
certificate that proves something happened, or proves something
never happened, like "no health data ever went to advertisers."
Anyone can check the receipt themselves on the Verify tab. You do
not have to trust the company. You do not even have to trust us.
You have already seen this problem in the news.
Therapy and prescription-discount apps paid multimillion-dollar FTC
settlements after health information reached advertisers through
tracking pixels. Regulators sued over subscriptions that take one
click to start and a maze of screens to leave. A DNA-testing company
went bankrupt, and millions of customers asked what happens to the
privacy promises attached to their data when it is sold. Every one of
those stories is a tab on this page.
How to drive this page: go through the numbered
tabs in order and press the buttons. The diary on the right fills in
as you go. In a hurry? Ratify in tab 1, then jump to tab 7: it runs
four complete stories (a casino, a robot, a bankruptcy, a chatbot) at
one click each. Everything runs on made-up data; no real people, no real
companies, and nothing actually gets sent anywhere.
Nothing here is hidden. Every result opens a glass
box with three tabs: Trace shows what happened step by step, Code shows
the actual program that just ran on this server (fetched live from the
running process, not a copy), and Math shows the formulas from the
filing with your numbers plugged in.
Words you will see on this page, in plain terms
Commitment
a promise written as a precise, checkable rule
Ratify
the company signs the rules so they officially count
Gate
the checkpoint every outgoing action must pass through
Attest
the gate's note that says "this was sent, and here is the record"
Suppress
the gate's note that says "this was blocked, and here is which rule stopped it"
Ledger
the sealed diary of everything that happened
Certificate
a receipt anyone can check on their own, even years later
VOID
what a receipt becomes when any part of it cannot be proven
The method, end to end
disclosure 2 · fig. 1
Commitments flow in from four source types and compile
to predicates. Events flow through the gate. Everything lands on the
ledger, and everything that leaves does so as a verifiable certificate.
The animated paths below are the only paths that exist: there is no
egress around the gate (I-GATE) and no claim without a record.
From policy to ratified commitments
disclosure 2, 3.14 · P1 P12 P15 · T13 T14
Extraction reads the sample policy and emits CSL
sentences. The four demo sentences are pre-translated (a declared
stub); the parse, compile, and ratification behind them are the
filed method. Ratification signs Commit(K) || H(doc): the
organization signs sentences it can read, and the machine evaluates
exactly those sentences. Extraction accuracy leaves the trust base.
The signature is the trust base.
Real worldThe FTC's
BetterHelp and GoodRx actions both began with privacy-policy
sentences almost identical to the four below. Here, sentences like
those stop being marketing copy and become signed, machine-checkable
rules.
Pseudocode executing behind this flow (P15, P12)The running code (conformance/csl.py), read live from this server
loading…
The running code (conformance/policy.py), read live from this server
loading…
The activation gate
disclosure 3.2, 3.9 · P2 · T2 T3
Every egress path factors through the gate. Fire
simulated events and watch each one route: attest clean, remediate
to a conformant variant, or suppress against the named commitment.
Suppressions are conformant outcomes. The score reflects that.
Real worldMost of the
health-data leaks in the news were tracking pixels nobody meant to
misconfigure: an intake form quietly firing to an ad platform. A
checkpoint that reads every outbound event catches that mistake
before it leaves the building, and writes down what it did.
Ratify the commitment set in flow 1
first. The gate evaluates events against the ratified set only.
Try the charge before and after fulfilling the
consult and prescription. The gate enforces order, not intent.
Same gate, other
embodiments
The checkpoint does not
care what industry it guards. Two more commitment sets are in force
from CONTRACT sources: a state gaming license and a robot
site-safety plan. Same six lines of gate code.
Real worldCasino
self-exclusion lists and warehouse-robot safety envelopes are
enforced today by policy documents and hope. Here they run through
the exact code you can open in the glass box below.
The last four run under three more sources: a
sanctions statute, an enclave data-processing agreement, and a
collective bargaining agreement. The health pixel above now also
violates a consent-order overlay, so the score decomposes across
SELF, STATUTE, CONTRACT, and CONSENT_ORDER at once.
Pseudocode executing behind this flow (P2)The running code (conformance/gate.py), read live from this server
Proving a negative. After a run with zero
health-to-adtech transmissions, the layer issues Cert-NT: an
absence proof over the sorted attest index, a continuity proof
that the gate never went dark, and the mock instrument quote.
Absence is proved by adjacency, not inferred from silence: the two
bracketing leaves sit side by side, so nothing fits between them.
Simulate an outage in the ledger panel and issuance fails closed.
No certificate exists to be wrong.
Real worldToday,
proving "we never sent your health data to an ad platform" takes
subpoenas, forensic reconstruction, and years of litigation. This
certificate is that proof, generated ahead of time, checkable by
anyone, and it refuses to exist for any period the checkpoint
cannot vouch for.
The second and third buttons are the same theorem
(T2) with the category and endpoint substituted: no solicitation
ever reached the self-excluded class; no actuation ever entered the
keep-out zone. One skeleton, many negatives.
Pseudocode executing behind this flow (P4)The running code (conformance/ledger.py), read live from this server
loading…
The running code (conformance/certs.py), read live from this server
"Cancel anytime" is a measurable claim. Enrollment
takes 4 steps. Cancellation takes 11, with 2 dead ends and an
interstitial offer. F weighs each flow; sigma is exit burden over
entry burden; theta = 1 means "at least as easy to leave as to
join". Drag the slider to strip cancellation steps and watch sigma
cross theta. Every added exit step weakly increases sigma. That is
Theorem T4, and you can feel it.
Real worldThe FTC sued
Amazon over a cancellation flow employees had nicknamed "Iliad,"
and click-to-cancel rules now demand that leaving a subscription be
as easy as joining. That demand is exactly one number: the ratio
this page computes live as you drag the slider.
Enrollment flow (fixed)
Cancellation flow
(11 steps)
0theta = 1.0 (conformance boundary)2+
σ = …
Pseudocode executing behind this flow (P5)The running code (conformance/certs.py), read live from this server
loading…
Consent-bound billing
disclosure 3.4 · P6 · T5
A recurring charge is valid only if a signed,
in-scope, unrevoked consent precedes it. The bind, H(charge ||
consent), is recorded with the charge. A charge with no consent, or
after revocation, is flagged with the reason named. Invalid charges
are detectable before they happen and provable after (T5).
Real worldThe gym that
keeps charging after you cancel. The app trial that quietly becomes
a paid subscription. Here, every charge must point at a signed
consent that came before it and was never revoked, or it gets
flagged on the spot with the reason written down.
Sequence to try: charge (FLAG, no consent), consent,
charge (BOUND), revoke, charge (FLAG, revoked).
Pseudocode executing behind this flow (P6)The running code (conformance/certs.py), read live from this server
One synthetic input record, two lanes. The
deterministic lane is a versioned pure function: replay the version
on the input and you must get the output, bit for bit. That chain
certifies as non-inference. The probabilistic lane is a local stub
labeled INFERENCE; a nonce enters its output, so no replay property
holds. Composing a P output into a D artifact is refused
structurally, and the refusal itself is a ledger record.
Real worldA hospital,
bank, or law firm using AI has to answer one question under oath:
which parts of this document were pure calculation, and which came
out of a model? This lane split makes the answer provable, and
makes mixing the two impossible rather than merely against
policy.
Pseudocode executing behind this flow (P8)The running code (conformance/certs.py), read live from this server
loading…
The same machine, four industries
disclosure 5.18 5.19 3.13 · P2 P4 P9 · T2 T8
Each button below runs a complete story, start to
finish, on this page's live engine: the events fire through the
same gate, land on the same ledger, and end in a certificate you
can send to Verify. Read the plain-language line first; the mono
line underneath is what the machine recorded. Ratify in flow 1
first if you have not.
A casino and the
self-exclusion list
Sam asked the state to keep
him out of gambling marketing. The casino's license depends on
honoring that, across every marketing system it runs.
A robot arm and the
keep-out zone
The safety plan says the
arm never enters the zone where people walk. A corrupted job file
is about to test that.
A bankruptcy and your
DNA
The company that holds the
genetic data goes under. The data gets sold. Do the promises go
with it?
A chatbot and a
14-year-old
Washington-class law says a
companion bot must remind a minor every hour that it is not a
person. Six hours of chat. One reminder does not go out.
Real worldStates are
passing exactly these disclosure-cadence rules for AI companion
apps right now. Enforcement today means subpoenaing chat logs after
something goes wrong. Here the missed reminder scores itself the
moment the hour passes.
Verify a certificate
disclosure 8, 11 · P14 · math 13
Paste any certificate this instance emitted.
Verification runs the P14 checks in order and names the failing
check: signature, instrument integrity, continuity, commitment
basis, type-specific evidence, and live ledger integrity. Tamper
with the ledger from the panel and watch a previously valid
certificate go VOID. The verifier trusts mathematics, not the
issuer.
Real worldAn auditor,
a regulator, a court, or a customer can run this same check years
from now, without asking the company for anything and without
taking anyone's word. If a single record was altered anywhere along
the way, the answer comes back VOID with the reason named.
Pseudocode executing behind this flow (P14)The running code (conformance/verify.py), read live from this server
loading…
One skeleton, thirty claim families
traceability matrix · docs/traceability_matrix.txt
The six flows above are one vertical (telehealth) of a
general mechanism. Every family below runs the same loop: a commitment
set from one of four sources, a gate on the governed action, a ledger
record, and a certificate. Families marked LIVE are running on this
page; click one and it runs its demonstration in front of you,
ratifying first if needed. The rest substitute the category and the endpoint, not the
method: non-solicitation is non-transmission with a user class in
place of an ad platform; non-actuation is the same theorem with a
robot's operating envelope; succession binds the commitments to the
data itself so they survive a bankruptcy sale, which is the question
millions of DNA-testing customers were left asking in 2025.
Sources of commitments: the organization's own
representations (SELF), inter-organizational agreements (CONTRACT),
machine-read law (STATUTE), and regulatory decrees (CONSENT_ORDER).
Same gate, same ledger, same certificates; per-source scores decompose
(T11), so a consent-decree compliance score falls out of the same
arithmetic.
The mathematics underneath
mathematics.txt · theorems T1 to T14
Every certificate on this page is backed by a theorem
with a proof at provisional depth, and the load-bearing four (T1, T2,
T7, T8) carry full reductions. The adversarial model is explicit:
five adversary classes, and for each theorem a stated standing.
Fail-closed is a design position: when continuity cannot be shown,
the certificate refuses to exist.
Theorem standing under the
adversarial model
A1 compromised insider · A2 gate bypass ·
A3 compromised verifier · A4 colluding counterparty ·
A5 replay or reordering. Entries: holds, fail-closed (the certificate
refuses issuance), or liability shift (the lie becomes legible).
The score, worked
(math sec 14)
Five ratified commitments, one week, 70 applicable
occasions. One pixel escaped before a rule update propagated; one
reminder occasion was missed. Weighted:
S = 0.9565
1 - 4/92, weights 3,2,1,3,1
Per-source
decomposition (T11)
SELF0.8333
STATUTE0.9846
CONTRACT1.0000
The SELF-source dip is what a Behavioral Integrity
Index trajectory surfaces. S enters the Data Trust Index as
dimension d_conf.
Evidence that travels
Certificates are portable
evidence objects, not a proprietary silo. The exemplar maps
field-for-field onto W3C Verifiable Credentials 2.0 (a voided
certificate is a revoked VC) and onto C2PA assertions, so an
ad-verification stack can check attested delivery in-line. Part B of
the exemplar is an FRE 902(13)/(14) declaration skeleton: the record
authenticates through the process that produced it, with hash values
obtained before any dispute arose.
