RDL and the Compiler Boundary

Route C / RDL and the Semantic Compiler Boundary

The compiler analogy is useful only if every component remains literal.

How does Runcible turn consequential language into something an institution can test?

RDL represents the matter. Runcible AI performs compiler-like clarification and testing. A structured record preserves the result. Legitimate authority decides what may proceed. Runcible OS makes an authorized change real.

This is not a metaphor for automated permission. Successful semantic compilation may establish that a proposition survives defined tests. It does not approve, publish, sign, spend, prescribe, govern, or bind.

Stable Technical MappingAnalogy → Literal Component
  1. Source materialConsequential information in context

    Document, claim, argument, contract, policy, recommendation, or proposed action

  2. Intermediate representationRDL

    Typed objects, terms, propositions, relations, operations, burdens, limits, and open conditions

  3. Compiler and testsRuncible AI

    Clarification, decomposition, typing, protocol selection, adjudication, diagnostics, and repair

  4. Build and test artifactStructured judgment

    Evidence, tests, support, failure, repair, provenance, reliance, and next conditions

  5. Release authorizationLegitimate authority

    Person, role, quorum, or explicit delegation responsible for the exact transition

  6. Execution environmentRuncible OS

    Persistent institutional state, controlled operations, accounting, consequence, correction, and memory

The analogy has a boundaryRDL is not the compiler. Runcible AI is not the release authority. Runcible OS is not merely a display surface.

What Actually Happens

Runcible constructs a testable representation of a matter and returns a bounded judgment about it.

Ordinary language is not executable institutional state. It omits too much and implies too much.

A sentence can leave its actor implicit, collapse several operations into one verb, refer to an undefined object, hide its scope, omit affected parties, claim causality without a causal design, and assume standing that no speaker possesses.

Runcible therefore does not test the sentence as an indivisible string. It establishes the institutional matter, translates the language into typed relations, identifies independently testable propositions, selects the burdens those propositions create, executes the applicable tests, and preserves every supported, failed, repairable, skipped, and open condition in a structured result.

01 / Bind

Establish the matter

Exact source, version, purpose, use, organization, program, role, evidence, authority, consequence, and required quality of judgment.

02 / Represent

Construct RDL

Identify objects, actors, actions, states, propositions, relations, measurements, conditions, interests, limits, and unresolved references.

03 / Adjudicate

Execute burdens

Select protocols and test identity, consistency, correspondence, possibility, causality, reciprocity, authority, liability, warrantability, and decidability.

04 / Diagnose

Return exact failure

Distinguish ambiguity, contradiction, missing evidence, missing authority, impossible operation, externalized cost, skipped test, and undecidability.

05 / Repair

Preserve what survives

Construct the strongest supportable version, state reliance limits, identify additional evidence, and leave conditions open when closure is unavailable.

06 / Record

Emit structured judgment

Preserve matter identity, propositions, evidence, tests, provenance, diagnostics, result, repair, authority requirements, and valid next operations.

The compiler analogy begins after the matter is established and ends before the institution grants permission.

RDL / Typed Operational Language

RDL makes the structure hidden in consequential prose explicit enough to inspect and test.

RDL is the current name for the typed operational representation. It is not a claim that ordinary language can be reduced without remainder.

The representation carries the distinctions that determine meaning, burden, and reliance. Where the source does not provide them, RDL must preserve missingness or ambiguity rather than silently complete the matter.

The exact production syntax, schema coverage, protocol bindings, and serialization are product-evidence and intellectual-property boundaries. The categories below describe what the representation must preserve; they are not presented as a published production grammar.

Identity

Objects and referents

Actor, role, object, institution, program, version, source, audience, counterparty, and affected party.

State

Before and after

Current condition, proposed condition, valid transition, time, location, jurisdiction, dependencies, and revocation.

Operation

What changes what

Action, instrument, object acted upon, preconditions, permissions, constraints, expected outcome, and failure mode.

Proposition

What is being asserted

Definition, relation, quantity, scope, causality, prediction, recommendation, obligation, promise, or proposed decision.

Measurement

Evidence and correspondence

Observed distinction, method, source, comparator, unit, uncertainty, provenance, falsifier, omission, and conflict.

Economics

Demand and satisfaction

Demand, supplied good or information, conditions of satisfaction, benefit, cost, transfer, externality, remedy, and restitution.

Authority

Who may decide

Role, person or delegation, scope, procedure, quorum, jurisdiction, time, review, approval, and escalation.

Liability

Who becomes answerable

Reliance, exposure, duty, warranty, consequence, accounting, correction, revocation, and unresolved responsibility.

Illustrative RDL ProjectionNot Production Syntax
Source sentence
“Vendor may use service data to improve its products.”
mattervendor_agreement / proposed_term / version_07
speech_actgrant_permission
actorvendor [affiliates? subprocessors? unresolved]
operationuse [process? train? profile? transfer? retain? unresolved]
objectservice_data [content? telemetry? metadata? derived data? unresolved]
purposeimprove_products [contracted service or unrelated products? unresolved]
scopeundefined jurisdiction / duration / recipients / revocation
exchangeservice demanded / additional durable data right supplied? unresolved
authorityanalysis allowed / acceptance and signature not authorized
burdensdefinition / necessity / reciprocity / privacy / security / liability / remedy
Conceptual representationThe point is not the notation. The point is that ambiguity, missingness, authority, and economic consequence become typed parts of the matter rather than prose the model may glide past.
RDL does not make uncertain language certain. It makes the location and consequence of uncertainty explicit.

Runcible AI / Semantic Compilation and Tests

Runcible AI lowers fluent language into explicit propositions, burdens, diagnostics, and repair.

A software compiler can reject a program because its syntax or types make execution impossible. Consequential language requires a broader process.

Runcible must test not only whether a statement is internally well formed, but whether its referents exist, its evidence corresponds to them, its operation is possible, its causal promise is supported, its exchange satisfies demand without transferring hidden costs, its authority exists, and its reliance can be bounded.

Foundation models may assist every generative step: interpretation, retrieval, alternative decomposition, hypothesis construction, counterexample generation, and repair. Their candidates remain candidates until the applicable burdens have been executed and preserved.

Front end / 01Parse and bind

Resolve the matter before testing the claim.

  • Bind exact source and version
  • Identify speech act and intended use
  • Resolve actors, objects, referents, and roles
  • Preserve unresolved identity rather than guessing
Front end / 02Normalize and decompose

Separate every proposition that can receive a different result.

  • Definitions and quantities
  • Relations and causal claims
  • Promises and implied operations
  • Scope, assumptions, alternatives, and exceptions
Middle end / 03Type and lower

Translate prose into state, operation, transformation, and consequence.

  • Before and proposed state
  • Operation and preconditions
  • Expected output and affected interests
  • Authority, liability, and reliance relations
Middle end / 04Select burdens

The matter determines what must be tested.

  • Domain protocols and evidence requirements
  • Scientific and causal burdens
  • Economic demand and reciprocity
  • Institutional rules, authority, and liability
Test engine / 05Execute and falsify

Attempt to disconfirm, narrow, or block each proposition.

  • Identity, consistency, and correspondence
  • Possibility, causality, and scope
  • Reciprocity and full accounting
  • Authority, warrantability, and decidability
Back end / 06Diagnose and repair

Return the strongest result the record can carry.

  • Supported and failed content
  • Typed diagnostics and skipped tests
  • Strongest supportable repair
  • Open conditions, provenance, and next operation
One Sentence / Six TransformationsVendor Term Example
Source“Vendor may use service data to improve its products.”

Fluent, compact, and institutionally underdetermined.

DecompositionPermission / data identity / use / purpose / necessity / exchange / duration / transfer / remedy

The sentence contains multiple propositions and proposed operations.

Typed failuresUndefined object / ambiguous operation / unbounded scope / absent reciprocity / unresolved liability

These are different defects and require different repairs.

Surviving propositionLimited processing may be necessary to perform the contracted service.

The record can preserve this without granting unrelated secondary rights.

RepairPurpose-limited processing / named recipients / no unrelated training or transfer / defined retention / deletion, audit, and remedy

The repair narrows permission to what the demand and evidence can support.

ResultRepair required / exact repaired version eligible for authorized review

Not permission to accept, sign, spend, transfer rights, or bind.

Semantic compilation is not stylistic rewriting. It changes an opaque sentence into inspectable propositions, failures, and conditions of reliance.

What the Compiler Is Asked For

A conventional compiler is asked to produce a machine that acts. This one is asked to produce a refusal.

Compilation failure is not a defect in the run. It is the deliverable — the explained error is the finding.

Because the logic is constructive and bottom-up, existence has to be built rather than asserted. “A square circle” cannot pass, because nothing can be constructed that satisfies both terms. “Justice means goodness” cannot pass either, because no actor, transfer, harm, obligation, or test has been supplied to build from. In neither case is the compiler failing to understand the claim. It has located the exact point at which the claim stopped referring to anything.

Discretion is the one input the compiler cannot supply. Where a claim would need someone’s judgment to proceed — a missing measurement, an ambiguous reference, an incomplete rule, an irreducible preference — the system reports that condition rather than guessing past it. This is the Runcible standard of decidability implemented as a type system instead of described as a policy: satisfaction of the demand for infallibility appropriate to the context, without the necessity of discretion.

The compile step therefore returns three outcomes rather than two — ternary logic, in the research vocabulary. Those three outcomes are the result states. What an institution reads from a result state is an action state.

01 / Input

Take the text as written

A description, an argument, a narrative, a contract term, or a generated answer — without first improving it.

02 / Operational prose

Restate it so it can be checked

Actors, actions, objects, conditions, and measurements become explicit. What the sentence left implicit is supplied or marked missing.

03 / Assertions

Separate what is claimed

The prose is divided into individual claims, each of which can receive a different result.

04 / RDL

Type the assertions

Objects, relations, operations, burdens, limits, and open conditions become typed parts of the matter rather than prose.

05 / Compile

Run the test

Construct what the claim requires, then attempt to falsify it. Errors are emitted and explained rather than absorbed.

Result state

Return what the run establishes

A construction that survived, an explained failure, or a matter that cannot close without discretion.

A fluent generated claim has no compile step. That is the whole difference between a candidate and an adjudicated result, and it is the mechanism behind the shorter statement that models hypothesize and Runcible adjudicates.

Result state / Compiles

Action states: Certified, Survives, Escalated

The construction held under the burdens that were run. What separates the three is authority: a legitimate role has certified the result and warranty attaches, or no authority decision has been taken and reliance stays inside the stated limits, or the result is supportable but the party holding it may not act on it and the exact version is routed to the role that may.

The test is identical in all three. What differs is who holds the decision.
Result state / Fails with an explained error

Action states: Repairable, Fails, Non-warrantable

Something specific could not be constructed, or did not survive falsification. What separates the three is what is left standing: a narrower version the record still supports, nothing at all, or a claim that may be supportable and that the institution still cannot attach proportional warranty and restitution to.

The error names what must change before reliance is possible.
Result state / Cannot close without discretion

Action states: Undecidable, Blocked

Missing information, an ambiguous reference, insufficient measurement, an incomplete rule, an unresolved alternative, or an irreducible preference. What separates the two is whether the process ran at all: the matter is open and can be reopened by supplying what is named, or a required protocol, source, or permission was absent and no operation may proceed until it is restored.

The matter stays open and states what would close it.

A result state is the outcome of the test. An action state is what the institution may do next. They are two jobs, not two names for one list: three result states, eight action states, and the fact that selects among the siblings above is always supplied by the institution rather than by the test. No action state adds a fourth outcome, and none is a governance vocabulary added on top of the compiler. The controlled definitions and the full mapping sit with the diligence material in the investor and partner glossary.

Decidability ends where discretion begins. A decision is an act of choice; decidability is the elimination of the need for choice.

Why Failure Must Be Specific

A confidence score cannot tell the institution what failed or how to repair it.

Two outputs can receive the same low score for entirely different reasons. One may need a definition. Another may be physically impossible. Another may be true but unauthorized.

Runcible treats failure as structured information. A diagnostic names the proposition, test, observed defect, consequence, provenance, repair condition, and whether the matter should be revised, supplied with evidence, escalated, blocked, or preserved as undecidable.

This is what makes the process useful to people and downstream systems. The result can drive a precise evidence request or workflow transition rather than another round of generic prompting.

IDENTITY_UNRESOLVED

The object is not stable.

“Service data” conflates content, telemetry, metadata, and derived information.

Repair: enumerate objects and rights separately.
OPERATION_AMBIGUOUS

The verb hides incompatible actions.

“Use” may mean process, retain, analyze, train, profile, sell, or transfer.

Repair: name each operation and condition.
EVIDENCE_INSUFFICIENT

The proposition outruns its record.

A claimed necessity is asserted without architecture, alternatives, or evidence.

Repair: supply evidence or narrow the claim.
RECIPROCITY_INCOMPLETE

The exchange does not satisfy the stated demand.

A customer demands a service while the term supplies the vendor an additional durable asset.

Repair: remove, price, limit, or reciprocate the transfer.
AUTHORITY_REQUIRED

The result may be supportable but not permitted.

The analyst can propose a repair but cannot accept a contract or bind the organization.

Repair: route the exact version to the legitimate role.
UNDECIDABLE_CURRENTLY

The record cannot responsibly close.

Required evidence, protocol, authority, or conditions are absent.

Repair: preserve open state and state what would permit rerun.
A useful error is a map from what failed to what the institution must learn or change.

The Category Distinction

Rules engines decide known cases inside a predefined world. Runcible helps establish what world the language is claiming.

DimensionRules and exceptionsRDL and Runcible AI
Starting inputKnown fields and classified factsConsequential language bound to an institutional matter
World modelAssumed by the rule designerObjects, relations, states, operations, scope, evidence, interests, and authority made explicit
Primary operationMatch conditions and execute a branchClarify, decompose, type, test, falsify, diagnose, repair, and preserve open conditions
UnknownsDefault, exception, manual queue, or missing valueTyped ambiguity, missing evidence, skipped burden, absent authority, or first-class undecidability
EvidenceUsually an input assumed to be trueSource, provenance, correspondence, conflict, sufficiency, and falsification are part of the test
OutputAllow, deny, route, or calculateStructured support, failure, repair, limits, provenance, authority requirements, and next conditions
AuthorityOften encoded inside the branch or host applicationSeparated from epistemic result and resolved as an explicit institutional relation
LearningChange rules when cases escape themReturn consequence to the matter, accounting, correction, protocol, and institutional memory

Constructed Basis, Bounded Claim

Probability may inform judgment. It cannot substitute for the structure that makes reliance defensible.

Runcible does not reject statistical evidence, uncertainty, or confidence estimates. It rejects using a scalar score as a proxy for identity, evidence, causality, authority, or liability.

The relevant artifact is constructive: what was asserted; how terms were defined; which evidence and methods were used; what tests ran or were skipped; what survived; what failed; what remains open; what would falsify the result; who may rely on it; and which authority must decide.

This is proof-like in the engineering sense of an inspectable construction. It is not a claim that Runcible produces infallible formal proofs of empirical, legal, medical, or institutional truth.

Probability

How uncertain is an estimate under a model?

Useful evidence, but dependent on definitions, data, method, scope, and assumptions.

Operational support

Can the proposition be stated and tested against reality?

Identity, measurement, correspondence, possibility, causality, and falsification.

Economic decidability

Does the supplied information or action satisfy the demand?

Interests, reciprocity, cost transfer, externalities, remedy, and full accounting.

Institutional warrant

May another party responsibly rely within declared limits?

Evidence sufficiency, provenance, role, authority, liability, review, and revocation.

Research proposition

Runcible research investigates whether claims from different paradigms can be reduced to common operational burdens of state, operation, transformation, measurement, comparison, consequence, and test.

The legacy page presented universality as already proved. The public technical claim should be narrower: this reduction is the methodological thesis and implementation direction. Its domain coverage, completeness, and limits require continuing evidence.

The record is stronger than confidence theater because it makes the basis, limits, and missing conditions inspectable.

Where the Compiler Analogy Ends

A proposition can survive its tests and still be outside the institution’s authority, purpose, or acceptable risk.

Structured judgment

What can survive examination?

Supported content, failure, repair, open conditions, provenance, and reliance limits.

Legitimate authority

What will the institution authorize?

Approve an exact version, request evidence, revise, negotiate, defer, reject, revoke, or preserve open.

Runcible OS

What changes in institutional state?

Version, permission, assignment, workflow, publication, contract, account, action, and responsibility.

Return from reality

What actually happened?

Performance, cost, benefit, harm, challenge, correction, revocation, precedent, and memory.

Accurate institutional question What can proceed, under what conditions, by whose authority, with what limits, and what must remain open?
Runcible AI inside Runcible OS

The record remains attached to the institutional object, authority path, controlled transition, accounting, and returned consequence.

Runcible AI licensed separately

The host must preserve matter identity, provenance, result state, authority requirements, reliance limits, execution control, audit, and outcome write-back.

What This Page Establishes

The architecture can be explained publicly without pretending every formal element is equally mature or disclosed.

Controlled public architecture
  • RDL as typed operational representation
  • Runcible AI as compiler-like clarification and testing process
  • Foundation models as candidate and retrieval contributors, not authorities
  • Structured judgment with diagnostics, repair, provenance, and open conditions
  • Legitimate authority separated from epistemic success
  • Runcible OS or another controlled host as execution environment
Evidence or disclosure still required
  • Exact RDL syntax and production serialization
  • Current type coverage and domain completeness
  • Protocol inventory, selection logic, and execution evidence
  • Verified interfaces among OS, AI, records, authority, and write-back
  • Performance, reliability, security, and longitudinal product evidence
  • Certification, warranty, insurance, and liability claims

The Technical Principle

Compilation can establish what survives. Only authority can decide what proceeds.

RDL makes consequential language operationally testable. Runcible AI determines what survives examination. Legitimate authority decides what may proceed. Runcible OS makes the authorized change real and preserves what follows.