Axioma.

I · Representation

Concepts, relations and sets

Describe a domain with concepts, fields, inheritance and classification rules. Query relations with set-builder notation. Concepts can also carry their purpose, defining boundary, examples and counterexamples.

concept Person
Person has age
ada: a Person { age: 36 }
Adult defines { is Person and age >= 18 }
println(ada is Adult)
println({ n | n <- 1..6, n mod 2 == 0 })

true
{2, 4, 6}

II · Logic

Make uncertainty explicit

Use classical logic, quantifiers and typed many-valued truth. Belnap’s four values distinguish support, denial, conflicting information and missing information. Strict rules derive conclusions; defeasible rules express defaults with exceptions.

println(?ᵇ)
println(⊤⊥ᵇ)
println(⊤ᵇ and ⊤⊥ᵇ)
println(forall x in {2, 4, 6} | x mod 2 == 0)

?ᵇ
⊤⊥ᵇ
⊤⊥ᵇ
true

The first two lines distinguish an information gap from a conflict. Each logic gives its operators a defined meaning.

III · Programming

Functions that work with data

Compose functions, match patterns, build pipelines and call collection methods. Dotted calls broadcast across data; connected dotted expressions fuse. Type annotations, contracts, modules and errors as values support larger programs.

double(x) = 2*x
next_value(x) = x+1
let xs = [1, 2, 3]
println(next_value.(double.(xs)))
println(xs.map(double) |> sum)
println(xs.length())

[3, 5, 7]
12
3

let declares a fresh immutable binding; var declares a mutable one. : and = bind or update. The first printed expression fuses; a pipe between stages is a materialization boundary.

IV · Computation

Exact numbers and matrices

Compute with arbitrary-precision integers and rational values, including exact matrix operations. Use explicit Float conversion when approximation is intended. Matrices have a shape; their linear indexing and cell iteration follow row-major order.

m = matrix([[1, 2], [3, 4]])
println(inv(m)[:])
println(1 / 8)
println(fdiv(1, 8))
for cell in m
    println(cell)
end

[-2, 1, 3/2, -1/2]
1/8
0.125
1
2
3
4

Matrix inversion preserves the fractions here. fdiv requests a Float result. The loop visits cells in the same order as linear indexing.

V · Reflection

Programs can inspect programs

Functions are values. Quotation, AST inspection and hygienic macros make code available to code. Ask the runtime for a function’s documentation, signature or source, and compose functions in either direction.

macro double(x) quasiquote(unquote(x) * 2)
println(double(21))
square(x) = x*x
println((square << (x -> x+1))(3))

42
16

<< composes right to left, like ∘. >> composes left to right. ASCII forms keep the same operations easy to type.

VI · Data

Query the same facts in SQL

A relation is a set of tuples. Axioma’s SQL surface queries and updates those relations; a set comprehension can ask the same question. Native knowledge-base persistence can retain supported knowledge across sessions.

relation teaches(teacher, student)
assert teaches("Socrates", "Plato")
assert teaches("Socrates", "Xenophon")
println({ S | S <- teaches("Socrates", S) })
println([sql | SELECT student FROM teaches
               WHERE teacher = 'Socrates'])

{"Plato", "Xenophon"}
{"Plato", "Xenophon"}

These two queries return the same set. The SQL surface has a defined subset and its own documented limits.