Language reference

!

Operator / syntax

!=

Operator / syntax

!==

Operator / syntax

!~

Operator / syntax

#

Operator

# comment | #comment

Examples

x: 5  # trailing comment

#----- section banner -----

len(xs)            # length (was #xs)

$

Operator

xs[$] | xs[$-k] | xs[i:$]

Examples

"Julius Caesar"[$]       # "r"

"Julius Caesar"[8:$]     # "Caesar"

"Julius Caesar"[$-3:$]   # "esar"

xs[$-1]                  # second-to-last

%

Operator

number % number

Examples

100 % 7            # Returns 2

-7 % 3             # Returns -1   (sign of dividend, integers)

2 + 10 % 3         # Returns 3    (% binds tighter than +)

100 mod 7          # Returns 2    (keyword alias)

remainder(100, 7)  # Returns 2    (prefix builtin)

&

Operator / syntax

and

Operator

expression1 and expression2

Examples

true and false

x > 0 and x < 10

'

Operator / syntax

's

Operator

object's property

Examples

john's name

stock's price

car's speed = 60

(

Operator / syntax

)

Operator / syntax

*

Operator

number * number | string * number | number * string

Examples

5 * 3              # Returns 15

2.5 * 4            # Returns 10.0

"-" * 32          # Returns "--------------------------------"

"hello" * 3       # Returns "hellohellohello"

5 * "hi"          # Returns "hihihihihi"

"=" * 10          # Returns "=========="

**

Operator / syntax

*=

Operator / syntax

+

Operator

number + number | string + string

Examples

5 + 3              # Returns 8

2.5 + 1.5          # Returns 4.0

"hello" + "world" # Returns "helloworld"

"Hello, " + "Alice!" # Returns "Hello, Alice!"

"" + "test"      # Returns "test"

"prefix" + ""    # Returns "prefix"

++

Operator / syntax

+:

Operator

element +: sequence | (+:)(element, sequence)

Examples

1 +: 2 +: `[]

(1 + 2) +: [4]

(1 +: [2]) :+ 3

+=

Operator / syntax

,

Operator / syntax

-

Operator / syntax

--

Operator / syntax

-=

Operator / syntax

->

Operator / syntax

.

Operator

object.property

Examples

person.age

stock.volume

vehicle.model = "Tesla"

.%

Operator

left .% right

.*

Operator

left .* right

.+

Operator

left .+ right

.-

Operator

left .- right

..

Operator

a..b | a..<b | a..b by s | a..b..±s | n..

Examples

1..5              # 1, 2, 3, 4, 5   (type(1..5) → "Range")

5..1              # descending: 5, 4, 3, 2, 1

1..<5             # exclusive: 1, 2, 3, 4

1..10 by 3        # stepped: 1, 4, 7, 10  (10..1 by 3 → 10, 7, 4, 1)

first(2.., 4)     # open-ended, lazy → [2, 3, 4, 5]

3 in 1..10 by 2   # true — O(1), the step grid counts

array(5..1)       # [5, 4, 3, 2, 1] — materialize in source order

...

Operator / syntax

..<

Operator / syntax

./

Operator

left ./ right

.^

Operator

left .^ right

.÷

Operator

left .÷ right

/

Operator

numerator / denominator

//

Comment

// comment through end of line

/=

Operator / syntax

:

Operator

identifier: expression

Examples

x: 42

name: "Bob"

apple: a Stock { price: 150 }

:+

Operator

sequence :+ element | (:+)(sequence, element)

Examples

[] :+ 1 :+ 2

`[1, 2] :+ 3

[1, 2] :+ [3, 4]

::

Operator / syntax

:>

Operator / syntax

:man

REPL command

:man topic | :manual topic

:manual

REPL command

:man topic | :manual topic

;

Operator / syntax

<

Operator / syntax

<-

Operator / syntax

<=

Operator / syntax

<==

Operator / syntax

<~~

Operator / syntax

=

Operator

variable = value | object.property = value

Examples

x = 10

person.name = "Alice"

stock's price = 200

==

Operator / syntax

===

Operator / syntax

==>

Operator / syntax

=>

Operator / syntax

=~

Operator / syntax

>

Operator / syntax

>=

Operator / syntax

?

Operator

cond ? a : b | ?X | empty?

Examples

n > 1 ? n : 0

fib(n) = n < 2 ? n : fib(n - 1) + fib(n - 2)

empty?([])

?.

Operator / syntax

??

Operator / syntax

???

Operator / syntax

?ᵇ

Symbol

?ᵏ

Symbol

?ⁱ

Symbol

@

Operator / syntax

Array

Type

Boolean

Type

Box

Symbol

Byte

Type

Bytes

Type

Complex

Type

Diamond

Symbol

Dictionary

Type

E!

Keyword

Float

Type

Integer

Type

List

Type

NA

Value

Null

Keyword

Omega

Symbol

PHI

Symbol

PI

Symbol

Rational

Type

Set

Type

Sigma

Symbol

String

Type

TAU

Symbol

Time

Type

Tuple

Type

[

Operator / syntax

\

Keyword

\param => expression  OR  \(params) -> expression

Examples

\x => x * 2                   # Simple double function

\(x, y) -> x + y              # Multiple arguments

map(\(n) [n * n], [1, 2, 3])  # Block-bodied prefix lambda

]

Operator / syntax

^

Operator / syntax

`[]

syntax

`[expression, ...] | `[]

Examples

`[]

`[1, 2, 3]

1 +: 2 +: `[]

`[1, 2] :+ 3

`name`

Operator

left `function` right   (matched pair of backticks)

Examples

mysum(x, y) = x + y

3 `mysum` 4                  # → 7   ≡ mysum(3, 4)

5 `max` 3                    # → 5   builtins too

"hello" `contains` "ell"     # → true

3 `mysum` 4 * 2              # → 14  binds like *, left-assoc

3 mysum 4                    # → 3   WITHOUT backticks: three statements

a

Keyword

InstanceName: a ConceptName { properties... }  OR  InstanceName: an ConceptName { properties... }  OR  InstanceName: a ConceptName with slot: value, ...

Examples

myCar: a Car { brand: "Toyota", year: 2023 }

laptop: an ElectronicProduct { price: 999 }

bike: a Vehicle with wheels: 2, brand: "Brompton"

abductive

Keyword

abs

Function

abs(x)

absent?

Function

absent?(value)

accident

Ontological Logic

subject accident predicate

Examples

Human accident Height

Book accident Color

accidental: Object accident Property

acos

Function

acos(x)

action

Keyword

Concept action name(params) [ body ]

Examples

Airplane action describe() [ it.brand + " (" + str(it.engines) + " engines)" ]

plane.describe()

activate

Function

adapt_case

Function

adapt_case(base_case, new_problem [, adaptation_method])

Examples

adapt_case(base_case, new_problem)

adapt_case(base_case, new_problem, "substitution")

adapt_case(base_case, new_problem, "transformational")

add

Function

add(x, y) OR add(x, y, z)

Examples

add(2, 3)      # Returns 5 (function mode)

add(2, 3, 5)   # Returns true (predicate mode)

add(2, 3, 6)   # Returns false (predicate mode)

forall x,y in Numbers: equal(add(x, y), add(y, x))

add1

Function

add_case

Function

add_case(library, problem, solution, outcome [, context])

Examples

add_case(lib, problem_obj, solution_obj, outcome_obj)

add_case(medical_lib, symptoms, diagnosis, results, patient_context)

add_concept

Function

add_default_fact

Function

add_default_rule

Function

add_deontic_agent

Function

add_dimension

Function

add_dl_concept

Function

add_dl_individual

Function

add_dl_role

Function

add_domain

Function

add_domain(space, name, dimensions [, options...])

Examples

fruit: conceptual_space("Fruit")

add_dimension(fruit, "sweetness", 0, 10)

add_dimension(fruit, "size", 0, 10)

add_domain(fruit, "taste_size", ["sweetness", "size"])

add_domain(fruit, "taste_size", ["sweetness", "size"], "metric", "manhattan", "weight", 2.0)

add_edge

AI Function

add_edge(graph, from_node, to_node[, weight])

Examples

add_edge(g, "A", "B")           # Unweighted edge

add_edge(g, "A", "B", 5)        # Weighted edge

add_edge(graph, "start", "end", 2.5)

add_epistemic_agent

Function

add_free_term

Function

add_knowledge_state

Function

add_node

Function

add_prob_conditional

Function

add_prob_formula

Function

add_prototype

Function

add_region

Function

add_relation

Function

add_semantic_link

Function

add_semantic_link(network, from, to, linktype [, strength])

Examples

add_semantic_link(net, "canary", "bird", "ISA", 1.0)

add_semantic_link(net, "tweety", "canary", "INSTANCE_OF")

add_semantic_link(net, "bird", "can_fly", "HAS_PROPERTY", 0.8)

add_semantic_node

Function

add_semantic_node(network, id, label, type)

Examples

add_semantic_node(net, "bird", "Bird", "Category")

add_semantic_node(net, "tweety", "Tweety", "Individual")

add_state

Function

add_taxonomy_node

Function

add_term

Function

add_to_domain

Function

add_transition

Function

add_world

Function

ai

Function

(retired) ai "…"  →  ask/any "…"

Examples

ask/any "what is a fixpoint?"      # what ai "…" used to mean

alias

Keyword

aliases

Function

all?

Function

all?(predicate, collection)

allow

Keyword

alnum?

Function

alpha?

Function

alphabet_of

Function

alphabet_of(taxonomy)

Examples

alphabet_of(porphyry)   # [("substance", "2"), ("material", "3"), ...]

always

Temporal Logic

always proposition

Examples

always true

always (mathematical laws)

eternal: always (logical principles)

an

Keyword

InstanceName: an ConceptName { properties... }  OR  InstanceName: an ConceptName with slot: value, ...

Examples

laptop: an ElectronicProduct { price: 999 }

analogous

Analogical Logic

domain1 analogous domain2

Examples

Mathematics analogous Music

SolarSystem analogous Atom

analogy: Domain1 analogous Domain2

analogy

Reserved vocabulary

and

Operator

expression1 and expression2

Examples

true and false

x > 0 and x < 10

and_then

Function

andalso

Operator

expression1 andalso expression2

Examples

1 < 2 andalso 3 > 4

i <= len(xs) andalso xs[i] > 0

annotation

Keyword

annotations

Function

annotations(fn)

Examples

twice :: Integer -> Integer

twice(x :: Integer) = x * 2

annotations(twice)          # → Integer -> Integer

annotations(twice).result   # → Integer

annotations(sqrt)           # → none

any?

Function

any?(predicate, collection)

append

Function

append(array, value)  |  append(path, text)

Examples

a: [1, 2]

append(a, 3)  # a is now [1, 2, 3]

append(%log.txt, "line\n")

append_map

Function

apply

Function

apply_mapping

Function

apropos

Function

apropos("term")

Examples

apropos("substr")        # find the substring family

apropos("regex")

arg

Function

argues

Argument Logic

premise argues conclusion

Examples

Evidence argues Theory

Premise argues Conclusion

argument: Data argues Hypothesis

arity

Function

arity(fn)

Examples

arity(func(a, b) [a + b])   # → 2

arity(map)                  # → 2

arity(round)                # → -1 (1 or 2 args — see signature)

array

Function

array([collection])

Examples

array()              # [] — the empty array

array({3, 1, 2})     # [1, 2, 3] — canonical order

array((1, 2, 3))     # [1, 2, 3] — from a Tuple

array(1..4)          # [1, 2, 3, 4]

array(5..1)          # [5, 4, 3, 2, 1] — source order

array?

Function

array_to_stack

Function

as

Keyword

import NAME as ALIAS from "path" | import "path" as M | PAT as NAME | implement I for T as { ... }

Examples

import sqrt as root from "lib/math.ax"

match n with | 1..9 as k => k

implement Iterable for Box as { iterate: func(x) [ [x.v] ] }

as_unit

Function

as_unit(quantity, unit)

Examples

as_unit(5 * kg, gram)   # displays as 5000 gram, still == 5*kg

asc

Keyword

ascii?

Function

asin

Function

asin(x)

ask

Function

ask "question" [{provider: "…", model: "…"}] | ask/axioma "…" | ask/any "…" | ask("…"[, {…}]) | ask/any("…"[, {…}])

Examples

ask "how do I make msft a Stock?"           # language door — the reply parses

reply: ask("how do I state a fact?")        # call form, bound

ask/any "one sentence on Leibniz"          # any topic

ask/any("…", {provider: "ollama"})         # one call on a local model

assert

Keyword

assert fact(args...)

Examples

relation edge(x, y)

assert edge("a", "b")

grounding("edge", "a", "b")  # "datum"

assert_dl_concept

Function

assert_dl_role

Function

assign_stmt

Function

assignment_stmt?

Function

assumes

Keyword

ast

Function

ast("source") | ast(fn) | ast(astValue)

Examples

a: ast("x + 1")           # parse, don't run — ast_string(a) → "(x + 1)"

eval(ast("a: 5\na * 2"))   # → 10 — whole program (parse() default → 5!)

ast_type(ast("zz: 9"))     # → "LetStatement"

eval(ast(func(x) [x * 2]))(5)   # → 10 — the function-definition twin of source

ast?

Function

ast_call_args

Function

ast_call_args(ast)

ast_call_name

Function

ast_call_name(ast)

ast_children

Function

ast_children(ast)

ast_eval

Function

ast_field

Function

ast_fields

Function

ast_fields(ast)

ast_has?

Function

ast_kind

Function

ast_string

Function

ast_type

Function

ast_with_context

Function

astar

AI Function

astar(graph, start_node, goal_node)

Examples

astar(g, "A", "Z")

astar(map, "home", "destination")

at

Keyword

for ELEM at I in ITERABLE [ body ]

Examples

for f at i in ["fig", "plum"] [ println("${i}. ${f}") ]

for n at i in 2..100 by 2 [ if i == 3 then [break] ]

for v, tag at i in pairs [ ... ]   # destructure + counter

at0

Function

at1

Function

atan

Function

atan(x_or_y, [x])

atan2

Function

atan2(y, x)

Examples

atan2(1, 1)   # Returns pi/4 (first quadrant)

atan2(1, -1)  # Returns 3*pi/4 (second quadrant)

atan2(1, 0)   # Returns pi/2 (straight up — no division by zero)

atend

Function

attach_coordinates

Function

attempt

Keyword

attribute

Keyword

average

Function

average(data, [axis])

axiom

Keyword

axiom fact(args...) | axiom/<kind> fact(args...) | axiom Name [scope]: expression ["documentation"]

Examples

axiom parent("john", "mary")

axiom/empirical weighs("apple", 95)

grounding("parent", "john", "mary")  # "axiom"

axiom NonNegative: balance >= 0

axiomadoc CLI Tool

Tools

axiomadoc <command> [options]

Examples

go build -o axiomadoc ./cmd/axiomadoc

./axiomadoc generate -input . -output docs -format html

./axiomadoc serve -port 8080 -watch

./axiomadoc validate -input . -check-links -run-examples

./axiomadoc generate -format html -template academic

./axiomadoc help  # Show detailed usage information

axioms

Function

b4_join

Function

b4_meet

Function

backarrow

Symbol

backward

Keyword

bag

Function

bag_add

Function

bag_of_set

Function

bag_of_string

Function

bag_remove

Function

band

Keyword

barvee

Symbol

barwedge

Symbol

base64_decode

Function

base64_encode

Function

bayesian_network

Function

bayesian_update

Function

because

Causal Logic

effect because cause

Examples

Smoke because Fire

Success because Effort

explanation: Result because Cause

bel

Function

bel …

belboth

Symbol

belfalse

Symbol

belief

Function

believes

Epistemic Logic

agent believes proposition

Examples

John believes false

Student believes hypothesis

opinion: Philosopher believes theory

belnap

Function

belnap("true" | "false" | "both" | "neither") — or the literals ⊤ᵇ ⊥ᵇ ⊤⊥ᵇ ?ᵇ

Examples

w: ⊤⊥ᵇ                          # ≡ belnap("both") — the glut literal

⊤ᵇ and ⊤⊥ᵇ                      # → ⊤⊥ᵇ (contamination propagates)

not ⊤⊥ᵇ                         # → ⊤⊥ᵇ (negating a glut keeps the glut)

belnap("true") == "true"        # → true (metalanguage equality coerces)

designated(⊤⊥ᵇ)                 # → true — and `if ⊤⊥ᵇ` takes the then-branch

match w with | ⊤⊥ᵇ => "glut" | ?ᵇ => "gap" | _ => "classical"   # literals are patterns

forall p in Belnap.values | designated(p or not p)   # → false (LEM's gap escape)

belnap_both

Symbol

belnap_false

Symbol

belnap_neither

Symbol

belnap_true

Symbol

belneither

Symbol

beltrue

Symbol

bench

Keyword

bench "label" expr   |   bench "label" [ … ]   |   bench(label, fn)

Examples

r: bench "qsort" qsort(xs)

r: bench("qsort", func() [qsort(xs)])

println(r.label, r.elapsed_ms, r.result)

beta

Function

between

Function

bf

Function

bfs

AI Function

bfs(graph, start_node, goal_node)

Examples

bfs(g, "A", "Z")

bfs(network, "source", "destination")

bidirectional

Keyword

big_and

Function

big_and(domain, predicate)

big_or

Function

bigcap

Function

bigcup

Function

bigintersect

Function

bigunion

Function

bin

Function

bin(n)

bind_stmt

Function

bind_stmt?

Function

bindings

Function

bindings()

Examples

x: 42

bindings()               # → ["x"]

binomial

Function

bit_and

Function

bit_not

Function

bit_or

Function

bit_shl

Function

bit_shr

Function

bit_xor

Function

bl

Function

block

Function

block?

Function

block_append

Function

block_at

Function

block_concat

Function

block_filter

Function

block_find

Function

block_first

Function

block_insert

Function

block_len

Function

block_map

Function

block_remove

Function

block_replace

Function

block_rest

Function

block_slice

Function

block_to_array

Function

block_words

Function

boolean

Function

boolean(value)

Examples

boolean(0)        # true  — zero is NOT falsy in Axioma

boolean("")       # true  — nor is the empty string

boolean([])       # true  — nor is an empty collection

boolean(none)     # false

boolean(om)       # false

boolean?

Function

bor

Keyword

bot

Symbol

boundary

Keyword

concept C { boundary: predicate }   |   { boundary~: predicate }

Examples

concept Adult { formed_by: "stipulation", boundary: age >= 18 and is Person }

concept Sage { formed_by: "stipulation", boundary~: age >= 65 and is Person }

box

Symbol

break

Keyword

break  |  break <expr>  |  break 'label  |  break 'label <expr>  |  if c then break

Examples

n: loop [ break 123 ]                  # n is 123

while true [ if done then break ]      # guarded exit

foreach i in a [ foreach j in b [ if p then break ] ]   # exits the INNER loop only

'outer: for n in xs [ for m in ys [ if p then break 'outer ] ]

found: 'search: loop [ break 'search cell ]

if x == 6 then "note" else break      # the else arm too

breakpoint

Function

breakpoint([line, ...])   |   breakpoint()

Examples

breakpoint([15, 30])         # pause at lines 15 and 30

breakpoint()                 # clear all breakpoints

clearbreakpoints()           # the explicit spelling (see: clearbreakpoints)

broadcast

Function

broadcast(fn, [...args])

bshl

Keyword

bshr

Keyword

builtin?

Function

builtins

Function

builtins() | builtins("name")

Examples

len(builtins())          # how many builtin functions exist

builtins("map")          # → true

[b | b <- builtins(), contains(b, "regex")]

butfirst

Function

butlast

Function

bxor

Keyword

by

Keyword

by_default

Keyword

byte

Function

byte(n)

bytes

Function

bytes(values...)

bytes_to_array

Function

bytes_to_hex

Function

bytes_to_string

Function

call

Function

call_expr?

Function

called

Keyword

cancel

Function

cancel(relation, args...)

Examples

flies(X) <~~ bird(X)

assert bird("pingu")

cancel("flies", "pingu")

canceled

Function

canceled(relation, args...)

Examples

canceled("flies", "pingu")  # true after cancel

cap

Symbol

capitalize

Function

capitalize(s)

cardinality

Function

cardinality(Concept, "slot", min [, max])

Examples

cardinality(Person, "age", 1, 1)

case

Keyword

case expr | pattern [when guard] => body | …

Examples

case pair | (1, x, 3) => x | _ => 0

case pair
| (1, x, 3) => x
| _ => 0

case/strict 1 | 1 => "one" | _ => "no"

switch pair | (1, x, 3) => x | _ => 0

case_library

Function

case_library(name, description)

Examples

case_library("Medical Cases", "Diagnostic case library")

case_library("Engineering Designs", "Design pattern library")

case_library_stats

Function

case_library_stats(library)

Examples

case_library_stats(medical_lib)

stats: case_library_stats(library); print(stats)

case_similarity

Function

case_similarity(case1, case2 [, method])

Examples

case_similarity(case1, case2)

case_similarity(case1, case2, "euclidean")

case_similarity(case1, case2, "cosine")

catch

Keyword

catch  |  catch e  |  catch e is Kind

Examples

try
    1 / 0
catch e is DivByZero
    0
catch e
    42
end

causally

Causal Logic

cause causally effect

Examples

Fire causally Smoke

Training causally Improvement

causation: Cause causally Effect

cbr_engine

Function

cbr_engine(case_library)

Examples

cbr_engine(medical_library)

cbr_engine(design_library)

cd_primitive?

Function

cd_primitives

Function

cd_roles

Function

ceil

Function

ceil(x)

ceiling

Function

ceiling(x)

cg_format

Function

cg_join

Function

cg_visualize

Function

chain

Keyword

challenge

Function

challenge(relation, args...)

Examples

axiom parent("john", "mary")

challenge("parent", "john", "mary")

challenged("parent", "john", "mary")  # true

challenged

Function

challenged(relation, args...)

Examples

challenged("parent", "john", "mary")

char

Function

char_alphabetic?

Function

char_numeric?

Function

char_whitespace?

Function

characteristic_numbers

Function

characteristic_numbers(RootConcept)

Examples

Dog extends Creature

characteristic_numbers(Creature)

every Dog is Creature    # true, by arithmetic

chars

Function

chars(s)

check

Automated Reasoning

check Concept | check function | check proposition [using strategy]

Examples

concept Adult { boundary: age >= 18 and is Person, examples: [alice], counterexamples: [kid] }

check Adult   # ⊤ᵇ when the boundary honors the contract

contract maximum { ensures: result[1] in a, generate: func() [ [random(-99, 99), random(-99, 99)] ] }

check maximum   # ⊤ᵇ, or ⊥ᵇ with a counterexample report

contract Account { operations: [deposit, withdraw], steps: 12, trials: 40 }

check Account   # stateful: ⊥ᵇ plus the operation sequence that broke the invariant

check "system consistency"

check_derivation

Function

check_double_negation

Function

check_effect

Function

check_explosion

Function

check_lem

Function

check_tfl_derivation

Function

chicken_game

Function

chicken_game()

choice

Function

choose

Function

choose(n, k)

Examples

choose(5, 2)   # Returns 10

chr

Function

chr(codepoint)

chunk

Function

ci

Keyword

circ

Symbol

circular_permutations

Function

circular_permutations(n)

Examples

circular_permutations(4)   # 6

cl_count

Function

cl_derive

Function

cl_exists

Function

cl_explain

Function

cl_infer

Function

cl_prove

Function

cl_query

Function

cl_translate

Function

classify

Keyword

classify_dl

Function

clear

Function

clear_screen

Function

clear_trace_log

Function

clear_trace_log()

Examples

clear_trace_log()            # start from an empty transcript

len(trace_log())             # → 0

clear_universe

Function

clearbreakpoints

Function

clearbreakpoints()

Examples

clearbreakpoints()           # remove all breakpoints

close_solutions

Function

close_solutions(stream)

closure

Function

cnf?

Function

Cognitive Science Features

Concept

Features aligned with cognitive science research

Examples

# Graded categorization (not just boolean)

similarity(Robin, Bird)     # 0.8 (very typical)

similarity(Penguin, Bird)   # 0.6 (less typical)



# Prototype effects

typicality(Robin)           # High (good prototype)

typicality(Ostrich)         # Lower (atypical bird)



# Hierarchical reasoning

Robin partOf Bird

Bird partOf Animal

Robin relatedTo Animal      # Transitive relationship

cognitive_word?

Function

collect

Function

collect(iterable)

combinations

Function

combinations(n, k)

Examples

combinations(5, 2)   # Returns 10

common_ancestor

Function

common_ancestor(taxonomy, a, b)

Examples

common_ancestor(porphyry, 10374, 66)   # → substance → material (body, 6)

compact

Function

compile

Function

compile("program") | compile('(expr))

Examples

c: compile("fib: func(n) [if n < 2 then n else fib(n-1) + fib(n-2)]\nfib(25)")

c()                        # runs the bytecode (call it as often as you like)

compile('(6 * 7))()        # a quoted AST compiles too → 42

try(compile("relation r(x)"))   # catchable: outside the VM subset

complement

Function

completeness

Keyword

complex

Function

complex(re, im)

complex?

Function

complexes

Value

compose

Function

compose(f, g, ...)

Examples

compose(double, incr)(5)              # Returns 11 — double first, then incr

(double >> incr)(5)                   # Returns 11 — the operator form

compose(double, incr)(5) == pipe(5, double, incr)   # true — same order

compose({(1,2)}, {(2,3)})             # Returns {(1, 3)} — relation composition

compose()(5)                          # Returns 5 — the identity element

compose_mappings

Function

computational_philosophy

System

Various philosophical operators and commands

Examples

# Modal Logic: necessarily, possibly, contingently

# Epistemic Logic: knows, believes with certainty measures

# Deontic Logic: ought, permitted, forbidden

# Automated Reasoning: derive, check with confidence metrics

# See individual operators for detailed usage

compute_extensions

Function

concept

Keyword

concept Name ["doc"] | concept/persist Name | concept Name { slot: default, ... } | concept Name { slot :: Type: default, ... } | concept Name with … end | concept Name extends Parent [implements I1, ...] {}

Examples

concept Person { name: "", age: 0 }

concept Measure { ratio :: Float: 1.0, label: "free" }

concept Stock "a tradable equity"

concept Airplane extends Vehicle implements Flyable {}

Airplane has wingspan: 35

concept?

Function

concept_and

Function

concept_not

Function

concept_or

Function

conceptnet_capableof

Function

conceptnet_isa

Function

conceptnet_partof

Function

conceptnet_query

Function

conceptnet_related

Function

conceptnet_relations

Function

conceptnet_usedfor

Function

concepts

Function

concepts()

Examples

concepts()               # the full concept landscape

"Integer" in set(concepts())   # → true

concepts_formed_by

Function

concepts_formed_by(mode)

Examples

concepts_formed_by("stipulation")

conceptual_graph

Function

conceptual_space

Function

conceptual_to_semantic

Function

conceptually

Reserved vocabulary

cond

Keyword

cond | predicate => body | else => body

Examples

cond | n > 0 => "pos" | n < 0 => "neg" | else => "zero"

cond | false => 1 | otherwise => 2

cond | false => 1 | _ => 3

confirm

Function

confluence

Function

conj

Function

conj(z)

conjugate

Function

conjugate(z)

connect

Keyword

cons

Function

cons(element, list) | element cons list

Examples

m: cons(0, list([1, 2]))  # `[0, 1, 2]

m: 0 cons list([1, 2])    # the same, written infix

4 cons 2 cons 3 cons list()  # `[4, 2, 3]

acc: cons(x, acc)         # the accumulate idiom; reverse(acc) closes it

consistency

Keyword

const

Keyword

const NAME = value

Examples

const MY_PI = 3.14159

const MAX_SIZE = 1000

const/persist CONFIG = {...}

const/transient TEMP_FLAG = true

constant

Function

constantly

Function

constantly(value)

constrain

Function

constrain(Concept, "slot", predicate)

Examples

constrain(Airplane, "year", lambda y => y >= 1903)

plane.year: 1800   # rejected, slot unchanged

contains

Operator

container contains element

Examples

{1, 2, 3} contains 2

["a", "b", "c"] contains "b"

Mammal contains Dog         # Concept hierarchy

animals contains Dog        # Set membership

context_assert

Function

context_create

Function

context_diff

Function

context_graph

Function

context_lift

Function

context_lower

Function

context_merge

Function

context_project

Function

context_query

Function

context_resolve

Function

context_set_parent

Function

context_stats

Function

contingently

Modal Logic

contingently expression

Examples

contingently true

contingently (the weather tomorrow)

continue

Keyword

continue  |  continue 'label  |  if c then continue

Examples

foreach x in xs [ if x % 2 == 1 then continue
  evens: push(evens, x) ]

'rows: for n in 1..3 [ for m in 1..3 [ if m == 2 then continue 'rows ] ]

repeat [n < 6] [ n: n + 1
  if n % 2 == 0 then continue ]   # still exits at n = 6

contract

Functions

contract name { purpose: "…", requires: expr, ensures: expr, decreases: expr, generate: func([size]) [...], examples: [...], classify: func(...) [...], param: { requires: …, ensures: … }, trials: n }  |  contract Concept { operations: [...], steps: n, trials: n }

Examples

maximum: func(a) [ ... ]

contract maximum { requires: len(a) > 0, ensures: result[1] in a }

maximum([])      # ERROR: contract violated: maximum requires clause 1 (len(a) > 0)

check maximum    # generated-input verification → Belnap verdict

contract push_end { ensures: len(result) == old(len(xs)) + 1 }   # pre-state via old()

contract fact { requires: n >= 0, decreases: n }   # dynamic termination measure

concept Account { balance: 0, invariant: balance >= 0 }   # the concept twin

contract twice { f: { requires: arg >= 0 }, ensures: result >= x }   # higher-order sub-contract

contract Account { operations: [deposit, withdraw], steps: 12 }   # stateful checking

prove maximum   # STATIC discharge for all inputs (the check twin)

contradiction

Keyword

contradicts

Keyword

control?

Function

converge

Function

converge(combiner, [f, g, ...])

Examples

converge(div, [total, count_of])([2,4,6,8])   # Returns 5 — the mean

converge(pair_up, [incr, double])(3)          # Returns [4, 6]

converge(pair_up, [add, mul])(3, 4)           # Returns [7, 12] — both args reach both branches

converse

Function

converse(categorical_proposition)

Examples

converse(no human is stone)      # simple, valid

converse(every human is animal)  # per_accidens — valid only w/ import

copy

Function

corrcoef

Function

cos

Function

cos(x)

cosh

Function

cosh(x)

cosine

Function

count

Function

count(collection, [target])

cov

Function

createFormalSystem

Function

createGodelSentence

Function

create_canvas

Function

create_fuzzy_set

Function

create_mapping

Function

create_porphyry

Function

create_porphyry()

Examples

porphyry: create_porphyry()

println(show_taxonomy(porphyry))

every human is animal   # true

create_taxonomy

Function

create_taxonomy(name)

Examples

tax: create_taxonomy("Zoo")

critical_pairs

Function

cset_digits

Function

cset_letters

Function

cup

Symbol

curry

Function

curry(f)

cut

Keyword

p(X) :- q(X), cut, r(X)

dataframe

Function

dataframe([columns], [options])

date

Function

date(year_or_string, [month], [day])

date?

Function

datetime?

Function

deactivate

Function

decidability

Keyword

declare

Keyword

declare <name> [:: Type] = <expression>

Examples

declare x = 1 + 2      # nothing computed yet

x                      # 3 — computed on this first read, then cached

declare a, b = 10, 20  # multiple lazy bindings

decode

Function

deduce

Keyword

deduce

Examples

deduce                      # Apply all rules

# After defining rules:

rule R1: A implies B

rule R2: B implies C

deduce                      # Derives A -> B -> C

deductive

Keyword

dedupe

Function

default_believes

Function

default_override

Function

default_theory

Function

define

Keyword

define_species

Function

define_species(taxonomy, species, differentia, genus)

Examples

define_species(porphyry, "dog", "domesticated", "beast")

every dog is animal       # true

definition_of(porphyry, "dog")   # "domesticated beast"

defines

Keyword

Concept defines { predicate }   |   Concept defines~ { predicate }

Examples

concept Minor

Minor defines { age < 18 and is Person }

kid is Minor   # true, derived

definition_of

Function

definition_of(taxonomy, term)

Examples

definition_of(porphyry, "human")   # "rational animal"

definitions

Keyword

defuzzify

Function

deg

Function

deg(x)

Examples

deg(pi)          # Returns 180

deg(atan2(1, 1)) # Returns 45 (the polar-heading idiom)

del_key

Function

delete

Keyword

delete a[i]  |  delete a[i:j]  |  delete h[k]   (prefix)    ConceptName delete   (postfix, deprecated)

Examples

xs: [10, 20, 30]

delete xs[2]       # 20 — xs is [10, 30]

old: delete xs[1]  # binds 10

h: {a: 1, b: 2}

delete h["a"]    # 1 — h is {b: 2}

Person delete      # Deprecated — use Person destroy

demonstrateIncompleteness

Function

denom

Function

denominator

Function

denominator(q)

denotes

Keyword

denoting

Function

deontic_model

Function

depth

Function

depth(stack)

Examples

s: stack()

push(s, 10)

depth(s)  # 1

derive

Automated Reasoning

derive proposition [from context] [using strategy]

Examples

derive "mathematical truth"

derive conclusion from premises using forward

result: derive theorem

desc

Keyword

describe

Function

describe(x)

Examples

describe(42)               # parity, sign, digit count, card pointer

describe("héllo")          # bytes vs runes

describe(round)            # signature + summary from the R3 spec

describe(none)             # the none-vs-om teaching card

describe_link_type

Function

describe_link_type(link_type)

Examples

describe_link_type("ISA")

describe_link_type("HAS_PROPERTY")

described

Keyword

designated

Function

designated(truth_value)

Examples

designated(⊤⊥ᵇ)                 # → true — a glut is true-enough to act on

designated(?ᵇ)                  # → false (the gap)

designated(om)                  # → false (K3 gap) — and `if om` now agrees (falsy, 2.5)

designated(lukasiewicz(0.9))    # → false (only 1.0 is designated)

forall p in Kleene.values | designated(p or not p)   # → false (LEM fails in K3)

destroy

Keyword

ConceptName destroy

Examples

Person destroy

Stock destroy

Vehicle destroy

det

Function

detect

Function

detect_option

Function

df_describe

Function

df_filter

Function

df_groupby

Function

df_groupby(dataframe, columns)

df_head

Function

df_info

Function

df_mutate

Function

df_mutate(df, column, values)

df_select

Function

df_sort

Function

df_tail

Function

dfs

AI Function

dfs(graph, start_node, goal_node)

Examples

dfs(g, "A", "Z")

dfs(maze, "start", "exit")

diag

Function

diagnose

Function

diagnose(arg)

Examples

declare_atomic("p")

taut: func(sd) [atom_truth(sd, "p") or not atom_truth(sd, "p")]

diagnose(taut).verdict          # "L_true"

diagnose(taut).confirmation       # 1.0

dm: diagnose("the Absolute is lazy")

dm.verdict                        # "pseudo"

dm.verifier_bound                 # false

diagonalize

Function

diagonalize(expression_string)

Examples

d: diagonalize("provable")

is_godel(d)   # true

dialect?

Function

diamond

Symbol

dict

Function

dict(args...)

dictionary

Function

dictionary(args...)

diff

Keyword

difference

Operator

set1 difference set2

Examples

{1, 2, 3} difference {2, 3}

all difference completed

different

Keyword

digit?

Function

digraph

AI Function

digraph(node1, node2, node3, ...)

Examples

digraph("Start", "Middle", "End")

digraph("State1", "State2", "State3")

dim

Function

dim(quantity)

Examples

dim(5 * kg)                 # "kg"

dim(metre / sec^2)          # "m/s^2"

dimensions_of

Function

direct

Keyword

discover

Keyword

dispatch

Function

distance

Function

distinct

Function

div

Operator

number div number

Examples

100 div 7          # Returns 14

100 idiv 7         # Returns 14   (word alias)

100 quotient 7     # Returns 14   (infix longhand)

10.0 div 3.0       # Returns 3

100 ÷ 7            # Returns 14   (glyph equivalent)

6 * 5 div 7        # Returns 4    (left-assoc with *)

div(100, 7)        # Returns 14   (prefix builtin, keyword spelling)

idiv(100, 7)       # Returns 14   (prefix builtin, idiv spelling)

quotient(100, 7)   # Returns 14   (prefix builtin, long spelling)

-7 div 3           # Returns -3   (floor, toward -inf)

div(-7, 3)         # Returns -3   (the call agrees, by construction)

division

Function

divmod

Function

divmod(a, b)

Examples

divmod(100, 7)     # Returns (14, 2)   — (quotient, remainder)

divmod(100, 7)[1]  # Returns 14        (quotient, 1-indexed)

divmod(100, 7)[2]  # Returns 2         (remainder)

divmod(-7, 3)      # Returns (-3, 2)   (floor quotient, remainder signed like the divisor)

divmod(100, 0)     # ERROR: divmod by zero

dl_consistent?

Function

dl_instance?

Function

dl_kb

Function

dl_stats

Function

dnf?

Function

do

Function

doc

Function

doc | doc <word> | doc(word) | doc("word")

Examples

doc Integer            # statement form

doc(Integer)           # call form — identical output

doc("if")              # keywords/operators need the string form

doc random             # builtin docs (seeding, ranges)

doc                    # the full sorted topic catalog (also doc())

Documentation Strings

Concept

Various documentation syntaxes for concepts and functions

Examples

concept Person "A Person represents a human being"

concept Vehicle """\nMulti-line documentation\nwith detailed descriptions\n"""

greet: lambda name => "Hello, " + name documented as "Simple greeting"

add: func(x, y) "Adds two numbers" [ x + y ]

Person document "Add documentation later"

document

Keyword

documented

Keyword

domain

Function

domains_of

Function

domains_of(space)

Examples

fruit: conceptual_space("Fruit")

add_dimension(fruit, "sweetness", 0, 10)

add_dimension(fruit, "size", 0, 10)

add_domain(fruit, "taste_size", ["sweetness", "size"])

domains_of(fruit)

doubts

Keyword

drop

Function

drop_while

Function

dsl_case

Function

dsl_cases

Function

dsl_compile

Function

dsl_define

Function

dsl_explain

Function

dsl_export

Function

dsl_import

Function

dsl_lint

Function

dsl_list

Function

dsl_match

Function

dsl_parse

Function

dsl_reference

Function

dsl_show

Function

dsl_test

Function

dsl_tokens

Function

dsl_trace

Function

dsl_validators

Function

dsl_vocab

Function

dup

Function

dup(stack)

Examples

s: stack()

push(s, 10)

dup(s)  # stack is now [10, 10]

dupnum

Function

duration?

Function

e

Value

each

Function

each_cons

Function

each_slice

Function

eachline

Function

eachline()  |  eachline(path)

Examples

for line in eachline("notes.txt") [ println(line) ]

efficiently

Keyword

eg_add_cut

Function

eg_add_cut(graph, cut)

Examples

cut: eg_cut(80, 80, 150, 50)

eg_add_cut(alpha, cut)

print(eg_format(alpha))  # Shows cut in graph structure

eg_add_predicate

Function

eg_add_predicate(graph, predicate)

Examples

pred: eg_predicate("Human", 1, 150, 150)

eg_add_predicate(beta, pred)

print(eg_format(beta))  # Shows predicate in graph

eg_alpha

Function

eg_alpha(description)

Examples

alpha: eg_alpha("Propositional logic example")

eg_add_predicate(alpha, eg_predicate("P", 0, 100, 100))

print(eg_format(alpha))

eg_beta

Function

eg_beta(description)

Examples

beta: eg_beta("First-order logic with quantification")

eg_add_predicate(beta, eg_predicate("Human", 1, 150, 150))

print(eg_format(beta))

eg_cut

Function

eg_cut(x, y, width, height [, style])

Examples

cut: eg_cut(50, 50, 200, 100)           # Solid cut

modal: eg_cut(100, 200, 150, 80, "dashed")  # Dashed cut for modal logic

eg_add_cut(graph, cut)

eg_erase_cut

Function

eg_erase_cut(graph, cut_id)

Examples

result: eg_erase_cut(graph, "cut_id_123")

if result.Success [

    print("Cut erased successfully")

]

eg_format

Function

eg_format(graph)

Examples

print(eg_format(alpha))  # Display Alpha graph structure

print(eg_format(beta))   # Display Beta graph with quantification

print(eg_format(gamma))  # Display Gamma graph with modal cuts

eg_gamma

Function

eg_gamma(description)

Examples

gamma: eg_gamma("Modal logic reasoning")

modal_cut: eg_cut(100, 100, 200, 100, "dashed")

eg_add_cut(gamma, modal_cut)

eg_insert_cut

Function

eg_insert_cut(graph, cut)

Examples

cut: eg_cut(100, 100, 120, 60)

result: eg_insert_cut(graph, cut)

print(result.Success)  # Check if operation succeeded

eg_iterate

Function

eg_iterate(graph, element_id, target_x, target_y)

Examples

result: eg_iterate(graph, predicate.ID, 400, 200)

print(result.Rules)  # Shows 'second_permission_iterate'

print(eg_format(result.Output))  # Displays copied element

eg_predicate

Function

eg_predicate(name, arity, x, y)

Examples

p: eg_predicate("P", 0, 100, 100)        # Proposition P

human: eg_predicate("Human", 1, 200, 150)  # Unary predicate

loves: eg_predicate("Loves", 2, 300, 200) # Binary relation

eig

Function

eighth

Function

elapsed

Keyword

elapsed expr   |   elapsed [ … ]   |   elapsed(fn)

Examples

d: elapsed(square(2))

d: elapsed qsort(xs)

d: elapsed [ setup(); qsort(xs) ]

elements

Function

elements(collection)

Examples

elements([1, 2, 3])

elements(my_custom_tree)

else

Keyword

if condition then consequent else alternative

Examples

println(if false then 1 else 2)

elseif

Keyword

if condition
  body
elseif other_condition
  other_body
else
  fallback
end

Examples

grade: if 7 > 9
  "high"
elseif 7 > 5
  "middle"
else
  "low"
end
println(grade)

email

Function

email(string)

email?

Function

emergence

Reserved vocabulary

empty?

Function

empty_set

Value

emptyset

Value

encode

Function

end

Keyword

if / while / for / loop / repeat / function / module … end

Examples

for n in 1..2
  println(n)
end

ends_with

Function

Enhanced Concept System

Concept

Multi-phase concept system with cognitive science features

Examples

# Phase 1: Multiple categorization

concept Duck implements Flyable, Swimmable { }

Duck is Flyable             # Interface check



# Phase 2: Inference rules (relation store)

rule flies(X) :- bird(X)    # Head derives whenever body holds

deduce                      # Apply forward-chaining



# Phase 3: Semantic relationships

Dog relatedTo Mammal        # Bidirectional relation

Engine partOf Car           # Hierarchical relation



# Phase 4: Prototype theory

similarity(Dog, Cat)        # Cognitive similarity

typicality(Robin)           # Prototypicality measure

prototype({animals})        # Find best example

entails

Argument Logic

premise entails conclusion

Examples

Axiom entails Theorem

Premise entails Conclusion

entailment: Logic entails Result

entity

Keyword

name: entity Concept { slot: value, ... }  OR  name: entity Concept with slot: value, ...

Examples

drone: entity Airplane { brand: "DJI" }

plane: a Airplane { brand: "Boeing" }

enum

Keyword

enum Name = Item1, Item2, ...

Examples

enum Day = Mon, Tue, Wed

Day enumerates Mon, Tue, Wed   # same

Mon.ord     # 0

succ(Mon)   # Tue

enumerate

Function

enumerate(xs)

Examples

enumerate(["a", "b"])    # [(1, "a"), (2, "b")]

for i, e in enumerate(xs) [ ... ]

{(i, e) | (i, e) <- enumerate(xs), i > 1}

enumerates

Keyword

Name enumerates Item1, Item2, ...

Examples

Day enumerates Mon, Tue, Wed

enum Season = Spring, Summer

Mon is Day   # true

Wed.ord     # 2

epistem

Type

epistem(relation, args...)  →  Epistem

Examples

relation parent(x, y)

axiom/empirical parent("john", "mary")

u: epistem("parent", "john", "mary")

type(u)   # "Epistem"

u.type    # "axiom"  (the grounding axis)

epistem?

Function

epistemic_model

Function

eq?

Function

eql?

Function

equal

Function

equal(x, y)

Examples

equal(4, 4)  # Returns true

equal(add(2, 3), 5)  # Returns true

forall x in Numbers: equal(add(x, 0), x)

equal?

Function

equijoin

Function

equiv

Symbol

equivalence_classes

Function

equivalent

Symbol

equivalent_terms

Function

equivalent_terms(taxonomy, a, b)

Examples

equivalent_terms(porphyry, human, "rational")   # true

eqv?

Function

erase

Function

erasenum

Function

err?

Function

err?(value)

error

Function

error(msg [, hint [, kind]])

Examples

e: error("bad input", "expected a number")

e.message

raise(e)

error?

Function

essence

Ontological Logic

subject essence predicate

Examples

Human essence Rationality

Triangle essence ThreeSided

essential: Concept essence Property

eval

Function

eval(ast)

Examples

expression: quote(x * 10)

x: 3

eval(expression)  # 30

eval_free_predicate

Function

even

Function

even?

Function

even?(n)

eventually

Temporal Logic

eventually proposition

Examples

eventually true

eventually (technology advances)

future: eventually discovery

every

Keyword

every S is P   |   every Concept has slot: default

Examples

create_porphyry()

every human is animal   # true — 10374 divisible by 546

every Car has wheels: 4

everyone

Keyword

exact?

Function

exact?(x)

exactly

Keyword

{fields} exactly | Ctor { fields } exactly

Examples

match h with | {name, age} exactly => name | _ => none

match dict() with | {} exactly => "empty"

match pt with | P { x, y, z } exactly => x

execute

Function

exists

Keyword

exists [op val] variable in set: predicate  OR  exists [lower <=] variable [<= upper]: predicate

Examples

exists x in {1, 2, 3}: x > 2

exists >= 3 x in domain: x > 2  # counting quantifier: at least 3

exists == 2 x in domain: even   # counting quantifier: exactly 2

exists 1 < x < 5: x == 3        # range quantifier

exists x <= 0: x == 0           # single-sided range

exists?

Function

exists_concept

Function

exp

Function

exp(x)

expand_dims

Function

expect

Function

expect(label, actual, expected)

expected_payoff

Function

explain

Keyword

explode

Function

explode(s)

explore

Reserved vocabulary

export

Keyword

export_visualization

Function

expr_stmt

Function

expr_stmt?

Function

extend

Function

extend(array, collection)  |  array extend collection

Examples

a: [1, 2]

extend(a, [3, 4])  # a is [1, 2, 3, 4]

a extend (5, 6)    # message form; tuples work too

extends

Keyword

concept Child extends Parent

Examples

concept Mammal extends Animal

concept Manager extends Employee

eye

Function

factorial

Function

factorial(n)

facts

Keyword

facts_by_kind

Function

facts_by_kind(kind)

Examples

axiom/empirical weighs("apple", 95)

facts_by_kind("empirical")

fail

Keyword

p(X) :- q(X), cut, fail

false

Keyword

falsum

Symbol

fdiv

Operator

a fdiv b | fdiv(a, b)

Examples

fdiv(1, 8)  # 0.125

8 fdiv 2  # 4.0

fdiv(10^400, 8*10^400)  # 0.125

fe

Keyword

fi

Keyword

fi'o

Keyword

fifth

Function

file

Function

file(string)

file?

Function

file_exists

Function

fill

Function

fill(count_or_array, value)

filter

Function

filter(predicate, collection)

Examples

filter(lambda x => x % 2 == 0, [1, 2, 3, 4])  # Returns [2, 4]

filter(is_prime, {2, 3, 4, 5})                # Returns {2, 3, 5}

finally

Keyword

try ⏎ body ⏎ finally ⏎ cleanup ⏎ end

Examples

try
    1 / 0
finally
    closed: true
end

find_all

Function

find_contradictions

Function

finite?

Function

first

Function

first(s, [n])

fix

Function

fix(f, args...)

flat_map

Function

flatmap

Function

flatten

Function

flatten(nested)

flip

Function

flip(f) or flip(f, a, b, ...)

Examples

flip(sub, 2, 10)          # Returns 8 — applies sub(10, 2)

flip(sub)(2, 10)          # Returns 8 — the swapped function itself

(flip(sub) >> incr)(2, 10)   # Returns 9 — opens a pipeline

float

Function

float(x)

float?

Function

floor

Function

floor(x)

fn

Keyword

fn [name](params) [body]  OR  name: fn(params) [body]

Examples

fn double(x) [ x * 2 ]         # Named declaration

double: fn(x) [ x * 2 ]        # Anonymous assignment form

fold_left

Function

fold_right

Function

foldl

Function

foldr

Function

for

Keyword

for item in source [ body ] | for item in source
  body
end

Examples

for n in 1..3
  println(n)
end

for_each

Function

forall

Keyword

forall variable[,variable2,...] in set: predicate  OR  forall [lower <=] variable [<= upper]: predicate

Examples

forall x in {1, 2, 3}: x > 0

forall 1 <= x <= 10: x > 0       # double-sided range

forall x < 5: x >= 0            # single-sided range (starts at 0)

forall x,y in {1, 2, 3}: (x + y) == (y + x)

forall_concept

Function

forbidden

Deontic Logic

forbidden proposition

Examples

forbidden false

forbidden (break promises)

prohibited: forbidden action

force

Function

force(x)

Examples

force(lazy (6 * 7))               # 42

force((x * 2 | x <- [1, 2, 3]))   # [2, 4, 6] — drains a generator

force(42)                          # 42 — not a promise, returned as-is

map(force, [lazy (1 + 1), lazy (2 + 2)])   # [2, 4]

force_cancel

Function

force_cancel(relation, args...)

Examples

force_cancel("tranquil", "sage")

foreach

Keyword

foreach item in source [ body ] | foreach item in source
  body
end

Examples

foreach n in [1, 2, 3]
  println(n)
end

forget

Function

forget(relation, args...)

Examples

forget("likes", "alice", "bob")

grounding("likes", "alice", "bob")  # "unknown"

forget_cascade

Function

forget_cascade(relation, args...)

Examples

disturbed(P) <~~ judges_bad(P)

assert judges_bad("novice")

forget_cascade("judges_bad", "novice")   # the disturbance lifts too

formally

Keyword

format

Function

format(format, args...)

Examples

format("%.2f", 1/3)        # "0.33"  (≡ stringf)

println(format("%x", 255)) # the Lua print(string.format(...)) idiom

formed_by

Keyword

concept C { formed_by: "mode", purpose: "...", examples: [...], counterexamples: [...] }

Examples

concept Adult { formed_by: "stipulation", boundary: age >= 18 and is Person }

concepts_formed_by("stipulation")

grounding("isa", alice, Adult)  # "axiom"

formula?

Function

forward

Keyword

fourth

Function

framed_qua

Function

framed_qua(relation, args..., handle)

Examples

departed("estate") qua "lost"

framed_qua("departed", "estate", "lost")        # true

framed_qua("departed", "estate", "given_back")  # false

framings_of

Function

framings_of(relation_name, arg1, arg2, ...)

Examples

framings_of("departed", "estate")

free_denotes

Function

free_exists

Function

free_logic_model

Function

frege_classic_example

Function

frege_classic_example(example_type)

Examples

modus_ponens: frege_classic_example("modus_ponens")

universal_inst: frege_classic_example("universal_instantiation")

identity: frege_classic_example("identity")  # a = a

frege_conditional

Function

frege_conditional(antecedent, consequent)

Examples

p_implies_q: frege_conditional(p, q)  # P → Q

print(frege_format(p_implies_q))  # Shows spatial layout

modus_ponens: frege_conditional(and_pq, q)  # ((P ∧ Q) → Q)

frege_content

Function

frege_content(formula, negated)

Examples

p: frege_content("P", false)  # Positive content

not_p: frege_content("P", true)  # Negated content

complex: frege_content("Human(x)", false)  # Predicate content

frege_format

Function

frege_format(frege_object)

Examples

print(frege_format(judgment))  # Display: ⊢—— "P"

print(frege_format(conditional))  # Spatial conditional layout

print(frege_format(universal))  # Quantification with concavity

frege_formula

Function

frege_formula(root, description)

Examples

formula: frege_formula(conditional, "Modus Ponens Structure")

complex: frege_formula(universal_conditional, "Universal Implication")

print(frege_format(formula))  # Display complete spatial layout

frege_function_app

Function

frege_function_app(function, argument, function_type, argument_type)

Examples

human_socrates: frege_function_app(human, socrates, "predicate", "object")

equals_5_plus_3: frege_function_app(equals_5, plus_3, "concept", "function")

print(frege_format(human_socrates))  # Function application display

frege_judgment

Function

frege_judgment(content, context)

Examples

judgment: frege_judgment(p, "Assertion of P")  # ⊢P

print(frege_format(judgment))  # Display: ⊢—— "P"

complex_judgment: frege_judgment(forall_x, "Universal statement")

frege_negation

Function

frege_negation(content)

Examples

not_p: frege_negation(p)  # ¬P

print(frege_format(not_p))  # Display: —|— "P"

double_neg: frege_negation(frege_negation(p))  # ¬¬P

frege_quantification

Function

frege_quantification(variable, quantifier, scope, content)

Examples

forall_x: frege_quantification("x", "universal", "object", px)  # ∀x P(x)

exists_y: frege_quantification("y", "existential", "object", qy)  # ∃y Q(y)

print(frege_format(forall_x))  # Display: —⌒— "P(x)" with x below

frege_to_modern

Function

frege_to_modern(frege_object)

Examples

modern: frege_to_modern(conditional)  # Convert P→Q to modern notation

if modern.Success then print(modern.Converted)  # Show modern form

print(modern.Mappings)  # Educational correspondence explanations

frequencies

Function

from

Keyword

from_base

Function

from_data

Function

from_json

Function

from_option

Function

from_result

Function

fu

Keyword

fullform

Function

fullform(expression)

Examples

fullform(2 + 3)            # → "+(2, 3)"

fullform([1, 2, 3])        # array literal AST

fullform(if x then y else z)

h: hold(2 + 3); fullform(h)  # unwraps held AST → "+(2, 3)"

fun

Keyword

func

Keyword

func [name](params) [body]  OR  name: func(params) [body]  OR  name(params) = expr

Examples

func double(x) [ x * 2 ]       # Named declaration

double: func(x) [ x * 2 ]      # Anonymous assignment form

double(x) = 2 * x              # Equation form (textbook/Julia style)

fact(0) = 1                    # Patterned equations accumulate as clauses

fact(n) = n * fact(n - 1)

function

Keyword

function?

Function

functions

Function

functions() | functions(Integer) | functions("Integer")

Examples

functions(Integer)         # every Integer-relevant builtin, sorted

functions("String")        # same catalog by name

"divmod" in set(functions(Integer))   # → true

functions()                # the cataloged type names

fuzzy_and

Function

fuzzy_category_membership

Function

fuzzy_from_prototype

Function

fuzzy_not

Function

fuzzy_or

Function

fuzzy_set

Function

g3_and

Function

g3_dne

Function

g3_false

Symbol

g3_implies

Function

g3_lem

Function

g3_not

Function

g3_or

Function

g3_true

Symbol

g3_unknown

Symbol

game

Function

gap

Symbol

gcd

Function

gcd(a, b)

ge

Symbol

gen_drop

Function

gen_next

Function

gen_take

Function

gen_take(n, stream)

Examples

squares: (x * x | x <- [1..10])

gen_take(3, squares)  # [1, 4, 9]

generalize

Keyword

generate

Keyword

generics

Language

func[T](x :: T) :: T [x]; name[T] :: T -> T

Examples

keep: func[T](x :: T, y :: T) :: T [x]
keep(1, 2)

echo[T] :: T -> T
echo: x => x
echo(7)

gensym

Function

gensym() or gensym(prefix)

Examples

gensym()        # "G__0"

gensym("var")  # "var__1"

geq

Symbol

geqslant

Symbol

get

Function

get_beliefs

Function

get_concepts

Function

get_dl_instances

Function

get_non_denoting

Function

get_option

Function

get_role_fillers

Function

get_superclasses

Function

get_word?

Function

getalias

Function

gfalse

Symbol

given

Keyword

given NAME = value   (RETIRED August 2026)

Examples

given G = 5      # ERROR: `given` was retired

let G = 5        # immutable binding (the migration)

const G = 5      # top-level named constant (the migration)

global

Keyword

global NAME = value   |   global NAME   then NAME = value

Examples

total = 0
function addall(t)
  for x in t
    global total = total + x
  end
  total
end

global ratio :: Float = 3   # converts; the cell is Float

glut

Symbol

glyph

Function

glyph(name)

Examples

glyph("union")       # Returns ∪

glyph("cup")         # Returns ∪ (LaTeX alias)

glyph("therefore")   # Returns ∴

glyph("U+222A")      # Returns ∪ (by codepoint)

glyph("alpha")       # Returns α (Greek letters included)

godel?

Function

godel_decode

Function

godel_encode

Function

godel_encode(source_string)

Examples

g: godel_encode("2 + 3")

godel_decode(g)   # "2 + 3"

is_godel(g)       # true

godel_value

Function

graph

AI Function

graph(node1, node2, node3, ...)

Examples

graph("A", "B", "C", "D")

graph(1, 2, 3, 4, 5)

graphform

Function

graphform(relation[, format])

Examples

relation edge(x, y)

assert edge("a", "b")

graphform(edge)              # ASCII adjacency

graphform(edge, "dot")       # Graphviz DOT

graphform(edge, "cg")        # Sowa CG: [a]→(edge)→[b]

graphform(edge, "png")       # writes PNG, returns path

graphform(edge, "svg")       # writes SVG (scalable)

greater

Function

greater(x, y)

Examples

greater(5, 3)  # Returns true

greater(2, 7)  # Returns false

forall x,y in Numbers: greater(x, y) or greater(y, x) or equal(x, y)

greater_equal

Symbol

grounding

Function

grounding(relation, args...)

Examples

axiom parent("john", "mary")

grounding("parent", "john", "mary")     # "axiom"

grandparent(X, Z) <== parent(X, Y) and parent(Y, Z)

grounding("grandparent", "john", "ann")  # "theorem"

group_by

Function

group_by(fn, collection)

groupby

Function

gtrue

Symbol

gunknown

Symbol

gödelValue

Function

had

Keyword

ConceptName had propertyName

Examples

Person had tempProperty

Stock had oldField

has

Keyword

ConceptName has property[:: Type][: value][, property[:: Type][: value], …]

Examples

Person has name

Stock has price

Stock has price: 150, ticker: "AAPL"

Economy has revenue :: Float, expenses :: Float: 2

Vehicle has speed

has_key

Function

has_meaning

Function

has_meaning(assertion, verifier)

Examples

v: verifier("glass_check", func() [intuit3("true")])

has_meaning("glass-1 contains water", v)

diagnose("glass-1 contains water").verdict  # "meaningful"

has_role

Function

hasalias

Function

hash_word?

Function

having

Keyword

hd

Function

hd(s, [n])

head

Function

hex

Function

hex(n)

hex_to_bytes

Function

hiding

Keyword

import * hiding NAME, ... from "path.ax"

Examples

import * hiding sqrt, abs from "lib/math.ax"

how

Keyword

how conclusion_expression

Examples

how grandparent("a", "c")   # Show derivation steps

how risk_level("stock")      # Explain calculation

how treatment("patient")     # Show treatment logic

hybrid_reasoning

Function

hypothesis

Keyword

ident

Function

identical

Keyword

identified

Keyword

identifier?

Function

identity

Function

identity(x)

idiv

Operator

a idiv b | idiv(a, b)

Examples

7 idiv 2           # Returns 3

idiv(7, 2)         # Returns 3

-7 idiv 3          # Returns -3   (floor, toward -inf)

10.0 idiv 3.0      # Returns 3.0

if

Keyword

if condition then consequence [else alternative] | cond ? a : b | expr if condition (postfix modifier) | head(Args) if body (rule clause) | name(args) = expr, if cond

Examples

if x > 5 then "big" else "small"

x > 5 ? "big" : "small"           # ternary, same AST

if age >= 18 then "adult"

cancel(d) if challenged(d)          # postfix conditional

path(X, Y) if edge(X, Y)            # rule clause ≡ path(X, Y) whenever edge(X, Y)

path(X, Y) if edge(X, Z) and path(Z, Y)

whichsign(n) = "Positive", if n > 0  # Miranda equation guard ≡ when

if_expr

Function

if_expr?

Function

iff

Operator

expression1 iff expression2

Examples

true iff true

x > 5 iff y > 5

im

Value

imag

Function

imag(z)

image

Function

impl

Keyword

impl …

implements

Keyword

concept Name implements Interface1, Interface2 [{ ... }]

Examples

concept Duck implements Flyable, Swimmable { }

concept GameObject implements Drawable, Moveable

concept Bird extends Animal implements Flyable { }

Duck is Flyable              # Interface membership query

implies

Operator

expression1 implies expression2

Examples

raining implies wet

x > 5 implies x > 0

implode

Function

implode(chars)

import

Keyword

import "path.ax" | import NAME [as ALIAS], ... from "path.ax" | import * [hiding NAME, ...] from "path.ax"

Examples

import "lib/math.ax"

import "lib/math.ax" as Math

import "./sib.ax" as Sib

import sqrt as root, pi from "lib/math.ax"

import * hiding sqrt, abs from "lib/math.ax"

impossibly

Keyword

in

Operator

element in collection  |  | name in collection => body

Examples

3 in {1, 2, 3}

"apple" in fruits

match n with | n in 1..9 => n | _ => none

in_prototype

Function

include

Keyword

include "path.ax" | include NAME, ... from "path.ax" | include * [hiding NAME, ...] from "path.ax"

Examples

include "./Core.ax"

include shown from "./base.ax"

index_of

Function

index_of(collection, target, [init])

index_of_option

Function

indexed

Accessor

xs.indexed | xs's indexed | xs.enumerated

Examples

[10, 20].indexed          # [(1, 10), (2, 20)]

(3..1).indexed            # [(1, 3), (2, 2), (3, 1)]

for i, f in fruits.indexed [ println(i, f) ]

induction

Keyword

inductive

Keyword

inexact?

Function

inexact?(x)

infer

Keyword

infer_subsumption

Function

Inference Engine

Concept

Forward-chaining rule-based reasoning system

Examples

# Define relation-store rules

relation edge(x, y)

assert edge("a", "b")

assert edge("b", "c")

rule path(X, Y) :- edge(X, Y)

rule path(X, Y) :- edge(X, Z) and path(Z, Y)



# Trigger inference

deduce                      # Fires all rules to a fixpoint (3 facts here)

{(X, Y) | (X, Y) <- path(X, Y)}   # Materialized transitive closure



# Named rule (operator form)

rule Mortality: mortal(X) <== human(X)

inferred

Function

inferred(fn)

Examples

raw(x) = x * 2

inferred(raw)            # → Integer -> Integer

annotations(raw)         # → none

infinite?

Function

infinite_set

Function

infinity

Keyword

infinity?

Function

infix

Function

infix_expr?

Function

inherits

Keyword

input

Function

input(prompt_string)

Examples

name: input("Your name? ")

input_number

Function

input_password

Function

input_password([prompt])

insert

Function

insert(relation, args..., [grounding])

Examples

insert("likes", "alice", "bob")

insert("likes", "bob", "carol", "postulate")

insert_at

Function

insert_at(array, value)  |  insert_at(array, position, value)

Examples

a: [10, 20, 30]

insert_at(a, 40)     # [10, 20, 30, 40]

insert_at(a, 2, 15)  # [10, 15, 20, 30, 40]

inspect

Keyword

instanceof

Function

int

Function

int(x)

integer

Function

integer(x)

integer?

Function

integers

Value

integral?

Function

integral?(x)

interactive?

Function

interpolate

Function

interpolate_path

Function

interpret_tanru

Function

intersect

Operator

set1 intersect set2

Examples

{1, 2, 3} intersect {2, 3, 4}

primes intersect evens

intersection

Symbol

intuit3

Function

intuit3("true" | "false" | "unknown") — or the literals ⊤ⁱ ⊥ⁱ ?ⁱ

Examples

p: ?ⁱ                           # ≡ intuit3("unknown")

p implies p                     # → ⊤ⁱ (reflexive — the intuitionistic signature)

not p                           # → ⊥ⁱ (G3 collapses unknown; K3 keeps it)

p == ⊤ⁱ                         # → false (Boolean equality — NOT the biconditional)

p iff p                         # → ⊤ⁱ (the biconditional's proper home)

g3_dne(?ⁱ)                      # → ?ⁱ — ¬¬P → P is NOT a G3 tautology

designated(g3_lem(?ⁱ))          # → false — LEM fails as an inference

intuitionistic_model

Function

inv

Function

inverse

Function

invert_mapping

Function

is

Keyword

subject is predicate | x is same as y | x is identical to y | there is x

Examples

sky is blue          # Predication

x is same as y       # Identity (sameness)

x is identical to y  # Identity (strict)

there is king        # Existence

isActive

Function

isGödel

Function

isValidProof

Function

is_absent

Function

is_all

Function

all?(predicate, collection)

is_alnum

Function

is_alpha

Function

is_any

Function

any?(predicate, collection)

is_array

Function

is_ascii

Function

is_assignment_stmt

Function

is_ast

Function

is_ast_has

Function

is_bind_stmt

Function

is_block

Function

is_boolean

Function

is_builtin

Function

is_call_expr

Function

is_cd_primitive

Function

is_char_alphabetic

Function

is_char_numeric

Function

is_char_whitespace

Function

is_cnf

Function

is_cognitive_word

Function

is_complex

Function

is_concept

Function

is_control

Function

is_date

Function

is_datetime

Function

is_dialect

Function

is_digit

Function

is_dl_consistent

Function

is_dl_instance

Function

is_dnf

Function

is_duration

Function

is_email

Function

is_empty

Function

is_epistem

Function

is_epistem(value)

Examples

relation parent(x, y)

f: axiom parent("john", "mary")

is_epistem(f)  # true

epistem?(42)   # false

is_eq

Function

is_eql

Function

is_equal

Function

is_eqv

Function

is_err

Function

is_error

Function

is_even

Function

even?(n)

is_exact

Function

exact?(x)

is_exists

Function

is_expr_stmt

Function

is_file

Function

is_finite

Function

is_float

Function

is_formula

Function

is_function

Function

is_get_word

Function

is_godel

Function

is_hash_word

Function

is_identifier

Function

is_if_expr

Function

is_inexact

Function

inexact?(x)

is_infinite

Function

is_infinity

Function

is_infix_expr

Function

is_integer

Function

is_integer(x)

Examples

is_integer(42)   # Returns true

integer?(3.14)   # Returns false

is_integral

Function

integral?(x)

is_interactive

Function

is_left

Function

is_let_stmt

Function

is_letter

Function

is_list

Function

is_lower

Function

is_minus

Function

is_module

Function

is_money

Function

is_nan

Function

is_negative

Function

is_none

Function

is_nsm_prime

Function

is_null

Function

is_number

Function

is_object

Function

is_odd

Function

odd?(n)

is_ok

Function

is_om

Function

is_pair

Function

is_partitioned

Function

is_partitioned(Concept)

Examples

Thing partition UpToUs, NotUpToUs

is_partitioned(Thing)

is_percent

Function

is_phrase

Function

is_plus

Function

is_positive

Function

is_prime

Function

is_prime(n)

Examples

is_prime(7)   # Returns true

is_prime(4)   # Returns false

prime?(17)    # Returns true

is_procedure

Function

is_program

Function

is_proposition

Function

is_punct

Function

is_rational

Function

is_reference

Function

is_right

Function

is_satisfiable

Function

is_satisfiable(expr)

Examples

is_satisfiable(func(p, q) [p and q])           # true

is_satisfiable(func(p) [p and (not p)])        # false

is_satisfiable(func(p) [p iff (not p)])        # false — Russell core

is_set

Function

is_some

Function

is_space

Function

is_stack

Function

is_string

Function

is_subclass_of

Function

is_subsumed_by

Function

is_subtype_of

Function

is_subtype_of(a, b)

Examples

is_subtype_of(10374, 546)   # true — every human is animal

is_subtype_of(66, 546)      # false — no stone is animal

is_symbol

Function

is_tag

Function

is_tautology

Function

is_time

Function

is_tuple

Function

is_upper

Function

is_url

Function

is_word

Function

is_zero

Function

is_zero_sum

Function

isa

Operator

(retired May 2026) — write: instance is Concept

Examples

myDog is Dog          # Direct instance check

myDog is Animal       # Inheritance check (Dog extends Animal)

Duck is Flyable       # Concept implements interface

d is/same d           # Identity sense

isatty

Function

isqrt

Function

it

Keyword

items

Function

items(hash)

iterate

Function

iterate(fn, start [, count])

Examples

iterate(func(v) [v * 2], 1, 5)   # [1, 2, 4, 8, 16]

iterate(func(v) [v * 2], 1)      # <generator>

jaro_winkler

Function

join

Keyword

kestrel

Function

kestrel(value, ignored)

keys

Function

keys(hash)

keywords

Function

keywords() | keywords(word)

Examples

len(keywords())          # 200+ — the full sorted catalog

"everyone" in keywords() # Returns true  (reserved: KM NL surface)

keywords("everyone")     # Returns true  (1-arg reservation check)

keywords("banana")       # Returns false (free to use as a name)

$everyone: {"a", "b"}    # the guard frees a reserved spelling

kleene

Function

kleene("true" | "false" | "unknown") — or the literals ⊤ᵏ ⊥ᵏ ?ᵏ

Examples

ku: ?ᵏ                          # ≡ kleene("unknown") (also kleene(om))

?ᵏ and ⊤ᵏ                       # → ?ᵏ (typed results stay Kleene)

om and true                     # → Ω (the untyped K3 path, unchanged)

?ᵏ == om                        # → true (canonical equality)

if ?ᵏ then "t" else "f"         # → "f" — unknown is not designated

?ᵏ implies ?ᵏ                   # → ?ᵏ (K3 — contrast G3's reflexive ⊤ⁱ)

kleene_false

Symbol

kleene_true

Symbol

kleene_unknown

Symbol

klfalse

Symbol

kltrue

Symbol

klunknown

Symbol

knows

Epistemic Logic

agent knows proposition

Examples

Socrates knows true

Alice knows (2 + 2 == 4)

knowledge: Expert knows theorem

kripke_model

Function

lambda

Keyword

lambda (param1, param2, ...rest) => expression  |  lambda binder1 binder2 => expression (curried)

Examples

lambda x => x * 2

lambda (x, y) => x + y

lambda x y => x + y          # curried: call as f(1)(2)

lambda (a, ...rest) => [a, rest]

double: lambda x => x * 2

land

Symbol

last

Function

last(s)

laws_of_thought

Function

laws_of_thought()

Examples

laws_of_thought()

len(laws_of_thought())  # 4

layout_algorithms

Function

layout_description

Function

lazy

Keyword

lazy <expression>  |  name/lazy

Examples

t: lazy (6 * 7)        # nothing computed yet

force(t)               # 42 — computed now, and memoized

unless(test, body/lazy) = if not test then body

pick(false, lazy slow())   # slow() never runs if the branch is not taken

lcm

Function

lcm(a, b)

le

Symbol

least_common_subsumer

Function

left?

Function

left?(value)

leftarrow

Symbol

leftrightarrow

Symbol

leibniz_decode

Function

leibniz_decode(taxonomy, number)

Examples

leibniz_decode(porphyry, 42)   # substance → material → animate

leibniz_encode

Function

leibniz_encode(taxonomy, path)

Examples

h: leibniz_encode(porphyry, ["substance", "material", "animate", "sensitive", "rational"])

h.value   # 10374 = 2·3·7·13·19

len

Function

len(collection)

Examples

len([1, 2, 3])          # Returns 3

len("hello")            # Returns 5

len({1, 2, 3})          # Returns 3

len({"a": 1, "b": 2})   # Returns 2

[1, 2, 3].len        # Returns 3   (dot accessor — same name)

[1, 2, 3]'s len     # Returns 3   (possessive — same name)

length

Function

length(collection)

Examples

length([1, 2, 3])          # Returns 3

length("hello")            # Returns 5

length({1, 2, 3})          # Returns 3

length({"a": 1, "b": 2})   # Returns 2

[1, 2, 3].length        # Returns 3   (dot accessor — same name)

[1, 2, 3]'s length     # Returns 3   (possessive — same name)

leq

Symbol

leqslant

Symbol

less

Function

less(x, y)

Examples

less(3, 5)  # Returns true

less(7, 2)  # Returns false

exists x,y in Numbers: less(x, y) and greater(add(x, 1), y)

less_equal

Symbol

let

Keyword

let NAME [:: Type] [= value]

Examples

let x = 5

let d :: Date = today()

let a, b = 1, 2

let x = 5
x: 6   # ERROR: `let` bindings are immutable — use `var`

let_stmt

Function

let_stmt?

Function

letter?

Function

levenshtein

Function

lfalse

Symbol

lhalf

Symbol

linguistic_var

Function

list

Function

list() | list(collection)

Examples

l: `[1, 2, 3]

list([1, 2, 3])  # convert an existing Array

first(l)  # 1 — O(1)

rest(l)   # `[2, 3] — O(1) shared tail

list?

Function

ln

Function

ln(x)

ln10

Value

ln2

Value

lnot

Symbol

local

Keyword

local NAME [:: Type] [= value] | local (a, b) = pair

Examples

local count = 0
count += 1
println(count)

local ratio :: Float = 3
println(ratio)

log

Function

log(x)

log10

Function

log2

Function

log_component

Function

log_component() | log_component(name)

log_debug

Function

log_debug(message, [fields...])

log_debugf

Function

log_debugf(format, values...)

log_enabled

Function

log_enabled(level)

log_error

Function

log_error(message, [fields...])

log_errorf

Function

log_errorf(format, values...)

log_info

Function

log_info(message, [fields...])

log_infof

Function

log_infof(format, values...)

log_level

Function

log_level()

log_set_level

Function

log_set_level(level)

log_warn

Function

log_warn(message, [fields...])

log_warnf

Function

log_warnf(format, values...)

logger

Value

logically_equivalent

Function

logo_item

Function

loop

Keyword

loop count [ body ] | loop item <- source [ body ] | loop count
  body
end | loop
  body
until condition
end

Examples

loop 2
  println("again")
end

lor

Symbol

lower

Function

lower(s)

lower?

Function

lowercase

Function

lowercase(s)

lozenge

Symbol

lp

Function

ltrue

Symbol

lukasiewicz

Function

lukasiewicz(x) for x in [0, 1] — canonical points have literals ⊤ł ½ł ⊥ł

Examples

half: ½ł                        # ≡ lukasiewicz(0.5)

half and lukasiewicz(0.25)      # → 0.25ł (min)

half implies lukasiewicz(0.25)  # → 0.75ł (min(1, 1-0.5+0.25))

½ł and 0.8                      # → ½ł (raw numbers embed, clamped)

½ł == 0.5                       # → true (raw-value equality, no clamping)

lukasiewicz(0.73)               # constructor for non-canonical values

lukasiewicz_false

Symbol

lukasiewicz_half

Symbol

lukasiewicz_true

Symbol

luke

Function

luke …

macro

Keyword

macro name(args) expression

Examples

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

double(21)

macroexpand

Function

macroexpand(macro_call)

Examples

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

macroexpand(double(10))  # <AST: (10 * 2)>

mag

Function

mag(quantity)

Examples

mag(5 * kg)                  # 5

mag(as_unit(5 * kg, gram))   # 5000

make_accessible

Function

make_array

Function

make_boolean

Function

make_call

Function

make_expr

Function

make_float

Function

make_identifier

Function

make_if

Function

make_infix

Function

make_integer

Function

make_lambda

Function

make_prefix

Function

make_rebind

Function

make_sequence

Function

make_set

Function

make_string

Function

make_tuple

Function

man

REPL command

:man topic | :manual topic

manual

Function

manual | manual <n> | manual "7.2" | manual word | manual "words to find" | manual(...) | manual/raw …

Examples

manual                         # the chapters

manual 7                       # §7 Set Theory & Comprehensions, with its sections

manual "7.2"                   # one section in full

manual comprehension           # search: headings, then text with line references

manual("refinement")           # call form, identical

manual/raw "7.1"               # the markdown source, unrendered — for copying

map

Function

map(function, collection)

Examples

map(lambda x => x * 2, [1, 2, 3])   # Returns [2, 4, 6]

map(square, {1, 2, 3})              # Returns {1, 4, 9}

map_err

Function

map_ok

Function

map_prototype

Function

mapcat

Function

Markdown Documentation

Documentation

/**md ... */ comment blocks

Examples

/**md\n# Function: calculate\n## Purpose\nCalculates something important\n## Parameters\n- x: number\n## Returns\nResult value\n*/

/**md\n# Mathematical Formula\n$f(x) = x^2 + 1$\n## Cross-References\n- {@link otherFunction}\n- {@concept RelatedConcept}\n*/

/**md\n## Example Usage\n```axioma\nresult: calculate(5)\nprintln(result)\n```\n*/

markov_chain

Function

match

Keyword

match expr with | pattern [when guard] => body ...

Examples

match x with | 0 => "zero" | n when n > 0 => "positive" | _ => "negative"

match pair with (1, x, 3) => x | _ => 0

match [1, 2, 3] with | [1 | rest] => rest

match n with | 1..9 => "digit" | _ => "other"

match n with | n in xs => n | _ => none

match h with | {name, age} exactly => name | {name, ..rest} => rest

match pt with | P { x, ..rest } => rest

match_pattern

Function

matching_pennies

Function

matching_pennies()

materially

Keyword

mathbb{C}

Symbol

mathbb{N}

Symbol

mathbb{Q}

Symbol

mathbb{R}

Symbol

mathbb{Z}

Symbol

matrix

Function

matrix(rows) | matrix(flat_data, rows, columns)

max

Function

max(values...)

max_by

Function

may

Keyword

mean

Function

mean(data, [axis])

median

Function

median(data)

member

Function

member(collection, target)

membership

Function

memoize

Function

memoize(f)

Examples

fast: memoize(slow)

fast(9)     # computes

fast(9)     # cached — slow() is not called again

fast(4)     # a different argument computes once, then caches

menu

Function

metalogical

Keyword

methods

Function

methods(Integer) | methods("Integer") | methods()

Examples

methods(Integer)           # ≡ functions(Integer)

methods(type(5))           # the catalog for a value's type

middle_terms

Function

middle_terms(taxonomy, S, P)

Examples

middle_terms(porphyry, human, body)   # ["animal", "living"]

min

Function

min(values...)

min_by

Function

minus?

Function

mixed_strategy

Function

mod

Operator

number mod number

Examples

100 mod 7          # Returns 2

100 modulo 7       # Returns 2    (longhand)

100 % 7            # Returns 2    (symbolic equivalent)

6 * 5 mod 7        # Returns 2    (left-assoc with *)

mod(100, 7)        # Returns 2    (prefix builtin, keyword spelling)

remainder(100, 7)  # Returns 2    (prefix builtin, long spelling)

-23 mod 7          # Returns 5    (floor-mod: sign of the divisor)

mod(-23, 7)        # Returns 5    (the call agrees, by construction)

mod_inverse

Function

mod_inverse(a, m)

Examples

mod_inverse(3, 11)   # Returns 4

mod_inverse(4, 8)    # Returns none

modal_grade

Function

modal_grade(relation, args...)

Examples

axiom claim("bedrock")

modal_grade("claim", "bedrock")   # "apodictic"

modal_syllogism

Function

modal_syllogism(major, minor, conclusion [, "aristotelian"|"boolean"])

Examples

modal_syllogism(necessarily(every M is P), every S is M, necessarily(every S is P))   # LXL — valid (Aristotle)

modal_syllogism(every M is P, necessarily(every S is M), necessarily(every S is P))   # XLL — invalid (the asymmetry)

modal_syllogism(possibly(every M is P), possibly(every S is M), possibly(every S is P))   # possibility Barbara — valid

model

Keyword

[ model | expression1, expression2, ... ]

Examples

[ model |
  relation mortal(x)
  axiom mortal("socrates")
  human(X) <== mortal(X)
]

model_set

Function

model_system

Function

modern_to_frege

Function

modern_to_frege(modern_formula)

Examples

frege_form: modern_to_frege("A → B")  # Convert to Begriffsschrift

quantified: modern_to_frege("∀x P(x)")  # Convert quantification

print(frege_format(frege_form.Converted))  # Display Frege notation

module

Keyword

module?

Function

modules

Function

modules([filter])

modulo

Operator

number modulo number

Examples

100 modulo 7       # Returns 2

100 mod 7          # Returns 2    (short form)

100 % 7            # Returns 2    (symbolic)

mod(100, 7)        # Returns 2    (prefix builtin)

modus_ponens

Keyword

modus_tollens

Keyword

money

Function

money(amount, [currency])

money?

Function

most_probable

Function

mu

Symbol

multinomial

Function

multinomial([count1, count2, ...])

Examples

multinomial([1, 4, 4, 2])   # 34650 — MISSISSIPPI

multinomial([2, 1])         # 3 — AAB, ABA, BAA

multiply

Function

multiply(x, y) OR multiply(x, y, z)

Examples

multiply(4, 5)     # Returns 20 (function mode)

multiply(4, 5, 20) # Returns true (predicate mode)

multiply(3, 4, 10) # Returns false (predicate mode)

exists x,y in Numbers: multiply(x, y) == 12

must

Keyword

must_not

Keyword

mut

Keyword

let mut NAME = value | type P = struct mut {x:: Float} | type P = record mut {x:: Float}

Examples

let mut x = 5
x: 6

let mut (a, b) = pair

$mut: 99   # the name, guarded

mutable

Keyword

let mutable NAME = value | type P = struct mutable {x:: Float} | type P = record mutable {x:: Float}

Examples

let mutable x = 5
x: 6

nCr

Function

nPr

Function

na

Value

Naming Conventions

Concept

ConceptName (uppercase) | objectName (lowercase)

Examples

concept Person          # Concept (uppercase)

john: a Person { name: "John" }  # Object (lowercase)

concept Stock           # Valid concept name

apple: a Stock { price: 150 }         # Valid object name

nan?

Function

nand

Function

nand(p, q, ...) | nand(collection)   (glyph infix: p ⊼ q; digraphs `nand / `barwedge)

Examples

nand(true, true)     # → false

true ⊼ false         # → true (glyph infix)

(p ⊼ p) == (not p)   # ¬ from nand alone

nand(true, true, false)  # → true (n-ary)

nash_equilibrium

Function

natural_join

Function

naturals

Value

ndim

Function

ne

Symbol

nearest_prototype

Function

necessarily

Modal Logic

necessarily expression

Examples

necessarily true

necessarily (2 + 2 == 4)

logical_truth: necessarily (A implies A)

neg

Function

neg(callable) | neg(number)

Examples

neg(33)               # → -33

abs(neg(33))          # → 33      (Miranda §1.3.2)

neg(odd?)(4)          # → true    (the combinator)

neg(negate(42))       # → 42

negate

Function

negate(callable) | negate(number)

Examples

isEven: negate(odd?)   isEven(4)   # → true   (the combinator)

negate(3)              # → -3      (the arithmetic negation)

negate(-3/4)           # → 3/4     — exact, stays Rational

negate(2.5)            # → -2.5

negate(negate(42))     # → 42      — an involution

signum(negate(n)) == negate(signum(n))   # → true for every n

neg(33)                # → -33     (short / Miranda spelling)

negative

Function

negative?

Function

negative_middle_terms

Function

negative_middle_terms(taxonomy, S, P)

Examples

negative_middle_terms(porphyry, human, stone)

neighbors

AI Function

neighbors(graph, node_id)

Examples

neighbors(g, "A")

neighbors(graph, "node1")

neq

Symbol

new

Keyword

InstanceName: ConceptName new

Examples

myCar: Car new

myCar.brand = "Tesla"

next

Keyword

next_solution

Function

next_solution(stream)

ninth

Function

nip

Function

no

Keyword

noi

Reserved vocabulary

nominally

Keyword

nondenoting

Function

none

Keyword

none

Examples

x: none

none == om          # false

none is None        # true

None == none        # false

if none then 1 else 0   # 0

str(none)           # "none"

none?

Function

none?(predicate, collection)

nor

Function

nor(p, q, ...) | nor(collection)   (glyph infix: p ⊽ q; digraphs `nor / `barvee)

Examples

nor(false, false)    # → true

true ⊽ false         # → false (glyph infix)

nor([false, false, false])  # → true (Wittgenstein's N)

(p ⊽ p) == (not p)   # ¬ from nor alone

norm

Function

normal

Function

normalize

Function

normalize(s, [form])

Examples

normalize("e\u{301}") == "\u{E9}"     # true  (NFC composes; bare == was false)

count(normalize("e\u{301}"))          # 1     (was 2 codepoints)

normalize("\u{FB01}", "NFKC")         # "fi"  (compatibility fold)

normally

Keyword

not

Operator

not expression

Examples

not true

not (x > 5)

not in

Symbol

not_equal

Symbol

not_in

Symbol

nothing

Keyword

(retired August 2026) — write: none

Examples

x: none             # write this

none is None        # the type of none

notin

Symbol

nsm_all_languages

Function

nsm_applicable_rules

Function

nsm_categories

Function

nsm_check_structure

Function

nsm_expand

Function

nsm_find_similar

Function

nsm_grammar_rule

Function

nsm_grammar_rules

Function

nsm_mapped_primes

Function

nsm_prime

Function

nsm_prime?

Function

nsm_prime_for_primitive

Function

nsm_primes

Function

nsm_primes_by_category

Function

nsm_primitive_for

Function

nsm_primitives

Function

nsm_translate

Function

nsm_validate_explication

Function

nsm_validate_grammar

Function

nsm_validate_text

Function

nth

Function

nth(collection, position)

null

Keyword

(retired August 2026) — write: none

Examples

x: none             # write this

none is None        # the type of none

null?

Function

number?

Function

numer

Function

numerator

Function

numerator(q)

object?

Function

observed_by

Keyword

obverse

Function

obverse(categorical_proposition)

Examples

obverse(every human is animal)   # "no human is non-animal", equiv: true

oct

Function

odd

Function

odd?

Function

odd?(n)

of

Keyword

xs :: Array of T: values

Examples

xs :: Array of Integer: [1, 2]
other: xs
push(other, 3)
println(xs)

ok?

Function

ok?(value)

om

Symbol

om?

Function

omega

Symbol

ominus

Symbol

on

Function

on(binaryFn, keyFn)

Examples

longer: on(func(a, b) [a > b], func(s) [len(s)])

longer("abcd", "ab")                 # Returns true — compares by length

on(sub, func(s) [len(s)])("abcd", "ab")   # Returns 2

once

Keyword

once(goal)

ones

Function

operands

Function

operator

Keyword

operator (&&&) = minInt [with precedence: product associativity: left end]

Examples

minInt(x, y) = if x > y then y else x
operator (&&&) = minInt
println(8 &&& 3) # 3

minus(x, y) = x - y
operator (⊛) = minus with
  precedence: sum
  associativity: right
end
println(20 ⊛ 5 ⊛ 2) # 17

oplus

Symbol

or

Operator

expression1 or expression2

Examples

true or false

x < 0 or x > 100

or_else

Function

oracle

Function

oracle word | oracle "word" | oracle("word") | oracle/on | oracle/off | oracle/status (also oracle/on() …)

Examples

oracle ogabund                 # statement form — the roles a new word could take

oracle("ogabund")             # call form, identical

oracle msft                    # a known word: what it is and what you can ask

oracle/on                      # turn the hints on for the rest of this run (the -o flag's twin; oracle/off, oracle/status)

ord

Function

ord(char)

order_states

Function

orderby

Keyword

orelse

Operator

expression1 orelse expression2

Examples

1 < 2 orelse 3 > 4

i > len(xs) orelse xs[i] > 0

otherwise

Operator

expression otherwise fallback  |  name(pats) otherwise = body  |  func name(pats) otherwise [body]  |  name(pats) = body, otherwise

Examples

parse_int("xx") otherwise 0

func sign(n) when n > 0 [1]

func sign(n) otherwise [0]

sign(n) otherwise = 0

sign(n) = 0, otherwise

otimes

Symbol

ought

Deontic Logic

ought proposition

Examples

ought true

ought (help others)

duty: ought (tell the truth)

over

Function

pa

Keyword

pack

Function

pair

Function

pair(key, value)

pair?

Function

paraconsistent_model

Function

parameters

Function

parameters(fn)

Examples

parameters(func(a, b) [a + b])   # → ["a", "b"]

parameters(round)                # → ["x", "[digits]"]

parse

Function

parse(code, [mode])

parse_as

Function

parse_as(type, s, [base])

parse_grammar

Function

partOf

Keyword

partial

Function

partial(f, args...)

particularly

Keyword

partition

Keyword

Concept partition Part1, Part2, ...

Examples

Thing partition UpToUs, NotUpToUs

is_partitioned(Thing)        # true while disjoint + exhaustive

partition_member(opinion, Thing)

partition_gap

Function

partition_gap(Concept)

Examples

mystery: a Thing {}

partition_gap(Thing)  # {mystery}

partition_member

Function

partition_member(instance, Concept)

Examples

partition_member(opinion, Thing) == UpToUs  # true

partition_overlap

Function

partition_overlap(Concept)

Examples

partition_overlap(Thing)  # {} when disjoint

partitions_of

Function

partitions_of(Concept)

Examples

partitions_of(Thing)

partOf

Keyword

parts

Function

pattern

Keyword

pause

Function

pause() | pause(seconds)

payoff_matrix

Function

peek

Function

peek(stack)

Examples

s: stack()

push(s, 10)

peek(s)  # 10 (stack remains [10])

percent

Function

percent(number)

percent?

Function

permitted

Deontic Logic

permitted proposition

Examples

permitted true

permitted (take a break)

allowable: permitted action

permutations

Function

permutations(n, k)

Examples

permutations(5, 2)   # Returns 20

perp

Symbol

phi

Value

phrase?

Function

pi

Value

pick

Function

pipe

Function

pipe(value, f, g, ...)

Examples

pipe(5, double, incr)     # Returns 11

5 |> double |> incr       # Returns 11 — the operator form

pipe(5, double, incr) == compose(double, incr)(5)   # true

pipe_try

Function

plus?

Function

poi

Reserved vocabulary

polar

Function

pop

Function

pop(stack | array)

Examples

s: stack()

push(s, 10)

pop(s)  # 10

a: [1, 2, 3]

pop(a)  # 3 — a is now [1, 2]

porphyry_categories

Function

porphyry_examples

Function

positive

Function

positive?

Function

possibly

Modal Logic

possibly expression

Examples

possibly false

possibly (tomorrow will rain)

contingent: possibly P and possibly not P

posterior

Function

postulate

Keyword

postulate fact(args...)

Examples

relation parent(x, y)

postulate parent("mary", "ann")

grounding("parent", "mary", "ann")  # "postulate"

postulates

Keyword

pow

Function

pow_mod

Function

pow_mod(base, exp, mod)

Examples

pow_mod(2, 10, 1000)   # Returns 24

powerset

Function

powerset(set)

powmod

Function

powmod(base, exp, mod)

Examples

powmod(2, 10, 1000)   # Returns 24

pred

Function

pred(x)

predicate

Keyword

predicates_of_term

Function

predicates_of_term(taxonomy, S)

Examples

predicates_of_term(porphyry, human)   # [animal, living, body, substance]

subjects_of_term(porphyry, "animal")  # [rational, human, irrational, beast, ...]

presupposes

Keyword

prime?

Function

prime?(n)

Examples

prime?(17)    # Returns true

print

Function

print(expression)

Examples

print("Hello, World!")

print(42)

print(person's name)

printf

Function

printf(format, args...)

Examples

printf("%05d|%6.2f\n", 42, 3.14159)   # 00042|  3.14

printf("%d\n", 35.0)                   # 35 (integral Float converts)

println

Function

println(values...)

prisoners_dilemma

Function

prisoners_dilemma()

prob_and

Function

prob_logic_kb

Function

prob_not

Function

prob_or

Function

probably

Keyword

procedure?

Function

prod

Function

prod(collection)

Examples

prod([1, 2, 3, 4])   # Returns 24

prod({2, 3, 5})      # Returns 30

product

Function

product(collection)

Examples

product([1, 2, 3])   # Returns 6

program

Function

program?

Function

project

Function

prompt

Function

proof

Function

proof(relation, args...)

Examples

mortal(X) <== human(X)

axiom human("socrates")

proof("mortal", "socrates")

proof_certify

Function

proof_certify_lines

Function

proof_certify_lines(steps, catalog)

proof_conclusion

Function

proof_hyps

Function

proof_is_theorem

Function

proof_is_theorem(value)

proper subset

Symbol

proper superset

Symbol

proper_subset

Symbol

proper_superset

Symbol

properties

Function

properties(x)

proposition?

Function

proprium

Keyword

prototype

Function

prototype(conceptSet)

Examples

prototype({Dog, Cat, Animal})       # Returns Dog

prototype({Bird, Robin, Eagle})     # Most typical bird

best: prototype(vehicles)      # Find best example

prototype_membership

Function

prototypes_of

Function

provable

Function

prove

Keyword

prove goal_expression  |  prove f   (f a contracted function)

Examples

prove mortal("socrates")     # Detailed proof attempt

prove ancestor(X, "alice")   # Find all ancestors of alice

contract inc { requires: x > 0, ensures: result > x }

prove inc                    # ⊤ᵇ — discharged for EVERY x, no sampling

v: prove inc                 # the verdict as a value (the check f twin)

proveIncompleteness

Function

prune

Keyword

p(X) :- q(X), prune, r(X)

pset

Function

pseudo_concept

Function

pseudo_concept(C)

Examples

concept GhostHunter

pseudo_concept(GhostHunter)  # true — bare label only

concept Stock

aapl: a Stock {}

pseudo_concept(Stock)        # false — has an instance

pseudo_statements

Function

pseudo_statements()

Examples

insert("likes", "alice", "bob")

pseudo_statements()  # includes unverified assertion strings

punct?

Function

push

Function

push(stack | array, value)

Examples

s: stack()

push(s, 42)

a: [1, 2]

push(a, 3)  # a is now [1, 2, 3]

puts

Function

qdup

Function

qed

Symbol

ql

Function

ql_decide

Function

ql_eval

Function

qr

Function

qty

Function

qty(magnitude, unit)

Examples

qty(5, kg)

qty(9.8, metre / sec^2)

qty(1, "kg*m/s^2")

qua

Operator

fact qua "handle"

Examples

departed("estate") qua "lost"

departed("estate") qua "given_back"

quasiquote

Keyword

quasiquote(expression)

Examples

y: 10

quasiquote(1 + unquote(y) * z)  # AST for 1 + 10 * z

quay

Reserved vocabulary

query

Keyword

query goal_expression

Examples

query mortal("socrates")     # Test specific fact

query human(X)               # Find all humans

query parent("john", Child)  # Find john's children

query grandparent(GP, GC)    # Find all grandparent pairs

query_fol

Function

query_prob

Function

query_prob_conditional

Function

qui

Reserved vocabulary

quote

Keyword

quote(expr)   |   quote <token>

Examples

quote(1 + 2)                  # Lisp form — returns AST node

quote(map(func(n) [n * 2], xs))

quote concept                 # Aristotle, Kant, Frege, Schopenhauer

quote isa                     # IS-A etymology (the isa spelling is retired — the copula is `is`)

quote +                       # Widmann 1489, Peano, Frege

quote lambda                  # Church 1936

quote ∀                       # Gentzen 1935

quote "law of excluded middle"   # string-key for multi-word

quotient

Function

a quotient b | quotient(a, b)

Examples

8 quotient 7       # Returns 1    (infix, same as 8 div 7)

quotient(100, 7)   # Returns 14   (prefix)

quotient(-7, 3)    # Returns -3   (floor, toward -inf — not -2)

div(-7, 3)         # Returns -3   (prefix form of the div keyword)

100 ÷ 7            # Returns 14   (glyph form)

100 div 7          # Returns 14   (infix keyword form)

quotient(100, 0)   # ERROR: quotient by zero

quu

Reserved vocabulary

rad

Function

rad(x)

Examples

rad(180)      # Returns pi

sin(rad(90))  # Returns 1

raise

Function

raise(x)

Examples

raise("printdots: negative input")

try(raise("x"))

rand_matrix

Function

random

Function

random() | random(n) | random(m, n)

Examples

random()        # Float in [0, 1)

random(6)       # die roll: Integer in 1..6

random(10, 20)  # Integer in 10..20 inclusive

random_seed

Function

random_seed(n) | random_seed()

Examples

random_seed(42)       # deterministic stream; returns 42

s: random_seed()      # entropy; s is the replayable seed

range

Function

range(stop) or range(start, stop[, step])

Examples

range(5)                 # 1..5

array(range(5))          # [1, 2, 3, 4, 5]

array(range(1, 10, 2))   # [1, 3, 5, 7, 9]

array(range(5, 1, -1))   # [5, 4, 3, 2, 1]

range(1, 5) == 1..5      # true

ranges

Keyword

rank

Function

rational

Function

rational(numerator, denominator)

rational?

Function

rationals

Value

rclear

Function

rdepth

Function

rdiv

Operator

a rdiv b | rdiv(a, b)

Examples

1 rdiv 8           # Returns 1/8

rdiv(1, 8)         # Returns 1/8

8 rdiv 2           # Returns 4     (whole quotient stays Integer)

1.0 rdiv 8.0       # Returns 0.125 (Float, same as /)

re

Keyword

read

Function

read_boolean

Function

read_boolean()

Examples

ok: read_boolean()

read_byte

Function

read_byte()

Examples

b: read_byte()

read_bytes

Function