Paper IV — TDLN: The Policy Compiler
Deterministic Translation of Natural Language
Normative keywords per RFC 2119/8174 (MUST/SHOULD/MAY) apply.
The Story
September 2024. An AI trading system. A regulatory investigation.
The system was supposed to "avoid trades that might manipulate the market." The developers interpreted this as: flag trades above $1 million. The regulators interpreted it as: detect coordinated patterns regardless of size.
Six months of trades were executed under the wrong interpretation. $340 million in fines. The investigation's central question: "What did 'might manipulate' actually mean in this system?"
No one could answer. The policy existed as a comment in the code:
# Avoid trades that might manipulate the market
if trade.amount > 1_000_000:
flag_for_review(trade)
The gap between human intent and machine execution was invisible. The interpretation was buried in an engineer's decision from months ago. There was no proof that this interpretation matched the policy. There was no way to verify what "should have" happened.
Now imagine a different architecture.
The policy is written in TDLN:
ruleset market_safeguards@v1.0
@policy manipulation_detection
@description "Detect trades that might manipulate the market"
when trade.amount > 1000000: flag_review
when trade.pattern IN ["wash", "layering", "spoofing"]: flag_review
when trade.velocity > context.market.avg_velocity * 3: flag_review
This policy compiles to a canonical AST with a deterministic CID:
canon_cid: b3:4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a...
The compilation produces a proof binding the source text to the AST. The proof is signed. If regulators ask "what did this policy mean?", the answer is the AST. If they ask "did the system follow the policy?", the answer is: compare the decision receipts to the policy hash.
The investigation becomes a hash comparison.
This is TDLN.
I. The Problem
Natural language is ambiguous. Code is rigid. The gap between human intent and machine execution is where systems fail.
Traditional approaches:
- Developers interpret requirements (lossy)
- Code encodes interpretation (drift)
- Tests verify code, not intent (mismatch)
- Production reveals the gap (incident)
The translation from "what I meant" to "what the machine did" is invisible, unverifiable, and unreproducible.
II. The Thesis
**Intention, when compiled under a signed ruleset, becomes a canonical, proof-carrying bundle.**
TDLN defines:
1. A typed policy language without ambiguity
2. A canonicalization function (ρ) that normalizes ASTs
3. A translation proof binding source to output
4. A Gate that evaluates bundles deterministically
The compiler is governance. The proof is accountability.