This directory contains a formalization of Peano arithmetic and basic number theory in Twelf, including definitions, proofs of fundamental properties, and statements of advanced theorems.

Quick Start

Loading All Files

Using the Twelf server interactively:

twelf-server

Then at the Twelf prompt:

loadFile nat.elf
loadFile add.elf
loadFile mult.elf
loadFile exp.elf
loadFile order.elf
loadFile div.elf
loadFile prime.elf
loadFile theorems.elf

Or load all files at once with a script:

twelf-server <<'EOF'
loadFile nat.elf
loadFile add.elf
loadFile mult.elf
loadFile exp.elf
loadFile order.elf
loadFile div.elf
loadFile prime.elf
loadFile theorems.elf
EOF

Running Computations

Once files are loaded, you can compute with %solve:

%solve _ : add (s (s z)) (s (s (s z))) N.   -- 2 + 3 = ?
%solve _ : mult (s (s z)) (s (s (s z))) N.  -- 2 * 3 = ?
%solve _ : exp (s (s z)) (s (s (s z))) N.   -- 2^3 = ?
%solve _ : factorial (s (s (s (s z)))) N.   -- 4! = ?

File Structure

Files must be loaded in order due to dependencies:

File	Description	Dependencies
`nat.elf`	Natural numbers (Peano axioms), equality	none
`add.elf`	Addition, commutativity, associativity	nat.elf
`mult.elf`	Multiplication, basic properties	nat.elf, add.elf
`exp.elf`	Exponentiation	nat.elf, add.elf, mult.elf
`order.elf`	Less-than, less-equal, trichotomy	nat.elf
`div.elf`	Divisibility, GCD, division with remainder	nat.elf, add.elf, mult.elf, order.elf
`prime.elf`	Primes, factorial, prime factorization	all above
`theorems.elf`	Computational tests, theorem summary	all above
`sources.cfg`	Configuration file for batch loading	-

Definitions

Natural Numbers (`nat.elf`)

nat : type.
z : nat.              -- zero
s : nat -> nat.       -- successor

Numbers: z = 0, s z = 1, s (s z) = 2, etc.

Abbreviations: one, two, three, four, five

Addition (`add.elf`)

add : nat -> nat -> nat -> type.
add/z : add z N N.                        -- 0 + N = N
add/s : add (s M) N (s P) <- add M N P.   -- (1+M) + N = 1 + (M + N)

Multiplication (`mult.elf`)

mult : nat -> nat -> nat -> type.
mult/z : mult z N z.                              -- 0 * N = 0
mult/s : mult (s M) N R <- mult M N P <- add N P R.  -- (1+M) * N = N + M*N

Exponentiation (`exp.elf`)

exp : nat -> nat -> nat -> type.
exp/z : exp N z (s z).                            -- N^0 = 1
exp/s : exp N (s M) R <- exp N M P <- mult N P R. -- N^(1+M) = N * N^M

Ordering (`order.elf`)

lt : nat -> nat -> type.   -- less than
lt/z : lt z (s N).                      -- 0 < 1+N
lt/s : lt (s M) (s N) <- lt M N.        -- M < N implies 1+M < 1+N

le : nat -> nat -> type.   -- less than or equal
le/z : le z N.                          -- 0 <= N
le/s : le (s M) (s N) <- le M N.        -- M <= N implies 1+M <= 1+N

Divisibility (`div.elf`)

divides : nat -> nat -> type.
divides/intro : divides D N <- mult D K N.  -- D | N iff N = D * K for some K

Primes (`prime.elf`)

prime : nat -> type.
prime/two   : prime (s (s z)).         -- 2 is prime
prime/three : prime (s (s (s z))).     -- 3 is prime
prime/five  : prime (s (s (s (s (s z))))).  -- 5 is prime
prime/seven : prime (s (s (s (s (s (s (s z))))))).  -- 7 is prime

Verified Theorems

These theorems have complete proofs checked by Twelf's totality checker (%total):

Addition Properties

add-total: Addition always produces a result
add-comm: M + N = N + M (commutativity)
add-assoc: (A + B) + C = A + (B + C) (associativity)
add-right-z: N + 0 = N (right identity)
add-right-s: M + (S N) = S(M + N)
add-cancel-left: A + B = A + C implies B = C (left cancellation)
add-func: Addition is deterministic

Multiplication Properties

mult-total: Multiplication always produces a result
mult-right-z: N * 0 = 0
mult-left-one: 1 * N = N
mult-right-one: N * 1 = N

Exponentiation Properties

exp-total: Exponentiation always produces a result
exp-one: N^1 = N
exp-base-one: 1^N = 1
exp-base-zero: 0^(S N) = 0

Order Properties

le-refl: N <= N (reflexivity)
le-trans: A <= B and B <= C implies A <= C (transitivity)
le-antisym: A <= B and B <= A implies A = B (antisymmetry)
lt-trans: A < B and B < C implies A < C
trichotomy-total: For all M, N: exactly one of M < N, M = N, M > N

Divisibility Properties

one-divides: 1 | N for all N
divides-zero: N | 0 for all N
divides-refl: N | N for all N

Factorial

factorial-total: Factorial always produces a result

Theorems Stated But Not Fully Proven

The following theorems are stated with proof sketches but require additional infrastructure:

Multiplication Commutativity

mult-comm: M * N = N * M
Requires the mult-right-s lemma (M * (S N) = M + M * N)

Distributivity

mult-distrib-left: A * (B + C) = AB + AC
Provable by induction on A

Multiplication Associativity

mult-assoc: (A * B) * C = A * (B * C)
Requires distributivity

Number Theory

has-prime-divisor-total: Every N > 1 has a prime divisor
infinitude-of-primes: For any prime P, there exists a prime Q > P
euclid-lemma: If P is prime and P | AB, then P | A or P | B
fundamental-theorem-existence: Every N > 1 has a prime factorization
fundamental-theorem-uniqueness: Prime factorization is unique up to ordering

How Twelf Proofs Work

Twelf uses the "judgments as types" methodology. A theorem is represented as a type family, and its proof is a term of that type.

Example: Addition Commutativity

add-comm : add M N P -> add N M P -> type.
%mode add-comm +D1 -D2.

This declares that add-comm takes a derivation D1 showing add M N P and produces a derivation D2 showing add N M P.

The %mode declaration specifies that D1 is an input (+) and D2 is an output (-).

Totality Checking

%worlds () (add-comm _ _).
%total D (add-comm D _).

%worlds () declares the proof works in the empty world (no hypothetical assumptions)
%total D (add-comm D _) verifies the proof terminates and covers all cases, with recursion on D

Understanding the Output

When you run %solve, Twelf shows the derivation tree:

%solve _ : add two three N.

Output:

add (s (s z)) (s (s (s z))) (s (s (s (s (s z)))))
   = add/s (add/s add/z).

This shows:

The result: 2 + 3 = 5
The proof: apply add/s twice, then add/z

Extending This Formalization

Adding New Theorems

Identify what lemmas are needed
Define the theorem type with appropriate mode
Write cases for each constructor
Add %worlds and %total declarations

Common Patterns

Induction on a natural number:

my-theorem : {N:nat} ... -> type.
%mode my-theorem +N ...
my-theorem/z : my-theorem z ...
my-theorem/s : my-theorem (s N) ... <- my-theorem N ...
%worlds () (my-theorem _ _).
%total N (my-theorem N _).

Induction on a derivation:

my-theorem : some-relation A B -> another-relation A B -> type.
%mode my-theorem +D1 -D2.
my-theorem/case1 : my-theorem some-relation/c1 another-relation/c1.
my-theorem/case2 : my-theorem (some-relation/c2 D) (another-relation/c2 D')
                    <- my-theorem D D'.
%worlds () (my-theorem _ _).
%total D (my-theorem D _).

References

Twelf Wiki
Twelf User's Guide
Harper & Licata, "Mechanizing Metatheory in a Logical Framework"

README.md

Peano Arithmetic in Twelf