Human interface to ARC (Auto Regressive Compiler) for deterministic semantic governance over Probabilistic Inferring Engines (PIEs).

Overview

E.L.I.A. is the point at which human business intent — especially normative and regulatory intent — is declared, concentrated, and controlled. The compiler ARC transforms these declarations into three classes of artefact required for execution with probabilistic AI systems:

• Hard prompts — deterministic, structured instructions that direct PIE behaviour without ambiguity.
• Expression/AST representations — formal encodings of declared business logic for analysis, transformation, and integration.
• Verification gates — design-time and execution-time admissibility checks that reject any behaviour deviating from declared meaning.

The language, together with its compilation pipeline, frees humans from continuous prompt engineering, manual output validation, post-hoc compliance reconciliation, and continuous adaptation to PIE behavioural changes, while guaranteeing auditable, reproducible enforcement.

E.L.I.A. natively supports multi-corpus environments (e.g. GDPR + DORA + NIS2) through domain-scoped semantic authority, explicit collision control, and lifecycle versioning.

The Problem: Semantic Drift and Vibe-Coding

Modern systems increasingly rely on Probabilistic Inferring Engines (PIEs) — large language models, AI agents, retrieval-augmented reasoning systems — whose behaviour emerges from statistical inference over learned representations.

PIEs exhibit a structural property that cannot be corrected by scaling or alignment alone: meaning decays as it propagates through layered processing. Each inference step introduces contextual bias and partial semantic collapse. In practice this produces:

• gradual blurring of context and precision,
• amplification or suppression of biases,
• shift toward the most common interpretations,
• loss of rare, subtle, or edge-case meanings,
• accumulation of conflicting interpretations across reasoning steps.

Mitigations applied at the PIE layer (alignment, guardrails, structured outputs, retrieval grounding, prompt engineering) operate within the same probabilistic substrate and inherit its limits. They require continuous human attention, recur with every model update, and cannot guarantee admissibility or produce auditable justification.

The human side suffers from vibe-coding: developers (or domain experts) write natural language prompts or instructions and accept results that "feel right", without formal guarantees. This leads to systems whose behaviour is brittle, unexplainable, and impossible to audit.

How E.L.I.A. Solves It

E.L.I.A. concentrates human control at a single point: declaration of business meaning and normative obligations. The compiler ARC produces hard prompts, formal representations, and verification gates from that declaration, enforcing the following properties:

• Meaning precedes execution. Semantic intent is fixed before any code runs or any PIE is invoked. Execution may only realise meaning; it must not define, alter, or reinterpret it.
• Determinism by construction. All admissibility, interpretation, and enforcement outcomes are reproducible, inspectable, and mechanically derived from declared constructs. No semantic decision depends on implicit runtime behaviour or probabilistic inference.
• Enforcement as architecture. Enforcement is embedded into the language, not added as a separate layer. Every construct participates in the deterministic enforcement graph, which governs admissibility across design, planning, execution, and audit phases.
• Explicit semantic boundaries. Domains own authoritative meaning. Boundaries between domains, modules, and external systems are declared, versioned, and enforced — preventing meaning from leaking, duplicating, or drifting.
• Human-machine semantic symmetry. Humans, programs, and AI systems all operate against the same declared semantic reality. AI systems are non-authoritative by definition and must pass enforcement before their outputs can affect canonical artefacts.
• Controlled evolution and collision resolution. Definitions are versioned and time-bound. Multiple normative corpora coexist under domain-scoped authority; contradictory obligations are surfaced by the compiler with traceable resolution paths.

The result is a system where human effort concentrates on what the system should mean and do, rather than on how to control probabilistic inference.

Business as Code

E.L.I.A. enables the Business as Code paradigm for any entrepreneur, domain expert, or builder. Business intent — rules, obligations, processes, decision logic — becomes a first-class, executable artefact, declared in the same language in which it is reasoned about.

The implementation layer is no longer the bottleneck. Routine engineering of inference control, prompt scaffolding, output validation, drift containment, and compliance reconciliation is absorbed by the compiler. What remains for the human is what only the human can do: define the business, its boundaries, and its obligations.

Now you are limited only by your vision.

The SPO Index Architecture: Bridging Law and Code

A critical challenge remains: translating real-world regulatory documents (GDPR, DORA, NIS2, etc.) into formal E.L.I.A. definitions is itself an interpretation-heavy task, prone to error and delay.

SPO Index Architecture addresses this by transforming the PIE from a free-generation engine into a synthesis-with-citation engine. The process is:

1. Original regulatory documents are broken into granular, paragraph-level units.
2. A set of formal, verified indices is created for each unit (one-time per regulatory document version, repeated only on regulatory updates).
3. The PIE, constrained by these indices, synthesises E.L.I.A. constructs (definition, constraints, enforces) with direct citation of the source paragraph. Citation traceability is mechanical, not interpretive — each synthesised construct is provably derived from a specific source paragraph, enabling defensible compliance documentation.
4. The synthesised model is immediately validated by the E.L.I.A. compiler (enforcement graph, diagnostic codes), and any conflicts or gaps are highlighted in real time.

This chain — original law/norm → verified indices → synthesised E.L.I.A. definitions (with citations) → compiled enforcement graph → PIE-agnostic execution — eliminates the "interpretation gap" and reduces the manual effort of formalising regulatory requirements from rewriting every article to a single verification step.

When a regulation is updated, only the corresponding indices are revised and re-verified. Downstream E.L.I.A. definitions are re-synthesised with new citations, while historical compliance artefacts remain bound to the prior version through immutable lifecycle attributes.

Built-in Lifecycle and Collision Control for Normative Corpora

E.L.I.A. is designed for environments where multiple regulatory frameworks coexist and evolve over time. The language provides intrinsic mechanisms for:

• Definition versioning (version, effective_date, deprecated_date, retired_date). Historical facts are always interpreted against the version of meaning that was active when they occurred, preserving audit integrity.
• Cross-corpus collision control. When domains inherit from or combine multiple normative corpora (inherits, supersedes, combines), the compiler detects contradictory must obligations and requires explicit resolution. Optional constraints (should, may) are permitted to overlap, but their interactions are highlighted.
• Domain-level governance. Each regulatory framework is modelled as a distinct domain with its own semantic authority. Exported semantic interfaces define exactly what may be relied upon, preventing unintended cross-jurisdictional mixing.

These features ensure that semantic drift across time and across legal instruments is blocked by construction, not by manual vigilance.

Language Constructs (Brief/selection)

• definition and explained as — authoritative meaning and intent justification, versioned and domain-owned.
• enforces — binding of obligations and constraints to concrete carriers.
• rule — deterministic, side-effect-free reasoning (R0–R6 normative classes).
• action, flow, delegate — execution constructs constrained by declared meaning.
• domain — unit of semantic authority and technological envelope.
• event, record, error — immutable, audit-safe factual constructs.
• semantic interface, data interface — controlled exposure of obligations and data contracts.
• Surrogates — compiler-managed intermediate carriers that preserve semantic integrity across probabilistic reasoning steps.

Enforcement in Practice

All enforcement is realised through a deterministic enforcement graph that connects definitions, constraints, rules, and execution carriers. Violations are surfaced as:

• Design-time diagnostics (93 normative error codes) emitted during real-time editing and compilation (phases P1–P6).
• Runtime verification gates that prevent execution of behaviour that deviates from declared meaning.
• AuditEvents generated automatically for all authorisation, boundary crossing, and violation events — immutable, ordered, and attributable.

The same enforcement graph supports live feedback: as a domain expert or engineer writes a definition, the compiler incrementally re-evaluates the graph and immediately highlights conflicts, missing obligations, or boundary violations.

Distinguishing Properties

• Not an implementation language, but a human interface for semantic governance. E.L.I.A. is the surface at which humans declare business meaning; ARC produces implementation artefacts.
• Business as Code. Business intent becomes a first-class, executable artefact. The implementation layer is absorbed by the compiler.
• Three-artefact compilation output. A single declaration yields hard prompts, AST, and verification gates simultaneously.
• Two-stage verification. Design-time gates catch violations at compilation; execution-time gates validate generated behaviour at runtime.
• Determinism by construction. Admissibility, interpretation, and enforcement outcomes are reproducible, inspectable, and mechanically derived.
• PIE-agnostic. The underlying probabilistic engine is substitutable without changing business declarations.
• Built-in lifecycle and collision control. Definitions are versioned and time-bound; the compiler detects contradictory obligations across coexisting normative corpora and surfaces resolution paths.
• SPO-enabled regulatory synthesis. Direct synthesis from verified legal indices with full citation, removing the interpretation gap.
• Live semantic feedback. Real-time validation of definitions and rules against the enforcement graph during authoring.
• Integrated architecture target. Semantic, behavioural, security, and normative concerns are governed under a unified enforcement model.

Patent Protection

The mechanisms underlying E.L.I.A. and ARC are protected under a portfolio of patents:

• PT 120955 — Auto Regressive Compiler (ARC) for Enforceable Semantic Governance in Probabilistic Inference Systems.
• PT 120960 — Method and System for Semantic Authority Preservation and Projection Across Deterministic and Probabilistic Execution Domains.
• PT 121181 — Method and System for Deterministic Navigation of Structured Documents for Language Model Reasoning.
• PT 121276 — Deterministic Inference Engine with Pre-Applied Structural Tension for Normative Corpora.

See LICENSE.md for rights and licensing terms.

Release Contents

• Full language specification (Sections 1–8): design principles, type system, grammar, semantic model, domain authority, enforcement architecture, resilience model.
• Annexes A–G: type registry, semantic type configuration, rule normative classes (R0–R6), compiler enforcement model, semantic normative classes (8), compilation error catalog (93 diagnostic codes), diagnostic and compilation reaction model (6-phase pipeline P1–P6).
• Formal AST grammar (BNF/ANTLR notation).
• Reference examples demonstrating definitions, rules, enforcement graphs, and lifecycle.

A reference implementation compiles E.L.I.A. and operates the resulting hard prompts, AST, and verification gates against local open-weight Probabilistic Inferring Engines.

Audience

• Programming language theory and design
• Formal verification and proof-carrying code
• Information flow type systems
• Knowledge representation and normative reasoning
• Compliance engineering for systems incorporating probabilistic inference
• AI safety research requiring auditable justification and deterministic admissibility
• Human-machine interface design for AI-assisted systems
• Enterprise architects and domain experts responsible for AI integration into industrial domains
• Entrepreneurs and founders building business logic directly on AI-integrated infrastructure