2026-08-31 A Brief Introduction to OxCaml Modes

Having recently read through the paper on OxCaml, the basic idea of modes as qualifiers on types was simple enough to grasp. A mode is a combination of three axes of qualifiers that determine how many times a value can be used, if a value has only reference to it and if a value can live beyond the region it is defined in. It’s only after working through the paper by writing snippets of code and poking at the type system did that rules become clear. This is the first of two-part post on the paper, so hopefully reading it is a good introduction to OxCaml’s type system, a topic for the post after this.

This entire post is a markdown file with pieces of code interspersed with explanatory comments. Some of these pieces are as presented in the paper or their slightly modified versions while others have been generated with the help Claude. All code presented here have been tested with OxCaml compiler versions 5.2 and 5.4.

Uniqueness #

The paper describes a unique value as one which the type system guarantees to have only one reference and hence a memory location at which that value can be replaced by a new one. Section 2.1 shows the following example:

type 'a list = Nil | Cons of { hd : 'a; tl : 'a list }

let rec rev_append xs acc =
  match xs with
  | Nil -> acc
  | Cons x_xs ->
    let tl = x_xs.tl in
    rev_append tl (Cons (overwrite_ x_xs with { tl = acc }))

let reverse xs = rev_append xs Nil

Both 5.2 and 5.4 failed to compile the above. For OxCaml 5.2, the error is:

Error: The overwriting extension is disabled
       To enable it, pass the '-extension overwriting' flag

Alert Translcore: Overwrite not implemented.
Fatal error: exception File "parsing/location.ml", line 1124, characters 2-8: Assertion failed

In 5.4:

Alert Translcore: Overwrite not implemented.
>> Fatal error: Location.todo_overwrite_not_implemented
Fatal error: exception Misc.Fatal_error

If it had been/When it is implemented, overwrite_ should replace the list in the tl of each Cons record with Nil (at the start of the rev_append function) or the reversed Cons record accumulated so far, thus reusing the same memory location for x_xs rather than a new allocation. This can only be possible when the xs is unique; being overwritten does not affect any other value in the program.

Parts of Unique types #

A pair type is defined as follows:

# type ('a, 'b) pair = { fst : 'a; snd : 'b };;
type ('a, 'b) pair = { fst : 'a; snd : 'b; }

The keyword unique is used to mark types as unique. Now how would a pair type marked with the unique mode behave? Let’s look at the following snippet:

let process_unique_pair (pair @ unique) =
  let x @unique = pair.fst in
  let y @unique = pair.fst in

  let repair @unique = {fst = y ; snd = x} in
                                        ^
  This value is used here, but it is already being used as unique

  let x @unique = repair.fst in
  let y @unique = repair.snd in

  Printf.printf "x = %d, y = %d \\n" x y


let _ = process_unique_pair {fst = 5; snd = 8}

The OxCaml type checker reports an error (indicated by ^ above). The first y is a binding storing a reference to a unique value. In creating the repair record, fst = y uses up the unique value pair.fst. At snd = x, the type-checker figures out that x also refers to the same unique value and responds that a unique value or reference cannot be used up twice. Now if we were to replace the first y binding as:

let process_unique_pair (pair @ unique) =
  let x @unique = pair.fst in
  let y @unique = pair.snd in

  let repair @unique = {fst = y ; snd = x} in

  let x @unique = repair.fst in
  let y @unique = repair.snd in

  Printf.printf "x = %d, y = %d \\n" x y

let _ = process_unique_pair {fst = 5; snd = 8}

x = 8, y = 5

Now there are no complaints from the type-checker. The first x and y are bindings to unique values and used to construct a new unique record (a fresh allocation in memory) so here we have repair as a unique value with fields containing references to distinct unique values. The second set of x and y bindings shadow the first and flipped values get printed at the end.

Adding a second record construction without unique modes on the first as:

let process_unique_pair (pair @ unique) =
  let x @unique = pair.fst in
  let y @unique = pair.snd in

  let repair = {fst = y ; snd = x} in

  let x = repair.fst in
  let y = repair.fst in

  let repair' = {fst = x ; snd = y} in
                                 ^
  This value is used here, but it is already being used as unique

  let x @ unique = repair'.fst in
  let y @ unique = repair'.fst in

  Printf.printf "x = %d, y = %d total: %d \\n" x y (x + y)

let _ = process_unique_pair {fst = 5; snd = 8}

The type-checker complains that in constructing repair', y is being reused even though both repair and y = repair.fst are not marked as unique. Starting from the pair @ unique type input to process_unique_pair, the type-checker traces that repair.fst is pair.snd, a unique value, and the second set of x and y are two different bindings referring to one unique value and so cannot be reused to construct repair'.

Uniqueness of a list #

The return type of the rev_append function is annotated with unique. The function reverses the list by consing elements starting with an empty list.

# let rec rev_append xs acc : _ list @ unique =
    match xs with
    | [] -> acc
    | (x :: rest) -> rev_append rest (x :: acc);;
val rev_append : 'a list @ unique -> 'a list @ unique -> 'a list @ unique =
  <fun>

# let rev_list @ unique = rev_append [4;6;8;2;19] [];;
val rev_list : int list = [19; 2; 8; 6; 4]

Aliased parts of a unique pair #

The mode that marks a value as not unique is @aliased and shown in the following snippet:

# let process_parts_aliased (pair @ unique) =
    let x @aliased = pair.fst in
    let y @aliased = pair.fst in
    Printf.printf "Aliased: x = %d, y = %d\\n" x y

  let _ = process_parts_aliased {fst = 5; snd = 8}

  Aliased: x = 5, y = 5\n

The same unique value has been assigned to two different variables x and y, both marked as aliased meaning values which may have more than one reference. x and y both refer to pair.fst which is unique. But a sub-moding relation between aliased and unique allows unique values to be used as aliased which makes pair.fst not unique within the function and permits two references to it.

Taking an earlier example, repair’s fst field is used to create two unique values:

let process_unique_pair (pair @ unique) =
  let x @unique = pair.fst in
  let y @unique = pair.snd in

  let repair @unique = {fst = y ; snd = x} in

  let x @unique = repair.fst in
  let y @unique = repair.fst in

  Printf.printf "x = %d, y = %d total = %d \\n" x y (x + y)

let _ = process_unique_pair {fst = 5; snd = 8}

x = 8, y = 8 total = 16

The second set of x and y end up as bindings to the same unique value. Why does then this piece pass the type-checker? The only explanation is that the second set of x and y are being used as aliased values.

When types are not explicitly marked unique, they are marked as aliased by default. In the piece below,x, y, z and z' are treated as aliased values as:

let process_parts_pair (pair @ unique) =
  let x = pair.fst in
  let y = pair.snd in

  let z =  x in
  let z' = y in

  Printf.printf "Test: x = %d, y = %d\\n" x y;
  Printf.printf "Test: z = %d, z' = %d\\n" z z'

let _ = process_parts_pair {fst = 11; snd = 22}

x = 11, y = 22\n
z = 11, z' = 22\n

Both z and z' are references t aliased values x and y. So using x and y twice, once directly in the first printf statement and the second time via z, z' is possible. Modifying the function into:

let process_parts_pair (pair @ unique) =
  let x = pair.fst in
  let y = pair.snd in

  let z = x in
  let z' = y in

  process_unique_pair pair;

  Printf.printf "Test: x = %d, y = %d\\n" x y;
                                            ^
  Error: This value is used here,
       but it is part of a value that has already been used as unique

  Printf.printf "Test: x = %d, y = %d\\n" z z'

let _ = process_parts_pair {fst = 11; snd = 22}

The type error comes up because after process_unique_pair is called using the unique input pair, the unique components of pair, pair.fst and pair.fst are used. The type-checker determines that the components of a unique value has already been used and the associated aliased references, x, y referring to those same unique values cannot be used.

Affinity for Closures #

Closures are ubiquitous in functional programming. They are functions that capture values from the lexical region around them. Capturing a value stores it in the closure.

let with_unrestricted_closures =
  let xs : int list @ unique = [1;2;3;4;5] in
  let f = fun zs -> rev_append xs zs in
  let ys @ unique = f [6] in
  let zs @ unique = f [7] in

 print_endline "";
 List.iter (fun x -> Printf.printf "%d " x) ys;

 print_endline "";
 List.iter (fun x -> Printf.printf "%d " x) zs

Error: This value is used here,
       but it is defined as once and has already been used:
File "...", line 9, characters 20-21:
9 |   let ys @ unique = f [6] in

In with_unrestricted_closure, closure f captures a value of list @unique type and returns a unique reversed list. The two calls to f mean using the same unique value twice. The error is pointing to the inferred mode for f which is @once:

  let f @ once = fun zs -> rev_append xs zs in ...

The type-checker is hinting that closures that capture unique values can only be called @once. The mode determining the number of times a function or closure can be called is called affinity. An affine value can be called at most once.

# let with_restricted_closure =
    let xs_1: int list @ unique = [1;2;3;4;5] in
    let xs_2 : int list @ unique = [1;2;3;4;5] in
    let f = fun ls -> rev_append xs_1 ls in
    let ys = f [6] in
    Printf.printf "\\n";
    List.iter (fun x -> Printf.printf "%d " x) ys;
    let g @ once = fun ls -> rev_append xs_2 ls in
    let zs = g [7] in
    Printf.printf "\\n";
    List.iter (fun x -> Printf.printf "%d " x) zs;;

5 4 3 2 1 6
5 4 3 2 1 7

with_restricted_closure works by giving each closure (f, g) its own unique list to capture; g is marked with @ once to make explicit that it may only be called only one time.

The paper makes the following statements:

Unlike with uniqueness, affinity cannot be forgotten. Uniqueness is a statement about the past (a value has not been aliased); it is safe to forget this detail. In contrast, affinity is a statement about the future (a value cannot be aliased); forgetting it could potentially make memory reuse observable

A value that is currently unique only has one reference and using it as an aliased value does not affect it’s underlying mode. A value’s affinity is a guarantee about how it will be used in the future.

The sub-moding for affinity is many < once i.e. values or types marked many can be used once but a once value can never be used many times. With unique < aliased, the unique value can “forget” its uniqueness and be used as a value with possibly more than one reference. But a once affinity can never be forgotten because if it were, the sub-moding relation would be once < many - closures that capture unique values could be called repeatedly thus clashing with the restriction on the reuse of unique values.

A list type with aliased elements #

The paper defines modes as deep wherein the elements constituting type with a mode also have that same mode. But if this restriction were to be eased up, then for example, an'a list can give the list itself and its elements different modes.

# type 'a list_with_aliased_elts =
    Nil
    | Cons of { hd : 'a @@ aliased;
                tl : 'a list_with_aliased_elts };;

type 'a list_with_aliased_elts =
    Nil
  | Cons of { hd : 'a @@ aliased; tl : 'a list_with_aliased_elts; }

a_list_with_aliased_elts type marks hd with the @@ aliased field modality. The list itself can be @ unique while each element is @ aliased

The paper describes a type:

val graph_nodes : graph -> node aliased list @ unique

Fleshing out this type and related code is very helpful in seeing how a unique list with aliased nodes can result.

NOTE: The OxCaml Stdlib provides a Modes.Aliased.t wrapper that pins a value to aliased mode. Wrapping the element type lets us use a plain 'a list (and standard functions List.map/List.iter) instead of a custom type.

module Aliased : sig
  type 'a t = { aliased : 'a @@ aliased } [@@unboxed]
end

In the type definition above, the [@@unboxed] attribute tells the compiler to not put the type in a box or allocate a separate block on the heap to store the type. By definition, this is only possible for types which have only one constructor with one argument or a record with one field.

type node = { id : int;
              mutable neighbors : int list }

type graph = { nodes : node array }

let graph_nodes (g : graph) : node Modes.Aliased.t list @ unique =
  let rec loop i =
    if i >= Array.length g.nodes
    then []
    else
      { Modes.Aliased.aliased = g.nodes.(i) } :: loop (i + 1)
  in
  loop 0

let () =
  let g =
     { nodes =
        [| { id = 1; neighbors = [ 2; 3 ] }
         ; { id = 2; neighbors = [ 1 ; 3; 4] }
         ; { id = 3; neighbors = [ 1; 2; 4] }
         ; { id = 4; neighbors = [ 2 ; 3] }
        |]
    }
  in
  let ns @ unique = graph_nodes g in
  List.iter (fun (w : node Modes.Aliased.t) ->
      Printf.printf "\\n node: %d " w.aliased.id) ns;
      Printf.printf "\\n graph still has %d nodes\\n" (Array.length g.nodes)

Here the node type is annotated with Modes.Aliased.t. The unique list resulting from calling graph_nodes is itself unique even when it contains aliased nodes. Iterating through the list does not use up its values.

let rev_graph_nodes graph =
  let aliased_nodes @ unique = graph_nodes graph in
  let nodes : int list @ aliased =
     List.map (fun (w : node Modes.Aliased.t) -> w.aliased.id) aliased_nodes in
  let rev_nodes = List.rev nodes in
    Printf.printf "Nodes for the reversed graph:\\n";
    List.iter (fun x -> Printf.printf "%d " x) rev_nodes

let () =
  let g =
    { nodes =
        [| { id = 1; neighbors = [ 2; 3 ] }
         ; { id = 2; neighbors = [ 1 ; 3; 4] }
         ; { id = 3; neighbors = [ 1; 2; 4] }
         ; { id = 4; neighbors = [ 2 ; 3] }
        |]
    }
  in
  rev_graph_nodes g

With aliased_nodes as the @unique input, the nodes function maps the ids of aliased nodes and returns a list that is aliased because a list that does not contain explicitly unique values is aliased. This is a reversal of how unique values can be used as aliased or a unique constructor can contain individually aliased values. But a list constructed by iterating over a list of unique values cannot be unique itself.

Locality #

Another mode specification is locality which constrains values from leaving a region. The definition of a region is OCaml is important to understand before moving on.

Functional languages such as Haskell have a function named main that is the function from which execution begins. In OCaml, there is no such restriction. OCaml programs are laid out as a sequence of let bindings with those at the first or top level of the file being global bindings and others being local to the function within which they are defined.

The body of a function (created by a let binding) is a region. Creating the following function results in:

let bad () = let xs @ local = [1;2;3] in xs

Error: This value is "local"
       but is expected to be "local" to the parent region or "global"
       because it is a function return value.
       Hint: Use exclave_ to return a local value.

let xs @ local = creates a local region. All values should remain within it but here, the list escapes to the outer region for the bad () function.

Rewriting the above removes the type error:

# let rec length_local (xs : 'a list @ local) : int =
    match xs with
    | [] -> 0
    | _ :: tl -> 1 + length_local tl;;
val length_local : 'a list @ local -> int = <fun>

# let good () = let xs : int list @local = [1;2;3] in
        let n = length_local xs in n;;
val good : unit -> int = <fun>

(Note: In 5.2 and 5.4, List.length is not mode-polymorphic (val length : 'a list -> int, no @ local), so it can’t take a local list at all. This is why the length_local function has been added).

Borrowing and a sneaky attempt #

Taking the idea from the Rust programming language, the borrow_ constructor is used to write a borrow function where a unique value is copied locally, passed to f and a tuple result with the original unique value and the result of the local copy of x applied to f. Since the borrow creates a local value, after f returns or the region of the let result = f (borrow_ (x : 'a @ local)) function no longer exists, only one reference to the x : 'a unique remains.

The &x in the paper apparently stands for the actual borrow_ construct.

type 'a global = { g : 'a @@ global }
type 'a aliased = { a : 'a @@ aliased }

let borrow x f = let result = f (borrow_ (x : 'a @ local))
      in (x : 'a @ unique), { a = result }

let sneaky : int list @ unique -> (int list * int list aliased) @ unique =
  fun xs ->
    let global_xs : int list global @ unique = { g = xs } in
    let { g = ys}, { a = ys' } =
      borrow global_xs (fun { g = xs' } -> xs') in
    ys, { a = ys' }

The provided snippet does not type check for 5.2 but does return the following error for 5.4:

Error: This value is aliased
         because it is the field g (with some modality) of the record at file "sneaky.ml", line 10, characters 8-18.
       However, the highlighted expression is expected to be unique
         because it is an element of the tuple at file "sneaky.ml", line 12, characters 4-19
         which is expected to be unique.

xs is a unique value. The borrow construct copies xs to ys. The field g is global (the global before the @unique) and so aliased by definition. This means it is not guaranteed to be unique, even though the entire record is marked as unique. Since the value of g cannot be both unique and aliased, the error crops up.

Modes #

All of the examples shown until now involve modes where a mode μ is a triple (a,u,l) with an affinity a, a uniqueness u and a locality l.

(modes)         μ ::= (a, u, l)
(affinities)    a ::= many | once
(uniquenesses)  u ::= unique | aliased
(localities)    l ::= global | local

Each mode axis has an order among its two constituent elements with:

many < once unique < aliased global < local

When a mode element μ ≤ μ', a term at modeμ can always be used where μ' is expected but never the other way around. This relation had been described as sub-moding and has already been used to construct correct code in the examples shown in the previous sections.

The paper describes modes are ordered pointwise i.e. the entire mode is determined by the triple made up of combining the determined order of three axes. For μ ≤ μ' to be valid, the conjunction of a ≤ a' and u ≤ u' and l ≤ l' must be valid.

Some type-qualifier systems (like Walker’s) attach qualifiers to every type, including value types nested inside pairs and records. A working version of such a system with linear types is documented here. Such systems needs additional checks (see containment_check at the above link) to make sure that side conditions in rules for type formation with qualified types are met.

OxCaml’s calculus adds qualifiers only to computation types. Since value types do not have any qualifiers or modes, in order to modify parts of data structures to have a mode different from the mode for the entire structure - an aliased field inside an otherwiseunique record for example — the calculus introduces a box type □^ν τ to represent the modality ν. Taking the box as the structure with a mode, the mode of the box’s content along one or more axes is described by modalities acting on mode triples to describe or determine these axes.

The three modalities A, M and G are:

A(a, u, l) = (a, aliased, l)
M(a, u, l) = (many, u, l)
G(a, u, l) = (a, aliased, global)

The A or (@@aliased) modality forces uniqueness to aliased. The M or (@@many) forces affinity to many and the G modality forces both uniqueness to aliased and locality to global. In the borrow construct, in order to copy a unique value to a local value, it is imperative to ensure that the value to be copied cannot be global as a 'a global makes the value silently default to aliased. In sneaky, xs is deliberately wrapped in the ’a global type before being borrowed and that is why it fails.

In OxCaml syntax, all three modalities show up as @@-tagged, [@@unboxed] wrapper records — the same shapes already used earlier in this post:

type 'a aliased = { a : 'a @@ aliased } [@@unboxed]
type 'a many    = { m : 'a @@ many }    [@@unboxed]
type 'a global  = { g : 'a @@ global }  [@@unboxed]

The [@@unboxed] attribute used when defining a type has zero allocation at runtime since each type, 'a aliased, 'a many, 'a global is a record with exactly one field, a narrower case from the definition described in the graph_nodes section.

§3.2 Syntax #

Let’s go over the syntax of the mode calculus.

Contexts are ordered lists of bindings, each binding either giving a variable a type and mode, or marking it unusable once it’s been consumed (Γ, x : −):

Γ ::= ∅ | Γ, x : − | Γ, x : τ @ μ

Types consist of the unit type, sums, products, the box type from §3.1, a function type that records the mode of both its argument and its result (τ @ μ → τ @ μ), and a type for space credits, ♣, for in-place memory reuse:

τ ::= 1 | τ + τ | τ × τ | □^ν τ | τ @ μ → τ @ μ | ♣

The expression language is:

e ::= x | ()
      | inl e | inr e | (e, e)
      | λx. e | e e
      | let x = e in e
      | box_ν e | unbox_ν e
      | let (x, y, z) = e in e
      | case e { inl x → e; inr y → e }
      | reuse e in (e, e)
      | borrow x = e for y = e in e

x, (), inl e, inr e, (e, e), λx. e, e e, let x = e in e, case e { inl x → e; inr y → e } are standard functional programming syntax for variables, unit and pairs, abstractions, applications, let bindings and pattern matching via case. box_ν e introduces the modality ν in e and unbox_ν eliminates the same from e.

let (x, y, z) = e in e destructures a pair e into y and z and hands back the pair’s own space credit x. If the allocation for x is unique, it can be later spent by reuse x in (e, e) to allocate a fresh pair without a new allocation. borrow x = e1 for y = e2 in e3 is the formal core behind the borrow/borrow_ constructs used in earlier examples. The paper doesn’t give stack-allocated regions their own separate syntax at all; a region is just borrow _ = () for y = e1 in e2 with e1 bound in a fresh region denoted by e2.

Acknowledgements and the Next Post: Type rules and Inference #

I hope this write-up has been a gradual and easy introduction to modes in OxCaml. For cleaning up text, generating code pieces and checking the final draft for errors, Claude’s help was very useful.

I hope to have the next post on the OxCaml type system and type inference up soon.

2026-08-01 Bounds for Ordered Sets

The essential idea from the previous post on orders is that comparing the elements of a set gives rise to relations between them and adding a “sense” (a measure that quantifies the relation mathematically) to the relation allows for the ordering of elements within the set. Taking only those ordered sets where elements can be related to themselves (irreflexive) and where not every element is related to another in the set (partial), taking subsets of such posets and checking if any notable properties emerge from them is interesting exercise, so let’s start there.

Subsets of ordered sets #

Take a subset $Y$ of an partially ordered set $X$ with relation $R$ on it. In $X$ :

• a lower bound is an element $x$ where $x R y, \forall y \in Y$ (x bounds Y from below)
• an upper bound is an element $x$ where $y R x, \forall y \in Y$ (x bounds Y from above)

The set of all lower bounds is defined as:

and the set of all upper bounds as:

(the set of all values in X that bound the subset Y from above)

Note that all of these arises from nothing more than taking a subset of the original partially set and using the relation $R$ to relate members of the original set $X$ and the subsets $Y$ . Because $X$ is an ordered set using a binary relation $R$ , the sets of bounds are also ordered in two directions - lower and upper.

When the set of upper bounds Y$^u$ has a least element, it is the least upper bound of $Y$ which is given by $x$ :

$$(\forall x' \in X [((\forall y \in Y) y R x' \iff x R x')])$$

Considering the dual, the set of lower bounds Y$^l$ has a greatest element or the greatest lower bound and is given by $x$ :

$$(\forall x' \in X [((\forall y \in Y) x' R y \iff x' R x)])$$

In literature, the least upper bound is the supremum (written as sup $Y$ ) of the subset $Y$ and the greatest lower bound is the infimum of Y
(written as inf $Y$ )

Important points to note are:

• A set Y need not have a supremum or an infimum.

  • E.g. Let X = {a, b, c, d} be a poset with:

    $R = \{a, c\}, \{a, d\}, \{b, c\}, \{b, d\}$ (neither c R d nor d R c holds).

  Take Y = {a, b}. To calculate the set of upper bounds for Y, $x \in X$ must be $y R x$ i.e. for each $y \in Y$ :

  y	relation	x
  a	a R c	c
  a	a R d	d
  b	b R c	c
  b	b R d	d

  S^u = {c, d}

  To get only one element out of $S^u$ requires a comparision between c and d but since R does not hold for both, there’s no least element or supremum in {c, d}.

• A supremum or an infimum, if either exist, are always unique. Looking at the definition above, if x and x’ are both upper bounds in $X$ , then we must have $x R x'$ and $x' R x$ which is only possible when x’ = x in a poset (the antisymmetry property).

• The supremum or the infimum of a set may or may not belong to the set itself.

  • The closed interval [0, 1] of reals has a sup of 1 which is contained in the set itself.
  • The open interval (0, 1) of reals again has a sup of 1 but this is not contained within the set {0,1}.

An poset X has a bottom element if there exists $\bot \in X$ (called bottom) with the property that $\bot R x$ for all x $\in X$ . The dual element in X is a top element which if exists is defined as $x R \top$ for all $x \in x$ . For the set of upper bounds Y$^u$ , the least upper bound or supremum $= \top$ and the set of lower bounds Y$_u$ , the greatest lower bound or infimum $= \bot$ .

Lattices #

So far, the definitions of subsets of posets have meant any subset of a poset $X$ . Now if the definition were to narrowed down to every two-element (or doubleton) subset of $X$ , then a structure called a lattice emerges from $X$ only if:

• $\forall x, y \in X$ , the least upper bound exists. This is called a join and denoted by $x \vee y$
• $\forall x, y \in X$ , the greatest upper bound exists. This is called a meet and denoted by $x \wedge y$

A poset $X$ is a join-semilattice (or upper-semilattice) in which $\forall x, y \in X$ , $x \vee y$ exists. The dual holds for meet-s semilattices (lower-semilattices) i.e. $\forall x, y \in X$ , $x \wedge y$ .

For a subsets $S \subseteq X$ :

• $\bigvee S$ is the least upper bound or join of subset $S$
• $\bigwedge S$ is the greatest lower bound or meet of subset $S$

If both $\bigvee S$ , $\bigwedge S$ exist for all $S \subseteq X$ , the $X$ is a complete lattice.

Filters #

A principal filter or principal up-set on a poset $X$ generated by an element $y$ is defined as:

$$\uparrow y = \{ z \in X | y R z \}$$

$\uparrow y$ is everything in the poset that is “at” or “above” y (at because y R y by definition).

The set of upper bounds of two element set, $\{x, y\}^{u} is given by$ y$ since x R y, nothing “below” $Y$ can be an upper bound. Since the least element of $\uparrow y$ is y, $x \vee y = y$ .

A principal down-set on a poset $X$ generated by an element $z$ is defined as:

$$\downarrow x = \{ z \in X | x R z \}$$

$\downarrow x$ is everything in the poset that is “at” or “below” x (at because again x R x by definition).

The set of lower bounds of two element set, $\{x, y\}^{l}$ is given by $\downarrow x$ as nothing “below” x can be a lower bound. Since the least element of $x is x, $x \wedge x = x$ .

Hasse diagrams #

This far, diagrams for definitions have shown abstract versions of posets, their subsets, upper/lower bounds. One representation of specific posets are Hasse diagrams. A Hasse diagram for a poset $X$ with $x, y \in X$ is done as follows:

1. Each $x \in X$ is represented by a small circle.
2. For each pair x $\lessdot$ y (y covers x i.e. y immediately succeeds x when ordered using $R$ ), a line from x to y is drawn
3. 1. and 2. must adhere to the following:
   • when x $R$ y, the circle depicting x is lower than the one
     depicting y
   • the lines joining circles may cross each other but the circles depicting elements much never intersect lines.

This Hasse diagram is a representation of poset $X = \{(a, d), (b, e), (b, d), (b, f), (c, f), (c, g), (d, h), (e, h), (e, i), (f, i), (g, i)\}$

Moving upward from an circle depicting an element shows the transitive relations e.g. b R e R h $\implies$ b R h. Elements e and d are not ordered by $R$ ($d \hspace{0.2em}|| \hspace{0.2em} e$ ). The reflexivity of elements is implied.

Lattices as an Algebraic Structure #

A mathematical or a computational entity has an algebraic structure when it is comprised of:

• a set of elements
• a finite collection of operations on its elements
• and a finite set of identities (axioms) which hold for all possible elements of the structure.

Sets themselves have identities that any set must follow. As ordered sets with other features, lattices are algebraic structures too,a denoted by $⟨L; \vee, \wedge⟩$

The following rules are equivalent for all lattices from poset $X$ , where $x, y\in X$ :

1. x R y
2. x $\vee$ y = y
3. x $\wedge$ y = x

and give rise to the following axioms with $x, y, z \in X$ :

• (x $\vee$ y) $\vee$ z = x $\vee$ (y $\vee$ z) (associative)
• x $\vee$ y = y $\wedge$ x (commutative)
• x $\vee$ x = x (idempotency)
• x $\vee$ (x $\wedge$ y)= x (absorption)

The four axioms hold for their dual versions where $\vee$ and $\wedge$ are exchanged.

Next #

Chapter 2 of the Lattices and Order has far more details on the topic of lattices if you are interested. A thorough understanding of these definitions should, hopefully, be enough to dig through how a lattice structure has been added to OCaml’s type system to build OxCaml in the next post.

It’s thanks to Claude credits that I could come up with the illustrative diagrams very easily.

2026-07-31 Putting Everything in Order

A paper I have been reading through on recently (OxCaml) does some very clever things with the OCaml type system. The basic idea is to wrap OCaml function types with qualifiers to ensure memory access safety statically from within the type system.

I wanted to write down notes on parts of the paper but then thought of a different idea - start with the underlying structure that has been used to add qualifiers to the type system and go from there. And for that, I thought I would start, as much as possible, from the beginning with relations and orders.

The Basics - Relations #

To understand what a relation is, let’s start with a set. Relying on the definition of a set to be a collection of objects, a relation can be thought of as a:

• function between sets, for example:

  • A as a set of numbers from 1 to 26 and
  • B as the set of all letters in the English alphabet,
  • the relation “is the nth letter in the alphabet” written as a function: $f(x) = y$ where $x \in A$ and $y \in B$

• sets of elements, where:

  • taking A as a set of numbers from 1 to 26 and
  • B as the set of all letters in the English alphabet,
  • the relation “is the nth letter in the alphabet” is denoted by R and consists of the set of pairs defined as: $(x, y) \in R$ where $x \in A$ and $y \in B$ .

Using the second definition, for any two sets X and Y, denoting X x Y as the set of all possible pairs with $x \in X$ , $y \in Y$ , a binary relation R is its subset i.e. the set containing pairs for R holds for $x,y$ . When both $x, y \in X$ , R is a relation on X itself.

Properties of Relations #

Using the notation $xRy$ for $(x,y) \in R$ , relations on a set X for all $x,y,z \in X$ can be characterized as:

It always helps to work through examples for dry mathematical definitions, so let’s see some for each property listed above. Given $x,y,z \in$ a set $X$ :

• empty ($\neg(xRy))$ :

  • R = $\varnothing$ and $X = {1,2,3,4,5}$ denotes R has no pairs. All of the other properties become vacuously true (hold for the empty set) except for the reflexive one. Since R is empty, there isn’t a way to relate every $x$ to itself.

  • The one subtlety is that if both R = $\varnothing$ and $X = \varnothing$ , then the reflexive property holds along with all others (all elements of an empty set are related to themselves via an empty relation).

• reflexive ($xRx$ ):

  • The relation $\leq$ on the set of integers where R = ${(x, x) | \hspace{0.5em} x \leq x}$ (E.g. 1 $\leq$ 1, 2 $\leq$ 2, …)

  • The relation “is reachable from” for nodes in a graph. R = ${(x, x) | \hspace{0.5em} \text{any node is reachable from itself}}$

• irreflexive ($\neg(xRx$ )): The relation $\le$ on the set of integers $X$ .

  • R = ${(x, x) | \hspace{0.5em} \neg(x \lt x)}$ = $\varnothing$ = $neg(1 \lt 1, 2 \lt 2, ...)$

  • R = ${(x, y) | \hspace{0.5em} x \subsetneq y}$ where $x,y$ are sets and elements of the powerset of set X. ($\subsetneq$ stands for “is a subset of and not equal to” and denotes a strict subset).

• identity ($xRy \to x = y$ ):

  • The relation “is equal to” on the set of natural numbers $X$ R = ${(x, y) | \hspace{0.5em} x = y }$

  • The relation “the result from an identity function” where R = $y = f(x) = {(x, y) | \hspace{0.5em} x = y}$

• transitive ($xRy \land yRz \to xRz$ ):

  • The relation $\leq$ on the set of integers where R = ${(x, x) | x \leq x}$ (1 $\leq$ 2 and 2 $\leq$ 3 $\to$ 1 $\leq$ 3)

  • The relation “is an ancestor of” in a graph whose nodes form a set $xRy$ and $yRz$ $\to$ $xRz$ i.e. node x is an ancestor to both y and z

• symmetric ($xRy \to yRx$ ):

  • For X = $\mathbb{R} \backslash {0}$ i.e. the set of reals excluding 0, multiplicative inverses i.e. $R = {(x, y) | \hspace{0.5em} x = 1/y}$

  • For X = $\mathbb{R}$ only, additive inverses i.e. $R = ${(x, y) | x = -y}$

  • For X be the set of all nodes in a graph with the depth of a node defined from its root. Then $R = {(x, y) | \hspace{0.5em} depth(a) = depth(b)}$

  are all symmetric

• antisymmetric ($xRy \land yRx \to x=y$ ):

  • For $X$ as the set of positive integers, xRy where R is “divides”. If x were to divide y and y x, then the only possibility is that x = y.

  • R = ${(x, y) | \hspace{0.5em} x \subset y}$ where $x,y$ are sets and elements of the powerset of set X. ($\subset$ stands for “is a subset of”). Only if $x = y$ can $xRy \land yRx$ hold

• asymmetric ($xRy \to \neg(yRx)$ ):

  • For X be the set of all nodes in a graph with R defined as “is the parent of”. R = ${(x, y) | \hspace{0.5em} \text{node x is node y's parent}}$ Alternatively: R = ${(x, x) | \hspace{0.5em} \text{node x cannot be its own parent}}$

  • The relation $\lt$ on the set of integers where R = ${(x, y) | x \lt y}$

There are two important points for each property described above where each:

• holds for a relation R if and only if it holds of its converse R$^{op}$ , defined by $xRy \iff yR^{op}x$ (courtesy of the duality principle)

• extends to Boolean combinations of the above properties i.e. those formed using the boolean ‘and’ ($\land$ ), ‘or’ ($\lor$ ) and ‘not’ ($\neg$ ).

The Sense in Relations #

With sets as a collections of elements and relations between such elements defined above, an idea of how we can use such relations to position elements within the set comes from the definitions of the relations themselves.

The original idea of using relations to determine relative positions of elements i.e. an order between them comes from a paper by Bertrand Russell titled “On the Notion of Order”. The crux of the paper is as follows:

A casual collection of terms may be ordered by counting, in which case they are correlated with the integers; by speech, in which case they are correlated with a series of times; or by writing, in which case they correlated with a series of places. But the order arises, in each case, from the intrinsic order of the integers, the times, or the places respectively. These have an order independent of our caprice-they form what I shall call independent or self-sufficient series. The casual terms correlated with them form, on the contrary, only a series by correlation. Series by correlation are generated from self-sufficient series as follows: If there be a self-sufficient series A, B, C, D, . . . a collection of terms $\alpha$ , $\beta$ … and a specific relation R which subsists between $alpha$ and A, and $\beta$ and B, etc., but not between $\alpha$ and B or C or D or etc. (with similar exclusions for $\beta$ …), then $\alpha$ , $\beta$ … acquire, by correlation with A, B, C, D, the order which belongs intrinsically to A, B, C, D. Thus all orders by correlation are logically dependent upon intrinsic orders. The latter alone will be considered in what follows.

Order depends fundamentally upon relations having what mathematicians call sense, i.e., such that the relation of A to B is different from that of B to A. Such are east and west, greater and less, before and after, etc. But if order is to arise, another condition is necessary. It must be possible for the same relation with opposite senses to attach to a given term. This excludes such relations as occupation of a place or a time. For though a time may be occupied by an event, there is nothing which the time itself can occupy; and similarly as regards a place. Where both conditions are satisfied, we in general have an order. That is, if there be any relation R, having two senses R$_{1}$ , R$_{2}$ ; and if a term B have the relation R$_{1}$ to A, while it has the relation R$_{2}$ to C, then B is between A and C, and the three terms have the, order ABC or CBA. Thus these two conditions are necessary for an intrinsic order of three terms, and become sufficient if we add that BR$_{1}$ A, BR$_{2}$ C are to imply the denial (emphasis mine) of AR$_{1}$ C”

The idea is that a “collection of terms” (a set) with binary relations between its elements has an “intrinsic” order where if R is a relation on elements $x, y, z \in$ set $X$ with the property of being:

• asymmetric (($xRy \to \neg(yRx)$ ))
• transitive ($xRy \land yRz \to xRz$ )

then elements $x, y, z$ can be compared using relations such as “is derived from”, “is less than”, “is contained in”, “happened before (/after)”, “comes before”. The asymmetry ensures the transitivity of the relation occurs only in one direction, without which there would be no way to put elements from $X$ in any distinct, comparative order. This is the “sense” talked about in the paper and translates to the common sense notion of order we use in our thinking and everyday speech.

Types of Orders #

From the fundamental understanding of an order in the last section, let’s build the definitions by adding or slightly modifying properties of relations.

If we were to add:

• irreflexive ($\neg(xRx$ ))
• transitive ($xRy \land yRz \to xRz$ ) (remains the same)
• asymmetric (($xRy \to \neg(yRx)$ )) (remains the same)

then a relation $R$ on ($x, y, z \in$ ) set $X$ is a (strict) partial order. The “partial” signifies that the relation holds only for those elements in the set which can be related using $R$ implying that it is not necessary for each element in $X$ to be related to every other element. The “strict” ensures that elements in $X$ can only be related to other element, never to itself.

Modifying the above definition to:

• irreflexive ($xRx$ )
• transitive ($xRy \land yRz \to xRz$ ) (remains the same)
• asymmetric (($xRy \to \neg(yRx)$ )) antisymmetric ($xRy \land yRx \to x=y$ )

defines a weak partial order and is denoted by $(X, ≤)$ . The set with such a order is a (weakly) partially ordered set (or a poset). The “weak” signifies that elements can be related to themselves.

An interesting mathematical property is that a relation is asymmetric if and only if it is both antisymmetric and irreflexive. So the asymmetry property of the strict partial order subsumes both an irreflexive property (superfluous in the definition actually) and an antisymmetry property. Weakening the definition to make the relation reflexive means the asymmetry property can no longer hold i.e. now when $xRy$ , it is possible $yRx$ . With the addition of antisymmetry, this can only be true when $x = y$ . This ensures that two elements can only be related in “both directions” if they are the same, implying that the equivalent guarantees of the asymmetry property are maintained in the presence of reflexivity for weak partial orders.

To work through a very simple example of a poset, let’s take a set $S$ = {1,2,3} and its powerset P($S$ ) = {$\varnothing$ , {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1, 2, 3}}. With $R$ defined as $\subseteq$ i.e. subset, $R$ is:

• reflexive - a set is always its own subset ({1} $. {2} $\subseteq$ {2} in P($S$ ))
• transitive - any element S$_1$ within S is a subset of another element S$_2$ which in turn is the subset of another element S$_3$ ({1} $\subseteq$ {1,3} $\subseteq$ {1,2,3} $\implies$ {1} $\subseteq$ {1,2,3}; all elements is P($S$ ) are subsets of the maximal element {1,2,3})
• antisymmetric - every element S$_1$ of P($S$ ) is subset of another element S$_2$ ; if S$_2$ is a subset of S$_1$ , then S$_1$ = S$_2$ ({1,2} $\subseteq$ {1,2} and {1,2} $\subseteq$ {1,2} only when {1,2} = {1,2})

An poset $X$ is termed a chain or a linearly ordered set or a totally ordered set when any two elements of $X$ are comparable ($\forall x, y \in X, xRy \lor yRx$ ).

The book “Introduction to Lattices and Order” covers many more definitions and examples on orders. The next topic that arises from the study of relations and orders are lattices which I’ll write it up in my next blog post.

References:

• Notes on Lattices from a course on Algebraic Logic
• Copy of Lattices and Order