Abstract Mathematics: Peano Axioms

Abstract Foundations of Mathematics: From Peano Axioms to Set Theory

Mathematics has evolved from intuitive observations of reality to rigorous abstract systems. Peano's axiomatics and set theory allow numbers to be defined without reference to the physical world, resolving paradoxes of infinity through formal logic.

Paradoxes of Infinity and the Birth of Analysis

Ancient thinkers grappled with problems of infinite processes, such as Zeno's paradox of Achilles and the tortoise. Logic suggests infinite division of distance without reaching the goal. Mathematical analysis resolved this by showing that an infinite sum of finite intervals can yield a finite time. However, analysis relied on vague infinitesimal quantities that did not fit into the algebra of real numbers.

This spurred a restructuring of foundations: from empirical rules to axiomatic systems independent of reality.

Peano Axioms: Numbers as a Chain of Succession

Giuseppe Peano introduced a minimal system for natural numbers in the late 19th century. Basic elements:

• Zero as the starting number: 0.
• A successor function S(...), where S(n) is the number following n.

Numbers are defined recursively:

1 := S(0)
2 := S(1) = S(S(0))
3 := S(2) = S(S(S(0)))
4 := S(3) = S(S(S(S(0))))

Addition is defined by two rules:

a + 0 := a  (rule 1)
a + S(b) := S(a + b)  (rule 2)

Computing 2 + 2:

• 2 + 2 = 2 + S(1) (by definition of 2).
• 2 + S(1) = S(2 + 1) (rule 2).
• 2 + 1 = 2 + S(0).
• 2 + S(0) = S(2 + 0).
• 2 + 0 = 2 (rule 1).
• S(2) = 3, then S(3) = 4.

Thus, 2 + 2 = 4 is derived purely formally, without intuition.

For demonstration in programming, a linked list is used to mimic the chain:

#include <stdio.h>

struct number { char* label; struct number* next; }
  five  = { "5", NULL },   four = { "4", &five }, three = { "3", &four },
  two   = { "2", &three }, one  = { "1", &two },  zero  = { "0", &one };

struct number* succ(struct number* num) { return num->next; }

struct number* pred(struct number* num) {
  struct number* ret = &zero;
  while (succ(ret) != num) ret = succ(ret);
  return ret;
}

struct number* add_numbers(struct number* num_a, struct number* num_b) {
  if (num_b == &zero) return num_a;
  return succ(add_numbers(num_a, pred(num_b)));
}

int main() {
  printf("2 + 3 = %s\n", add_numbers(&two, &three)->label);
}

This implementation recursively applies Peano's rules, modeling arithmetic without predefined integers.

Set Theory: Ordinals from Emptiness

To handle infinity, Zermelo-Fraenkel set theory is used. Numbers are constructed as sets:

• 0 := {} (empty set).
• 1 := {0} = {{}}.
• 2 := {0, 1} = { {}, {{}} }.
• 3 := {0, 1, 2}.
• 4 := {0, 1, 2, 3}.

Successor function: S(n) := n ∪ {n}. Each ordinal is the set of all previous ones, avoiding self-reference.

This approach visualizes structure: the nesting of sets reflects order.

S(n) := n ∪ {n}

Comparison of Approaches and Applications

| Aspect | Peano Axioms | Set Theory |

|--------|--------------|-----------------|

| Base | Zero and S | Empty set |

| Numbers | Successor labels | Nested sets |

| Addition | Recursive rules | Union |

| Infinity | Limited | Supports ordinals |

Peano axioms are a minimal model for proofs, akin to a Turing machine in computer science. Set theory underpins modern mathematics, including Gödel's theorems.

Key points:

• Abstract systems allow properties to be proven without physical interpretation.
• Paradoxes like Zeno's are resolved by limits but require rigorous foundations.
• Recursive definition of operations simplifies induction and recursion.
• Ordinals model infinite sequences of natural numbers.
• Such constructions are critical for formal software verification and logic.

Significance for Developers

In computer science, axiomatic numbers are used in typed languages and proof systems (Coq, Agda). Linked lists in C demonstrate how formal mathematics is implemented in code, avoiding assumptions about data types.

— Editorial Team