I.
Sets are first-class
Set-builder notation, comprehensions, and the full algebra of sets — straight from the page into the runtime.
nums: [1, 2, 3, 4, 5, 6] { n | n <- nums, n mod 2 == 0 } ⇒ {2, 4, 6}
State what is true. Let the language reason.
A cognitive programming language for knowledge representation and reasoning — sets, logic, and many-valued truth, with a natural-language syntax that runs entirely in your browser.
Most languages compute with numbers. Axioma computes with truth.
Axioma reads like mathematics and runs like a program. Each construct below is real, executable syntax — try any of it in the playground.
Set-builder notation, comprehensions, and the full algebra of sets — straight from the page into the runtime.
nums: [1, 2, 3, 4, 5, 6] { n | n <- nums, n mod 2 == 0 } ⇒ {2, 4, 6}
Universal and existential quantifiers range over sets and evaluate to a truth value — ∀ and ∃, as code.
forall x in {2, 4, 6} | x mod 2 == 0 ⇒ true exists x in {1, 2, 3} | x > 2 ⇒ true
Declare facts and Horn-clause rules in four flavours — strict <== / ==> derive theorems, defeasible <~~ / ~~> derive conjectures. Recursion computes the full transitive closure, Datalog-style; relation / assert are optional in the obvious cases.
ancestor(X, Z) <== parent(X, Z) ancestor(X, Z) <== parent(X, Y) and ancestor(Y, Z)
Boolean, Kleene K3, Łukasiewicz L3, Belnap B4, and Gödel G3 — first-class logics for the unknown and the contradictory.
belnap("both") ⇒ ⊤⊥ om or true ⇒ true # unknown ∨ true
Russell's copula, made precise: identity, predication, and existence — with concepts, instances, and classification.
concept Stock { price: 0 } aapl: a Stock { price: 150 } aapl is Stock ⇒ true
The whole interpreter compiles to WebAssembly — no install, no server. It also speaks Forth-style stacks and prose-like definitions.
# a function, REBOL-style binding sq: func(n) [n * n] map(sq, [1, 2, 3]) ⇒ [1, 4, 9]
Before the logic, the everyday shape of the language. Axioma's surface is inspired by a lineage of expressive languages: you bind a name with a colon, group expressions in [ ] blocks, and treat functions as ordinary values you can pass and compose. Every snippet here runs in the interactive tutorial →
No let and no var — just bind a name with a colon (and several at once). = reassigns an existing binding; it doesn't create one.
answer: 42 greeting: "hello" x, y, z: 1, 2, 3 # multi-bind
Square brackets group a sequence of expressions; the block's value is its last line — which is exactly how a function body is written.
r: [ a: 3 b: 4 a * a + b * b ] ⇒ 25
A function is a value too — bound with :, its body a [ ] block (or a lightweight lambda). Being values, they recurse, form closures, and compose.
square: func(x) [x * x] double: lambda x => x * 2 square(9) ⇒ 81
Because functions are values, they pass straight into map / filter / reduce — and compose into pipelines.
nums: [1, 2, 3, 4, 5] map(func(x) [x * x], nums) ⇒ [1, 4, 9, 16, 25]
Operators are values, so arithmetic reads three ways: infix by default, prefix as a function you can pass to map / reduce, and a Forth-style stack for postfix / RPN.
2 + 3 ⇒ 5 # infix +(2, 3) ⇒ 5 # prefix reduce(*, 1, [1,2,3,4]) ⇒ 24
The philosophy is the headline — but the ordinary tools are all here too. Pattern matching, errors-as-values, strings, enums, lazy streams, stacks, higher-order functions, loops. Complete in breadth; the depth is in the tutorial and the worked algorithms.
ML-style match … with, with when guards and a _ catch-all. An unmatched match returns om — total by construction.
grade: func(n) [ match n with | n when n > 90 => "A" | n when n > 60 => "pass" | _ => "fail" ] grade(95) ⇒ "A"
No exceptions, no stack unwinding: try hands back the fault as an inspectable value that auto-classifies, and otherwise gives a fallback.
e: try(10 / 0) e is DivByZero ⇒ true (10 / 0) otherwise 99 ⇒ 99
${…} interpolation and \u{…} escapes that reach the whole of Unicode — a string can carry ∃ or 😀 directly.
name: "Ada" "hello ${name}" ⇒ "hello Ada" "sum ${2 + 3}" ⇒ "sum 5" "exists \u{2203}" ⇒ "exists ∃"
Ada/Pascal-style enums with ordinals, membership and iteration — sum types that read like a list.
Day enumerates Mon, Tue, Wed, Thu, Fri len(Day) ⇒ 5 Wed.ord ⇒ 2 Mon is Day ⇒ true
Parenthesise a comprehension and it streams instead of materialising — pull with gen_take or force.
squares: (x * x | x <- [1,2,3,4,5]) gen_take(3, squares) ⇒ [1, 4, 9]
A first-class Forth / Pop-11 stack: push · pop · peek · dup · swap · depth.
s: stack_new() push(s, 10) push(s, 20) pop(s) ⇒ 20 depth(s) ⇒ 1
The universal triad over any collection — functions are ordinary values you pass, return and compose.
nums: [1, 2, 3, 4, 5] map(lambda x => x*x, nums) ⇒ [1,4,9,16,25] filter(lambda x => x>2, nums) ⇒ [3,4,5] reduce(lambda (a,x) => a+x, 0, nums) ⇒ 15
Comprehensions and recursion are idiomatic — but imperative while, repeat … until and foreach are right there too.
n: 1 while n <= 3 [ println(n) n: n + 1 ] # prints 1, 2, 3
A concept is more than a class. It can hold its own purpose, the mode by which it was formed, a defining boundary, and the cases that test it — then validate itself to a four-valued truth. The everyday parts read like English; the philosophical parts are executable.
# A concept is MORE than a class — it starts as one, but also carries # actions, a defining boundary and a grounding (below). Plain English + doc: concept Vehicle "anything that moves people or goods" # Fields: add several at once with `has`, drop one with `had` Vehicle has wheels: 4, speed, cargo # wheels carries a default Vehicle had cargo # …dropped again # Actions (methods) — `it` is the receiving instance Vehicle action summary() [ str(it.wheels) + " wheels @ " + str(it.speed) ] # Inheritance: extends declares Car ⊆ Vehicle (auto-creates Car) Car extends Vehicle Car has doors # Instances — the indefinite article `a` (consonant) / `an` (vowel) tesla: a Car { wheels: 4, speed: 250, doors: 2 } Aircraft extends Vehicle jet: an Aircraft { wheels: 3, speed: 900 } tesla.summary() → "4 wheels @ 250" (inherited action) # Read a field by dot — or with the 's possessive (Russell's genitive) tesla's speed → 250 (an instance's own value) Vehicle's wheels → 4 (a concept's default) # Classify it with the copula `is` (Russell's ∈ and ⊆) tesla is Car → true (membership ∈) tesla is Vehicle → true (inherited) Car is Vehicle → true (class inclusion ⊆) # Auto-classification — a rule decides membership SportsCar defines { is Car and speed > 200 } tesla is SportsCar → true # Lifecycle: suspend, revive, or destroy a concept concept Draft "scratch" Draft suspend # frozen Draft unsuspend # live again Draft destroy # gone for good is Draft → false
The everyday surface: declare a concept and several fields at once with has (had removes one), attach actions — methods where it is the instance — inherit with extends, instantiate with a / an, read a field by dot or the 's possessive (on an instance or a concept), classify with is, and manage a concept's whole life — suspend · unsuspend · destroy. Every → is the interpreter's real output.
concept Man Man has age Man has married alex: a Man { age: 30, married: false } sam: a Man { age: 28, married: true } # A concept carries its own epistemology — not just fields: concept Bachelor { purpose: "an unmarried adult male — Quine's analytic example" formed_by: "stipulation" # 1 of 5 formation modes boundary: is Man and age >= 18 and married == false # the intension examples: [alex] # must fall inside counterexamples: [sam] # must fall outside } alex is Bachelor → true (boundary derives the extension) sam is Bachelor → false (married) check(Bachelor) → ⊤ᵇ (Belnap: examples in, counterexamples out) examine(Bachelor) → {meaningful: true, pseudo: false, …} grounding("isa", alex, Bachelor) → "axiom" (stipulated ⇒ axiomatic)
The philosophical surface: a concept carries its purpose, the formed_by mode it came from (abstraction · combination · distinction · stipulation · metaphor), a boundary that turns intension into extension, and examples / counterexamples it must honour. check grades that contract in Belnap four-valued logic; examine runs a Carnap pseudo-statement test; and because Bachelor was stipulated, its memberships are graded axiom.
| Epictetus' dichotomy of control“some things are up to us, some are not” | Thing partition UpToUs, NotUpToUs |
is_partitioned → true |
| Stoic adiaphorawealth is judged indifferent, not unvalued | value_indifferent("wealth", …) |
value_kind_of → "indifferent" |
| Russell's definite descriptionsa class named by a property | the Stock where price > 1000 |
luxury is it → true |
| Frege's sense vs. referenceone fact under two framings | departed("estate") qua "lost" |
framings_of → {…} |
The full concept vocabulary
A relation is a named predicate; an assert drops a fact into it. In the obvious case both keywords fall away. And every fact carries an epistemic grounding — how well-founded it is — kept strictly apart from its truth.
# Explicit — the keywords spell out the intent relation edge(x, y) assert edge("a", "b") assert edge("b", "c") # Optional — a bare UPPERCASE-arg header declares the relation, # and a bare call asserts a fact. Same result, less ceremony: near(X, Y) # ≡ relation near(x, y) near("a", "b") # ≡ assert near("a", "b") near("b", "c") { (P, Q) | (P, Q) <- near(P, Q) } ⇒ {("a","b"), ("b","c")}
The keyword form is for clarity, the bare form for speed. The rule: a header with uppercase arguments (logic variables) reads as a declaration, a call with concrete values reads as a fact — so near(X, Y) declares while near("a", "b") asserts.
# Grade a fact as you assert it — a /refinement picks the rung assert/axiom mortal("socrates") assert/postulate rain("tuesday") assert/hypothesis dark_matter("halo") assert barks("rex") # plain assert ⇒ datum, the floor grounding("mortal", "socrates") ⇒ axiom grounding("rain", "tuesday") ⇒ postulate grounding("barks", "rex") ⇒ datum # Two rungs are EARNED by inference, never asserted: human(X) <== man(X) # strict ⇒ theorem sage(X) <~~ wise(X) # defeasible ⇒ conjecture # axiom > postulate > theorem > conjecture > hypothesis > datum # Grounding is orthogonal to truth — a fact is true (⊤ᵇ) until told otherwise truth("mortal", "socrates") ⇒ ⊤ᵇ set_truth("barks", "rex", "both") ⇒ ⊤⊥ᵇ # true AND false
Six grades, one ladder: axiom > postulate > theorem > conjecture > hypothesis > datum. Four are asserted with a /refinement (axiom, postulate, hypothesis, and the bare datum); two are earned — a strict rule <== derives a theorem, a defeasible rule <~~ a conjecture. And grounding (how well-founded) is a different axis from truth (true / false / both / neither): one fact can be rock-solid and contradictory at once.
Beyond running your program, Axioma reasons about its own knowledge — where a fact came from, how sure it is, and how to explain it. The [ model | … ] lens even charts your code on the knowledge lifecycle as you write it.
[ model | relation mortal(x) axiom mortal("socrates") human(X) <== mortal(X) { X | X <- human(X) } ] ┌─ model · epistemic lifecycle ───────────────────────────────────── │ ✓ represented │ ✓ grounded │ ✓ inferred │ ✗ proved → why <conclusion> · proof(rel, args…) chains back to axioms · prove / derive / refute (automated reasoning) │ ✗ truth-valued → set_truth(rel, args…, "both") · truth(rel, args…) (T / F / Both / Neither) │ ✗ applied → check Concept / examine Concept (→ B4) · examples / counterexamples · reconcile against KB / Cascade · understand X runs the whole arc └─ 3/6 phases present · advisory only — your code runs exactly as written. ⇒ {"socrates"}
Wrap any block in [ model | … ] and Axioma runs it untouched — returning {"socrates"} — then charts how far that knowledge has travelled: represented → grounded → inferred → proved → truth-valued → applied. Here three of six phases are present, and every unreached phase (✗) names the exact next step. It's Calculemus turned on the program itself: computing a result is one thing — knowing what you've actually established is another.
understand · examine · abduce — Peirce's inference-to-the-best-explanation as a built-in (the "fifth paradigm").
flies(X) <~~ bird(X) abduce("flies", "tweety") ⇒ ("bird(tweety)", defeasible)
Ask why a conclusion holds and get a prose proof traced back to its founding axioms.
why mortal("socrates") # ⇒ a theorem, from # human("socrates") [axiom]
Axioma is named for the axiom — you don't just assert facts, you grade them (axiom > postulate > theorem > conjecture > hypothesis > datum), and the grade propagates through every proof. A bare assert lands at datum — the floor: a plain statement of fact.
axiom mortal("socrates") # top of the ladder assert barks("rex") # the floor grounding("barks", "rex") ⇒ datum
Defeasible rules (<~~) hold by default and retract for exceptions — non-monotonic logic, provenance kept.
flies(X) <~~ bird(X) cancel("flies", "pingu") # penguins excepted; tweety still flies
No stack unwinding — a fault becomes an inspectable value that auto-classifies into a concept you can match on.
e: try(10 / 0) e is DivByZero ⇒ true parse_int("x") otherwise 0 ⇒ 0
Homoiconic to the core: parse strings to ASTs, quote code, write hygienic macros, and introspect with fullform / treeform / tableform / graphform.
macro double(x) quasiquote(unquote(x) * 2) double(21) ⇒ 42
A REBOL-style /word tunes one keyword instead of multiplying keywords. The copula is tests membership; is/same tests identity. The same dialect controls persistence — /persist vs /transient.
rex is Dog ⇒ true # ∈ membership rex is/same fido ⇒ true # = identity concept/transient Scratch # skip the KB
One fact carries independent dimensions at once — its Belnap truth, its epistemic grounding, and its kind (empirical, logical, …). The four truth values form a bilattice — ordered by truth and by information.
axiom/empirical color("apple", "red") # grounding + kind set_truth("color", "apple", "red", "both") grounding("color", "apple", "red") ⇒ axiom truth("color", "apple", "red") ⇒ ⊤⊥
Model meaning directly: NSM semantic primes and Schank Conceptual Dependency on cognitive words, Lojban-style selbri places on relations, plus natural-language dialects (<<Lojban| … >>) and cross-language translate.
# each place carries a semantic role relation gives(g -> "giver", x -> "gift", r -> "recipient") gives("John", "book", "Mary") {X | X <- gives(X, "book", _)} ⇒ {"John"}
Set theory and intensional logic, the geometry of meaning, prime-number taxonomy, the opacity of belief — each is a chip in the playground, one click from running.
Leibniz's 1666 dream: encode primitive concepts as primes, so that subsumption becomes plain divisibility.
human: 2*3*7*13*19 # a prime fingerprint is_subtype_of(human, 2*3*7) ⇒ true
Russell's the X where … — name a class by a property, then test membership or iterate its extent.
big: the Stock where price > 1000 luxury is big ⇒ true
Write the symbols mathematicians use — quantifiers ∀ ∃, membership ∈, set difference \, proper subset ⊊.
∀ x in {2,4,6} | x mod 2 == 0 ⇒ true {1,2,3,4} \ {2,4} ⇒ {1, 3} {1,2} ⊊ {1,2,3} ⇒ true
Gärdenfors conceptual spaces — concepts as convex regions, categorization by the nearest prototype.
add_prototype(fruit, "apple", [7,5]) nearest_prototype(fruit, [6,5]) ⇒ "apple"
Intensionality made executable — the same fact under divergent value-laden descriptions (Epictetus, Ench. 11).
departed("estate") qua "lost" departed("estate") qua "given_back" framings_of("departed", "estate") ⇒ {"lost", "given_back"}
Real knowledge is incomplete and sometimes contradictory. Axioma builds that in: Belnap's four-valued bilattice treats missing and conflicting information as first-class truth values.
Contradiction propagates through rules instead of crashing — and every derived fact carries its epistemic grounding, from axiom down to datum.
Axioma is a cognitive programming language — built for knowledge representation, symbolic reasoning, and explainable AI. After procedural, object-oriented, functional, and logic programming comes a fifth paradigm, whose defining act is to understand: to model a thing into a model of everything. Seventeen logics and eight knowledge-representation systems, unified under a single old dream.
“Calculemus. Let us calculate.”— G. W. Leibniz, on settling every dispute by computation
characteristica universalis + calculus ratiocinator — a universal language of thought, and a calculus to reason in it.
The Laws of Thought — the algebra of logic.
Begriffsschrift — the first formal logic; quantifiers, sense & reference.
Types, definite descriptions, and the three meanings of “is.”
Incompleteness — and numbering a formal system within itself.
Programs with common sense.
The relational model — data as sets of tuples, queried in first-order logic.
The cognitive language — 17 logics and 8 knowledge-representation systems, executable in your browser.
Seventeen logics, one dispatcher
The bare connectives — and · or · not · implies — dispatch to whichever logic your values inhabit, so a single proof can cross between them without changing notation.
Eight ways to represent knowledge
From classic symbolic AI through geometric and linguistic semantics — each is real, with working builtins, not a sketch.
Declare a relation and assert facts into it, and you have built exactly what Codd called a relation — a table whose rows are tuples. So SQL is not a separate engine bolted on: it is a second notation for the set-comprehensions you already write, over the very same facts. Same question, same answer, compiled to the same Axioma set.
relation teaches(teacher, student) # a table — two columns assert teaches("Socrates", "Plato") # a row / tuple assert teaches("Socrates", "Xenophon") assert teaches("Plato", "Aristotle")
Three facts asserted into one relation — three rows in the table teaches(teacher, student). Now ask who did Socrates teach? two ways:
The mathematician's set-builder — bind a variable over the relation, keep what matches.
{ S | S <- teaches("Socrates", S) }
⇒ {"Plato", "Xenophon"}The same projection and filter, in the language every analyst already knows.
[sql | SELECT student FROM teaches WHERE teacher = 'Socrates'] ⇒ {"Plato", "Xenophon"}
# Axioma compiles your SQL back to the formalisms it was built to hide: [sql -> calculus | SELECT student FROM teaches WHERE teacher = 'Socrates'] ⇒ { t.student | teaches(t) ∧ t.teacher = 'Socrates' } # Codd's tuple calculus — a set-builder [sql -> algebra | SELECT student FROM teaches WHERE teacher = 'Socrates'] ⇒ π_{student}(σ_{teacher='Socrates'}(teaches)) # selection σ + projection π
A SELECT is selection (σ) and projection (π) over a set — Codd's 1970 relational algebra and tuple calculus, which rest in turn on set theory and first-order logic: the same ancestry as the rest of the language. Joins, GROUP BY and aggregates compile the same way, and hand back sets of tuples — GROUP BY region yields {("east", 7), ("west", 15)}. None of this leaves Axioma, so it all runs in the browser: open the “SQL = sets” example in the playground →
A surface, not a database. And not read-only — INSERT, UPDATE and DELETE compile too, writing to the very same relations, so you can search and edit your facts in SQL if that is the interface you prefer. Those relations live in memory for the session — in the browser, that is the whole story — and you can keep them: Axioma persists your concepts, relations and assertions to a SQLite knowledge base, so the same tables survive across sessions. Either way there is no separate database to load or sync. It stays one set of tuples — under whichever notation suits you.
One bracket form, more than one runtime: translate Axioma to Python, run Python inline, or symbolize plain English into runnable Axioma. These reach beyond the interpreter — to a Python runtime, to an LLM — so they need the native axioma binary, and are shown here rather than in the browser playground. (SQL is different — it never leaves Axioma; see above.)
Compile a comprehension to idiomatic Python source — deterministic and offline.
[axioma -> python | [n*n | n <- range(10)]] ⇒ "[n * n for n in range(10)]"
Run Python inline, or pull a Python function into Axioma scope and call it.
[python --> axioma | def double(x): return x*2] double(5) ⇒ 10
Describe what you want in plain English; an LLM emits Axioma you can run.
[nl --> axioma | the empty list] ⇒ []
The interpreter runs in your browser — write a comprehension, prove a theorem, watch a rule reach its fixpoint.
▶ Open the PlaygroundThe browser runs the core language. The native binary adds a teaching ladder, a persistent knowledge base, AI-assisted translation, and a real command line. The boxes marked native live in the terminal — the knowledge base and the AI features aren't in the WASM sandbox.
A #language directive narrows the language to a learning dialect: axioma/beginner allows one canonical form per construct, axioma/knowledge-core restricts to a monotonic Horn-rule proof core. (This one runs in the browser too.)
#language axioma/beginner double: lambda x => x * 2 ⇒ ERROR: lambda is not allowed here — use func(args) [body].
Learn by doing in the terminal — --learn walks a dozen checked tasks; --recipe is an HtDP "design-recipe" tutor in six stages.
axioma --learn # 12 guided tasks axioma --recipe # design-recipe tutor
Opt in with --kb and axioms, concepts and relations persist in a SQLite store — the very cascade.db the Cascade engine reads. Off by default; native-only.
axioma --kb script.ax # facts survive across runs, # shared with the Cascade graph
Translate between languages from inside a script. Axioma→Python is deterministic and offline; the other directions use a provider (OpenRouter · Grok · Gemini · Ollama · Claude). axioma --mcp serves it all over MCP.
[axioma -> python | [n*n | n <- range(10)]] ⇒ "[n * n for n in range(10)]"
The command line