Appendix: Operators

This appendix covers all operators in the Kleis language. For built-in functions, see Built-in Functions. For numerical linear algebra, see LAPACK Functions.

Arithmetic Operators

Comparison Operators

Logical Operators

Note: All Unicode variants for implication (→, ⇒, ⟹) and the ASCII -> are equivalent. All Unicode variants for biconditional (↔, ⇔, ⟺) are equivalent.

Postfix Operators

Prefix Operators

Big Operators (v0.95)

Kleis supports big operator syntax for summations, products, integrals, and limits:

Examples

// Sum from i=1 to n
Σ(1, n, i^2)

// Product from k=1 to 5
Π(1, 5, k)

// Integral from 0 to 1
∫(0, 1, x^2, x)

// Limit as x approaches 0
lim(x, 0, sin(x)/x)

Custom Mathematical Operators

Kleis recognizes many Unicode mathematical symbols as infix binary operators. These can be used directly in expressions like a • b.

Complete Operator Table

These operators are syntactic only — they are parsed as infix operators but have no built-in semantics. They remain symbolic: 2 • 3 evaluates to •(2, 3), not a number.

These operators cannot be used for computation. Kleis does not connect • to any function — u • v will always stay symbolic as •(u, v).

To compute, use a named function instead: define dot(u, v) and call it directly. The • operator is only useful for notation in axioms.

Important: These operators do NOT compute values. 2 • 3 returns •(2, 3) symbolically. To give them meaning, define functions and use those instead.

What They Actually Do

These operators are parsed but stay symbolic:

λ> :eval 2 • 3
✅ •(2, 3)      ← NOT computed to 6!

λ> :eval A ⊗ B
✅ ⊗(A, B)      ← stays symbolic

When to Use Them

Use these operators in axioms and symbolic expressions where you want readable mathematical notation:

structure VectorSpace(V) {
    // Use • for notation in axioms
    axiom symmetric : ∀(u : V)(v : V). u • v = v • u
    axiom bilinear : ∀(a : ℝ)(u : V)(v : V). (a * u) • v = a * (u • v)
}

For Actual Computation

If you need operators that compute values, use:

1. Built-in operators: +, -, *, /, ^
2. Function calls: dot(u, v), tensor(A, B), union(s1, s2)

// These compute actual values:
define sum = 2 + 3           // → 5
define product = times(4, 5)  // → 20

// These stay symbolic (for axioms):
define symbolic = a • b      // → •(a, b)

Type Operators

Precedence Table

From lowest to highest precedence:

Examples

Arithmetic Precedence

define ex1 = 2 + 3 * 4        // 14 (not 20)
define ex2 = (2 + 3) * 4      // 20
define ex3 = 2 ^ 3 ^ 2        // 512 (= 2^9, right associative)
define neg_sq(x) = -x^2       // -(x^2), not (-x)^2

Logical Precedence

define logic1(P, Q, R) = P ∧ Q ∨ R        // (P ∧ Q) ∨ R
define logic2(P, Q, R) = P → Q → R        // P → (Q → R)
define logic3(P, Q) = ¬P ∧ Q              // (¬P) ∧ Q

Postfix with Power

n!^2        // (n!)^2 - factorial first, then square
Aᵀᵀ         // (Aᵀ)ᵀ = A - transpose twice

Type Expressions

ℝ → ℝ → ℝ        // ℝ → (ℝ → ℝ) (curried binary function)
(ℝ → ℝ) → ℝ      // Higher-order: takes function, returns value
ℝ × ℝ → ℝ        // Takes pair, returns value

See Also

• Built-in Functions - List, string, matrix operations
• LAPACK Functions - Numerical linear algebra
• Complex Numbers - Complex number operations