Axioma.

Sets are first-class

Set-builder notation, comprehensions, union, intersection, difference and subset tests — mathematical notation evaluated directly by the runtime.

nums: [1, 2, 3, 4, 5, 6]
println({ n | n <- nums, n mod 2 == 0 })

{2, 4, 6}

Logic is executable

Quantifiers range over collections and evaluate: ∀ (“for all”) and ∃ (“there exists”). A separate [logic/…] solver portfolio includes SAT for Boolean satisfiability, SMT for supported arithmetic and equality theories, answer-set programming for rules and defaults, chase-style database inference, and quantified reasoning. Read the returned engine and regime metadata: these engines have different supported fragments and limits.

println(forall x in {2, 4, 6} | x mod 2 == 0)
println([logic/smt | x + 0 == x])

true
«engine=smt regime=decidable (quantifier-free linear integer) grounding=theorem result=true»

Rules reason for you

Horn-clause rules that read as English: head whenever body derives theorems, typically head whenever body defeasible conjectures (also head if body / rule~) — with operator twins when you want arrows (strict <== / ==>, defeasible <~~ / ~~>, Prolog :-). Recursive rules can compute transitive closure over finite relations, Datalog-style; relation / assert are optional in the obvious cases.

relation edge(x, y)
assert edge("a", "b")
assert edge("b", "c")
path(X, Y) whenever edge(X, Y)
path(X, Y) whenever edge(X, Z) and path(Z, Y)
println({ Y | Y <- path("a", Y) })

# Bare declarations and facts also work.
parent(X, Y)
parent("bob", "ann")
parent("ann", "pat")
ancestor(X, Z) whenever parent(X, Z)
ancestor(X, Z) whenever parent(X, Y) and ancestor(Y, Z)
println({ Z | Z <- ancestor("bob", Z) })

{"b", "c"}
{"ann", "pat"}

Truth needn't stop at two values

Plain booleans are fully classical — two values, all the classical laws. When a problem calls for more, opt in per value: Kleene K3 and Łukasiewicz Ł3 add an unknown, Gödel G3 uses a three-valued intuitionistic truth algebra (excluded middle is not generally valid), and Belnap B4 adds a value for contradictory evidence. The values are literals — what Axioma prints is valid source — and one such value in an expression makes the operators follow that logic.

println(true and not true)
println(om or true)
println(⊤ᵇ and ⊤⊥ᵇ)

false
true
⊤⊥ᵇ

“is” means three things

Russell's copula, made precise — one English word, three relations kept distinct: predication (∈, membership in a concept), identity (=, spelled is/same so bare is never conflates it), and existence (∃, there is …).

concept Planet {}
hesperus: a Planet {}        # the Evening Star…
phosphorus: hesperus          # …is the Morning Star
println(hesperus is Planet)
println(hesperus is/same phosphorus)
println(there is hesperus)

true
true
true

Reasoning runs anywhere

The core evaluator compiles to WebAssembly and runs locally in your browser. Stacks, prose-like definitions and the examples here need no server. Host I/O, external runtimes, native persistence and AI providers require the native application.

# a function, colon binding
sq: func(n) [n * n]
println(map(sq, [1, 2, 3]))

[1, 4, 9]

A cognitive kernel

understand, examine and abduce connect representation with inspection and candidate explanations. In the spirit of Peircean abduction, the example identifies a premise that could support the goal. A candidate explanation is not automatically the best explanation, an established fact or a causal finding.

flies(X) <~~ bird(X)
println(abduce("flies", "tweety"))

[("bird(\"tweety\")", "defeasible")]

It solves problems

Pólya-inspired blocks can find an unknown in a finite domain, attempt to prove a supported goal, or plan using Newell–Simon-style means–ends analysis (gps). This example searches 1 through 20 and rechecks the condition for 13. Search bounds and the supported problem form matter; this is not an unrestricted problem solver.

r: [solver/polya |
  find d in [1..20]
  condition d * d == 169 ]
println(r.answer)

13

┌─ solver · Pólya · four phases ────────────────────────────────────
│ 1 understand  unknown d ; data (none) ; condition d * d == 169
│ 2 devise      finite search over [1..20], filtered by the condition
│ 3 carry out   { d | d <- [1..20], … } → answer 13
│ 4 look back   ✓ condition re-checked — holds
└─ the engine PRODUCED the answer; it was not given in the source.

Self-explaining proofs

Ask why a supported conclusion holds and inspect its premises and rule-based justification. The explanation shows what follows inside the model; the premises still need their own justification.

relation human(name)
assert/axiom human("socrates")
mortal(X) <== human(X)
why mortal("socrates")

Explanation for: mortal(socrates)
This is a theorem derived by strict inference from:
  - human("socrates")  [axiom]

Knowledge has grades

Axioma is named for the axiom. Grounding distinguishes adopted starting points, observations and derived claims. A plain assert receives datum; axiom records an adopted premise. See the full grounding example above for strict and defeasible derivations.

axiom mortal("socrates")      # top of the ladder
assert barks("rex")           # the floor
println(grounding("barks", "rex"))

datum

Defaults & exceptions

Defeasible rules (<~~) hold by default and retract for exceptions — non-monotonic logic, provenance kept.

relation bird(name)
assert bird("pingu")
assert bird("tweety")
flies(X) <~~ bird(X)
println({ X | X <- flies(X) })
cancel("flies", "pingu")
println({ X | X <- flies(X) })

{"pingu", "tweety"}
{"tweety"}

Errors are values

try turns a fault into an inspectable value that auto-classifies into a concept you can match on.

e: try(10 / 0)
println(e is DivByZero)
println(parse_int("x") otherwise 0)

true
0

Code is data

Code can be represented and inspected: parse strings to ASTs, quote code, write hygienic macros, and introspect with fullform / treeform / tableform / graphform.

macro double(x) quasiquote(unquote(x) * 2)
println(double(21))

42

It describes itself

Local help is available in the runtime: doc looks up names, keywords and operators; describe inspects a value; apropos searches names and documentation. functions(Integer) lists associated functions. source(f) and ast("src") expose definitions and parsed code. REPL :manual (short alias :man) searches the embedded Manual; oracle provides local hints. The online Textbook offers This Book and All Docs search. Reserved and experimental entries are labeled.

double(x) = x*2
println(signature(round))
println(source(double))
println(eval(source(double))(21))

round(x, [digits])
double: func(x) [(x * 2)]
42

Refinements adapt a word

A /word refinement tunes one keyword instead of multiplying keywords. The copula is tests membership; is/same tests identity. The same dialect controls persistence — /persist vs /transient.

concept Dog
rex: a Dog {}
fido: rex
println(rex is Dog)
println(rex is/same fido)
concept/transient Scratch
println(is Scratch)

true
true
true

Orthogonal axes & the bilattice

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")
println(grounding("color", "apple", "red"))
println(truth("color", "apple", "red"))

axiom
⊤⊥ᵇ

Meaning, made executable

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")
println({X | X <- gives(X, "book", _)})

{"John"}

Concepts as numbers

A Leibniz-inspired finite encoding assigns primes to primitive attributes and combines them by multiplication. In this representation, divisibility tests whether one bundle includes another. It illustrates a chosen taxonomy, not an encoding of every possible concept.

human: 2*3*7*13*19   # a prime fingerprint
println(is_subtype_of(human, 2*3*7))

true

Definite descriptions

The description the X where … forms a class satisfying a property. You can test membership or inspect its extent. Inspired by the logical analysis of descriptions, this class form does not on its own impose Russell’s unique-existence condition.

concept Stock
Stock has price
luxury: a Stock { price: 1500 }
ordinary: a Stock { price: 100 }
big: the Stock where price > 1000
println(luxury is big)
println(ordinary is big)

true
false

Textbook notation

Write the symbols mathematicians use — quantifiers ∀ ∃, membership ∈, order ≤ ≥ (they chain), set difference \, proper subset ⊊.

x: 5
println(∀ x in {2,4,6} | x mod 2 == 0)
println(0 ≤ x < 10)
println({1,2,3,4} \ {2,4})
println({1,2} ⊊ {1,2,3})

true
true
{1, 3}
true

The geometry of meaning

Gärdenfors-inspired conceptual spaces represent quality dimensions, prototypes and regions. Here categorization selects a nearby prototype in two specified dimensions. The dimensions, distance and examples determine the result; they do not establish a universal geometry of meaning.

fruit: conceptual_space("Fruit", "Two illustrative quality dimensions")
add_dimension(fruit, "sweetness", 0, 10)
add_dimension(fruit, "crunch", 0, 10)
add_prototype(fruit, "apple", [7, 5])
add_prototype(fruit, "pear", [9, 2])
println(nearest_prototype(fruit, [6, 5]))

apple

One fact, two framings

Represent the same event under divergent value-laden descriptions, as in Epictetus’ Enchiridion 11. qua records the framings and can distinguish their rule consequences. Changing a description in the model does not itself establish a psychological change in a person.

relation departed(item)
departed("estate") qua "lost"
departed("estate") qua "given_back"
println(framings_of("departed", "estate"))

{"given_back", "lost"}

Bindings

Use : or = to bind or update a name, including multiple bindings. Use let for a fresh immutable declaration and var for a mutable one. These forms make declaration and later updates explicit when that distinction matters.

Binding mutability and field mutability are independent: an immutable let can hold a mutable struct. See type declarations and records.

answer: 42
greeting: "hello"
x, y, z: 1, 2, 3      # multi-bind
B = {2, 4, 6}            # = also binds (textbook math)
let fixed = 7
var counter = 0
counter = counter + 1
println(answer)
println(greeting)
println([x, y, z])
println(B)
println([fixed, counter])

42
hello
[1, 2, 3]
{2, 4, 6}
[7, 1]

Blocks

In a function body or a statement block, square brackets group a sequence of expressions; its value is the last expression. Brackets also form arrays in value positions. Multiline control-flow bodies can instead end with end; see the loop examples below.

r: [
  a: 3
  b: 4
  a * a + b * b
]
println(r)

25

Functions

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
println(square(9))

81

Composition

Functions pass into map, filter and reduce, and compose with ∘ or its ASCII spelling << (right to left). >> composes left to right. A pipeline |> applies a value to the next call; _ selects an argument position when needed.

square(x) = x*x
double(x) = 2*x
println((square << double)(3))
println((double >> square)(3))
println(map(square, [1, 2, 3, 4, 5]))

36
36
[1, 4, 9, 16, 25]

Prefix · infix · postfix

Operators are values, so arithmetic reads three ways: infix by default, prefix as a function you can pass to map / reduce, and a stack for postfix / RPN.

println(2 + 3)
println(+(2, 3))
println(reduce(*, 1, [1,2,3,4]))

5
5
24

Pattern matching

ML-style match … with, with when guards and a _ catch-all. An unmatched match returns none; this fallback does not make arbitrary programs total.

grade: func(n) [
  match n with
  | n when n > 90 => "A"
  | n when n > 60 => "pass"
  | _ => "fail" ]
println(grade(95))

A

Errors are values

Handle evaluation failures explicitly: try hands back the fault as an inspectable value that auto-classifies, and otherwise gives a fallback.

e: try(10 / 0)
println(e is DivByZero)
println((10 / 0) otherwise 99)

true
99

Strings & interpolation

${…} interpolation and \u{…} escapes that reach the whole of Unicode — a string can carry ∃ or 😀 directly.

name: "Ada"
println("hello ${name}")
println("sum ${2 + 3}")
println("exists \u{2203}")

hello Ada
sum 5
exists ∃

Enumerated types

Ordinal types with membership and iteration. The unified header type Day = enum Mon, Tue, Wed, Thu, Fri has the same meaning as the existing form below.

Day enumerates Mon, Tue, Wed, Thu, Fri
println(len(Day))
println(Wed.ord)
println(Mon is Day)

5
2
true

Algebraic data types

Tagged alternatives, declared with type Shape = variant Circle(Float) | Dot or the existing data form below — constructor patterns in match, and --typecheck catches a missing arm. Option/Result ship seeded, with railway composition via |?>.

data Shape = Circle(Float) | Dot
area(s) = match s with
  | Circle(r) => 3.14159 * r*r
  | Dot => 0
println(area(Circle(2.0)))
double(n) = n * 2
println(Some(5) |?> double)

12.56636
10

Lazy generators

Parenthesise a comprehension and it streams instead of materialising — pull with first or force.

squares: (x * x | x <- [1,2,3,4,5])
println(first(squares, 3))

[1, 4, 9]

Stack programming

A first-class Stack that reads like prose — mutate with message verbs push · pop · dup · swap, read with the possessive 's top · 's depth.

s: a Stack
s push 10
s push 20
println(s's top)
s pop
println(s's depth)

20
1

Higher-order functions

Three familiar operations over supported collections — functions are ordinary values you pass, return and compose.

nums: [1, 2, 3, 4, 5]
println(map(lambda x => x*x, nums))
println(filter(lambda x => x>2, nums))
println(reduce(lambda (a,x) => a+x, 0, nums))

[1, 4, 9, 16, 25]
[3, 4, 5]
15

Loops, when you want them

Comprehensions and recursion sit alongside imperative for/foreach, while, repeat and loop. Use bracket bodies or multiline end forms. The last loop here demonstrates the end-terminated spelling.

n: 1
while n <= 3 [ println(n)  n: n + 1 ]
# prints 1, 2, 3
repeat 3 [ println("hello axioma") ]
# prints hello axioma ×3
for value in [4, 5, 6]
  println(value)
end

1
2
3
hello axioma
hello axioma
hello axioma
4
5
6

Set-comprehension

The mathematician's set-builder — bind a variable over the relation, keep what matches.

relation teaches(teacher, student)        # a table — two columns
assert teaches("Socrates", "Plato")         # a row / tuple
assert teaches("Socrates", "Xenophon")
assert teaches("Plato", "Aristotle")
println({ S | S <- teaches("Socrates", S) })

{"Plato", "Xenophon"}

SELECT

The same projection and filter, in the language every analyst already knows.

relation teaches(teacher, student)        # a table — two columns
assert teaches("Socrates", "Plato")         # a row / tuple
assert teaches("Socrates", "Xenophon")
assert teaches("Plato", "Aristotle")
println([sql | SELECT student FROM teaches
WHERE teacher = 'Socrates'])

{"Plato", "Xenophon"}

Translate

Compile a comprehension to idiomatic Python source — deterministic and offline.

println([axioma -> python | [n*n | n <- range(10)]])

[n * n for n in range(10)]

Embed & call

Execute a Python definition with [python | …] and call it through python.call. Separately, [python --> axioma | …] asks an AI provider to translate the definition and execute the generated Axioma in the surrounding scope. Direct foreign execution and translation are different routes.

[python | def double(x): return x * 2]
println(python.call("double", 5))

10

[python --> axioma | def double(x): return x*2]
println(double(5))

Symbolize

Describe an expression in English and request an Axioma symbolization from a configured model. Treat the result as a proposed interpretation: inspect its assumptions and validate it before using it for inference. Provider output is not deterministic.

[nl --> axioma | the empty list]

Teaching subsets

A #language directive selects a learning dialect. axioma/beginner narrows allowed forms; this example uses its canonical func(args) [body] spelling. lambda is rejected there with a migration hint. axioma/knowledge-core selects a restricted monotonic Horn-rule surface. Restrictions apply to the chosen dialect, not to the full language.

#language axioma/beginner
double: func(x) [x * 2]
println(double(5))

10

Guided wizards native

Learn by doing in the terminal — --learn walks a dozen checked tasks; --recipe is an HtDP "design-recipe" tutor in six stages.

axioma --learn
axioma --recipe

Knowledge base native

Opt in with --kb and select a store with --kb-path. Native persistence retains supported knowledge in SQLite. why explains a derivation even without persistence, as in the example below. Cascade is a related graph application; shared-storage or federation behavior must be checked against its own version and repository, rather than assumed from a working Axioma example.

relation human(name)
assert/axiom human("socrates")
mortal(X) <== human(X)
why mortal("socrates")

Explanation for: mortal(socrates)
This is a theorem derived by strict inference from:
  - human("socrates")  [axiom]

AI & translation native

The supported Axioma-to-Python source translator is deterministic and offline. Other translation and symbolization routes can use configured providers such as OpenRouter, Grok, Gemini, Ollama and Claude; authentication depends on the provider. axioma --mcp exposes supported tools to compatible clients. AI-generated formalizations are proposals to inspect, not automatically verified conclusions.

println([axioma -> python | [n*n | n <- range(10)]])

[n * n for n in range(10)]