Executable Science · Axiologic Research Editions
Executable Natural Language
From Fluent Language to Symbolic Consequence
A machine can give the right answer for the wrong reasons. The harder question is whether its conclusion can survive being turned into an artifact.
Fluency is not an execution trace
“Executable” is a stronger word than “interpretable,” and this book insists on earning it. A database query, state machine or constraint problem has a defined effect on a state; its result can be reproduced from an artifact and semantics. A language-model answer may resemble an algorithm, but the rule used at a particular moment is neither separately inspectable nor guaranteed to be applied consistently. The book’s foundational distinction is therefore simple: an LLM can propose an executable object; its next-token generation should not itself be treated as execution.
That proposal must materialize. It may be a relational query, a logical theory, a temporal constraint, a decision table, a finite automaton or a typed graph with registered operators. Crucially, the object needs grammar, types, semantics and a source map. Valid JSON is not enough: a schema checks shape, not whether an entity was invented, a quantifier reversed or a SQL join semantically wrong. The trust boundary comes after source grounding, type checking, semantic compatibility and formal compilation.
The book does not answer the limits of language with a simplistic call to replace neural systems by symbolic ones. It argues for a federative architecture in which components can correct one another. Models retain the work at which they excel—hypothesis generation, semantic normalization, breadth and recovery from unusual language. A small formal core owns admissibility, invariants, execution, witnesses and reproducibility. The system names four authorities that should not silently collapse into one model: source authority, semantic authority, rule authority and execution authority.
The fault line beneath a correct answer
Why can a correct solver still yield the wrong answer? Because the formalization gap sits before the solver. The source may have been translated with the wrong referent, scope, time relation, modality, ontology or evidential basis. A perfectly sound solver can faithfully execute the wrong policy. The book breaks this gap into obligations and argues that systems must report their assumptions rather than borrowing certainty from the formal core.
Where should uncertainty live? In explicit alternatives and coverage claims, not in a polished sentence. If a pronoun has several plausible bindings and the verdict varies between them, the run should expose the dependency or ask for clarification. Negative claims need a coverage token defining the source revision, scope, method and completeness policy. “Unknown” is sometimes the correct result.
How can a system explain without inventing? A solver’s result should be rendered from a canonical structure of licensed claims, evidence, assumptions and scope. A language model may organize or paraphrase it, but each sentence can be linked to an allowed result identifier and checked for unsupported additions. The book treats explanations as another boundary, not decorative prose added after verification.
Rigor means refusing to transfer confidence across boundaries that the system cannot actually check.
A language that can be made to answer for itself
Executable Natural Language brings together controlled languages, formal semantics, semantic parsing, program induction, abstract interpretation, symbolic execution, model checking and current LLM-assisted systems. Its case study of LongTextJS, CircuitJS and nllAgent is deliberately critical: public architectures are useful starting points, but grounded inputs, declared formalism choices, independent execution and honest limits decide whether they become scientifically defensible systems. The proposed pipeline is practical rather than mystical: anchor the source, produce candidate observations, preserve identity and time alternatives, select a formalism, compile, execute, retain a witness, replay, then render.
Policy, compliance, scientific reasoning and software analysis all meet the same threshold: a persuasive sentence must not quietly acquire the status of a decision. The book is also a demanding lens for claims about “neuro-symbolic reasoning”: benchmark formalization fidelity separately from formal execution, or a final-answer score will hide where the system actually succeeded—or failed.