<![CDATA[Life & Computing Science]]> https://alhassy.github.io/ Tue, 28 Nov 2023 06:52:09 -0500 <![CDATA[Java CheatSheet]]>

Article image
Abstract
This is a quick reference of concepts in modern Java.

Modern Java is a strongly-typed, eagery evaluated, case sensative, yet whitespace insensative language. It uses hierarchies of classes/types to structure data, but also has first-class support for functional-style algebraic datatypes.

Java programs are made up of ‘classes’, classes contain methods, and methods contain commands. To just try out a snippet of code, we can

  • Open a terminal and enter jshell; then enter: 

    1 + 2 // The jshell lets you try things out!

// Say hello in a fancy way
import javax.swing.*;
JOptionPane.showMessageDialog(new JFrame(), "Hello, World!");
  • Alternatively, in IntelliJ, click Tools then Groovy Console to try things out!
  • Finally, VSCode allows arbitrary Java code to be sent to a jshell in the background(!) and it echoes the result in a friendly way.

1. The Philosophy of Classes & Interfaces

Real life objects have properties and behaviour. For example, my cat has the properties of name and age, and amongst its behaviours are sleep and meow. However, an apple does not have such features. The possible features of an object are understood when we classify it; e.g., my cat is an animal, whereas an apple is food. In Java, a set of features is known as a class and objects having those features are called “objects of that class”. Just as int is the type of the value 12, we say a class is a type of an object.

We tend to think in (disjoint, hierarchical) categories; for example, in my library, a book can be found in one section, either “Sports” or “History” or “Trees”. So where should books on the history of football be located? Or books on the history of trees? My library places such books under “Sports”, and “Tree” respecively, but then adds a “historical” tag to them. Likewise, in Java, to say different kinds of things have a feature in common, we “tag” them with an interface. (Real life tagging is a also known as multi-class-ificiation.)

Java's Main Organisational Mechanisms

    With state Without state
Attributes & properties   class record
Partial implementations   abstract class interface
Here is a teaser of nearly all of these packaging mechanisms 
interface Hospitable {
    String name();   /* unimplemented method signature */
    default void greet() { /* derived, implemented, method */
        System.out.printf("%s says “Welcome!”", name());
    }
}

////////////////////////////////////////////////////////////////////////////////

class Person implements Hospitable {
    String name;
    int age;
    public String name() { return name; }
}

// Actual usage of “Person”:
Person me = new Person();
me.name = "Musa";
me.age = 31;
me.greet();

////////////////////////////////////////////////////////////////////////////////

record Person2(String name, int age) implements Hospitable { }

// Actual usage of “Person2”:
Person2 me = new Person2("Musa", 31);
me.greet();
“Interfaces are the types of classes”

A module is a bunch of utilities that can be defined from some shared set of parameters. Those utilities can be thought of as an interface 𝑰. Then a module is a function from parameters to an anonymous implementation of an interface. However, functions that return implementations are essentially records/classes that implement the interface; i.e., 

   𝑰 R(params) { return new 𝑰() { 𝑰_𝑶𝑽𝑬𝑹𝑰𝑫𝑬𝑺 }; } // module-as-function
≈  record R(params) implements 𝑰 { 𝑰_𝑶𝑽𝑬𝑹𝑰𝑫𝑬𝑺 }; // module-as-record

This equation justifies the phrase “interfaces are the types of records/classes” since a record declaration (i.e., the right side of the “≈”) can be converted to an (abstract) module (of type 𝑰) —i.e., the left side of the “≈”.

Algebraic Data Types :ignore

Finally, suppose there's something you want to do and there are a number of ways/configurations to get it done. You could write it as a method in a class with a bunch of if's to account for all of those ways. Better would be to create an interface, then have a bunch of classes that implement it: One class for each possible implementation. Finally, if you know all configurations, you can move those classes into the definition of the interface and make it sealed: This is known as an algebraic data-type, whose kill-feature is that you can use switch to pattern match on instances of the interface.

🔗
ADT example

An example 3-level hierarchy that can be easily represented with ADTs rather than a traditional class hierarchy. 

sealed interface Monster {

    sealed interface Flying extends Monster { }
    record Griffin() implements Flying { }
    record Pegasus() implements Flying { }

    sealed interface Ground extends Monster { }
    record Ogre() implements Ground { }
}

Then we can actually use this new type as follows: 

private static String glare(Monster m) {
    return switch (m) {
        case Monster.Griffin it -> "Roar";
        case Monster.Pegasus it -> "HeeHaw";
        case Monster.Ogre it -> "Grrr";
    };
}

glare(new Monster.Flying.Griffin()); // "Roar"

Or only look at the Flying sub-type: 

private static int attackDamage(Monster.Flying f) {
    return switch (f) {
        case Monster.Flying.Griffin it -> 120;
        case Monster.Flying.Pegasus it -> 60;
    };
}

attackDamage(new Monster.Pegasus()); // 60
Reads
  • “MOOC” Massive Open Online Course - University of Helsinki
    • Useful for learning Java, Python, Haskell, JavaScript.
    • I highly reccommend their “full stack” course on web development, with JS!
  • Effective Java, 3rd Edition by Joshua Bloch
  • Seriously Good Software Code that Works, Survives, and Wins
  • Functional Programming in Java Harnessing the Power of Java 8 Lambda Expressions
  • Java Generics and Collections Speed Up the Java Development Process
  • Java 8 Lambdas Pragmatic Functional Programming - Richard Warburton
🔗
Null

There is a special value named null that denotes the absence of a meaningful value. Ironically, it is a value of every type (excluding the primitive types). Here is a neat story about null.

2. Primitive Objects

For performance reasons, there are a handful of types whose values are created by literals; i.e., “What you see is what you get”. (As such, primitives are a basic building block which cannot be broken apart; whereas non-primitives (aka references) are made-up from primitives and other references.) For example, to create a value of int we simply write 5.

There are no instance methods on literals; only a handful of operator methods. For example, we cannot write 2.pow(3) to compute 2³, but instead must write Math.pow(2, 3). Finally, variables of primitive types have default values when not initialised whereas object types default to null —note: null is a value of all object types, but not of primitive types. 

// Declare a new object type
class Person { String name; }

Person obj; // ≈ null (OBJECT)
int prim;    // ≈ 0   (PRIMITIVE)

// Primitives are created as literals
prim = 1;    // ≈ 1

// Objects are created with “new”
obj = new Person(); // ≈ a reference,
   // like: Person@66048bfd

// Primitives are  identified by
// thier literal shape
assert prim == 1;

// Objects are identified by
/// references to their memory
// locations (not syntax shape!)
assert obj != new Person();

// Primitives copy values
int primCopy = prim;  // ≈ 1

/// Objects copy references
Person objCopy = obj;
  // ≈ a reference, like: Person@66048bfd

// Changing primitive copy has
// no impact on original
primCopy = 123;
assert prim == 1;

// Changing object copy also
// changes the original!
assert obj.name == null;
objCopy.name = "woah";    // Alter copy!
// Original is altered!
assert obj.name.equals("woah");
Wrapper Types

Java lets primitives shift back and forth from their literal representations and the world of reference objects somewhat-harmoniously by automatically “boxing” them up as objects when need be. This is done by having class versions of every primitive type; e.g., the primitive int has the class version Integer. 

Integer x = 1; // auto-boxed to an object
int y = new Integer(2); // auto-unboxed to a primitive

Primitives require much less memory! An int requires 32-bits to represent, whereas an Integer requires 128-bits: The object requires as much space as 4 primitives, in this case.

3. Properties and methods have separate namespaces

Below we use the name plus1 in two different definitional roles. Which one we want to refer to depends on whether we use "dot-notation" with or without parenthesis: The parentheis indicate we want to use the method. 

class SameNameNoProblem {
    public static int plus1(int x){ return x + 1; } // Method!
    public static String plus1 = "+1";             // Property!
}

class ElseWhere {
    String pretty = SameNameNoProblem.plus1;
    Integer three = SameNameNoProblem.plus1(2);
}

The consequence of different namespaces are

  1. Use apply to call functions bound to variables.
  2. Refer to functions outside of function calls by using a double colon, ::.

4. Anonymous functions:    (arg₁, …, argₙ) → bodyHere    

Functions are formed with the “→” notation and used with “apply”

// define, then invoke later on
Function<Integer, Integer> f  =  x -> x * 2;

f.apply(3) // ⇒ 6
// f(3)    // invalid!

// define and immediately invoke
((Function<Integer, Integer>) x -> x * 2).apply(3);

// define from a method reference, using “::”
Function<Integer, Integer> f = SameNameNoProblem::plus1;

Let's make a method that takes anonymous functions, and use it

// Recursion with the ‘tri’angle numbers: tri(f, n) = Σⁿᵢ₌₀ f(i).
public static int tri(Function<Integer, Integer> f, int n) {
    return n <= 0 ? 0 : f.apply(n) + tri(f, n - 1);
}

tri(x -> x / 2, 100);  //  ⇒  Σ¹⁰⁰ᵢ₌₀ i/2 = 2500

// Using the standard “do nothing” library function
tri(Function.identity(), 100);  //  ⇒  Σ¹⁰⁰ᵢ₌₀ i = 5050

Exercise! Why does the following code work?

int tri = 100;
tri(Function.identity(), tri); //  ⇒ 5050

Function<Integer, Integer> tri = x -> x;
tri(tri, 100); //  ⇒ 5050

In Java, everything is an object! (Ignoring primitives, which exist for the purposes of efficiency!) As such, functions are also objects! Which means, they must have a type: Either some class (or some interface), but which one? The arrow literal notation x -> e is a short-hand for an implementation of an interface with one abstract method…

5. Lambdas are a shorthand for classes that implement functional interfaces

Let's take a more theoretical look at anonymous functions.

5.1. Functional Interfaces

A lambda expression is a (shorthand) implementation of the only abstract method in a functional interface ——–which is an interface that has exactly one abstract method, and possibly many default methods.

For example, the following interface is a functional interface: It has only one abstract method. 

  public interface Predicate<T> {

      boolean test(T t);  // This is the abstract method

      // Other non-abstract methods.
      default Predicate<T> and(Predicate<? super T> other) { ... }
      // Example usage: nonNull.and(nonEmpty).and(shorterThan5)
      static <T> Predicate<T> isEqual(T target) {...}
      // Example usage: Predicate.isEqual("Duke") is a new predicate to use.
  }

Optionally, to ensure that this is indeed a functional interface, i.e., it has only one abstract method, we can place @FunctionalInterface above its declaration. Then the complier will check our intention for us.

5.2. The Type of a Lambda

Anyhow, since a lambda is a shorthand implementation of an interface, this means that what you can do with a lambda depenends on the interface it's impementing!

As such, when you see a lambda it's important to know it's type is not "just a function"! This mean to run/apply/execute a lambda variable you need to remember that the variable is technically an object implementing a specific functional interface, which has a single named abstract method (which is implemented by the lambda) and so we need to invoke that method on our lambda variable to actually run the lambda. For example, 

  Predicate<String> f = s -> s.length() == 3;   // Make a lambda variable
  boolean isLength3String = f.test("hola");     // Actually invoke it.

Since different lambdas may implement different interfaces, the actually method to run the lambda will likely be different! Moreover, you can invoke any method on the interface that the lambda is implementing. After-all, a lambda is an object; not just a function.

Moreover, Function has useful methods: Such as andThen for composing functions sequentially, and Function.identity for the do-nothing function.

5.3. Common Java Functional Types

Anyhow, Java has ~40 functional interfaces, which are essentially useful variations around the following 4:

Class runner Description & example
Supplier get Makes objects for us; e.g., () -> "Hello"!.
Consumer accept Does stuff with our objects, returning void;
    e.g., s -> System.out.println(s).
Predicate test Tests our object for some property, returning a boolean
    e.g., s -> s.length() == 3
Function apply Takes our object and gives us a new one; e.g., s -> s.length()

For example, 𝒞::new is a supplier for the class 𝒞, and the forEach method on iterables actually uses a consumer lambda, and a supplier can be used to reuse streams (discussed below).

The remaining Java functional interfaces are variations on these 4 that are optimised for primitive types, or have different number of inputs as functions. For example, UnaryOperator<T> is essentially Function<T, T>, and BiFunction<A, B, C> is essentially Function<A, Function<B, C>> ———not equivalent, but essentially the same thing.

  • As another example, Java has a TriConsumer which is the type of functions that have 3 inputs and no outputs —since Tri means 3, as in tricycle.

5.4. Eta Reduction: Writing Lambda Expressions as Method References

Lambdas can sometimes be simplified by using method reference:

Method type        
Static   \((x,ys) → τ.f(x, ys)\) ≈ \(τ::f\)
Instance   \((x,ys) → x.f(ys)\) ≈ \(τ::f\), where τ is the type of \(x\)
Constructor   args → new τ<A>(args) ≈ τ<A>::new

For example, (sentence, word) -> sentence.indexOf(word) is the same as String::indexOf. Likewise, (a, b) -> Integer.max(a, b) is just Integer::max.

  • Note that a class name τ might be qualified; e.g., x -> System.out.println(x) is just System.out::println.

6. Variable Bindings

Let's declare some new names, and assert what we know about them.

Integer x, y = 1, z;

assert x == null && y == 1 && z == null;

τ x₀ = v₀, …, xₙ = vₙ; introduces 𝓃-new names xᵢ each having value vᵢ of type τ.

  • The vᵢ are optional, defaulting to 0, false, '\000', null for numbers, booleans, characters, and object types, respectively.
  • Later we use xᵢ = wᵢ; to update the name xᵢ to refer to a new value wᵢ.

There are a variety of update statements: Suppose \(τ\) is the type of \(x\) then,

Augment:  x ⊕= y  ≈  x = (τ)(x ⊕ y)
Increment:   x++  ≈  x += 1)
Decrement:  x--  ≈  x -= 1)

The operators -- and ++ can appear before or after a name: Suppose \(𝒮(x)\) is a statement mentioning the name \(x\), then

𝒮(x++)  ≈  𝒮(x); x += 1
𝒮(++x)  ≈  x += 1; 𝒮(x)

Since compound assignment is really an update with a cast, there could be unexpected behaviour when \(x\) and \(y\) are not both ints/floats.

  • If we place the keyword final before the type τ, then the names are constant: They can appear only once on the right side of an ‘=’, and any further occurrences (i.e., to change their values) crash the program. final int x = 1, y; y = 3; is fine, but changing the second y to an x fails.
  • We may use var x = v, for only one declaration, to avoid writing the name of the type τ (which may be lengthy). Java then infers the type by inspecting the shape of v.

  • Chained assignments associate to the right:

    a += b /= 2 * ++c;  ≈  a += (b /= (2 * ++c));

    (The left side of an “=”, or “⊕=”, must a single name!)

7. Scope, Statements, and Control Flow

var x = 1;

{ // new local scope
  var x = 200; // “shadows” top x
  var y = 300;
  assert x + y == 500;
}

// y is not visible here
assert y == 20; // CRASH!

// The top-most x has not changed
assert x == 1;

⊙ Each binding has a scope, which is the part of the program in which the binding is visible.

⊙ local bindings are defined within a block and can only be referenced in it.

⊙ Names within a block /shadow//hide bindings with the same name.

Besides the assignment statement, we also have the following statements:

  • Blocks: If Sᵢ are statements, then {S₀; …; Sₙ;} is a statement.
  • Conditionals: if (condition) S₁ else S₂

  • The “for-each” syntax applies to iterable structures —we will define our own later. 

    // Print all the elements in the given list.
for (var x : List.of(1, 2, 3))
   System.out.printf("x ≈ %s\n", x);

  • While-Loops  while (condition) S  and for-loops  for(init; cond; change) body . 

       var i = 0; while (i < 10) System.out.println(Math.pow(2, i++));
≈
   for(var i = 0; i < 10; i++) System.out.println(Math.pow(2, i));

    Exit the current loop with the break; statement. Similarly, the continue; statement jumps out of the body and continues with the next iteration of the loop.

8. switch

Dispatching on a value with switch

⟦Switch Statement⟧ 

switch (x){
  case v₁: S₁
  ⋮
  case vₙ: Sₙ
  default: Sₙ
}

The switch works as follows: Find the first 𝒾 with x == vᵢ, then execute {Sᵢ; ⋯; Sₘ;}, if there is no such 𝒾, execute the default statement Sₙ. Where Sₘ is the first statement after Sᵢ that ends with break;.

E.g., case v: S; case w: S′; break means do S;S′ if we see v but we do S′ when seeing both v and w. 

switch (2){
  case 0: System.out.println(0);
  case 1: System.out.println(1);
  case 2: System.out.println(2);
  default: System.out.println(-1);
} // ⇒ Outputs: 2 -1

⟦Switch Expression⟧ If we want to perform case analysis without the fall-over behaviour, we use arrows ‘→’ instead of colons ‘:’. 

   switch (2){
     case 0 -> 0;
     case 1 -> 1;
     case 2 -> 2;
     default -> -1;
   } // ⇒ 2

9. Strings

Any pair of matching double-quotes will produce a string literal —whereas single-quote around a single character produce a character value. For multi-line strings, use triple quotes, """, to produce text blocks.

String interpolation can be done with String.format using %s placeholders. For advanced interpolation, such as positional placeholders, use MessageFormat. 

String.format("Half of 100 is %s", 100 / 2) // ⇒ "Half of 100 is 50"
  • s.repeat(𝓃) ≈ Get a new string by gluing 𝓃-copies of the string 𝓈.
  • s.toUpperCase() and s.toLowerCase() to change case.
  • Trim removes spaces, newlines, tabs, and other whitespace from the start and end of a string. E.g., " okay \n ".trim().equals("okay")
  • s.length() is the number of characters in the string.
  • s.isEmpty()  ≡  s.length() == 0
  • s.isBlank()  ≡  s.trim().isEmpty()
  • String.valueOf(x) gets a string representation of anything x.
  • s.concat(t) glues together two strings into one longer string; i.e., s + t.

10. Equality

  • In general, ‘==’ is used to check two primitives for equality, whereas .equals is used to check if two objects are equal.
  • The equality operator ‘==’ means “two things are indistinguishable: They evaluate to the same literal value, or refer to the same place in memory”.
  • As a method, .equals can be redefined to obtain a suitable notion of equality between objects; e.g., “two people are the same if they have the same name (regardless of anything else)”. If it's not redefined, .equals behaves the same as ‘==’. In contrast, Java does not support operator overloading and so ‘==’ cannot be redefined.
  • For strings, ‘==’ and .equals behave differently: new String("x") == new String("x") is false, but new String("x").equals(new String("x")) is true! The first checks that two things refer to the same place in memory, the second checks that they have the same letters in the same order.
    • If we want this kind of “two objects are equal when they have the same contents” behaviour, we can get it for free by using records instead of classes.

11. Arithmetic

In addition to the standard arithmetic operations, we have Math.max(x, y) that takes two numbers and gives the largest; likewise Math.min(x, y). Other common functions include Math.sqrt, Math.ceil, Math.round, Math.abs, and Math.random() which returns a random number between 0 and 1. Also, use % for remainder after division; e.g., n % 10 is the right-most digit of integer \(n\), and n % 2 == 0 exactly when \(n\) is even, and d % 1 gives the decimal points of a floating point number \(d\), and finally: If d is the index of the current weekday (0..6), then d + 13 % 7 is the weekday 13-days from today. 

// Scientific notation: 𝓍e𝓎 ≈ 𝓍 × 10ʸ
assert 1.2e3 == 1.2 * Math.pow(10, 3)

// random integer x with 4 ≤ x < 99
var x = new Random().nextInt(4, 99);

Sum the digits of the integer $n = 31485$

int n = 31485;
int sum = 0;
while (n % 10 != 0) { sum += n % 10; n /= 10; }
assert sum == 3 + 1 + 4 + 8 + 5;

A more elegant, “functional style”, solution: 

String.valueOf(n).chars().map(c -> c - '0').sum();

The chars() methods returns a stream of integers (Java characters are really just integers). Likewise, IntStream.range(0, 20) makes a sequence of numbers that we can then map over, then sum, min, max, average.

12. Collections and Streams

Collections are types that hold a bunch of similar data: Lists, Sets, and Maps are the most popular. Streams are pipelines for altering collections: Usually one has a collection, converts it to a stream by invoking .stream(), then performs map and filter methods, etc, then “collects” (i.e., runs the stream pipeline to get an actual collection value back) the result.

Lists are ordered collections, that care about multiplicity. Lists are made with List.of(x₀, x₁, …, xₙ). Indexing, xs.get(𝒾), yields the 𝒾-th element from the start; i.e., the number of items to skip; whence xs.get(0) is the first element.

Sets are unordered collections, that ignore multiplicity. Sets are made with Set.of(x₀, x₁, …, xₙ).

Maps are pairs of ‘keys’ along with ‘values’. Map<K, V> is essentially the class of objects that have no methods but instead have an arbitary number of properties (the ‘keys’ of type K), where each property has a value of type V. Maps are made with Map.of(k₀, v₀, …, k₁₀, v₁₀) by explicitly declaraing keys and their associated values. The method ℳ.get(k) returns the value to which the specified key k is mapped, or null if the map ℳ contains no mapping for the key. Maps have an entrySet() method that gives a set of key-value pairs, which can then be converted to a stream, if need be.

Other collection methods include, for a collection instance 𝒞:

  • 𝒞.size() is the number of elements in the collection
  • 𝒞.isEmpty()  ≡  𝒞.size() == 0
  • 𝒞.contains(e)  ≡  𝒞.stream().filter(x -> x.equals(e)).count() > 0
  • Collections.fill(ℒ, e)  ≅  ℒ.stream().map(_ -> e).toList(); i.e., copy list ℒ but replace all elements with e.
  • Collections.frequency(𝒞, e) counts how many times e occurs in a collection.
  • Collections.max(𝒞) is the largest value in a collection; likewise min.
  • Collections.nCopies(n, e) is a list of \(n\) copies of e.

Stream<τ> methods

  • Stream.of(x₀, ..., xₙ) makes a stream of data, of type τ, ready to be acted on.
  • s.map(f) changes the elements according to a function \(f : τ → τ′\).
    • s.flatMap(f) transforms each element into a stream since \(f : τ → Stream<τ′>\), then the resulting stream-of-streams is flattened into a single sequential stream.
    • As such, to merge a streams of streams just invoke .flatMap(s -> s).
  • s.filter(p) keeps only the elements that satisfy property p
  • s.count() is the number of elements in the stream
  • s.allMatch(p) tests if all elements satisfy the predicate p
  • s.anyMatch(p) tests if any element satisfies p
  • s.noneMatch(p)  ≡  s.allMatch(p.negate())
  • s.distinct() drops all duplicates
  • s.findFirst() returns an Optional<τ> denoting the first element, if any.
  • s.forEach(a) to loop over the elements and perform action a.
    • If you want to do some action, and get the stream s back for further use, then use s.peek(a).

13. Generics

Java only lets us return a single value from a method, what if we want to return a pair of values? Easy, let's declare record Pair(Object first, Object second) { } and then return Pair. This solution has the same problem as methods that just return Object: It communicates essentially no information —after all, everything is an object!— and so requires dangerous casts to be useful, and the compiler wont help me avoid type mistakes. 

record Pair(Object first, Object second) { }

// This should return an integer and a string
Pair myMethod() { return new Pair("1", "hello"); } // Oops, I made a typo!

int num = (int) (myMethod().first()); // BOOM!

It would be better if we could say “this method returns a pair of an integer and a string”, for example. We can do just that with generics! 

record Pair<A, B>(A first, B second) { }

Pair<Integer, String> myMethod() { return new Pair<>(1, "hello"); }

int num = myMethod().first();

This approach communicates to the compiler my intentions and so the compiler ensures I don't make any silly typos. Such good communication also means no dangerous casts are required.

We can use the new type in three ways:

Pair<A, B> explicitly providing the types we want to use Pair with
Pair<> letting Java infer, guess, the types for Pair by how we use it
Pair defaulting the types to all be Object

The final option is not recommended, since it looses type information. It's only allowed since older versions of Java do not have type parameters and so, at run time, all type parameters are ‘erased’. That is, type parameters only exist at compile time and so cannot be inspected/observed at run-time.

]]> https://alhassy.github.io/java-cheat-sheet.html https://alhassy.github.io/java-cheat-sheet.html Tue, 28 Nov 2023 06:52:09 -0500 <![CDATA[💐 Repl Driven Development: /Editor Integrated REPLs for all languages/ 🔁]]>

Article image
Abstract

The MELPA package makes the philosophy of REPL Driven Development (RDD) accessible to any language that has a primitive CLI repl: The result is an Emacs interface for the language, where code of your choosing is evaluated, and results are echoed at your cursor in overlays.

That is, with Repl aided development, you make software by starting with an already working program (i.e., the repl) then incrementlly “teach it” to be the program you want, by defining & redefining things. Until satisfied, loop: Type/modify code in your editor, press some keys to evaluate what you wrote/modified in the currently running system, and explore/test the resulting runtime.

RDD is programming emphasising fast & rich feedback from a running system. RDD is fantastic for quickly teaching/exploring an idea; as such, the running example of this article will be on servers —no prior experience with servers is assumed. The main examples will be in JavaScript, Python, and Java. (Since JavaScript is just Lisp in C clothing, we will not discuss Lisp.) Since Java is verbose, the power of REPLs really pays off when exploring a new idea. We see how many imports and setup-code simply disappear in the RDD approach, letting you focus on the core idea you're exploring/teaching. For comparison, a traditional self-contained Java server program is ~30 lines long whereas the focused RDD approach is ~4 lines long.

tdlr: This library provides the Emacs built-in C-x C-e behaviour for arbitrary languages, provided they have a primitive cli REPL.

1. A Rapid Overview of RDD

1.1. How do people usually code? 🌤️

Either you,

  1. Use a code editor and edit multiple lines, then jump into a console to try out what you wrote⏳, or
  2. You use an interactive command line, and work with one line at a time —continuously editing & evaluating 🔄

The first approach sucks because your code and its resulting behaviour occur in different places 😢 The second is only realistic for small experimentation —after all, you're in a constrained environment and don't generally have the same features that your code editor provides 🧟‍♂️

1.2. If only we could have our cake, and eat it too! 🍰

With an editor-integrated REPL, we get both approaches! No need to switch between the two any more! For example, Emacs out-of-the-box lets us just select some code and press C-x C-e ---E for Evaluate! 😉 

;; Press “control and x, then control and e”, at the end of the line, to run the following code
(message-box "hello world")

The MELPA software gives us this feature for any language! For example, Press C-x C-e at the end of the following line to get an Emacs-integrated REPL for Java —i.e., C-x C-j will now evaluate a selection, or the entire line, as if it were Java code.

  • Why C-x C-j  ?  Well, C-x C-“e” for Emacs Lisp code, and C-x C-“j” for Java code!
  ;; C-x C-j now evaluates arbitrary Java code
  ;; ⟦Emacs spawns a new “jshell” process, then “C-x C-j” sends text to that process.⟧
  (repl-driven-development [C-x C-j] "jshell" :prompt "jshell>")

We can now press C-x C-j to execute any Java code, and see results echoed inline in an overlay, such as: 

  1 + 2                     // ⇒ 3
  System.out.println(2 + 3) // ⇒ 5
  "hello"[0]                // 🚫 Type error: Java strings are not arrays

  IntStream.range(0, 100).toArray() // A multi-line overlay of numbers 0..99

  import javax.swing.*;     // (No output; this is an effectful operation)

  var frame = new JFrame(){{ setAlwaysOnTop(true); }};  // ⇒ ‘frame’ is defined

  JOptionPane.showMessageDialog(frame, "Super nice!");  // ⇒ A GUI appears 💝

👀 This extension is an easy Emacs-integrated-REPL builder for any language! 😲

Learn more Java from .

Say that again, but use Python please! 🐍

With an editor-integrated REPL, we get both approaches! No need to switch between the two any more! For example, Emacs out-of-the-box lets us just select some code and press C-x C-e ---E for Evaluate! 😉 

;; Press “control and x, then control and e” to run the following code
(message-box "hello world")

The MELPA software gives us this feature for any language! For example, Press C-x C-e on the following line to get an Emacs-integrated REPL for Python: 

    ;; C-x C-p now evaluates arbitrary Python code
    (repl-driven-development [C-x C-p] "python3")

We can now press C-x C-p to execute any Python code, such as: 

import os                       # ⇒ Module OS imported
f"Hello, {os.environ['USER']}!"  # ⇒ “Hello, musa!”

More exciting fun is to produce an increasing family of colourful circles, in a GUI: 

# Ensure we have some GUI capabilities installed; press “C-x C-e”:
# (async-shell-command "brew install python-tk")

import turtle
it = turtle.Turtle()  # This opens a new window

# The following fragment was “discovered” by trying things out repeatedly with “C-x C-p”.
for i in range(10):
    it.pencolor("green" if i % 2 == 0 else "red")
    it.pensize(i / 2)
    it.circle(i * 10)


# Note for Python, the above “for” loop is “complete” if we also send the extra
# newline after it.

Learn more with The Beginner's Guide to Python Turtle.

TODO: Make this into a Gif, that incrementlly shows the turtle appearing? ie it starts off with an experiment of the loop body, then it wraps it in the for, then re-runs and all of this is discovered live!

👀 This extension is an easy Emacs-integrated-REPL builder for any language! 😲

1.3. Technically speaking, how is Emacs itself the REPL? 🤔

Let's do what math-nerds call proof by definition-chasing:

  1. Definition: REPL is any software that supports a Read-Evaluate-Print-Loop cycle.
  2. C-x C-e / C-x C-j will echo the results next to your cursor, in your editor
  3. So it retains each of the read, eval, and print parts of the Read-Evaluate-Print-Loop
  4. Moreover, since the program doesn't terminate, you're still in the loop part until you close Emacs

1.4. 🛗 Summarising Evaluator Pitch ⚾

Make Emacs itself a REPL for your given language of choice

Suppose you're exploring a Python/Ruby/Java/JS/TS/Haskell/Lisps/etc API, or experimenting with an idea and want immediate feedback. You could open a terminal and try things out there; with no editor support, and occasionally copy-pasting things back into your editor for future use. Better yet, why not use your editor itself as a REPL.

The MELPA software provides the Emacs built-in C-x C-e behaviour for arbitrary languages, provided they have a primitive cli REPL.

Benefits

Whenever reading/refactoring some code, if you can make some of it self-contained, then you can immediately try it out! No need to load your entrie program; nor copy-paste into an external REPL. The benefits of Emacs' built-in “C-x C-e” for Lisp, and Lisp's Repl Driven Development philosophy, are essentially made possible for arbitrary languages (to some approximate degree, but not fully).

Just as “C-u C-x C-e” inserts the resulting expression at the current cursour position, so too all repl-driven-development commands allow for a C-u prefix which inserts the result. This allows for a nice scripting experience where results are kept for future use —e.g., when writing unit tests where you have an expression but do not know what it results to.

1.5. 🤖 💪 🤖 Features of RDD.el 💪 🤖 💪

  • 👀 Evaluation results are echoed at your cursor, in your editor, by your code, in an overlay
  • 🔑 You can specify whatever keys you want, for evaluating code. That keybinding is itself well-documented, just invoke C-h k then your keybinding.
  • 🩹 Press C-u C-x C-j to get the results of your evaluated expression printed inline, at your cursor.
  • 📚 Documentation is supported out of the box: Put the cursor over a function name (like "print" or "error"). Then press C-u C-u C-x C-j and you get the documentation of that function.

2. Teaching a runtime, incrementally, to be a web server 🍽️ 🔁 🤖

RDD by example: Let's start with a JavaScript runtime and incrementally turn it into a web server.

“RDD ≈ Programming as Teaching”: Start from a program that already works and “teach it” to be the program we actually want. This makes programming a goal-directed activity.

Below we demonstrate this idea by starting a runtime and, like talking to a person, we teach it new behaviours. Once it has all the desired behaviours, then we're done and the text we've written (in our editor) is the resulting program. Most importantly, we actively interact with the running program as it evolves; where each “teaching step” is influenced by observing the program's reactions to various stimuli (e.g., how things look, how they function, etc).

The “𝒳 as teaching” meme
  • The “𝒳 as teaching” meme is about accomplishing the goal 𝒳 as if you were talking to a friend in-person, explaining how to do something.
  • Almost everything in programming can stand-in for 𝒳; e.g., writing a function or a git commit is a good way to ‘teach’ your colleagues how to improve the code-base —as such, if the function/commit does “too much” then it is a “poor teacher” and so not ideal.
  • Related video: “How to Write a Great Research Paper (7 Excellent Tips)” by Simon Peyton Jones.
Wait, I already do this RDD stuff everyday, in the shell!

You can “discover” a bash script by running various incantations at the terminal, pressing the up-arrow key, tweaking your incantation —and repeating until you're happy with the result. In this way, you are teaching the shell a new skill —by repeatedly checking whether it can perform the skill and if not, then refining your definitions.

Anytime you execute a query, in some system, you're using a read-evaluate-print-loop!

Examples include: Writing shell & SQL queries, visiting web-pages by writing URLs, exploring HTTP APIs using curl/httpie, and using the JavaScript Console in your browser.

Sadly, the interface to such REPLs is generally very limited. There is no syntax highlighting, no code completion, no linting, it is difficult to work with multi-line input. This article proposes instead to use your editor as the interface to a REPL: You write some code in your feature-rich editor then press some keys to have only the newly written code executed.

RDD let's you use your favourite language as a Bash replacement scripting language

If your code-base is in language 𝐿, might as well write your scripts in 𝐿 as well!

For example, if you want to say run a simple for-loop on a payload of an HTTP request then might as well use your favourite language 𝐿 —and not Bash. Likewise, want to run a for-loop on the results of a SQL query: Use your favourite language 𝐿, not a SQL scripting language that you're not terribly comfortable with.

Why script in your favourite language 𝐿, and not Bash?

  1. If your an 𝐿 language developer, writing scripts in 𝐿 lets you make use of all of your existing experience, knowledge, and familiar tool-set of 𝐿.
  2. Stay in the comfort of your favourite IDE: Autocomplete, syntax highlighting, docs, tooltips, linting, etc.
  3. Lots of libraries!
  4. The gain in expressivity & clarity & test-ability.
  5. Rich data structures, error checking, and compositionality.
    • Since Bash only has unstructured data via strings, this means to compose two different Bash programs you have to get them to “understand a common structure” and this means you have to convert unstructured data to JSON somehow (e.g., using jc, which JSONifies the output of many CLI tools) or parse it yourself! Might as well use your favourite language, since it probably has support for JSON and has real structured objects.
  6. An 𝐿-REPL is a shell with 𝐿-syntax, and features! —Since you're actually using 𝐿.
  7. Bash is imperative, but your favourite language is (probably) multi-paradigm —you can do imperative or more!
  8. By trying out API calls in your language 𝐿 instead of Bash, you get working code in your language right away that you can build an app around —no need to figure out how to do that later on in your language.

The next time you need to write a loop in Bash, consider breaking out your REPL and seeing what you can come up with instead!

Slightly paraphrasing from: How to Replace Bash with Python as Your Go-To Command Line Language

“Bash ↦ JavaScript” Personal anecdote: One time I automated a bunch of tedious tasks at work with Bash by using jc, which JSONifies the output of many CLI tools, alongside jq, a JSON query language; along with a friendly-alternative to curl known as httpie. However, as the Bash incantations grew larger and larger, it became more practical to switch to JavaScript and read the http payloads as proper JavaScript objects (rather than use jc), and quickly work with them via the usual JS methods .map, .filter, .reduce. With Bash, I used jq and it's special syntax, but with JavaScript I just use JS in both places 💐 Finally, this automated work required updating JSON configurations, but I wanted the result to be pretty-printed for future human readers. Since JSON is literally JS, it's most natural to use JS to work with JSON and so that's what I did. Below are 2 very useful methods from this Bash↦JavaScript move.

withJSON: Alter the contents of a JSON file as if it were a JavaScript object 
/** Alter the contents of a JSON file as if it were a JavaScript object.
 *
 * - `path : string` is a filepath to a `.json` file.
 * - `callback : function` is a (possibly async) function that mutates a given JS object.
 * - `newFile : boolean` indicates whether this is a completely new file, in which case `callback` is provided with an empty object.
 *
 * Trying to access a JSON file that does not exist, when not enabling `newFile`, will result in an error.
 *
 * Write the JSON file, and format it nicely.
 *
 * ### Example use
 * ```
 * // Add a new `WOAH` key to the configuration file.
 * withJSON("~/myConfig.json", data => data.WOAH = 12)
 * ```
 *
 * ### Warning! ---Also Design Decision Discussion
 *
 * A purely functional approach would require `callback` to have the shape `data => {...; return data}`.
 * However, we anticipate that most uses will be to update a field of `data` and so `callback` will
 * have the shape `data => {data.x = y; return data}` and we want to reduce the ceremony: We work with mutable references,
 * so that `data => data.x = y` is a sufficient shape for `callback`. However, this comes at the cost that we cannot
 * wholesale alter a JSON file ---which is an acceptable tradeoff, since this is likely a rare use case.
 *
 * ```
 * withJSON(`~/myfile.json`, data => data = {x: 1, y: 2})      // BAD! Will not alter the underyling JSON file.
 * withJSON(`~/myfile.json`, data => {data.x = 1; data.y = 2}) // GOOD!
 * ```
 *
 * A program should not just compute, it should also motivate, justify & discuss.
 * This human nature makes it easier to follow, detect errors, use elsewhere, or extend.
 * After all, the larger part of the life of a piece of software is maintenance.
 *
 * Flawed programs with good discussion may be of more use in the development of related correct code,
 * than working code that has no explanation.
 */
function withJSON(file, callback, newFile) {
  file = file.replace(/~/g, process.env.HOME)
  try {
    let data = newFile ? {} : JSON.parse(fs.readFileSync(file))
    callback(data)
    fs.writeFileSync(file, JSON.stringify(data, null, 2))
  } catch (error) {
    console.error(`🤯 Oh no! ${error}`)
    console.error(callback.toString())
    process.exit(0)
  }
}
shell: Run a shell command and provide its result as a string; or crash when there's an error 
/** Run a shell command and provide its result as a string; or crash when there's an error.
 * This is intentionally synchronous; i.e., everything stops until the command is done executing.
 *
 * @param {string} command - A Unix bash incantation to be executed.
 * @param {boolean} ignore - Whether to actually avoid doing any execution; useful for testing/experimentation.
 * @returns {string} The textual stdout result of executing the given command.
 *
 * - TODO: Consider switching to ShellJS.
 * - Why ShellJS? https://julialang.org/blog/2012/03/shelling-out-sucks/
 * - See also `Executing shell commands from Node.js`, https://2ality.com/2022/07/nodejs-child-process.html
 *
 * ### Examples
 * ```
 * // Who is the current user?
 * console.log( shell('whoami') )
 *
 * // Make me smile!
 * console.log( shell('fortune') )
 *
 * // See your Git credentials: Name, email, editor, etc.
 * shell("git config --list")
 *
 * // Crashes if the provided command does not exist
 * shell(`nonexistentprogram`); console.log(`You wont see this msg!`) // Boom!
 *
 * // Pass non-falsy second argument to invoke as a dry-run only
 * shell(`nonexistentprogram`, true); console.log(`You WILL see this msg!`)
 * ```
 *
 * Consider a program to be written primarily to explain to another human what it is that we want the computer to do,
 * how it is to happen, and why we can believe that we have achievied our aim.
 * (The “another human” might be you in a few months time when the details have escaped your mind.)
 */
function shell(command, ignore) {
  return ignore
    ? `\n🤖 This is a DRY RUN, so I haven't done anything but I would have:\n🧪🧪🧪\n${command}\n🧪🧪🧪`
    : require('child_process').execSync(command).toString().trim()
}

/** NodeJS dislikes `~` in file paths, so this helper lets you read files with `~` in their path.
 * @param {string} path - The (possibily relative) path to a file
 * @returns {string} The contents of the file located at the given path
 */
function readFile(path) {
  return fs.readFileSync(path.replace(/~/, process.env.HOME))
}
Quick Example of using JS as a command-line-language 
 var axios = require('axios')
 var { name, blog, bio } = (await axios.get('https://api.github.com/users/alhassy')).data
Java: run a shell command and see the output 
execCmd("whoami")  // ==> "musa\n"

// Source: https://stackoverflow.com/a/20624914/3550444
public static String execCmd(String cmd) throws java.io.IOException {
    java.util.Scanner s = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream()).useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}

Further reading:

Goal: Make an web server with a route localhost:3030/about that shows information about the user's environment variables.

rdd-teaching-a-js-runtime-to-be-a-webserver.png

First, 

   ;; C-x C-j now evaluates arbitrary JavaScript code, I'd also like docs for JS and Express
   (repl-driven-development [C-x C-j] "node" :docs "javascript express")

Then, here's how we do this …

Visit http://localhost:3030/about, if that works, then we're done! 

// First get stuff with C-x C-e:
// (async-shell-command "npm install -g express axios@0.21.1")

let app = require('/usr/local/lib/node_modules/express')()
let server = app.listen(3030) // 📚 Press “C-u C-u C-x C-j” to see docs about “listen” ;-)

// Now visit http://localhost:3030/
// ... and see “Cannot GET /”
// ... Neat, it works but it does nothing! Importantly it works!

// Let's add a route...
let visited = 1
app.get('/hi', (req, res) => res.send(`Hello × ${visited++}`))

// Now visit:  http://localhost:3030/hi
// Refresh the page a few times 😉

// Excellent; let's add an end-point to return the variables in scope
app.get('/about', (req, res) => res.send(html()) )

// Whoops, there's no “html”! So we see an error!
// Let's define that!
let
html = _ => "<div style='color:green; background-color:cyan'>" + info() + "</div>"

// Whoops, there's no “info”! So we see an error!
// Let's define that!
let info = function () { return {visited, user: process.env.USER, time: new Date() } }

// Uh-oh, we see “[object Object]” since we didn't convert the
// JS object into a JSON string, so let's fix that!
html = _ => "<div style='color:green; background-color:cyan'>" + JSON.stringify(info(), null, 3 /* indentation */) + "</div>"

/* uh-oh, the output doesn't look good; let's redefine `html` using <pre> tags.

   pre tells the browser engine that the content inside is pre-formatted and it can be displayed without any modification. So browser will not remove white spaces, new lines etc. code is for making it more semantic and denotes that the content inside is a code snippet. It has nothing to with formatting.
 */
html = _ => `<h1>Welcome, visitor ${visited++}!</h1><pre style='color:green; background-color:cyan'>` + JSON.stringify(info(), null, 3 /* indentation */) + "</pre>"


// Notice how we built this end-point from the top-down: We knew what we wanted, and saw some
// errors ---on the client side--- then fixed them right here, with no reloading!

// Actually, let's add more info: It's not enough to see the current user, let's see all environvment variable values
info = _ => ({user: process.env, time: new Date(), platform: os.platform(), architecture: os.arch(), home: os.homedir(), user: os.userInfo(), machine: os.machine()})

// So cool!

// Eventually, consider closing the server!
server.close()

TODO: Make the above into a short youtube video/*GIF*, where I keep “improving” the definition of html / info and see it live!

RDD is about Unobtrusive Redefining

Notice that our demonstration above is mostly redefining things, making interactive observations about them, then redefining them to be better.

Most importantly, this redefining cycle is not impeded by the need to restart the program each time.

Instead, the already-working program “learns” what we have taught it —and continues to be a working program.

Programming   ≈   Definitions and re-definitions

In the previous section we saw how easy it was to add & redefine things without having to restart our program; as such we have the motto “RDD ≈ Interactive Programming”.

In RDD, we can re-define functions & types live, as the program is running!
Future uses of the function/type will use the new definition!

In stark contrast, the traditinal approach forces us to restart the whole program whenever we make a modification, no matter how small! That's like rebuilding your entire house when you only wanted to put up a shelf! 🤮

Let's explore the issue of redefinitions a bit more.

If you define a function \(f\) and declare \(x = f()\), but then decide to redefine \(f\), what should happen to \(x\)? Well, \(x\) is already declared and already has a value, so nothing happens to it! If you want it to be the result of the re-defined \(f\), then re-evaluate \(x = f()\). 👍

However, when re-defining a data-type/class/record/struct, languages such as Java and Common Lisp, will insist that any previously defined instances now conform to the new data-type formulation! Likewise, for methods whose inputs are of the old formulation, they need to be updated to the new one.

Take a look at this interactive Java session… 

record Person(String name) { }
var me = new Person("Musa"); // New instance.
 // Can operate on it, using a functional *variable* or a *method*
Function<Person, String> speak = p -> p.name() + " says HELLO!"
String greet(Person p) { return "Hello, I'm " + p.name(); }


// Redefining our data-type
record Person(int age) { }
//
// ⇒
//  record Person(int age) { }
// |  replaced record Person
// |    update replaced variable me which cannot be referenced until this error is corrected:
// |      incompatible types: java.lang.String cannot be converted to int
// |      var me = new Person("Musa");


// ⇒ As such, since “me” cannot be updated to be an instance of the reformulated data-type, it is kicked out of scope!
me    // ⇒ No such variable is declared!
speak // ⇒ No such *variable* is declared!
greet // ⇒ No problem, but can only run it if you define a  Person::name  instance method! 😲

greet(new Person(12)) // ⇒ Attempted to call method greet(Person) which cannot be
                      // invoked until method name() is declared

Whereas Java says you can no longer use stale instances, Common Lisp tries to “re-initialise” existing instances —and prompts the user if it cannot do so automatically. The Common Lisp approach may have benefits, but it comes at a dangerous cost: Your runtime is now no longer tied to text you've written! It is for this reason, that MELPA intentionally does not allow users to run code in the *REPL/⋯* buffers: If you want to modify the running system, write your modification down (in your working buffer, then save,) then evaluate it.

3. Concluding Remarks

I've found RDD to be a fun way to code. I get fast feedback from my code as I design it, being able to test my assumptions against how the code actually works. When I'm satisfied with something, I codify that behaviour via unit tests so that I'm aware when my evolving design diverges —as I continue iterating on the design in the REPL.

rdd-workflow.png

Some languages have tight integration with Emacs!

Programs in these languages are essentially “constructed incrementally” by “interactive conversations” with Emacs (as the REPL).

The first such language is Common Lisp. Which also inspired a similar setup for Smalltalk —e.g., Pharo and Squeak.

I hope you've enjoyed this article!

Bye! 👋 🥳

Appendix: Recipes for a number of languages

🔗
JavaScript ---and a minimal server

We can set up a JavaScript REPL in the background as follows… 

   ;; C-x C-j now evaluates arbitrary JavaScript code
   (repl-driven-development [C-x C-j] "node -i")

That's it! Press C-x C-e on the above line so that C-x C-j will now evaluate a selection, or the entire line, as if it were JavaScript code.

  • Why C-x C-j  ?  Well, C-x C-“e” for Emacs Lisp code, and C-x C-“j” for JavaScript code!
  • For instance, copy-paste the following examples into a JavaScript file —or just press C-x C-j in any buffer to evaluate them!
1 + 2                                     // ⮕ 3

1 + '2'                                   // ⮕ '12'

let me = {name: 'Jasim'}; Object.keys(me) // ⮕ ['name']

me.doesNotExist('whoops')                 // ⮕ Uncaught TypeError

All of these results are echoed inline in an overlay, by default. Moreover, there is a REPL buffer created for your REPL so you can see everything you've sent to it, and the output it sent back. This is particularly useful for lengthy error messages, such as those of Java, which cannot be rendered nicely within an overlay.

How this works is that Emacs spawns a new “node -i” process, then C-x C-j sends text to that process. Whenever the process emits any output —on stdout or stderr— then we emit that to the user via an overlay starting with “⮕”.

Finally, “C-h k C-x C-j” will show you the name of the function that is invoked when you press C-x C-j, along with minimal docs.

A useful example would be a minimal server, and requests for it. 

// First get stuff with C-x C-e:
// (async-shell-command "npm install -g express axios")

let app = require('express')()
let clicked = 1
app.get('/hi', (req, res) => res.send(`Hello World × ${clicked++}`))

let server = app.listen(3000)
// Now visit   http://localhost:3000/hi   a bunch of times!

// Better yet, see the output programmatically...
let axios = require('axios')
// Press C-x C-j a bunch of times on the following expression ♥‿♥
console.log((await axios.get('http://localhost:3000/hi')).data)

// Consider closing the server when you're done with it.
server.close()

Just as “Emacs is a Lisp Machine”, one can use “VSCodeJS” to use “VSCode as a JS Machine”. See http://alhassy.com/vscode-is-itself-a-javascript-repl.

🔗
Python

We can set up a Python REPL in the background as follows… 

    ;; C-x C-p now evaluates arbitrary Python code
    (repl-driven-development [C-x C-p] "python3 -i")

Example use… 

1 + 2             # ⮕ 3

hello = 'world!'  # (No output; this is an effectful operation)

print(hello)      # ⮕ world!

2 + 'hi'          # 🚫 TypeError: unsupported operand type(s) for +

Learn more by reading… Python: A Gentle Introduction to Socket Programming

🔗
Java

We can set up a Java REPL in the background as follows… 

(repl-driven-development [C-x C-j] "jshell --enable-preview" :prompt "jshell>")

Now, we can select the following and press C-x C-j to evaluate the Java code: 

// Ensure you're not fullscreen, and you'll see a dialog window appear.
import javax.swing.*;
JOptionPane.showMessageDialog(new JFrame(), "Super nice!");

Or doing algebraic datatypes in Java: 

sealed interface Maybe {
    record None() implements Maybe {}
    record Just(int x) implements Maybe {}
}

var thisPrettyPrintsNicelyInTheREPL = new Maybe.Just(3);

new Maybe.Just(3).equals(new Maybe.Just(3)) // yay
🔗
Clojure

We can set up a REPL in the background as follows… 

   ;; C-x C-k now evaluates arbitrary Clojure code
   (repl-driven-development [C-x C-k] "clojure" :prompt "user=>")

For example… 

(+ 1 2) ;; ⮕ 3

(defn square [x] (* x x)) ;; ⮕ #'user/square
(square 3) ;; ⮕ 9
🔗
Haskell

We can set up a REPL in the background as follows… 

   ;; C-x C-h now evaluates arbitrary Haskell code
   (repl-driven-development [C-x C-h] "ghci" :prompt "ghci>")

For example… 

-- Sum of the first 100 squares
sum [ x ** 2 | x <- [1..100]] -- ⇒ 338350.0

-- The positive evens at-most 12
[x | x <- [1..12], x `mod` 2 == 0] -- [2,4,6,8,10,12]

-- Define a function...
myLast = head . reverse

-- Then use it...
myLast [1, 2, 3] -- ⇒ 3

Note that Haskell has “typed holes” with the syntax _A: 

1 + _A  -- ⇒ Found hole: _A::a; it :: forall {a}. Num a = a

Another language with typed holes is Arend…

🔗
Arend: Quickly making a terse Emacs interface for a language without one

The Arend Theorem Prover has an IntelliJ interface (since it's a JetBrains proof assistant), but no Emacs counterpart —which may be annoying for Agda/Coq programmers accustomed to Emacs but want to experiment with Arend.

We can set up an Arend REPL in the background as follows… 

    ;; C-x C-a now evaluates arbitrary Arend code
    (repl-driven-development [C-x C-a]
                             (format "java -jar %s -i"
                                     (f-expand "~/Downloads/Arend.jar")))

Then, 

1 Nat.+ 1 -- ⇒ 2
:type 4  -- ⇒ Fin 5

-- Declare a constant
\\func f => 1
:type f -- ⇒ Nat
f -- ⇒ 1

-- Declare a polymorphic identity function, then use it
\\func id {A : \\Type} (a : A) => a
id 12  -- ⇒ 12

-- Arend has “typed holes”
1 Nat.+ {?}  -- ⇒ Nat.+{?}: Goal: Expectedtype: Nat
🔗
PureScript

First brew install spago, then we can set up a PureScript REPL in the background as follows… 

    ;; C-x C-p now evaluates arbitrary PureScript code
    (repl-driven-development [C-x C-p] "spago repl")

For example…. 

import Prelude

-- Define a function
add1 = (\x -> x + 1)

-- Use the function
add1 2    -- ⇒ 3

-- Experiment with a typed hole
1 + ?A  -- ⇒ Hole ?A has the inferred type Int
🔗
Idris

First brew install idris2, then we can set up an Idris REPL in the background as follows… 

    ;; C-x C-i now evaluates arbitrary Idris code
    (repl-driven-development [C-x C-i] "idris2")

Here's some random code… 

-- Like Lisp, Idris uses “the” for type annotations
the Nat 4  -- ⇒ 4 : Nat

with List sum [1,2,3] -- ⇒ 6

-- defining a new type (REPL specific notation)
:let data Foo : Type where Bar : Foo

:t Bar -- ⇒ Foo

-- Experiment with a typed hole [Same notation as Haskell]
1 + ?A -- prim__add_Integer 1 ?A
🔗
Racket
Racket is a modern programming language in the Lisp/Scheme family.

First brew install --cask racket, then we can set up an Racket REPL in the background as follows… 

    ;; C-x C-i now evaluates arbitrary Racket code
    (repl-driven-development [C-x C-r] "racket -I slideshow")

Here's some random code… 

(define (series mk) (hc-append 4 (mk 5) (mk 10) (mk 20)))

;; Shows 3 circles of increasing radius, in an external window
(show-pict (series circle))

Meeting Racket for the first time is probably best done with DrRacket.

]]> https://alhassy.github.io/repl-driven-development.html https://alhassy.github.io/repl-driven-development.html Fri, 08 Sep 2023 00:00:00 -0400 <![CDATA[Arabic CheatSheet]]>

Article image
Abstract
This is a quick reference of concepts in the Arabic language.

1. Sentences without Verbs

English sentences are usually of the form Subject + Verb + Object. Recall that a verb is an “action word”; the subject is the one doing the action; and the object is the one having the action done to them. Arabic sentences do not need verbs! These are known as equational, non-verbal, sentences.

I am Samir ≈ سمير انا
He is tall ≈ طويل هو

Each sentence above has (1) a subject [the topic of the sentence: A noun or pronoun] and (2) a predicate [information about the topic; e.g., a noun or an adjective].

  • Notice the English has “am”, which is not needed in Arabic.
  • A noun is a person, place, or thing.
  • A pronoun is a word such as “He, him, her, this, that, …”

The predicate can either be a (pro)noun that renames the subject —as in \arb{سميرُ طالبٌ} which "renames" the subject Samir to the subject doctor—; or the predicate can be an adjective that describes the subject —as in \arb{سميرُ طويلٌ}. If the predicate is a definite noun (discussed below!), then it does not use nunation; e.g., \arb{هو الطالبُ} He is the doctor.

2. Adjectives

Adjectives, “descriptive words”, follow nouns and must agree with them in gender, number, definiteness, and case. The agreement is what distinguishes a noun-adjective phrase from an equational sentence!

the new book ≈ الكتابُ الجديدُ
The book is new. ≈ الکتابُ جديدُ.

3. Questions

The question marker هَلْ is placed at the start of a statement to turn it into a question.

You are a student. ≈ انت طالب.
Are you a student? ≈ هل انت طالب؟
  • ما has many uses in Arabic, one of them being the question word “what” ---which can only be used with things, not people!
  • مَنْ [`men'] means “who” and is used to refer to people. − (Becareful not to confuse this with the preposition from, مِنْ [`min']!)
  • أيْنَ means “where”.
What is this? ≈ ما هٰذا؟
Who is this? ≈ من هذا؟
Where are you from? ≈ مِنْ أين أنتَ؟

4. Inflection & Conjugation

The “shape” of an Arabic word changes to tell us information about the word.

  • “Conjugation”: Verbs change with who is doing the action.
  • “Case”, الاعراب: Nouns, and adjectives, change to tell us whether they are doing an action, are having something done to them, or own/possess something.

For example, in English, there are 3 ways to refer to oneself: I, me, my.

My cat saw me, and I jumped!

The shape of the word depends on its case. Here's the rules:

  • (Nominative!) When I am doing something, I say: I did it
  • (Accusative!) When something is being done to me, I say: It was done to me.
  • (Genitive!) When I have an item, I say: My thing….

So, in English, the word used to refer to myself changes depending on what is happening by me, to me, or of me / what I own.

5. Nominative Case

Case refers to the form a word —mostly nouns and adjectives— take depending on their function in a sentence. The subject of any sentence will always be in the nominative case, which is indicated by placing a ـُـ at the end of the word. The only other time a word will be in the nominative is if it is the predicate of a non-verbal sentence.

He is the student ≈ هو الطالبُ   huwa al-talib-u
He is a student ≈ هو طالبٌ   huwa talib-un

Pronouns, such as انا} and \arb{هذا, do not have case endings.

I am the teacher ≈ انا المدرسُ   ana al-mudaras-u

6. معرفة Definiteness

A word is considered definite معرفة when it refers to something specific in the world, and indefinite نكرة when it does not. For example, “a car” or “cars” do not refer to anything specific in the world and thus both examples are indefinite. Conversely, “my car” or “my cars” both refer to specific / known objects in the world and thus both examples are definite.

When is a word definite?

  1. If it is a proper name such as احمد.
  2. If it has the definite article ال/“the” in front of it.
  3. If it is a pronoun —i.e., it already refers to something. Such as هو or هذا.
  4. If it is owned by something; e.g., book is definite in both John's book (Idaafa) and his book (Possessive pronoun ending). Both concepts are discussed below!

7. Nunnation/Tanween

Arabic does not have an indefinite article: To make a word indefinite, we double its case ending; with the second instance pronounced as ن, “n”. This doubling of case endings, and adding the sound “n”, is known as Tanween. For the nominative case, the ــُــ is written twice but often written in the shape ــٌــ.

An indefinite adjective (usually one without ال) will have tanween:

The student is new ≈ الطالبُ جديدٌ   al-talib-u jadeed-un

8. Case endings of Equational Sentences

From the preceding discussions: Both the subject and predicate of an equational sentence should be in the nominative! Remember that the subject can be any (pro)noun and the predicate is any (pro)noun or adjective —if it is an adjective, then it is indefinite and so ends in ــٌــ.

9. Helping Vowels for أَل

  1. The hamza-fatha of the definite article أَل will always be replaced by the final vowel of the preceding word; thus the two words sound like one word!

    You (m) are the director ≈ انتَ المُدير antal-mudiir
    You (f) are the director ≈ انتِ المُديرة antil-mudiira

  2. When أَل} follows a “sun letter” is also not pronounced.

    You are the student ≈ انتَ الطّالب antat-talib

  3. Most words end in vowels, since Arabic case endings are vowels. If a word does not end in a vowel, such as هَلْ, then we add a helping kasra vowel:

    Is the director an idiot? ≈ هَلِ المُديرُ بليد؟ halil-mudiiru baled?

    The only exception to this rule is the word مَنْ, which gets a helping fatha vowel.

10. اسماء الإشارة —“This is a X” —“This X” —“This is the X”

  1. “This” هٰذا is used to refer to things that are close by, whereas “that” ذالِكَ refers to objects that are distant or is used in a constrast: هٰذا طالبٌ وذلِكَ مُدرِّسٌ, This is a student and that is a teacher. The feminine forms of “this” and “that” are هٰذِهِ and تِلْكَ.
  2. Whenever any of these 4 words is followed by a definite noun, we have one unit meaning “this noun”.
    • Such phrases often serve as the subjects of an equational sentence.
  3. We can separate this one unit into two pieces by inserting a pronoun in-the-middle, which gives us “This is the noun”.
1. This is a book. ≈ هذا كتاب.
2a. this book… ≈ هذا الكتاب...
2b. This book is heavy. ≈ هذا الكتابُ ثقيلٌ.
3. This is the book. ≈ هذا هو الكتابُ.

11. The Accusative Case

The Accusative Case is mostly used for the direct objects of verbs: It is indicated by a fatha. For example,

  I studied the book.
≈ دَرَسْتُ الكتابَ.

Notice that above we did not write أنا, “I”, since verbs change shape to tell us who is doing the action! (Changes to nouns is called case; changes to verbs is called conjugation!)

There is one more rule. To place an indefinite word not ending in ة} in the accusative —which makes the sound “an”. E.g., I studied a book becomes درستُ کتاباً.

12. Genitive Case

The genitive case is used for a word following a preposition or a word occuring as the second or later term in an Idaafa construction (discussed below).

Prepositions are words like عن، الی، لِ، بِ، في، علی، مِن، قبل: They are written “pre”ceeding a word and tell us something about its “position”.

The genitive case ending is a final kasra for a definite word and two kasras for an indefinite word, with the second kasra pronounded as ن as in the Nominative case.

Let's explain the following example.

انتَ المُديرُ في هٰذا المکتبِ
You are the director in this office.

Here انت المدير is an equational sentence followed by a prepositional phrase. Both the subject and predicate of an equational sentence should be in the nominative, but انت} is a pronoun and so does not take case. Moreover is definite, it takes a single dhamma. Finally, since هذا المكتب is a demonstrative followed by a definite it is treated grammatically as a single word, which means the (genitive) case ending goes at the very end of المكتب.

13. Idaafa

Idaafa means “addition“, or “annexation“, and it is used to indicate possesion in Arabic —just like how English uses 's to indicate possession.

  John's book
≈ the book of John
≈ كتابُ جون

Idaafa, possesion, is formed by putting nouns next to each other —to make a super-duper big noun, formally called a noun-phrase. That is all.

13.1. Noun-phrases of Idaafa

Noun-phrases are similar to nouns:

  • This noun-phrase is (in)definite exactly when its final noun is (in)definite.
  • This noun-phrase takes case endings on its first noun.
    • All other words in the noun-phrase must be in the genitive case.
    • Only the final noun can have nunnation.
  This is an office director's car
≈ This is a car of a director of an office
≈ هذه سيارةُ مديرِ مکتبٍ

13.2. Noun-phrases and “this”/“that”

Remember that demonstratives form noun-phrases and so can be used in-place of a noun in an Idaafa.

  The director of this office is stupid.
≈ مُديرُ هذا المكتبِ بليدٌ

This is an equational sentence. The subject is مدير هذا المکتب which needs to be in the nominative case, and it is definite since the last word is definite, thus only one dhamma needs to be added (to the first noun; and the last noun gets no nunnation). The topic is بليد which must also be in the nominative indefinite.

14. Descriptions for Idaafa

In English, a descriptive word can come before the owned item: John's heavy book. In Arabic, adjectives must follow the Idaafa and cannot interrupt it: کتاب جون الثقيل. For example, here is an equational sentence whose subject is a 3-term Idaafa followed by the adjective Arabic (remember only the last term in an Idaafa can have ال):

The study of Arabic grammar is enjoyable ≈ دراسةُ قواعدِ اللغةِ العربية مُمتعةٌ

14.1. Agreement

Since adjectives come after an Idaafa, how do we describe different parts of the Idaafa? Easy; adjectives must “agree” with the word they describe: They must have the same gender, number, definiteness, and case as the word being described.

The teacher's new book is in the office. ≈ . كتابُ المدرسِ الجديدُ في المکتبِ
The new teacher's book is in the office. ≈ . کتابُ المدرسِ الجديدِ في المکتبِ

(Usually only the last term of an Idaafa is actually modified by an adjective.)

14.2. Multiple adjectives

Of-course you can modify multiple words, or use multiple modifiers on the same word!

the new student of the Americian university ≈ طالبةُ الجامعةِ الامريکيةِ الجديدةُ
the student of the new Americian university ≈ طالبةُ الجامعةِ الامريکيةِ الجديدةِ

15. Sound Plurals

A sound plural is an ending added to a word to make it plural. The ending communicates gender, case, and definiteness.

  Nominative Genitive & Accusative
Masculine indefinite ـونَ ـينَ
Masculine definite ـي ـو
Feminine definite ـاتٌ ـاتٍ
Feminine definite ـاتُ ـاتِ

Notice that the usual small nunation symbols making the ن-sound actual become the ن-letter! As such, the actual ن is written or not depending on the general rules of nunnation.

In Arabic, you must learn the plural of each word when you learn its singular form. However, many words referring to human males have sound plurals. Likewise, many words ending in ة have a feminine plural by replacing the final ة with ـات.

For example,

I saw the directors. ≈ رَأیْتُ المُدیرينَ.
The directors are superb. ≈ المُديرونَ ممتازونَ.
The (female) directors are superb. ≈ المُديراتُ ممتازاتُ.
I saw the newspaper reporters. ≈ شاهدتُ مراسلي الجريدةِ.

15.1. Sound Plurals and Possessive Endings

Remember: Possessive endings make words genitive & definite, and so nunnation cannot apply.

his teacher ≈ مُدرسهُ
his teachers ≈ مُدرسيهِ
my teacher ≈ مُدرسي
my teachers ≈ مُدرسيّ

Let's talk more about possessive endings… ;-)

16. Pronouns

A pronoun is a word that stands-in for a noun. For example, below we refer to someone in 3 different ways:

His cat saw him, and he jumped!

16.1. Personal Pronouns

A personal pronoun replaces a noun that refers to a person (e.g., Jasim ate ≈ he ate),

  singular plural
1 أنا I نَحْنُ we
2m أَنْتَ you انْتُمْ you
2f أَنْتِ you انتُنَّ you
3m هُوَ he/it هُمْ they
3f هِيَ she/it هُنَّ they

When I am talking, the speaker is the “first person” (“1”); when taking about you, then you are the “second person” and may be masculine (“2m”) or feminine (“2f”), or a group of you (“plural”); finally, when talking about someone who is not here in the conversation, they are in the “third person” (“3m, 3f”).

16.2. Possessive & Object Pronouns

A possessive pronoun replaces a noun that involves ownership (e.g., Jasim's book ≈ his book), while an object pronoun replaces a noun that is having an action done to it (e.g., I saw Jasim ≈ I saw him.)

In Arabic, possessive and object pronouns are attached pronouns; they are joined to the end of a word: For example, house بیت becomes my house بیتِي and from he helped نَصَرَ we get نَصَرَني he helped me. Arabic's object & possessive pronouns are the same, except for the “my/me” case:

  singular plural
1 ـِي my; ـني me ـنَا our/us
2m ـكَ your/you كُمْ your/you
2f ـكِ your/you كُنَّ your/you
3m ـَهُ his/him ـهُمْ their/them
3f ـَهَا hers/her ـهُنَّ their/them

The dhamma of the endings ـهُ ، ـهُم ، ـهُنَّ becomes a kasra whenver these endings come after a kasra or a ي.

an office ≈ مکتبٌ
in an office ≈ في مکتبِ
in his office ≈ في مکتبِهِ

17. Kinds of Arabic Verbs

Sound Verbs
Verbs with no \arb{و} or \arb{ي} as a root.
Defective Verbs
Verbs whose last root is either \arb{و} or \arb{ي}.
Hollow Verbs
Verbs whose middle root is either \arb{و} or \arb{ي}.
Assimilated Verbs
Verbs whose first root is either \arb{و} or \arb{ي}.
Doubled Verbs
Verbs whose second and third roots are the same.

These are not a big deal. They happen often enough to get names.

]]> https://alhassy.github.io/arabic-cheat-sheet.html https://alhassy.github.io/arabic-cheat-sheet.html Wed, 14 Jun 2023 00:00:00 -0400 <![CDATA[A Brisk Introduction to Karate]]>

Article image
Abstract

What are the basic forms of Karate? What is Karate?

“The ultimate aim of karate lies not in victory or defeat but in the perfection of the character of its participants … to subdue the enemy without fighting is the highest skill, know your enemy and know yourself, in a hundred battles you will not be defeated” says Gichin Funakoshi —known as The Father of Modern Karate.

Karate means “empty hand” and was developed on the island of Okinawa —part of modern-day Japan. The major styles (“Ryu”) are Shotokan, Wado-ryu, Shito-ryu, and Goju-ryu —many other styles of Karate are derived from these four. I'm focusing on Goju-Ryu in this article: Goju-Ryu was founded by Chojun Miyagi; whose colleague, Gichin Funakosi, founded Shotokan-Ryu.

Article image

Occasionally one sees Karate-Do, which means “the way of the empty hand”. This usage is a reminder that Karate is not just about fighting, but is also a spiritual discipline.

The basic form of Goju-Ryu karate is Sanchin, “3 battles”: The battles of the mind, the body, and the spirit. However, this was considered a bit difficult for beginners, and so new forms were needed as a way of introducing fundamental karate forms to a wider audience. There are the “peaceful and safe” forms known as Pinan/Heian, the “first course” or Taikyoku forms, the “popularising forms” known as Fukyugata —the second of which was rebranded as “attack & smash”, Gekaisai— and, finally, there is the so-called Dachi-waza form. This last one is relatively new, and aims to be a smooth introduction to the world of forms/Kata.

In this article, I'd like to discuss the basic forms and their relationships.

Article image

1. Kata: Learning by Patterns

Kata means “forms”, which are patterns used to learn sequences of techniques. Besides teaching kicking, strikes, etc; the repetition of patterns/Kata improves physical conditioning and muscle memory.

  • Interestingly, the phrase “kata” is used in Software Engineering for the same goals: To refer to “families of similar (coding) problems” which may be solved using an existing set of “design patterns”.

In general, repeating a fixed pattern over and over —i.e., “doing kata”— reinforces the knowledge of fundamental techniques and stances via repetition. However, there are numerous other benefits:

Solo Practice
Training without a partner is important, since you can then train whenever and wherever you want. E.g., at your lunch break at work.
Mucle Memory
Repeatedly practicing kicks, strikes, blocks, etc, means it will become easier to perform them, and doing them in fixed sequences means your body will internalise different combinations. E.g., middle-block, followed by forward-punch, and concluding with a snap-kick.
Improved Fitness

Doing a kata, while focusing on your breathing & stances, is itself a quick workout. Adding weights, or doing the kata on your toes only, or doing them slowly, or with extra power, not only provide a challenge but also make the kata into a sort-of moving meditation: Gichin Funakoshi says, In traditional karate-do, we always keep in mind that the true opponent is oneself.

  • Of-course “real opponents move fast”, so one can also try practising the kata at increased speeds, but ensuring the techniques are performed correctly.
  • “Imaginary opponents don't hit back”, so the addition of weights, or the use of extra power, can be used to compensate.

When you train, do so as if on the battlefield. Your eyes should glare, shoulders drop, and body harden. You should always train with intensity and spirit and in this way you will naturally be ready. —Anko Itosu

Safety

Dangerous techniques can be practised without anyone getting hurt. E.g., leg breaks, or the use of weapons, can be practised against an imaginary opponent before actually practising with a real person.

Do not think that you have to win, think rather that you do not have to lose. —Gichin Funakoshi

Application / Bunkai
When fixed patterns are already learned, one can adapt them to various real-life situations involving another person. I personally liked it when the teacher would explain immediate applications of a pattern while I was learning the pattern: It made it easy for me to imagine an opponent attacking me as I practised the kata. Unfortunately, some teachers insist on learning the patterns first, then learning the applications.
  • I think having some immediate application removes boredom, for beginners especially; otherwise, the kata may feel too rigid and vague.
Accessibility

Anyone can join in! E.g., I've done kata with my kids: It's a fun little dance we do together; the goal is to have fun as a family.

The ultimate aim of Karate lies not in victory or defeat, but in the perfection of the character of its participants. —Gichin Funakoshi

The benefits of kata depends on your end-goal: Are you looking for a workout? Practising fundamental kicks & stances? Fighting imaginary opponents? Or is it just a way to relax from a hectic day. It's important to keep in mind that Karate is not just about fighting!

The different uses of Karate

Approach Goal
Self-defence Practising with other people; practising real-life dangerous situations
Art-form Like painting, the goal is to relax, get creative, and get disciplined
Sport Like soccer, the goal is to master the patterns and win competitions

I like Karate because it's a nice way to stay physically healthy and meet new people.

See also:

2. Succession of Miyagi   The Five Taikyokus

Following the death of Chojun Miyagi Sensei in 1953, four main schools teaching Goju Ryu emerged.

School Founder
Meibukan, The House of the pure-minded warrior Meitoku Yagi
Jundokan, House in which we follow in the master’s footsteps Eiichi Miyazato
Shoreikan, House of politeness and respect Seikichi Toguchi
Goju Kai, The Japanese Goju Association Gogen Yamaguchi

The graphic of this article, the closed fist, is the symbol of Goju Kai which was popularised in Ontario, Canada, by Don Warrener. Initially, Miyagi tasked Gogen “The Cat” Yamaguchi with spreading Goju Ryu in mainland Japan, outside of Okinawa: Yamaguchi designed the closed fist symbol, based on the right hand of Miyagi; he unified all karate schools in Japan; he propagated Goju all over the world. Moreover, in this Goju Kai style, Yamaguchi added to the Goju system the “Taikyoku Katas”, First-course formations, which consists of 5 formations all making an “I”-shape in movement: The student starts at the bottom-middle of the “I”, moves left, then right, then up, and eventually back down to the starting position. Each formation reinforces basic principles, such as a certain block and stance. These are intended as training methods for the beginner students to prepare them for the more advanced kata.

Other schools skip these “school-children” fundamentals and start-off with Gekisai Ich, Attack and Destroy, which is known as Goju Karate's first Kata. However, the Jundokan school works up to this Kata a different way…

3. From Standing to Destroying   TeshiWaza FukyuKata Gekisai

Jundokan starts with these

TeshiWaza, Stances, or Formation-11
Fukyu Kata 1, to Spread or to Make Popular formation
Fukyu Kata 2, to Spread or to Make Popular formation

The Fukyu Kata were made to popularise Karate and make it accessible. Miyagi renamed Fukyu Kata to Gekisai Dai Ichi, “Attach and Destroy 1” —of-course the second kata of Goju Karate is known as “Attack and Destroy 2” or Gekisai Dai Ni.

  • Geki ≈ to attack
  • Sai ≈ to smash, break, crush
  • Gekisai ≈ to pulverise, to attack and destroy

The aggressive renaming of the ‘popularising’ kata, in the 1940s, may have been due to Japan's war-time efforts.

tachi-fukyu-gekai-sai.png

4. Jundokan: Standing in Style   Tachi_Waza_Kata

Eiichi Miyazato was a Judo champion and a student of Miyagi; he wanted to pass on Miyagi's legacy and so opened his own training-hall: The Jundokan —which literally means House of Father's Way or House for Following in the Father's Footsteps. Among his famous students is Teruo Chinen, who introduced “Tachi-Waza Kata” into the Jundokan Goju Kata syllabus.

Note: Tachi and Dachi are the same word, in Japanese, meaning stance. The sound changes depending on if the letter is the start of a word.

Above is “Formation 11”, a slight variation of “Dachi-Waza Kata” which is performed as follows.

Article image

Starting with heels touching, toes pointing out, and hands to the side.

  1. Article image Article image Musubi-dachi, Joining/United stance; Formal Attention stance
    • Heels together, toes open at about 45 degrees;
    • Hands move up to waist: Hands remain on the sides of the waist through-out!
    • In this stance, the body should be straight, knees are slightly bent, heels are touching and feet are pointing out making a 45° angle.
  2. Article image Article image Heiko-dachi, Parallel stance; Attention Stance
    • The feet open to shoulder width apart, and their outer edges are parallel.
    • In this stance, the feet are shoulder-width apart, the big toes and the second toes should face forward, the inner edges of the feet are parallel, and the center of gravity is at the mid-point between the two feet.
  3. Article image Sagi-ashi-dachi, Heron-foot stance
    • left leg steps to the left, right leg follows then upward with the knee
    • In this stance, one leg is raised and bent while the other leg is slightly bent and supports the whole body weight The toe of the raised leg points downward.
    • This is also known as Tsuru-ashi-dachi, Crane-foot stance.
  4. Sagi-ashi-dachi - to the right

  5. Article image Article image Zenkutsu-dachi, forward stance - to the left

    • This is a long frontal stance where the weight is mostly on the front leg.
    • It has exactly the same height as shiko-dachi (below), but the rear leg is completely straight at the knee and extended back.
    • The front foot is placed frontal (toes facing forward), the rear foot is turned out 30 degrees, but never 90 degrees as seems natural to new practitioners because this precludes any forward motion.
    • The heel of the rear foot rests on the ground.

    Zenkutsu is performed as follows:

    1. From the natural stance, step forward so that the distance between the back foot and the front foot is roughly about one and a half to two shoulder width
    2. The feet are one shoulder width apart
    3. The front foot points forward and the back foot points diagonally at about 30 degree angle
    4. The front knee is bent, turned slightly inward, and should be forward enough that you are not able to see the toes
    5. The back leg is naturally straight but not locked
    6. Most of the body weight is placed on the front leg
    7. The heel of the back leg should be placed firmly on the ground.
  6. Article image Article image Kokutsu-dachi, Back Long stance - to the right, but head still facing to the left
    • This is a back stance derived from the zenkutsu dachi stance.
    • Start with zenkutsu dachi, move your back leg across so that the front leg and the back leg are on the same line.
  7. Zenkustu Dachi - back to the left

  8. Article image Article image Sanchin-dachi, Three Battle stance - take a step into sanchin, facing leftwards

    This is the most difficult stance to master and probably the most important stance in Goju Ryu. It is performed as follows:

    1. Begin with heiko dachi, step one foot forward
    2. The heel of the front foot should be on the same line as the toes of the back foot
    3. The toes of both feet should turn inward slightly
    4. The front foot is turned inward at about 20° angle
    5. Tense your tandien, buttocks and thigh muscles and then pull the hips upwards
    6. The knees should bend and turn inward
    7. The feet should be placed firmly on the ground with the toes gripping the ground
    8. The center of gravity should be at the midpoint between the two feet
    9. Keep your back straight and your chin tucked in.

    Sanchin kata, considered the core and most difficult kata in Goju Ryu is done entirely in the sanchin dachi stance.

  9. Zenkusti Dachi - Look right, then with right leg move into Zenkutsu, then end-up facing rightwards with right leg at the front. Through-out the left remains in-place, just pivoting.
  10. Kokustu Dachi - to the left, but head still facing to the right
  11. Zenkustu dachi - back to the right
  12. Sanchin Dachi - take a step into sanchin, facing rightwards

  13. Article image Article image Hesoku-dachi, feet together stance; informal attention stance - right moves up to touch the left, then head faces to the front center

    In this stance, your back is straight and relaxed, your feet are placed together, and the weight is equally distributed between the two feet.

  14. Zenkustu dachi - to the front center, with left leg leading
  15. Article image Hachiji-dachi, Natural stance - right leg takes a step forward, left follows, to end-up in a should-width stance
    • This stance is close to the natural way people stand.
    • The feet are shoulder width apart, the toes point out at about 45°, the body is relaxed and the knees are slightly bent.
  16. Zenkustu Dachi - look over the left-shoulder, turn with left leg; end-up in left leading zenkustu facing the back right corner

  17. Article image Article image Neko Ashi Dachi, Cat stance - Bring the left back, with toes on ground, heel up.

    To assume neko ashi dachi:

    1. Start with musubi dachi (formal attention stance) and step forward for a distance of about one foot
    2. Lower the hips deeply and transfer most of the body weight to the back leg
    3. The front leg is bent and the heel of the front leg is raised slightly with only the toes and the ball of the front foot touches the ground
    4. The back foot points outward at about 30 to 45 degree angle
    5. About 90% of the body weight is placed on the back foot.

    Note:

    • All weight rests on the back leg, which is bent at the knee.
    • The rear foot is turned at about 20-30 degrees out and the knee sits at the same angle.
    • Only the toes of the front foot rest on the ground, positioned in front of the back heel.
    • There is no weight on the front foot, and there is no bent in the ankle joint - front knee, front shin, and the rise of the foot (but not the toes) form a single line.

  18. Article image Bensoku-dachi, Cross-legged stance - Drop the left down, toes pointing to the right. Right steps towards the back right corner of the room. Finally, left leg slides behind the right leg, ending with the heel up and the toes planted and facing the right leg.

    To assume bensoku dachi:

    1. Cross one leg behind the other
    2. Bend both knees
    3. The front foot is placed firmly on the ground but only the ball of the back foot touches the ground
    4. The knee of the back foot is nested against the back of the front knee.

    Bensoku dachi is a transitional stance that is used when one needs to change direction. It appears in kata like Seiyunchin and Sepai.

  19. Zenkustu with the right leg towards the back left of the room; the left leg only pivots.
  20. Neko Ashi Dachi - Bring the right leg back into a cat stance
  21. Drop the right down and do a Bensoku Dachi

  22. Article image Article image Shiko-dachi, Square Stance, Horse Stance, Straddle Leg Stance

    The left leg moves towards the back of the room, ending in a shiko dachi; right leg remains where it is.

    The toes face out at about 45 degrees. Knees point outward, and stance is often low.

    To assume shiko dachi, start with hachiji dachi stance, turn the heels to point the toes outward at about 45 degrees and lower the hips.

    In this stance:

    • The feet are about two shoulder width apart
    • The big toes point outward diagonally at about 45 degrees
    • The knees are turned outward
    • The back is straight
    • The hips are lower than in kiba dachi and the thighs are almost parallel to the ground
    • The body weight is evenly distributed between the two legs
    • The soles of the feet are firmly in contact with the ground.

    Shiko dachi is a great stance for developing lower body strength and stability.

  23. Look rightwards towards the center of the room, then do a shiko dachi —ending with body facing the right side of the room; i.e., right leg is in the back.
  24. Bring the back leg, the right leg, up to the front leg into a Musubu Dachi.

5. Fukyu Kata Ichi

  1. Kyotsukei, Attention: Palms at sides, arms straight
  2. Rei, Bow: Eyes slightly down, hands still at sides
  3. Kamae, Ready stance: heels together Palms down in front of body, L hand over R hand
  4. Turn left into a left forward stance; down-block with left-hand
  5. Step forward with right foot into Right forward stance; right middle (solar plexus) punch
  6. Turn around into a right forward stance, while doing a right down-block
    1. Move right foot behind body and to the left
    2. Extend left arm and chamber with right fist at left elbow
    3. Pivot 180°-rigtwards, on the left-foot, into right forward stance
    4. Right down block
  7. Step forward with left foot into left forward stance; left middle (solar plexus) punch
  8. Turn 90°-leftward, pivoting on the right foot, to face the front; enter into a left Zenkustu; down-block with left
  9. Step forward with R foot into R forward stance (R foot straight, L foot diagonal)
    • R middle (solar plexus) punch
  10. Step forward with L foot into L forward stance (L foot straight, R foot 45 diagonal)
    • L middle (solar plexus) punch
  11. Step forward with R foot into R forward stance (R foot straight, L foot 45 diagonal)
    • R middle (solar plexus) punch
  12. Move L foot behind body and to the R (move beyond where you extended in step 3 - this time you will end up 225 degrees from start)
    • Keeping R arm extended, chamber with L fist on R elbow
  13. Pivot (on R foot) 225 L into L forward stance - you are now facing 45 L from back of dojo
    • Down block L
  14. Step forward with R foot into R forward stance (R foot straight, L foot 45 diagonal)
    • High block R
  15. Pivot 90 R (on L foot) into R forward stance - you are now facing 45 R from back of dojo
    1. Down block R
  16. Step forward with L foot into L forward stance (L foot straight, R foot 45 diagonal)
    • High block L
  17. Pivot 45 L (on R foot) into L forward stance - you are now facing back of dojo
    • R reverse middle punch
  18. Step forward with R foot into R forward stance (R foot straight, L foot 45 diagonal)
    • L reverse middle punch
  19. Step forward with L foot into L forward stance (L foot straight, R foot 45 diagonal)
    • R reverse middle punch
  20. Step forward with R foot into R forward stance (R foot straight, L foot 45 diagonal)
    • L reverse middle punch
  21. Move L foot behind body and to the R (move beyond where you extended in step 3 - you will end up turning 225 degrees to the left)
    • Extend R arm and chamber with L fist at R elbow
  22. Pivot 225 L (both feet) into L forward stance, facing 45 L of dojo front
    • Down block L
  23. Step forward with R foot into R forward stance (R foot straight, L foot 45 diagonal)
    • High punch R
  24. Pivot 90 R (on L foot) into R forward stance Extend L arm and chamber with R fist at L elbow
  25. Facing 45 R of dojo front Down block R
  26. Step forward with L foot into L forward stance (L foot straight, R foot 45 diagonal)
    • High punch L
  27. L foot pulls back to starting position, heels together
    • Palms down in front of body, L hand over R hand

Note: This is also known as “Kihon Kata Ichi”, Basics Form One.

6. Gekisai Dai Ichi —“Attack & Destroy One”

(Side View)

(Front View)

  1. Attention stance
  2. Left foot steps out into Yoi (ready stance) shoulder width apart
    1. Alternatively: Yoi with feet together at attention left hand over right several inches away from the groin
    2. the left hand pushes down while the right hand pushes up creating (explosive) tension
  3. From either Yoi right foot steps forward and you turn left 90 degrees into hourglass stance
    1. High block with left hand
    2. If feet are apart in Yoi when the right foot steps forward you pivot on the center (ball and heel) of the foot so that the stance is even
    3. If feet are together in Yoi left foot pivots on the heel and the right on the ball so the stance is even
    4. if hands and feet are together in Yoi the right arm explodes from underneath almost like a fanning block before turning
  4. Step forward into hourglass stance with the right foot
    • High punch with the right hand
  5. Step back into square/horse stance so that the body is facing the direction of the attention stance
    • Low block with the left
  6. Turn the body 90 degrees and left foot slides behind the right into hourglass stance
    • High block with the right hand
  7. Step forward into hourglass stance with the left leg
    • High punch with the left hand
  8. Step back into square/horse stance so that the body is facing the direction of the attention stance
    • Low block with the right
  9. Left leg steps in and then forward into hourglass stance
    • Middle block with the left
  10. Step forward into hourglass stance with the right
    • Middle block with the right
  11. Left front kick and land in a front stance
    1. Left elbow strike as blocking right hand pulls back into chamber
    2. Left downward back fist face level
    3. Left hand transitions to low block
    4. And right hand punches with a “Kiai”
  12. Turn right 90 degrees into a ready stance (with head facing to right)
    1. Right knife hand strike to the side of the temple
    2. Alternatively: during this transition the back leg of the previous front stance lifts up as if avoiding a sweep
  13. Turn right 90 degrees to right, step forward with the left into hourglass stance
    • Left hand middle block
  14. Right front kick and land in a front stance
    1. Right elbow strike as blocking left hand pulls back into chamber
    2. Right downward back fist face level
    3. Right hand transitions to low block
    4. Left hand punches with a “Kiai”
  15. Turn left 90 degrees into a ready stance (with head facing to left)
    1. Left knife hand strike to the side of the temple
    2. Alternatively: during this transition the back leg of the previous front stance lifts up as if avoiding a sweep
  16. Turn left 90 degrees and left leg steps back into front stance
    1. As stepping back left hand pulls back as if pulling the arm of an opponent
    2. Left hand in chamber palm down, right in chamber palm up
    3. Double punch with left hand to the lungs and right to the stomach
    4. Alternatively: when stepping back the left hand turns in like an open handed fanning block
    5. Right hand in chamber comes out and performs a middle block
    6. Then both hands pull back to chamber with left palm down and right palm up
    7. Then double punch
  17. Step forward into ready stance
    1. Reverse fist orientation
    2. Alternatively: Step forward feet together, both knees bent
    3. Right arm turns in as if for a fanning block
    4. Left arm arcs around in front for a middle block
    5. Then both hands are pulled back into chamber in the revers orientation they were before in the prior step
  18. Step back with the right leg into front stance
    • Double punch, right hand to the heart and left to the liver
  19. Step forward into attention stance
    1. Alternatively: open left hand
    2. Turn right fist to palm facing up and place it in the open hand
    3. Open the right hand
    4. Step forward to attention as the hands turn staying left over right and return to the beginning position
  20. Bow

Geki Sai Ni is very similar…

Article image

7. Closing: Possibly Interesting Reads

Article image

]]> https://alhassy.github.io/karate.html https://alhassy.github.io/karate.html Thu, 02 Feb 2023 00:00:00 -0500 <![CDATA[My Family Tree]]>

Article image

1. The tree

family-tree.png

]]> https://alhassy.github.io/family-tree.html https://alhassy.github.io/family-tree.html Thu, 02 Feb 2023 00:00:00 -0500 <![CDATA[A Brisk Introduction to the Fundamentals of Arabic Grammar, نحو]]>

Article image
Abstract

In short: In English sometimes we mess-up between “I/me/my”, likewise in Arabic we might mess up with “ابو / ابا / ابي”: These are just اب followed by one of ا/ي/و (which are the pronounced case endings!)

~ ~ ~ ~ ~ ~ ~

How do Arabs say the English “a/an/the”, as in “an apple” or “the chair”? Easy! By default, all words are indefinite (“a/an”); and made definite (“the”) by adding الـ to the front of the word.

But… there's some subtleties, which first require us to discuss vowel markings… which also change if the feminine marker ة is used, so we also need to briefly discuss gender.

English relies on word order for meaning; for example, Jim hit Bob is a sentence where the person doing the action is Jim and we know it has to be Jim, and not Bob, since Jim is the word before the action hit. However, in Arabic words can be ordered in almost any way you like! Then how do we identifiy who does an action? We use case markings: We add small symbols to the end of words to indiciate the role they play in a sentence.

With vowel markings, we can finally flesh-out the nature of “a/an/the” in Arabic… but then something wild happens if we stick an (in)definite followed by a definite! We get the concepts of ownership and complete sentences that don't need a verb!

Finally, we conclude with an explanation of why in the world English Qurans use the single word muslim where's Arabic Qurans use both مسلمون and مسلمين.

Some interesting concepts will also be mentioned, for those curious, but should be ignored on a first reading. These will be hidden away in clickable/foldable regions.

These are notes of things that I'm learning; there's likely errors.

نحو literally means direction; but when talking about Arabic grammar, it means syntax (how words are combined to form phrases) and, in-particular, case endings / إعراب.

1. Al-I'rab: Case Endings, الاعراب

One day, my wife and I were looking at the word خبز, and we each read it differently: I read it as خَبَزَ “he baked”, but she read it as خُبْزْ “bread”. Without a context, we each guessed different short vowels!

Tell me more about vowels!

Arabs infer vowels from context, otherwise words alone such as حمل are ambigious: It could mean حَمَلَ “he carried” or حُمِلْ “he was carried”.

As an example sentence with vowels written, Prophet Muhammad is known to have said:

أنَا مَدِينَةُ الْعِلْمِ وَعَلَيٌ بَابُهَا
I am the city of knowledge and Ali is its gate

Incidentally, Ali was the one who commissioned the system of vowels. https://blogs.transparent.com/arabic/the-beginning-of-dotting-and-diacritics-in-arabic/

Arabic has only three short vowels, or حركات (literally: “movements”), which are written as small symbols above/below letters.

Vowel name Vowel sound Arabic English example
Fatha; فتحة a ـَ mat
Dhamma; ظمّة u ـُ sugar
Kasra; كسرة i ـِ bit

The “no vowel” marker is suukun/سكون: While هههه has its vowels guessed to be هَهَهَهَ “hahahah”, we obtain “hhhh” by using sukkun, هْهْهْهْ. It is important for consonant-vowel-consonant syllables, such as بَابْ “bab” which means door.

Incidentally, when a sound needs to be repeated twice, it is usually written once with a Shadda ـّـ to indicate the doubling. For example, فَهِمَ fahima “he understood” but فَهَّمَ fahhama “he explained”. Shadda is used with الـ + ‘sun letters’. Unlike the other short vowels, the Shadda is usually written even in informal Arabic, to avoid ambiguity.

Arabic has 3 long vowels, which are formed using specific letters after the short vowels:

Long vowel sound Arabic English example
aa ـَا far
ii ـِي meet
uu ـُو boot

Since short vowels are normally not written, letters ا ي و play two roles: They behave as long vowels aa,ii,uu (when preceded by short vowels) and also behave as consonant sounds a,y,w.

  • For example, as a consonant, ي makes an English “y” sound; but as a long vowel it makes an “ii” sound.
  • Occasionally, aa is written using ی (which is like ي but without the dots), or یٰ, rather than an alif. This always happens at the end of a word and is called alif maqsuura “broken alif”; for example علی “on” and موسیٰ “Musa”.

The following video reads all Arabic letters, where each letter is vowelised by one of the 3 short vowels. It's a really nice video: https://www.youtube.com/embed/U1Cl6W8EEBQ?start=6.

Here's another one..

1.1. One word, many readings

What does حملت mean? Since ح−م−ل means “carrying”, and ـت is the past tense suffix, we have at least the following meanings:

حَمَلْتُ I carried
حَمَلْتَ You (masculine) carried
حَمَلْتِ You (feminine) carried
حَمَلَتْ She carried
حُمِلتْ She was carried

Without the short symbols, the only way to distinguish the intended meaning is for the word to be contextually located within a sentence —and even then, this would require experience.


Tell me more about how verbs change, conjugate!

Arabic verbs are conjugated in the past tense by adding suffixes to the stem of the verb.

  singular plural
1 ـْتُ ـْنا
2m ـْتَ ـْتُمْ
2f ـْتِ ـْتُنَّ
3m ـَـ ـُوا
3f ـَتْ ـْنَّ

For example, “they (feminine) studied” is هُنَّ دَرَسْنَّ.

  • Exercise: Conjugate to study دَرَسَ for each subject above. ( Answer )
  • Exercise: Conjugate to be generous كَرُمَ and to drink شَرِبَ.
  • Exercise: What does درست mean?
    • Trick question! You need the context, sentence, to infer the required conjugation.

Note that the conjugation for the third-person masculine, هُمْ/they, is not phonetic: The ending ـُوا has the long vowel ـُو pronounced, but the alif is silent. E.g., they studied is هُمْ دَرَسُوا and is read “hum darasuu”.

The personal pronouns (I, you, they, etc) are not usually used, since the verb conjugation tells us who the subject is. Sometimes they are used for emphasis. E.g., they studied is دَرَسُوا and is read “darasuu”.

Arabic has no “to X” form, as in English to eat, to drink, etc. Instead, it uses the he form of a verb when referring to a verb in-general. For example, he studied دَرَسَ is used to mean to study when we are taking about how the verb to study changes depending on who is doing the studying. This form is chosen since it is the simplest form: It's the main 3 root consontants of the verb, followed by a fatHa.

1.2. Word Order

Likewise, what does نصرت فاطمة mean? Does it mean “Fatimah helped (someone)”? Or does it mean “Fatimah was helped (by someone)”?

One English sentence can be written a number of ways in Arabic:

Fatima helped Zaynab
نصرت فاطمةُ زينبَ
نصرت زينبَ فاطمةُ
فاطمةُ نصرت زینبَ

The way the listener knows what’s the subject and what’s the object is quite literally carried around with the nouns themselves. The endings make all the difference.

This is اعراب, I'rab, which literally means “to Arabize” or “to make elegant/clarify”.

The second instance above might seem weird at first, since the object comes before the subject, but it is more common when the object is an attached pronoun:

نصرتْها فطمةُ Fatima helped her.

This is a common example of the verb-object-subject word order!

Anyhow, in general, in Arabic the action word, the verb, can occur in the first or second positions within a sentence whereas the subject (the person doing the action) and the object (the thing/person being acted upon) can occur anywhere! Here's another example:

Verbal sentences can have 4 different word orders

Below are 4 ways to say Muhammad wrote the lesson in Arabic!

Sentence Order of words
كَتَبَ مُحَمَّدٌ الدَّرسَ object ⇷ subject ⇷ verb
كَتَبَ الدَّرسَ مُحَمَّدٌ subject ⇷ object ⇷ verb
مُحَمَّدٌ كَتَبَ الدَّرسَ object ⇷ verb ⇷ subject
الدَّرسَ كَتَبَ مُحَمَّدٌ subject ⇷ verb ⇷ object

I personally have never encountered the fourth/last form above when actually talking Arabic to other people.

Um actually, it's more accurate to say: Verbs must be singular before subjects
  • Verbs can come before or after the subject, and the choice is largely a matter of emphasis/level of formality.
  • However, Arabic verbs change according to the subject, such as whether it's one person or multiple people doing the action.
  • If the subject is a group of people, the verb will be singular if it comes before the subject. It will only change according to whether the subject is masculine or feminine.

For example,

. كَتَبَتْ البَنات خِطابات، ثُمَّ خَرَجْنَ
The girls wrote letters and then went out.

Here كَتَبَتْ/wrote is a singular feminine form of the verb كَتَبَ/to-write since it comes before the subject, which is البَنات/the-girls. Likewise, خَرَجْنَ/went-out is a plural feminine, since it comes after the subject.

Finally, as we will encounter later in this article, Arabic also has sentences without verbs! These are just the subject followed by the predicate, which is what is happening to the subject. Since these non-verbal sentences are only two pieces (possibly complicated pieces), there are two ways to order them and both are valid!

The man died.
≈ مَاتَ الرَّجلُ
≈ الرَّجلُ مَاتَ
The tall man died.
≈ مَاتَ   الرَّجلُ الطَّویلُ
≈ الرَّجلُ الطَّویلُ   مَاتَ

1.3. Where is this case stuff in English!?

This words-changing-due-to-role behaviour also happens in English, but mostly with pronouns: For example, He saw me   ≈   I was seen by him.

In English, there are 3 ways to refer to oneself: I, me, my. For example,

My cat saw me, and I jumped!

Here's the rules:

  • (Nominative!) When I am doing something, I say: I did it.
  • (Accusative!) When something is being done to me, I say: It was done to me.
  • (Genitive!) When I have an item, I say: My thing....

So the word used to refer to myself changes depending on what is happening by me, to me, or of me / what I own.

Um, actually there's a 4th way: myself!

Myself is the forth way to refer to oneself in English. Like me, it is used when something is being done to me such that the person doing the action is also me …err, myself.

Here are some examples,

I care for myself, by running everyday.
I describe myself as happy.
I like myself.

As a rule of thumb, myself should only be used if I is used in the same sentence. Otherwise, just use me.

1.4. So, what's the deal?

Just as people dress according to roles or occassions (such as a suit at work and pajamas in bed), so too Arabic words have different case endings, التشكيلُ, to show their roles within a sentence.

Roles are indicated by the vowel sign on the final letter of a word

Role Ending Vowel Case (Grammatical Name)
Subject; the one doing an action ـُــ مرفوع / Nominative
Object; the one being acted upon ـَــ منصوب / Accusative
Owner of a thing ـِــ مجرور / Genitive

More accurately, the genitive case is used when a word follows a preposition and it is used for all words after the first word in a possessive phrase —which is known as إظافة in Arabic, covered below. [Idafa is Arabic's way of quickly introducing possession without the preposition “of”: English has Jim's apple, whereas Arabic would say (the) apple (of) Jim, تفاحة جیم .]

Nunation/تنوين/Tanween: When the word is indefinite, one “doubles” the symbols, which causes an extra -n sound to each vowel: u ـُـ, a ـَـ, i ـِـ are replaced by un ـٌـ, an ـًـ, in ـٍـ. (If a word does not end in ة, the ـًـ ending is written اً.) This is all covered below. For example,

Muhammad was present. حَضَرَ مُحَمَّدٌ
I saw Muhammad. رَأیْتُ مُحَمَّداً
I passed by Muhmmad. مَرَرْتُ بمُحَمَّدٍ

The accusative alif, اً, is our first example of Arabic case endings, اعراب, affecting the basic spelling and pronunciation of words.

When speaking, endings are ignored in natural pauses

The case endings on the last word in a sentence are not pronounced. Nor are they pronounced before any natural pause. For example,

.هذا طالبُ جدیدٌ
hatha talib-un jadded

The last word is read jadded and not jadded-un (with the case ending).

Likewise, any ة is not voiced as ت in such natural pauses. More on ة below.

Anyhow, with the little we now know about these case endings, let's do one more puzzle!

What does     كتاب المدرس الجدید في المكتب     mean?

Hopefully by the end of this article, you'll be able to guess the missing short vowels. However, the word الجديد could be correctly vowelised in 2 ways, according to the 2 nouns we have (teacher and book) and it's not clear which one is the correct one!

What do the following sentences mean?

. كتابُ المُدرّسِ الجدیدُ في المكتبِ A teacher's new book is in the office.
. كتابُ المُدرّسِ الجدیدِ في المكتبِ A new teacher's book is in the office.

Explain these interpretations please!

Here is a vague explanation, that can only make sense when the concepts mentioned have already been understood —and they are covered later on in this article.

  1. In the first sentence we have a new book since the word new الجدیدُ has the same case ending as كتابُ: This is called nominative or مرفو and denoted by ـُـ. (Note: new starts with الـ since كتاب is definite, since it the start of an Idaafa.)
  2. In the second sentence we have a new teacher since the word new الجدیدِ has the same case ending as المُدرّسِ: This is called genitive or مجرور and denoted by ـِـ.

Without the case markings, you'll have to rely on context and common sense.

Otherwise, the number and plurality of the adjective (if any) would match that of the word it is describing. For example, in مقالة المدرس الجدیدة we know to read this as the teacher's new article since the words new and article both have the same feminine gender.

1.5. Formality: When do we see these markings?

Depending on the formality of some Arabic text, such as Classical Arabic or Quranic Arabic, you might see and hear additional grammatical endings.

In this article, we'll see that these endings —even when not explicitly written as markings— do alter the writing of words in certain situations. For example, درست كتابا has its markings guessed to be دَرَسْتُ كِتَاباً “I studied a book” —the extra alif is really the alif-tanween of the accusative case, اً.

1.6. I can't live without vowels! Yes, you can! 💪

What do you think the following English sentences say?

  • Y cn prbbly rd ths sly dspt th lck f vwls!

    You can probably read this easily despite the lack of vowels!

  • Ys, y cn lv wtht vwls! Y cn vn wrt nglsh wtht thm; t nly nds sm prctc nd th rslt s drstclly shrtr sntncs! f nd b, lk Arbc, s vwls nly whn thr s mbguty.

    Yes, you can live without vowels! You can even write English without them; it only needs some practice and the result is drastically shorter sentences! If need be, like Arabic, use vowels only when there is ambiguity.

It might seem weird, for an English speaker, for vowels to be left-out, but conversely an Arabic speaker might think it's extra effort in English to write out every vowel. It's different cultures, and traditions.

Just as it's a bit funny to drop the vowels in English, we can drop the dots in Arabic and the result is still somewhat readable! In-fact, old Arabic did not have dots written down!


Translation: Do you know that you can read complete passage without points? Because you are able to understand words through the context of the sentences, and the proof is that you have just read this passage.
Source

2. ة —Gender and “tied-up t/ت”

Arabic nouns (words that name people, objects, or ideas) are classified as masculine مُذَكَّر (“mudhakkar”) or feminine مُؤَنَّث (“mu'annath”). This classification affects how other words in a sentence are written, such as action words or descriptive words.

Arabic Gender Rule

In general, if a word ends in ة or refers to a female person, then it is a feminine word; otherwise it is a masculine word.

In more detail:

  1. Words that end with the “feminine ending marker” ة are مُؤَنَّث.
    • The ة is known as the Taa Marbuta (literally: “tied-up ت”) and it is pronounced as a short vowel a sound.
  2. Words referring to female people but not ending in ة are مُؤَنَّث.
  3. Most country names, natural features, and parts of the body that come in pairs are مُوَّنَّث.
  4. Everything else is مُذَكَّر

Using the above rules, guess the genders of the following words. Hover/click on the orange box to show the answer.

Word Gender Explanation
سيّارة car مُؤَنَّث See Rule-1 above
حقيبة bag مُؤَنَّث See Rule-1 above
خالة aunt مُؤَنَّث See Rule-1 above
بنت girl مُؤَنَّث See Rule-2 above
اُّمّ mother مُؤَنَّث See Rule-2 above
رجل leg مُؤَنَّث See Rule-3 above
شمس sun مُؤَنَّث See Rule-3 above
صحراء desert مُؤَنَّث See Rule-3 above
مصر Egypt مُؤَنَّث See Rule-3 above
أب father مُذَكَّر See Rule-4 above
بيت house مُذَكَّر See Rule-4 above
كتاب book مُذَكَّر See Rule-4 above
Quranic Quandary: خَلِیفَة

There are a few masculine words with the ة ending, but the only common on is خَلِيفَة “khalifa”. In the Quran this word has the strict seance of successor or viceroy. In later times, this was generalised to caliph.

2.1. On the nature of tied-up-t

Taa Marbuta ة is a formed by taking the ends of ت and tying-them together to get ة. (Note: ت is also known as “ta mabsuta”, which literally means the “happy t” since the letter ت looks like a smiling face “🙂”)

Examples:

0. grandfather جَدّ “jadd”
1. grandmother جَدَّة “jadda”
2. a grandmother جَدَّةً “jaddatan”
3. my grandmother جَدَّتي “jaddaty”
4. grandmothers جَدَّات “jaddaat”
5. the boy's grandmother جَدَّةُ الولد “jaddatu al-walad”
Example #1
The Taa Marbuta is special in contrast to the other letters: It can only be written at the end of a word, either unjoined as ة or joined as ـَـة:
  • It is purely a grammatical letter, it has no sound!
    • It is the ending of most singluar feminine nouns/adjectives, or nouns referring to female people.
  • It always follows a Fatha vowel, as in جدَة or غرفَة, and so people would say ة makes a short a sound —but this is really due to the vowel that always comes before ة!
Example #0 changes to #1
As a suffix, ـَـة / ة is used to make feminine adjectives or nouns from masculine ones.
Examples #2 and #3
It becomes “untied/opened ت” when suffixes/endings are added.
  • The formal indefinite, Example #2, is discussed below.
Example #4
A feminine word, ending in ـَـة is made plural by extending the Fatha into a long vowel ـَـا and opening the Taa Marbuta into ت.
Example #5
When it is followed by another word, the pronunciation of ة is t −-−though the spelling remains unchanged. Putting two words beside each other is known as possession, addition, إظافة, and it's covered below.
ة has a number of other interesting uses
It forms singulatives from collectives

From a word that refers to a collection of things, we can refer to one of those things by adding ة.

For example, we get cow بَقَرَة‎ “baqara” from cows بَقَر‎ “baqar”; and we get tree شَجَرَة‎ “shajara” from trees شَجَر‎ “shajar”.

It is used this way to indicate one of something. For example, from watermelon بطيخ and carrot جزر we obtain one watermelon بطيخة and one carrot جزرة.

It forms instances from general verbal nouns

We can refer to a single instance of an action by adding ة.

For example, we get a smile اِبْتِسَامَة‎ “ibtisama” from smiling اِبْتِسَام‎ “ibtisam”; and an uprising اِنْتِفَاضَة‎ “intifatha” from rising up اِنْتِفَاض‎ “intifith”.

It forms nouns referring to devices from occupational/characteristic nouns and adjectives
For example, tank دبابة “dabbaba” from crawler دباب “dabab”; and printer (device) طَابِعَة‎ “tabi'a” from printer (person) طَابِع‎ “tabi'”.

2.2. Grab a snack and watch these helpful videos, !

What is ة
Everything about ة
Body parts in Arabic, fun!

3. When do you really know a thing?

You and your friends are talking, and someone says the word bag حقیبة. Is it a random bag (nonspecific, general, “indefinite”, نَكِرَة), or is it one you know something about it (specific, “definite”, مَعْرِفَة)?

An item   Do we know to whom it belongs?
a bag حقیبة 🤷 It's a random bag!
the bag الحقیبة 😎 It's the one we're already talking about!
her bag حقیبتها 😎 It belongs to someone we've mentioned already!
Zaynab's bag حقيبة زینب 😎 It belongs to Zaynab!
the teacher's bag حقیبة المُدرّسة 😎 It belongs to the teacher!
a teacher's bag حقيبة مُدرّسة 🤷 It's a bag that belongs to a random teacher!

So, it seems a word can have exactly one of “a/the/my”, that is, it can be either indefinite with tanween, definite with al, or possessed (by a pronoun or an Idafa, covered below).

In the rest of this section, we will talk about the first pair of examples.

  • The last group will be covered later on in this article.

  • The middle group, حقیبتها, is just bag along with the pronoun her added to the end, and the ة opens-up into a ت as discussed already. There's not much here, besides reviewing Arabic pronouns.

    Tell me more about pronouns!

    Personal pronouns are the equivalent of the English I, we, you she, he, ….

      singular plural
    1 أنا   I نَحْن  we
    2m أَنْتَ   you أَنْتُم  you
    2f أَنْتِ   you أَنتُن  you
    3m هُوَ   he/it هُم   they
    3f هِيَ   she/it هُنَّ   they

    When I am talking, the speaker is the “first person” (“1”); when taking about you, then you are the “second person” and may be masculine (“2m”) or feminine (“2f”), or a group of you (“plural”); finally, when talking about someone who is not here in the conversation, they are in the “third person” (“3m, 3f”).

    Possessive pronouns are the equivalent of the English my, his, ours, …. In Arabic, they are joined to the end of a word: For example, house بیت becomes my house بیتِي.

    Here are the attached possessive pronouns:

      singular plural
    1 ـِي ـنَا
    2m ـكَ ـكُمْ
    2f ـكِ ـكُنَّ
    3m ـَهُ ـهُمْ
    3f ـَهَا ـهُنَّ

    Exercise: Add these endings to the word house; for example, my house بیتِي.

3.1. Tanween, Formally Indefinite, نَكِرَة: “a/an” or “un” ـٌــ

Technically, Arabic does not have an indefinite article like English's a/an. Instead, indefininte/nonspecific words have doubled case markings: So instead of ـِـ ـُـ ـَـ we have ـٍـ ـٌـ ـًـ, where the second marking is pronounced as a ن/n sound. This is known as تنوین/Tanween, or nunation, which means pronouncing the letter ن at the end of a word, or putting a nun/ن on. (Often the double ـُـ is written as one ـُـ with a tail: ـٌـــ.)

English Arabic Transliteration Explanation
a boy ولدٌ walad-un Nomative ـٌـ; a boy is doing something
a book كتابٍ kitaab-in Genitive ـٍـ; a book is being owned
a car سيّارةً sayarat-an Accusative ـًـ; something is happening to a car
a book كتاباً kitaab-an Accusative ـاً; something is happening to a book
  • Notice that if a noun ends in ة “tied-up t”, the t is actually pronounced before the Tanween.
  • Secondly, unless a word ends in ة or ی or ـاء, then double-fatha ـًـ has to be written on an alif as اً. This alif is a spelling convention; it is not pronounced; unlike case markings, it is always written (e.g., كتابا possibly without the ـًـ).

3.2. Definite, مَعْرِفَة - “the” or “al” الـــ

There is no indefinite article equivalent to the English “a/an”. However, the large majority of nouns and adjectives have tanween (the addition of the sound n) to the final vowel of a word) to indicate that the word is indefinite:

a reward أجْرٌ ajurn
a sign/verse آيْةٌ ayatun
a recitation قُرْآنٌ qur'anun

What is آ ?

It has become standard for a hamza followed by a long aa sound to be written as two alifs, over vertical and on horizontal: آ. This is known as the alif madda.

This was already discussed in: http://alhassy.com/arabic-roots#Arabic-has-112-symbols-and-112-sounds

However, in everyday, non-vowelised, Arabic there is no separate word/marking for “a/an”, as in “a chair” or “an apple”.

  • By default, words are indefinite: For example, مكتب means “an office”, even though there is no separate word for the “an”.

  • To make a noun definite we add الـ “al” joined to it, which means “the”. For example:

      “the office”
    ≈ “the” ⇸ “office”
    ≈ ال ⇷ مكتب
    ≈ المكتب
    What are directed additions ⇸ and ⇷?

    I will use directed addition symbols ⇸ and ⇷ to mean the same as “+” but also to indicate the direction one should read it. For example, X + Y could mean X Y in English's left-to-right reading, but it could also mean Y X in Arabic's right-to-left reading. Whereas X ⇷ Y can only mean X Y (read right-to-left).

Frequently, the sound of الـ al may have both the a sound, the l sound, or both sounds change! The rules are pretty simple.

  • These are changes in pronunciation only, the spelling of “al” الـ doesn't change.
ٱلْـ / Elision: The “a” of “al” الـ is silent if the previous word ends in a vowel

If الـ “al” comes directly after a vowel, the “a” of “al” الـ will drop out, or elide, leaving just the “l” sound. This only affects pronunciation and not the spelling.

For example,

the house البيت “al-bayt”
in the house في البيت “fi l-bayt”
Assimilation: The Sun Letters Assimilate the “l” of “al” الـ

Nouns starting with certain letters of the Arabic alphabet cause the pronunciation of “al” الـ to change: The “l” sound becomes the same as the first sound of the noun. This double-pronunciation of the first letter of the noun is indicated with a Shadda ـّـ symbol, if vowel marks are written.

For example,

a car سيّارة “sayyara”
the car السّيّارة “as-sayyara”

Notice that السّيّارة is not read “al-sayyara”! The “l” sound changes to be the sound of the first letter of سيّارة, namely “s”.

Likewise, a river is نهر whereas the river is النّهر “an-nahr”.

The letters which cause this pronunciation assimilation are called sun letters, الحروف الشمسية “al-huruf ash-shamsiyya”, as ش/sh is itself an assimilating letter. Half of Arabic's 28 letters are Sun Letters. The remaining half of the letters are called Moon Letters, الحروف القمرية “al-huruf al-gamariyya”, as ق/G is not an assimilating letter.

☀️ Sun Letters
ت ث د ذ ر ز س ش ص ض ط ظ ل ن
🌙 Moon Letters
ا ب ج ح خ ع غ ف ق ك م ه و ي

Just as we use a shadda ـّـ on a sun letter, we place a sukoon ـْـ on the ل when it comes after moon letters: For example, اَلْقمر “al-qamar” —the sukoon gives us a slight pause after the “l” sound.

The above two rules are explained by the following theoretical justification.

Um, actually the definite article is really just لْ

In fact, the definite article is in essence simply a لْ, an “l” sound. But as Arabic phonetic theory holds that words cannot begin with an unvowelled consonant, the vowel a (Fatha) is added to the لْ to give اَلْ, al. Theory holds that this a vowel is not an integral part of the definite article and is required when no other vowel precedes the article l. In effect this means that the added vowel is only at the beginning of a sentence. In other places, the vowel Fatha is replaced by a “joining sign” (wasla) to obtain ٱلـ, which tells you to link the l of the definite article to the final vowel of the preceding word.

In short, you will find اَلْـ at the beginning, and ٱلْـ elsewhere in the sentence. The use of the two can be seen as follows:

the clear book اَلْكِتَابُ ٱلْمُبِينُ al-kitab-u l-mubeen-u

Note: In front of Sun Letters, اَلـ is written with no sukkun on the ل, since there is no pause on the ل; in-fact the ل is assimilated and makes a different sound altogether.

We will get to sentence formation, later below.

Exercise: From your knowledge of pronunciation of ة and the two special pronunciation rules of الـ, guess how the following would be read.

السَّيَّارَةُ الجَدِيْدَة
as-sayyara-tu l-jadded-a

Remember: Since tanween indicates indefiniteness, a definite word cannot have tanween!

a boy ولدٌ “walad-un”
the boy الولدُ “al-walad-u”

Quranic Quandary: اَل ⇷ ل = اَلّ

In the Quran, when the definite article is prefixed to a word beginning with ل, only one ل is written. For example,

the night اَلَّیْلُ al-laylu

This is not normally the case in modern Arabic.

😉 Arabic is so simple! Unlike other languages, Arabic has الـ for the regardless of whether we're talking about one person, or many! For example, in French, we have 3-ways to say the: le, la, les.

الـ is usually part of Arabic names!

For example, a person named John who happens to be a smith, a worker in metal, might be referred to as John the smith. In English, this became John Smith, and in Arabic it becomes جون الحداد “john al-hadad” —where حداد means smith.

A more important figure would be حسن العسكري: A person named حسن/Hassan who lived in a town of soldiers/عسكر. He is a great grandson of Prophet Muhammad.

This name-followed-by-profession/town construction is known as Idafa/إظافة and it is discussed later in this article.

4. Idafa: (In)definite followed by definite

What happens when you stick two nouns together? What about definiteness?

4.1. Possession: Addition إظـافـة “idafa”

Arabic expresses possession by placing two nouns next to each other: possessor ⇷ possessed (read right-to-left). This is إظـافـة, which literally means addition.

1. Anwar's book
≈ كتاب أنور
2. the manager of the department
≈ the department's manager
≈ مدير القسم
3. the manager of a department
≈ a department's manager
≈ مدير قسم

Since the possessed item is known to belong to the possessor, the English translations all use “the” before the possessed item: The X of Y. That is, just as in English Y's X means X is known to definitely belong to Y, Arabic treats the possessed word in an إظافة as “definite in meaning” (even though it is not “definite in form; has no الـ”); see example #3 above. We can summarise this observation as follows.

Case endings for Idaafa: Only one of “a/the/my”!

The first term of an Idafa will be in any case the sentence requires; and only the last term in an Idafa (however complex) can have the definite article or nunation or an attached possessive pronoun —this is like English, “a X's Y” or “the X's Y” or “my X's Y”— and this choice determines the definiteness of the Idafa. Also, all terms of an Idafa, other than the first term, must be in the genitive case.

a nurse's book كتابُ مُمرّضةٍ
the nurse's book كتابُ ٱلْمُمرظةِ
my nurse's book كتابُ مُمرّضتي

Note that nunnation is indefinite, whereas الـ and possessive-pronouns are definite.

What's the deal with pronoun suffixes?
her book كتابها

Technically, we can treat “her book” as an Idaafa construction, with the pronoun “her”, written in Arabic as an attached ending ـها, being the second term in the Idafa. Since pronouns are technically definite, they will always end an Idafa whenever they are used. Here's another example,

my brother's book كتاب اخي

The result of an addition, إظافة, is noun phrase which itself can be the possessor of something else. Whether this result is definite or not is determined by whether the final noun in the إظافة is definite or not; see example #2 above.

The result of an addition, إظافة, is noun phrase which itself can be the possessor of something else. As such, we can repeat the إظافة construction onto itself a number of times:

  the son of the manager of the sales department
≈ the son of (the manager of (the department of sales))
≈ ابن مدير قسم المبيعات
Idiomatic uses of Idafa

  1. The use of 2 nouns in an idafa to represent an idea that has to be translated as a noun and a qualifying adjective. Duh, that's the whole point of idafa with adjectives, to created qualified nouns!

    قَوْمُ سَوْءٍ
    ≈ people of evil
    ≈ an evil people

  2. The use of certain words, such as umm, ab, ibn, ahl, saahib, dhu (accusative dhaa, genitive dhii found only with a following genitive) to represent a single idea. lol see #1 above.

    اِبْنُ ٱلسّبِیلِ
    ≈ son of the road
    ≈ traveller
    أَهْلُ بَیْتٍ
    ≈ family of a house
    ≈ a household
    ذُو ٱلْفَضْلِ
    ≈ possessed of bounty
    ≈ bountiful
Exercise: Form the Idafa with the correct case endings!

Write the Arabic Idafa for each English phrase and, for simplicity, place the first term of the Idafa in the nominative case.

Colloquial phrase Unfolding into using “of” Arabic
A university professor ≈ a professor (of) a university ≈ استاذُ جامعةٍ
The office director ≈ the director (of) the office ≈ مُدیرُ المكتبِ
the house yard ≈ the yard (of) the house ≈ سَاحَةُ البَيْتِ
the bedroom ≈ the room (of) sleeping ≈ غُرْفَةُ النَّوْمِ
A teacher's house ≈ a house (of) a teacher ≈ بیتُ مُدرّسٍ
The teacher's house ≈ the house (of) the teacher ≈ بیتُ المُدرّسِ
An office director's car ≈ a car (of) a director (of) an office ≈ سیّارةُ مُدیرِ مكتبٍ
The office director's car ≈ the car (of) the director (of) the office ≈ سیّارةُ مُدیرِ المكتبِ
Allah's mercy ≈ the mercy (of) Allah ≈ رَحْمَةُ ٱللَّهِ
the people of the book ⟦Quranic reference to people who obtained revelation⟧ ≈ اَّهْلُ ٱلْكِتَابِ
my brother's watch ≈ the watch (of) my brother ≈ سَاعَةُ أخِي
my mum's aunt ≈ the aunt (of) my mother ≈ خَالَةُ أُمِّي

🤷 Personally I'm not sure when proper names should have the case markings. So any guidance regarding the following examples would be welcomed! Inshallah I will keep learning and eventually figure this out. 🤷

Mohammed's car   ≈ سَيَّارَةُ مُحَمَّد
Ali's table   ≈ طَاوِلَةُ عَلِي
Sarah's job   ≈ وَظِيْفَةُ سَارَة
Yemen's map   ≈ خَرِيْطَةُ اليَمَن
“This book!” Demonstratives make definites!
  “this/these” “that/those”
masculine singular هٰذا (haathaa) ذٰلِكَ (thaalika)
feminine singular هٰذِهِ (haathihi) تِلْكَ (tilka)
plural هؤَلاءِ (haa'ulaa'i) أُولئكَ ('ulaa'ika)

Often non-verbal sentences are formed using demonstratives:

This is a book. .هذا كتاب
This is my sister. .هذهِ أُخْتي
That is my mother. .تِلْكَ أُمّي

As always, definitness in an Idafa distinguishes between a complete sentence and an adjectival phrase:

This is a book. .هذا كتاب
This book … … هذا الكتاب
(This book is heavy. .هذا الكتاب ثقیل )
This is the book. .هذا هو الكتاب

The first is a sentence, the second is not. Finally, notice that you need to add the appropriate noun, in this case هو, if you want to say the sentence This is the book. (This is the Pronoun of Separation, discussed below.)

The Pronoun of Separation

Above we declared

Non-verbal Sentences   ≈   indefinite description ⇷ defininite noun

However, we can have definite predicates in a sentence such as God is the truth. To separate a definite predicate from a definite subject, a third person pronoun (known as thamir al-fasl, the pronoun of separation) is inserted between subject and predicate.

Non-verbal Sentences   ≈   definite description ⇷ pronoun ⇷ defininite noun

The unbelievers are wrongdoers. .اَلْكٰفِرُون ظٰلِمُون
The wrongdoing unbelievers … … اَلْكٰفِرُون ٱلظّٰلِمُن
The unbelievers are the wrongdoers. .اَلْكٰفِرُون هُمُ ٱلظّٰلِمُونَ

Here is another sentence:

.اَللّٰهُ هُوَ ٱلتَّوَّابُ
≈ (Allah) (He) (the relenting).
≈ Allah is the Relenting one.

4.2. Sentences without verbs: Replacing a noun with an adjective

The Idafa construction is about two nouns next to each other; however Arabic has only 3 kinds of words —in contrast to English's 8.

Kind Description
اسم Nouns, adjectives, adverbs, etc
فعل Verbs: action words
حرف Particles, such as prepositions في and علی

What's an Adjective? Some common adjectives

Descriptive words such as “beautiful, new, heavy” are known as adjectives in English.

     
beautiful جميل jamiil
ugly قبيح GabeH
new جديد jaded
old قديم Gadeem
heavy ثغيل thaGeel
light خفيف khafeef
big / large كبير kabeer
small صغير sagheer
tall / long طويل Taweel
short قصير Gaseer
broken مكسور maksuur
happy مسرور masruur
famous مشهور mashHur
married متزوج mitazawwij
suitable موناسب munasib

So, what kind of meaning do we get if we replace one of the nouns in an Idafa construction with an adjective, a descriptive word? We get sentences!

Descriptive Phrases   ≈   description ⇷ noun

1. (a) beautiful girl بنت جميلة
2. (a) beautiful river نهر جميل
3. a beautiful river نهرٌ جميلٌ
4. the beautiful river النهر الجميل
5. the beautiful river النهرُ الجميلُ
6. their beautiful river نهرهم الجميل

Notice that the description جميل changes according to what is being described: The first has an extra ة since it's describing a female, the third (and fifth) has markings that match the markings of what's being described, the fourth (and sixth!) is definite since it's describing something definite.

Adjective Agreement

Adjectives are placed after the noun they describe, and agree with the noun in gender, definiteness, number, and case endings. (Number, or plurality, is the last thing covered in this article.)


What if I have multiple adjectives?

Just place them after the noun, as usual, and seperate them with and وَ “wa”. Here's two examples, one definite and the other indefinite.

a large new school مدرسة كبيرة وَجديدة
the beautiful old chair الكرسي الجميل وَالقديم

In the English sentence Allah is powerful and mighty., it is necessary to link the adjectives by using and. This is not necessary in Arabic —even though وَ could be used—, especially when tanween is fully pronounced. For example:

.اَللّٰهُ قَوِيٌّ عَزِیزٌ
Allah is powerful and mighty.

An Exception: Colours as adjectives

The (masculine) colours are as follows:

red أحمَر ahmar
blue أزرَق azraG
green أخضَر akhthar
yellow أصفَر asfar
black أسوَد aswad
white أبيَض abyath
  1. Notice that all colours start with أ and have a Fatha ـَـ on the next-to-last letter.
  2. The feminine versions of colours are formed by pushing the أ to the end، dropping the ء to the floor, and bringing the Fatha to the first letter.
    • For example, masculine أحمَر has corresponding feminine حَمراء. Likewise, we have زَرقاء ، خَضراء ، صَفراء ، سَوداء ، بَيضاء .

  3. Even though adjectives must agree with their nouns in case endings, colours are an exception: They always have the ـُـ ending, (for both definite and indefinite).

    a beautiful pen قلمٌ جميلٌ Galam-un jameel-un
    a red pen قلمٌ أحمرُ Galam-un ahmar-u
    the red pen القلمُ الأحمرُ al-Galam-u al-ahmar-u

The rule about agreement in definiteness is crucial, because a definite noun followed by an indefinite adjective is a complete sentence, not requiring a verb. That is, mixing definiteness results in sentences, complete thoughts.

Non-verbal Sentences   ≈   indefinite description ⇷ defininite noun

For example,

The river is beautiful. ≈ .النهر جميل
The river is beautiful. ≈ .النهرُ جميلٌ
Allah is might. ≈ .اَللّٰهُ عَزِیزٌ

Again, since Arabic's word classes put adjectives and nouns in the same group, اسم, we can replace the adjective with a noun. For example,

Yusuf is beautiful. ≈ .يوسف جميل
Yusuf is a teacher. ≈ .يوسفُ مُدَرّسٌ
Equational Sentences: Do It Yourself Examples!

These kind of no-verb sentences are also known as equational sentences: For example, You are Muhammad is written أنتَ مهمد and “could be thought of as” you = Muhammad —an equation! Likewise, Muhammad = student is another equation, which is written مهمد طالب.

Exercise 1: (1) pick any pronoun you like, (2) any name you like, then (3) stick them beside each other to make more example sentences!

Here are a few to get you started!

  • هم مُدرّسون — They are teachers.
  • انا سمير — I am Samer.
  • انا سميرة — I am Samera.

Exercise 2: (1) Pick any name you like, (2) pick any job/adjective you like, then (3) stick them beside each other to make more example sentences!

Here are a few to get you started!

  • زينب كاتبة — Zaynab is a writer.
  • سارة طويلة — Sarah is tall.
  • بنيامين مسرور — Benjamin is happy.

Notice how cool that is! Arabic let's us create sentences without an equivalent for am, is, are —the subject is just followed by the rest of the sentence. Moreover, notice that since subjects must have the nominative ending ـُـ/ـٌـ, the rest of the sentence matches in case —this is the same rule of matching for adjectives! (For this reason, non-verbal sentences are also called nominal sentences.)

Here are some more examples:

I am busy today. .انا مَشْغولٌ الیوم
The window is broken. .الشُّباكُ مَكْسورٌ

Notice that pronouns, such as انا, do not get case markings. And we use the indefinite ـٌـ marking for adjectives.

Exercise: Write the correct case markings!

Sentence   Translation Correct Case Markings
الطالب جديد   The student is new. الطالبُ جديدٌ
الكتاب جديد   The book is new. الكتابُ جديدٌ
الطالب جميل   The student is beautiful. الطالبُ جميلٌ
المدير طالب   The manager is a student. المُديرُ طالبٌ
انتَ مُدير   You are a manager. انتَ مُديرٌ
انا المُدرس   I am the teacher. انا المُدرسُ

Questions: Stick a “question marker” in front of a sentence! Also اعرب affecting writing!

English makes sentences into question by moving words around: The sentence You are a student. becomes the question Are you a student?

Arabic just adds هَلْ or اَ to a non-verbal sentence to turn it into a question: For example, You are a student is انتَ طالب, and we turn it into a question as follows.

  Are you a student?
≈ هَلْ انتَ طالب؟
≈ اانتَ طالب؟

Here are more question words:

where أینَ ayna
who مَنْ men (like gentlemen)
what + noun ما ma
what + verb ماذا matha
why لِماذا limatha
when مَتی mataa
which أيّ ayy
how كَیفَ kayfa
how many كَم kam
how much (price!) بِكم bikam

There are three important things to note here:

ما/ماذا

There are 2 words for what, one is used for a following noun and the other for a following verb.

What's your address? ما عنوانك؟
What are you doing? ماذا تفعل؟

Also,

What's this? ما هٰذا؟
كم

كم is followed by an indefinite singular noun that must be in the accusative case; i.e., it ends with ـًـ if the word ends with ة/ی/اء and otherwise ends with اً.

This is another example of Arabic case endings, اعراب, affecting the basic spelling and pronunciation.

For example, كم ولداَ؟ How many boys?

من

The question word who مَنْ “men” (as in “gentlemen”) can be easily confused with the preposition from مِنْ. “min” (as in “minimum”). Unless the vowels are written, it's the context that distinguishes them apart.

For example,

  Where are you from?
≈ From where are you?
≈ مِنْ أَیْنَ انتَ؟

Likewise, من انت؟ only means Who are you? (“men anta”), since the phrase From you? would be written with an attached pronoun as مِنْك؟ “min-ak”.

Laysa: Not-to-be

If you want to make a nominal sentence negative, you need to use the special verb Laysa.

While Arabic doesn't use a verb “to be” (is/am/are) in simple non-verbal sentences, it does have a verb “to not be”!

We make a sentence, such as Haani is a doctor هاني طبیب, negative by adding لَیْسَ (and concluding the sentence in the accusative case) or by adding لِیْسَ…بِـ (and concluding in the genitive case).

Haani isn't a doctor.
. لِیْسَ هاني طبيباً
. لِيْسَ هاني بِطبيب

لِيْسَ is unusual because it looks like a past verb, but always has a present meaning: Haani wasn't a doctor would be لم یكن هاني طبیباً.

However, لِیْسَ does change according to the subject:

  singular plural
1 لَسْتُ   I'm not لَسْنا   we're not
2m لَسْتَ   you're not لَسْتُمْ   you're not
2f لَسْتِ   you're not لَسْتُمْ   you're not
3m لَیْسَ   he's not لَیْسوا   they're not
3f لَیْسَتْ   she's not لَسْنَ   they're not

Just as in elementary school, we memorised multiplication times in math class; when learning a new language there are various conjugation tables that must simply be memorised.

Here's a final example,

. لَستُ بِمُدرّس
. لَستُ مُدرساً
I'm not a teacher.

4.3. Describing Possession

Adjectives, descriptive words, come at the end of an Idafa —even if they describe the first word in an Idafa.

The adjective will match the gender of the noun it is describing, and will have الـ if the noun is definite. For example, the presence of ة below is what decides which noun of the Idafa is being described.

the town's beautiful river نهر المدينة الجميل
the beautiful town's river نهر المدينة الجميلة

Here's a puzzler for you! What does the following sentence mean?

  شباك البيت السغير
≈? the window of the small house
≈? the small window of the house

Answer…

It's not clear! Such ambiguities also exist in English! For example, “the boy touched the girl with the flower”: Does this mean the boy used a flower to touch the girl, or does it mean the boy touched the specific girl who had a flower with her.

However… Arabic has markings, or اعراب which literally means “to make clear, eloquent”. As such, if we use markings, we can remove the ambiguity.

Adjective Agreement

Adjectives are placed after the noun they describe, and agree with the noun in gender, definiteness, and case endings.

The second noun in an Idafa (and any subsequent nouns) will have the genetive case ending: Either ـِـ if definite, or ـٍـ if indefinite. (The case of the first noun will vary depending on the role it plays within the sentence.)

As such, we have:

  شباك البيتِ السغيرِ
≈ the window of the small house
شباكُ البيتِ السغيرُ
≈ the small window of the house

5. Plurals: Seeing إعراب in the main script!

In English to talk about many instance of a “house” or a “mouse” we use the words “houses” and “mice”. In Arabic, one has to generally learn the plural when learning a word. However, there are two kinds of words that we just add an ending to form the plural.

5.1. Sound Feminine Plurals

For groups of females, or (female or male) non-human nouns, we form the plural by adding ـَـات at the end of a word —which is essentially just expanding any existing ـَـة.

(female) teacher مُدرّسة mudarrisa
(female) teachers مُدرّسَات mudarrisaat
(male) animal حيوان Haywaan
  animals حيوانَات Haywaanaat

Notice that the Arabic word for animals is grammatically feminine. In-general, the plurals of all non-humans are treated grammatically as feminine singular 🤯 As such, for example, descriptive words are singular for animals, but plural for teachers.

The (female) teachers are beautiful.
≈ المُدرّسَات جميلَات
The animals are beautiful.
≈ الحيوانَات جميلة

5.2. Sound Masculine Plural (SMP)

For groups of males, or groups of mixed males & females, we form the plural by adding ـُـونَ at the end of a word when the word is doing the action (i.e., it's in the nomiative case) and otherwise we add ـِـينَ.

teacher مُدرّس mudarris
The teacher is here. المُدرّسُ هُنا al-mudarris-u huna
The teachers are here. المُدرّسُونَ هُنا al-mudarris-uuna huna
I saw the teacher. رأیتُ ٱلمُدرّسِ r'aytu al-mudrarris-i
I saw the teachers. رأيتُ المُدرّسِينَ r'aytu al-mudarris-iina

Notice that the Irab in the singular are stretched out in the plural! Super cool stuff!

  • We see this often in the Quran, where God talks about مسلمون (Muslims doing something) and مسلمين (Muslims having something done to them, or owning something).

The sound masculine plural is one of the few instances of the case ending being written as part of the main script and universally pronounced.

Here's another somewhat common one!

A few nouns have long final vowels when they are the first element in an Idafa.

  nomative accusative genitive
father اب أَبُو أَبَا أَبِي
brother اخ أَخُو أَخَا أَخِي

Since this plural explicitly indicates a case, either nomative with ـُـونَ and otherwise with ـِـينَ; but the second noun (and any subsequent nouns) in an Idafa must be in the genetive case. As such, in an Idafa whose final word is a sound masculine plural, the ـِـينَ ending is always used. Moreover, when this plural is the first word in an Idafa, it loses the shared ending ـنَ. For example,

The boy's teachers are here. مُدرّسو الولدِ هُنا
I saw the boy's teachers. رأيتُ مُدرّسي الولدِ

Tell me more about why we lose ـنَ at the start of an Idafa

In an Idafa, the first noun is definite (even when it does not start with الـ): In X's Y, we know that Y belongs to X, and so it's not some arbitrary unknown Y. As such, the first noun in an Idafa can only have the defininte case endings ـَ ـِ ـُ and not the indefinite ones ـَ ـٍ ـٌ . It is for this reason that the final ـنَ ending of the SMP must be dropped when a SMP is the first noun in an Idafa.

Here's some more examples:

أُولُو ٱلْأَلبَابِ
≈ (literally!) possessors of hearts
≈ men of understanding
أُولِي ٱلْأَبْصَارِ
≈ (literally!) possessors of sight
≈ men of insight

Another example is Children of Israel placed in an Idafa to get banu israil in the nomiative, and banii israil in the genitive.

So, the way sound masculine plurals are written is due to the إعراب rules. We started with I'rab and ended with it; we've come full circle 😊

Bonus: The Dual Also Shows-off إعراب in the main script!

Arabic has three notions of number:

Singular When talking about one thing,
Dual When talking about two things,
Plural When talking about three or more things.

The dual is used for both masculine and feminine,

you (two) أَنْتُما
they (two) هُما

If you want to refer to two people or things (/nouns/), you add the dual ending ـانِ (“aani”) in the normative case and ـَینِ (“ayni”) in the accusative & genitive cases.

book كتاب   two books كتابانِ
city مدینة   two cities مدينتانِ

The dual ending is also added to adjectives:

هُناكَ مُمَرّضَتانِ جدیدتانِ في المُسْتشْفَی
There are two new nurses in the hospital.
]]> https://alhassy.github.io/arabic-word-order.html https://alhassy.github.io/arabic-word-order.html Thu, 03 Nov 2022 00:00:00 -0400 <![CDATA[Arabic Roots: The Power of Patterns]]>

Article image
Abstract

I want to quickly introduce the Arabic language, through its “root system” —i.e., most words have 3-letters at their core— and how these roots can be placed in “patterns” to obtain new words.

I'd like to take a glance at Arabic's Verb Forms: These give you 10 words for each root!

Some interesting concepts will also be mentioned, for those curious, but should be ignored on a first reading. These will be hidden away in clickable/foldable regions.

These are notes of things that I'm learning; there's likely errors.

1. The Arabic Root System

Most Arabic words are derived from a three-letter root —notable exceptions are words like “and” وَ and “on” علی. A root, or مصدر “masdar”, refers to the core meaning of a word. Simply put, roots are identified by ignoring all non-vowel letters, resulting in usually 3 letters —and, rarely, 4 letters. Roots are the building blocks of the Arabic language and are helpful for guessing the meaning of vocabulary.

For example, the sequence of letters س−ف−ر (read right-to-left as s-f-r) carries the meaning of “travel”. Any word containing these letters, in this order, likely has something to do with travel. For example:

English Arabic Transliteration
journey سفر safar
he travels يسافر yusafir
amabassdor سفير safeer
traveller مسافر musafir
embassy سفارة sifara

All of these words are derived from the root س−ف−ر, s-f-r, in this order. Much of Arabic grammar is concerned with how the root is manipulated to create different related meanings: Additional letters, or vowels, modify the meaning according to different general patterns.

Likewise, ك−ت−ب is a root regarding “writing”, from which we can obtain numerous words:

Can't we simply just stick the roots together?

No.

For example the letters ح−م−ل have the meaning of “to carry” but naively connecting the letters gives us حمل, which, without any context, could be read as

  • حَمَلَ “he carried”, or
  • حُمِلْ “he was carried”!
    • (Vowel signs ـْ ـَ ـِ ـُ are discussed below.)

Both of these words are specific to

  1. a male person,
  2. in the past, and
  3. it's not clear whether the person is doing the carrying or the one being carried.

Thus حمل is far more specific than the general meaning of ح−م−ل “to carry” —which is not itself a word, but an abstract sequence of letters.

Irregular Roots

Irregular roots do not consist of 3 different consonants; instead, they fall into three categories:

Doubled roots

where the second and third root letters are the same.

− If a doubled verb is put into a form involving a sukkun ـْـ on the 3rd root, then the 2nd and 3rd letters are written separately; otherwise, the 2nd and 3rd letters are written together with a shadda ـّـ.

− For example, ر−د−د “to reply” becomes رَدَّ “he replied” when placed in the masculine-second-person-past-tense form فَعَلَ, but becomes رَدَدْتُ “I replied” when placed in the first-person-past-tense form فَعَلْتُ. More on forms below!

  • In doubt: Doubled roots are usually written together.
Weak roots

where one of the three root letters is و or ي; for example ق−و−ل “to speak”.

  • These letters are “so weak” that they change from the constant sounds و/w and ي/y to vowel sounds or disappear entirely, depending on the pattern the root is placed in.

− If و‌/ي is the first root, then it almost always drops out in the present tense. For example, و−ص−ل “to arrive” becomes أَصِلُ “I arrive” in the first-person-present-tense أَفْعُلُ form. Contrast this with the regular root ك−ت−ب “to write” becoming أَكْتُبُ “I write”.

Hamzated roots
where one of the root letters is hamza ء; for example ق−ر−ء “to read”.

1.1. Meanings of roots   Interactive

Enter 3 letters to get a link to Arabic words that are derived from that root:

⇨ Derived words from {{first}}-{{second}}-{{third}}

Alternatively, this link provides more information, but has less roots.

2. Arabic has 112 symbols and 112 sounds

What are the vowels that can be added to roots to make new words?

Arabic has 28 letters, and like cursive English, it is written with letters connected.

Each letter has 4 forms: The isolated form, the form where the letter starts a word, the form where the letter is in the middle of a word, and the form where a letter is at the end of a word. So, Arabic has 28 * 4 = 112 distinct shapes for its alphabet. (Since some letters do not connect forwards, the isolated form actually does appear in written text. For example, او means “or” and it consists of two isolated letters.) For example, the letter ha has the following forms:

isolated initial medial final
ه هـ ـهـ ـه

If a friend texts you something funny, you reply with ههههه −−− “hahaha”.

But, where are the short vowels “a”? Arabic short vowels are generally not written!

There are only three short vowels in Arabic: a, i and u. They are denoted by small symbols above/below letters, for example:

Vowel Example English reading
ـَـ هَهَهَهَ hahahaha
ـُـ هُهُهُهُ huhuhuhu
ـِـ هِهِهِهِ hihihihi

Incidentally, the sound “h” is obtained by using the “no vowel” marker: هْـ. So with the 3 short vowels and the fourth symbol to indicate the absence of a vowel, there are a total of 4 * 28 = 112 sounds in Arabic.

Tell me more about Arabic Vowels!

Arabs infer vowels from context, otherwise words alone such as حمل are ambigious: It could mean حَمَلَ “he carried” or حُمِلْ “he was carried”.

An example sentence with vowels written:

arabic-irab.png

Arabic has only three short vowels, or حركات (literally: “movements”), which are written as small symbols above/below letters.

Vowel name Vowel sound Arabic English example
Fatha / فتحة a ـَ mat
Dhamma / ظمّة u ـُ sugar
Kasra / كسرة i ـِ bit

The “no vowel” marker is suukun/سكون: While هههه has its vowels guessed to be هَهَهَهَ “hahahah”, we obtain “hhhh” by using sukkun, هْهْهْهْ.

Arabic has 3 long vowels, which are formed using specific letters after the short vowels:

Long vowel sound Arabic English example
aa ـَا far
ii ـِي meet
uu ـُو boot

Since short vowels are normally not written, letters ا ي و play two roles: They behave as long vowels aa,ii,uu (when preceded by short vowels) and also behave as consonant sounds a,y,w.

  • For example, as a consonant, ي makes an English “y” sound; but as a long vowel it makes an “ii” sound.
  • Occasionally, aa is written using ی (which is like ي but without the dots), or یٰ, rather than an alif. This always happens at the end of a word and is called alif maqsuura “broken alif”; for example علی “on” and موسیٰ “Musa”.

The following video reads all Arabic letters, where each letter is vowelised by one of the 3 short vowels. It's a really nice video: https://www.youtube.com/embed/U1Cl6W8EEBQ?start=6.

Of-course, there is more to the story! There is the “glottal stop”, Hamza ـٔ , and other special characters and symbols above/below letters. So the counts of 112 are not exact. For example, some letters, like alif ا, have the same shape for different forms, but sometimes it can be written as ی (such as علی “on”) یٰ (such as موسیٰ “Musa”).

The Arabic Hamza ـٔ is like the English Apostrophe ـ'
  1. In both cases there is uncertaininty as to when and how to use it, even among native speakers.
  2. Whereas in English we ask ourselves: Should the apostrophe come before the “s” or after the “s”?, in Arabic the question becomes: Which letter should carry the hamza?.
  3. The hamza itself is considered a consonant, not a vowel, pronounced as a short pause.
  4. Like the apostrophe, the rules for hamza are more concerned with where to place it than how to pronounce it.
  5. General rules:
    • At the start of a word, hamza is written on an alif: أ
    • This might result in two alifs side-by-side, if so then merge them into alif madda آ, which is read as a long aa sound.
    • Otherwise, the letter carrying the hamza tends to relate to the vowel before the hamza: If we have ـُـ ، ـِـ ، ـَـ before the hamza, then the hamza is written ؤ ، یٔ/ـٔـ ، أ respectively.
      • If we have ـْـ before the hamza, we write ؤ ، یٔ/ـٔـ ، أ depending on the vowel the hamza root should be taking. For example, س−ء−ل “to ask” becomes يسْأَل “he asks” in the masculine-second-person-present-tense (يَفْعَلُ form, for this particular root).

The following video reads all Arabic letters, where each letter is vowelised by one of the 3 short vowels. It's a really nice video.

3. ف−ع−ل : The template for any 3 core root letters

As a symbol to represent the three root letters of any word, Arabic grammar uses the roots of the prototypical verb فعل “to do”, read fa'al.

For example, the root ك−ت−ب is associated with “writing”. The word for “office” مَكْتَب is the مَفْعَل-pattern: The root letters have مَـ before them, a sukkun ـْـ over the first root letter, and a fatha ـَـ over the second root letter. In the same way, “books” كُتُب is the فُعُل-pattern.

Below are some example patterns. If you are faced with an Arabic word that you have never heard before, you can guess the meaning by its root and pattern.

3.1. The فَعَّال-pattern: “the person whose job is X”

This pattern gives the profession associated with a core root. Here's some examples:

Profession Core meaning
كَتَّاب ك−ت−ب
Scribe to write
فَنَّان ف−ن−ن
Artist to be artistic
خَبَّاز خ−ب−ز
Baker to bake
عَطَّار ع−ط−ر
Perfume vendor to perfume
رَكَّاض ر−ك−ظ
Runner to run
جَرَّاح ج−ر−ح
Surgeon to cut

3.2. The مَفعَل-pattern: “the place where X is done”

This pattern gives the place associated with a core root. Here's some examples:

Place Core meaning
مَسكَن س−ك−ن
home to live
مَكتَب ك−ت−ب
office to write
مَدخَل د−خ−ل
entrance to enter
مَخبَز خ−ب−ز
bakery to bake
مَعبَر ع−ب−ر
crossing point to cross
مَسبَح س−ب−ح
swimming pool to swim

4. Verb Forms: The True Power of Arabic's Form System

The richness of Arabic is based on its system of word roots, and nowhere is this more evident than in the verb system.

In English we can add extra letters to form different but connected meanings —for example: value, revalue, validate. Arabic takes this principle much farther with many different patterns that add meaning to the origninal root form. These derived forms are the major way in which Arabic achieves its richness of vocabulary. For example, from ق−ت−ل “to kill”, we can obtain

he killed قتل qatala
he massacred (“killed intensely”) قتّل qattala
he battled (“tried to kill”) قاتل qaatala
they fought each other تقاتلوا taqaataluu

Here are the significant verb forms. For simplicitly, I'm presenting them in the past tense using the root ف−ع−ل “to do”.

Form Common Meanings Example
1. فَعَلَ “doing an action X”; (this is the most basic form) كَتَبَ “he wrote” from ك−ت−ب “to write”
2. فَعَّلَ “doing X to another”; “making another do X” خَرّجَ “he made someone go-out/graduate” from خ−ر−ج “to go out”
  “doing X intensely/repeatedly” كَسَّرَ “he smashed” from ك−س−ر “to break”
3. فَاعَلَ “doing X with someone else” جَالَسَ “he sat with (someone)” from ج−ل−س “to sit”
  “trying to do X” سَابَقَ “he raced” from س−ب−ق “to come before”
4. أَفْعَلَ Transitive meaning: “doing X to another”; like Form-2 أَسْخَنَ “he heated (something)” from س−خ−ن “to be hot”
5. تَفَعَّلَ “doing X to yourself”; this is Form-2 + تَـ تَذَكَّرَ “he remembered” from ذ−ك−ر “to remind”
6. تَفَاعَلَ “doing X together (as a group)”; this is Form-3 + تَـ تَعَاوَنَ “he cooperated” from ع−و−ن “to help”
7. اِنْفَعَلَ Passive meaning: “to be X-ed”. This is Form-1 + اِنْـ اِنْحَمَلَ “he was carried” from ح−م−ل “to carry”
8. اِفْتَعَلَ No consistent meaning; “to make yourself do X” اِفْتَعَلَ “he incited” from ف−ع−ل “to do”
9. اِفْعَلَّ ‌used for changing colours: “to turn colour X” اِحْمَرَّ “he blushed / turned-red” from أحمر “red”
10. اِسْتَفْعَلَ “asking for X”; this is nearly Form-1 + اِسْتَـ اِسْتَعْلَمَ “he inquired” from ع−ل−م “to know”
  “to consider or find something to have quality X” اِسْتَحْسَنَ “he admired” from ح−س−ن “to be beautiful”
  • Exercise! Place the roots ع−م−ل into all of these patterns, except form-9; then guess their meanings! ( Solution )
  • AlManny.com is an excellent online dictionary to finding out the meanings of words when placing them in these forms.
All the derived forms do not exist for all roots, but most roots have at least one or two forms in general circulation.
  1. You'll need to look in a dictionary, or the above root-meaning tool, to know exactly which forms exist.
  2. There are an additional 5 forms, but they are super rare in usage.
  3. In addition, Arabic speakers will sometimes make up new verbs from existing roots, either as a joke or in an effort to be creative or ✨poetic💐.

5. Closing & Useful Resources

I've often seen introductions to Arabic mention the power of roots & patterns, but one usually has to work through a host of fundamental topics before actually seeing some of these patterns.

I've written this brief introduction so that one can actually see some of these patterns in action.

It's been a lot of fun —I had to learn a lot more than I thought I knew to make this happen. It seems writing about things forces you to understand them better!

Anyhow, I'm going to keep writing about Arabic since it seems fun and I'd like to have a way to quickly review my notes on what I'm learning.

5.1. Resources

  • Mastering Arabic Grammar by Jane Wightwick & Mahmoud Gaafar

    Perhaps the most accessible book I've seen on Arabic grammar.

    It's a small book, whose chapters are also small/focused and digestible.

    It assumes you're familiar with the Arabic alphabet and takes you to forming full sentences, and reading short stories.

  • https://arabic.fi/

    Almost every word in every sentence and phrase on this website is clickable, and takes you to a page with generous information about the word, along with audio clips. It's a free, beautiful, interactive website.

  • All The Arabic You Never Learned The First Time Around (PDF)

    This seems like a very good book.

  • OERabic

    OERabic is an ambitious initiative that aims to enhance the mastering of Arabic by creating bespoke creative learning (and teaching) resources.

6. Appendix: Arabic Input Setup

How was this article written? Emacs!

On the left below is what I type, and on the right is what you see in this article (which include hover/tooltips for the cards).

Source

[[card:I have a question]] How was this article written? green:Emacs!

card:Yes With Emacs, I type /phonetically/ (based on sounds) to get Arabic; e.g.,
typing  *musy$ alHsaIY* gives me *موسیٰ الحسائي*, my name /Musa Al-hassy/.

Result

How was this article written? Emacs!

With Emacs, I type phonetically (based on sounds) to get Arabic; e.g., typing musy$ alHsaIY gives me موسیٰ الحسائي, my name Musa Al-hassy.

Moreover, this is how Arabic looks like within Emacs:

arabic-irab.png

Figure 1: This is how Arabic looks like within Emacs. (Old Arabic did not have any of the coloured symbols; not even the dots!)

The rest of this section details my Emacs setup.

6.1. The look within Emacs

;; Makes all dots, hamza, diadiract marks coloured!
(set-fontset-font "fontset-default" '(#x600 . #x6ff) "Amiri Quran Colored")
How did I find this font?
  1. Look for a font I like on https://fonts.google.com/?subset=arabic
  2. brew search amiri
    • Look to see if there is a font associated with it
  3. brew install font-amiri
    • Install the likely candidate
  4. (set-fontset-font "fontset-default" '(#x600 . #x6ff) "Amiri Quran Colored")
    • Get the full name by: Emacs -> Options -> Set Default Font
Why even bother with this line?

I found that I personally need the above set-fontset-font line, since I was typing the phrase

اهلاً وسهلاً
“Hello, and welcome”
Literally: ‌/Be with family, and at ease/

Yet I could not see the Fatha Tanween, ـًـ, on the Lam-Alif لا. This issue was only within Emacs: When I exported to HTML via C-c C-e h o then لاً would render with the tanween.

Anyhow, here are some other fun fonts to try out. 

 "Times New Roman"    ;; Default?
 "Libian SC"          ;; Default?
 "Noto Sans Arabic"   ;; Also good! -- brew install  font-noto-sans-arabic  --cask
 "Sana"               ;; is super fun!
 "Al Bayan"
 "Baghdad"
 "Damascus"           ;; Thin
 "Beirut"             ;; Super thick!
 "KufiStandardGK"     ;; Reasonable bold
 "Diwan Kufi"         ;; fancy, almost calligraphic
 "DecoType Naskh"     ;; Tight; looks like handwritten; does not support `___` elongations.
 "Farah"              ;; sloppy handwritten
 "Waseem"             ;; handwritten
 "Farisi"             ;; Persian-style: Super thin and on an angle
 "Noto Nastaliq Urdu" ;; Like Farisi, but a bit larger & thicker
 "Noto Kufi Arabic UI"
 "Geeza Pro"          ;; nice and thick
 "DecoType Naskh"

6.2. Actually typing Arabic

The "arabic" input method (via C-\, which is toggle-input-method) just changes my English QWERTY keyboard into an Arabic keyboard —useful if one has already mastered touch typing in Arabic!

In contrast, the Perso-Arabic input method (known as farsi-transliterate-banan) uses a system of transliteration: ASCII keys are phonetically mapped to Arabic letters.

  • C-\ farsi-transliterate-banan RET M-x describe-input-method to enter this method and to learn more about it.
    • For example, wrb ≈ عرب and alwrbYTh ≈ العربية
  • When you're done writing in Arabic, just press C-\ to toggle back to English.
M-x describe-input-method 
Input method: farsi-transliterate-banan (mode line indicator:ب)

Intuitive transliteration keyboard layout for persian/farsi.
  See http://www.persoarabic.org/PLPC/120036 for additional documentation.


KEYBOARD LAYOUT
---------------
This input method works by translating individual input characters.
Assuming that your actual keyboard has the ‘standard’ layout,
translation results in the following "virtual" keyboard layout
(the labels on the keys indicate what character will be produced
by each key, with and without holding Shift):

     +----------------------------------------------------------+
      | ۱ ! | ۲ ْ | ۳ ً | ۴ ٰ | ۵ ٪ | ۶ َ | ۷ & | ۸ * | ۹ ( | ۰ ) | − ـ‎ | = + | ٔ ّ |
     +----------------------------------------------------------+
        | غ‎ ق‎ | ع‎ ء‎ | ِ ٍ | ر‎ R | ت‎ ط‎ | ی‎ ي‎ | و‎ ٓ | ی‎ ئ‎ | ُ ٌ | پ‎ P | [ { | ] } |
       +---------------------------------------------------------+
         | ا‎ آ‎ | س‎ ص‎| د‎ ٱ‎ | ف‎ إ‎ | گ‎ غ‎ | ه‎ ح‎ | ج‎ ‍ | ک‎ ك‎ | ل‎ L | ؛‎ : | ' " | \ | |
        +--------------------------------------------------------+
           | ز‎ ذ‎ | ض‎ ظ‎ | ث‎ ٕ | و‎ ؤ‎ | ب‎ B | ن‎ « | م‎ » | ، < | . > | ‌ ؟‎ |
          +-----------------------------------------------+
                    +-----------------------------+
                    |          space bar          |
                    +-----------------------------+

KEY SEQUENCE
------------
You can also input more characters by the following key sequences:

Th ة   kh خ   sh ش   ch چ

Also watch Perso-Arabic Input Methods And BIDI Aware Apps (also on youtube).

Vowel me to the moon!

fatha fathaTan kasrah kasrahTan dhama dhamTan sukun hamza alif madda shadda
  بَ بً بِ بٍ بُ بٌ بْ بٔ بٰ بٓ بّ
  ^ # e E o O @ ` $ U ~

Arabic Tatweel: Stretching out the handwritten text for beauty!

We can obtain elongation by pressing underscore: j_______w________f_______r gives us جـــــــعـــــــفــــــــر

  • جعفر is read Jaafar; it is a popular name that also means small stream.

6.3. Typing outside of Emacs

TypingClub ~ Arabic is a fun & free website to learn how to type Arabic on a standard keyboard. I highly recommend it.

Being able to type Arabic while thinking in Arabic, instead of thinking of sounds using the English alphabet to approximate Arabic sounds, may be helpful in actually learning Arabic.

6.4. Using Images as Emojis

I found some images online, from OERabic​, that I thought could be used to enhance my prose.

  • I want to treat them like emojis, as such they're intentionally small, so that they can more-or-less be used inline within sentences.
  • When you click on them, they take you to the actual image source.
    • This is better than me downloading the images then having to host them somewhere then linking back to the source to credit the people who made the images.
  • When you hover over them, you see the translation.

The docstring of org-deflink has nice examples, so we quickly adapt the very first example for our needs: We look at the label given to the link, then depending on that, we show an clickable image along with a tooltip. 

(org-deflink card
 "Show one of 6 hardcoded phrases as a small inline image."
 (-let [url
        (pcase o-label
          ("Let's take a break" "https://i0.wp.com/oerabic.llc.ed.ac.uk/wp-content/uploads/2020/09/Visual-Communication-Signs-IRAQI-19.png")
          ("Yes" "https://i1.wp.com/oerabic.llc.ed.ac.uk/wp-content/uploads/2020/09/Visual-Communication-Signs-IRAQI-20.png")
          ("No" "https://i0.wp.com/oerabic.llc.ed.ac.uk/wp-content/uploads/2020/09/Visual-Communication-Signs-IRAQI-21.png")
          ("Agree" "https://i0.wp.com/oerabic.llc.ed.ac.uk/wp-content/uploads/2020/09/Visual-Communication-Signs-IRAQI-22.png")
          ("Disagree" "https://i1.wp.com/oerabic.llc.ed.ac.uk/wp-content/uploads/2020/09/Visual-Communication-Signs-IRAQI-23.png")
          ("I have a question" "https://i1.wp.com/oerabic.llc.ed.ac.uk/wp-content/uploads/2020/09/Visual-Communication-Signs-IRAQI-35.png"))]
   (format "<a href=\"%s\" class=\"tooltip\" title=\"%s\"><img src=\"%s\" height=50></a>" url o-label url)))

Below is how I would go about actually using this new link type. The left shows what I would write within Emacs, and the right is the resulting HTML (which I also see within Emacs, and the Chrome Browser.)

Source

[[card:Let's take a break]]
[[card:Yes]]
[[card:No]]
[[card:Agree]]
[[card:Disagree]]
[[card:I have a question]]

Result

]]> https://alhassy.github.io/arabic-roots.html https://alhassy.github.io/arabic-roots.html Wed, 02 Nov 2022 00:00:00 -0400 <![CDATA[Glossary of Arabic Linguistic Terms]]>

Article image
Abstract

Definitions, and discussions, of jargon relating to learning the Arabic language.

1. Noun

noun

noun

A word naming a person, object, or idea; for example: House, boy, freedom.

In Arabic, words are classified into 3 categories —in contrast to English's 8.

Kind Description
اسم Nouns, adjectives, adverbs, etc
فعل Verbs: action words
حرف Particles, such as prepositions في and علی

As such, the word “noun” when talking about Arabic will sometimes mean the more general category اسم.

2. Roots

root

root

The Arabic language is based on “roots” that link words of related meanings.

An Arabic “root” is the sequence of (usually 3) Arabic letters that carry the underlying meaning of a word, for example ش−ر−ب “to drink” and ح−م−ل “to carry”.

Vowels and consonants are added around the roots to create related words. Roots are the building blocks of the Arabic language and are helpful for guessing the meaning of vocabulary.

Generally foreign loan words, such as internet انترنت, fall outside the root system.

For more, see www.alhassy.com/arabic-roots

3. Vowels, Short & Long

vowels

vowels

Arabs infer vowels from context, otherwise words alone such as حمل are ambigious: It could mean حَمَلَ “he carried” or حُمِلْ “he was carried”.

As an example sentence with vowels written, Prophet Muhammad is known to have said:

أنَا مَدِينَةُ الْعِلْمِ وَعَلَيٌ بَابُهَا
I am the city of knowledge and Ali is its gate

Incidentally, Ali was the one who commissioned the system of vowels. https://blogs.transparent.com/arabic/the-beginning-of-dotting-and-diacritics-in-arabic/

Arabic has only three short vowels, or حركات (literally: “movements”), which are written as small symbols above/below letters.

Vowel name Vowel sound Arabic English example
Fatha; فتحة a ـَ mat
Dhamma; ظمّة u ـُ sugar
Kasra; كسرة i ـِ bit

The “no vowel” marker is suukun/سكون: While هههه has its vowels guessed to be هَهَهَهَ “hahahah”, we obtain “hhhh” by using sukkun, هْهْهْهْ. It is important for consonant-vowel-consonant syllables, such as بَابْ “bab” which means door.

Incidentally, when a sound needs to be repeated twice, it is usually written once with a Shadda ـّـ to indicate the doubling. For example, فَهِمَ fahima “he understood” but فَهَّمَ fahhama “he explained”. Shadda is used with الـ + ‘sun letters’. Unlike the other short vowels, the Shadda is usually written even in informal Arabic, to avoid ambiguity.

Arabic has 3 long vowels, which are formed using specific letters after the short vowels:

Long vowel sound Arabic English example
aa ـَا far
ii ـِي meet
uu ـُو boot

Since short vowels are normally not written, letters ا ي و play two roles: They behave as long vowels aa,ii,uu (when preceded by short vowels) and also behave as consonant sounds a,y,w.

  • For example, as a consonant, ي makes an English “y” sound; but as a long vowel it makes an “ii” sound.
  • Occasionally, aa is written using ی (which is like ي but without the dots), or یٰ, rather than an alif. This always happens at the end of a word and is called alif maqsuura “broken alif”; for example علی “on” and موسیٰ “Musa”.

The following video reads all Arabic letters, where each letter is vowelised by one of the 3 short vowels. It's a really nice video: https://www.youtube.com/embed/U1Cl6W8EEBQ?start=6.

4. Pronoun

pronoun

pronoun

A pronoun is a word that stands-in for a noun. For example, below we refer to someone in 3 different ways: “His” cat saw “him”, and “he” jumped!

  • A personal pronoun replaces a noun that refers to a person (e.g., Jasim ate ≈ he ate),
  • while a possessive pronoun replaces a noun that involves ownership (e.g., Jasim's book ≈ his book),
  • and an objective pronoun replaces a noun that is having an action done to it (e.g., I saw Jasim ≈ I saw him.)

<hr> Below are Arabic's personal pronouns alongside their English translations.

  singular plural
1 أنا   I نَحْن  we
2m أَنْتَ   you أَنْتُم  you
2f أَنْتِ   you أَنتُن  you
3m هُوَ   he/it هُم   they
3f هِيَ   she/it هُنَّ   they

<hr> In Arabic, possessive and object pronouns are attached pronouns; they are joined to the end of a word: For example, house بیت becomes my house بیتِي, and from he helped نَصَرَ we get نَصَرَني he helped me. Arabic's object & possessive pronouns are the same, except for the “my/me” case.

  singular plural
1 ـِي   my ـنَا   our
2m ـكَ   your ـكُمْ   your
2f ـكِ   your ـكُنَّ   your
3m ـَهُ   his ـهُمْ   their
3f ـَهَا   hers ـهُنَّ   their

When I am talking, the speaker is the “first person” (“1”); when taking about you, then you are the “second person” and may be masculine (“2m”) or feminine (“2f”), or a group of you (“plural”); finally, when talking about someone who is not here in the conversation, they are in the “third person” (“3m, 3f”).

5. Passive

passive

passive

A “passive” verb is one where the subject undergoes the action of the verb rather than carries out the action, for example حُملت “she was carried” and يُستخدم “it is used”.

6. Transitive

transitive

transitive

A “transitive” verb is a verb that requires an object to express a complete thought, otherwise it is “intransitive”. Some verbs are both transitive and intransitive.

A “transitive” verb needs to transfer its action to something or someone —the object. In essence, transitive means “to affect something else.”

For example, “Please bring coffee.” would not be a complete thought without the object “coffee”. That is, “Please bring.” is an incomplete thought: What or whom should we bring? As such, “bring” is a transitive verb. In contrast, “Please sing.” is a complete thought, and so “sing” is an intransitive verb —actually, it's also transitive.

In Arabic, the Form-4 أفْعَلَ pattern turns intransitive verbs into transitive ones; and turns transitive verbs into doubly-transitive verbs —which means it takes two objects: E.g., “I gave the boy the ball”, here “gave” is doubly-transitive. E.g., in Form-4, ر−س−ل “to send” gives the transitive verb أرْسَلَ which means it can be followed by two objects: أرْسَلَ الولد لكتاب “The boy sent the book”.

]]> https://alhassy.github.io/arabic-glossary.html https://alhassy.github.io/arabic-glossary.html Tue, 01 Nov 2022 00:00:00 -0400 <![CDATA[Dora, The Arab Explorer]]>

Article image
Abstract

A simple interface to watch the engaging children's show “Dora the Explorer” in Arabic

{{selectedEpisode.title}}

]]> https://alhassy.github.io/dora.html https://alhassy.github.io/dora.html Fri, 21 Oct 2022 11:20:00 -0400 <![CDATA[💐 Making VSCode itself a Java REPL 🔁]]>

Article image
Abstract

VSCode evaluates Java code wherever it sees it, by sending it to a JShell in the background, and echos the results in a friendly way!

This is achieved with a meta-extension for VSCode that makes VSCode into a living, breathing, JS interpreter: It can execute arbitrary JS that alters VSCode on-the-fly. (Inspired by using Emacs and Lisp!)

The relevant docs show how to make a similar REPL for Python, Ruby, Clojure, Common Lisp, JavaScript, Typescript, Haskell, and of-course Java.

1. How do people usually code?

Either you,

  1. Use a code editor and edit multiple lines, then jump into a console to try out what you wrote⏳, or
  2. You use an interactive command line, and work with one line at a time —continuously editing & evaluating 🔄

The first approach sucks because your code and its resulting behaviour occur in different places 😢 The second is only realistic for small experimentation —after all, you're in a constrained environment and don't generally have the same features that your code editor provides 🧟‍

2. If only we could have our cake, and eat it too! 🍰

With a few lines of JavaScript, to alter VSCode, we can get both approaches! No need to switch between the two anymore! Just select some code and press Ctrl+X Ctrl+E ---E for Evaluate! 😉

  1. Install the meta-extension Easy-Extensibility.
    • Easy-Extensibility makes VSCode into a living JavaScript interpreter; that can execute arbitrary JS to alter VSCode on-the-fly: Just press “⌘+E” to “E”valuate code! 😲
    • You can save and reuse your code by placing it in an ~/init.js file.
    • Video Intro to Easy-Extensibility: https://youtu.be/HO2dFgisriQ
  2. Make a ~/init.js file —or just invoke Cmd+h Find user's init.js file, or provide a template.

  3. Stick the following code in there; this code will be run every time you open VSCode.

    • Restart or run Cmd+h Reload ~/init.js file.
    commands['Evaluate: Java'] = {
 'ctrl+x ctrl+e': E.REPL({
   command: '/usr/bin/jshell',     // Ensure this points to wherever you have JShell
   prompt: 'jshell>',
   errorMarkers: [/Error:/, /\|\s*\^-*/, /\|\s+Exception/, /\|\s+at/, /cannot find symbol/, /symbol:/],
   echo: E.overlay,   // For notification-style output, change this to:  E.message
   stdout: result => result.includes(' ==> ') ? result.replace('==>', '⮕') : `⮕ ${result} `
 })}

  4. Now you can select any Java code and press Ctrl+X Ctrl+E to evaluate it! 🥳

    👀 Take another look at the above gif for what's possible 🔼

3. Wait, how does the above JavaScript work?

Look at the docs!

Article image

🤯 The docs are longer than the code itself 😼

4. Technically speaking, how is VSCode itself the REPL?

Let's do what math-nerds call proof by definition-chasing:

  1. Definition: REPL, an alias for command line, stands for Read-Evaluate-Print-Loop
  2. Ctrl+X Ctrl+E will echo the results in an overlay at the end of the selection —or at the end of the line, when no explicit selection is made
  3. So it retains each of the read, eval, and print parts of the Read-Evaluate-Print-Loop
  4. Moreover, since the program doesn't terminate, you're still in the loop part until you close VSCode

Bye! 👋 🥳

]]> https://alhassy.github.io/making-vscode-itself-a-java-repl.html https://alhassy.github.io/making-vscode-itself-a-java-repl.html Mon, 05 Sep 2022 00:00:00 -0400 <![CDATA[💐 VSCode is itself a JavaScript REPL 🔁]]>

Article image
Abstract

A meta-extension for VSCode that makes VSCode into a living, breathing, JS interpreter: It can execute arbitrary JS that alters VSCode on-the-fly. A gateway into the world of Editor Crafting!

(Inspired by using Emacs and Lisp!)

1. How do people usually code?

Either you,

  1. Use a code editor and edit multiple lines, then jump into a console to try out what you wrote⏳, or
  2. You use an interactive command line, and work with one line at a time —continuously editing & evaluating 🔄

The first approach sucks cause your code and its resulting behaviour occur in different places 😢 The second is only realistic for small experimentation —after all, you're in a constrained environment and don't generally have the same features that your code editor provides 🧟‍♂️

2. If only we could have our cake, and eat it too! 🍰

With the VSCode Easy-Extensibility extension, we get both approaches! No need to switch between the two any more! Just select some code and press Cmd+E ---E for Evaluate! 😉

Why the strange name? Why isn't this extension called something more informative, such as JS-repl-to-the-moon? 👀 Take another look at the above gif 🔼 Besides plain old JavaScript, this extension let's us alter VSCode itself!! (It's a meta-extension! 😲)


Intro to Easy-Extensibility

3. Technically speaking, how is VSCode itself the REPL?

Let's do what math-nerds call proof by definition-chasing:

  1. Definition: REPL, an alias for command line, stands for Read-Evaluate-Print-Loop
  2. Cmd+E will echo the results in the notification area, in the bottom right-corner of VSCode
  3. So it retains each of the read, eval, and print parts of the Read-Evaluate-Print-Loop
  4. Moreover, since the program doesn't terminate, you're still in the loop part until you close VSCode

Bye! 👋 🥳

]]> https://alhassy.github.io/vscode-is-itself-a-javascript-repl.html https://alhassy.github.io/vscode-is-itself-a-javascript-repl.html Wed, 17 Aug 2022 00:00:00 -0400 <![CDATA[Typed Lisp, A Primer]]>
21 Aug 2019
Article image

Abstract

Let's explore Lisp's fine-grained type hierarchy!

We begin with a shallow comparison to Haskell, a rapid tour of type theory, try in vain to defend dynamic approaches, give a somewhat humorous account of history, note that you've been bamboozled —type's have always been there—, then go into technical details of some Lisp types, and finally conclude by showing how macros permit typing.

Goals for this article:

  1. Multiple examples of type constructions in Lisp.
  2. Comparing Lisp type systems with modern languages, such as Haskell.
  3. Show how algebraic polymorphic types like Pair and Maybe can be defined in Lisp. Including heterogeneously typed lists!
  4. Convey a passion for an elegant language.
  5. Augment Lisp with functional Haskell-like type declarations ;-)

Unless suggested otherwise, the phrase “Lisp” refers to Common Lisp as supported by Emacs Lisp. As such, the resulting discussion is applicable to a number of Lisp dialects —I'm ignoring editing types such as buffers and keymaps, for now.

( Original print by Baneen Al-hassy as a birthday present to me. )

1 “Loving Haskell & Lisp is Inconsistent”

I have convinced a number of my peers to use Emacs/Spacemacs/Doom-emacs, but my efforts to get them to even consider trying Lisp have been met with staunch rejection. These peers are familiar with Haskell, and almost all know Agda, so you'd think they'd be willing to try Lisp —it's there, part of their editor— but the superficial chasm in terms of syntax and types is more than enough apparently. In this article, I aim to explore the type system of (Emacs) Lisp and occasionally make comparisons to Haskell. Perhaps in the end some of my Haskell peers would be willing to try it out.

lisp_cycles.png
Figure 1: xkcd - Lisp is a language of timeless elegance

  • ↯ I almost never use Haskell for any day-to-day dealings.

    ✓ The ideas expressed by its community are why I try to keep updated on the language.

  • ↯ No one around me knows anything about Lisp, but they dislike it due to the parens.

    ✓ I love it and use it for Emacs configuration and recently to prototype my PhD research.

  • ⇅ I love that I can express a complicated procedure compactly in both by using zips, unzips, filters, and maps (งಠ_ಠ)ง

    • Lately, in Lisp, I'll write a nested loop (gasp!) then, for fun, try to make it a one-liner! Sometimes, I actually think the loop formulation is clearer and I leave it as a loop —Breaking news: Two Haskell readers just died.

      jvSOG.png
      Figure 2: From the awesome “Land of Lisp” book

  • What I like and why:

    Haskell ⇒ Executable category theory; compact & eloquent
    Lisp ⇒ Extensible language; malleable, uniform, beautiful

  • Documentation?

    Haskell ⇒ Hoogle; can search by type alone!
    Emacs Lisp ⇒ Self-documenting; M-x apropos

  • How has using the language affected me?

    Haskell I almost always think in-terms compoistionality, functors, & currying
    Lisp Documentation strings, units tests, and metaprogramming are second nature

It may not be entirely accurate to say that Lisp's type system is more expressive than Haskell's as it's orthogonal in many respects; although it is closer to that of Liquid Haskell.

2 Why Bother with Types? A Terse Tutorial on Type Systems

Types allow us to treat objects according a similar structure or interface. Unlike Haskell and other statically typed systems, in Lisp we have that types can overlap. As such, here's our working definition.

A type is a collection of possible objects.

To say “\(e\) has type \(τ\)” one writes \(e : τ\), or in Lisp: (typep e 'τ).

Haskellers and others may append to this definition the following, which we will not bother with: Type membership is determined by inspecting syntactic structure and so is decidable.

✓ Typing is one of the simplest forms of “assertion-comments”: Documenting a property of your code in a way that the machine can verify.

If you're gonna comment on what kind of thing you're working with, why not have the comment checked by the machine.

Table 1: Lisp's type hierarchy is a “complemented lattice” ♥‿♥
Common types integer, number, string, keyword, array, cons, list, vector, macro, function, atom
Top t has everything as an element
Unit null has one element named nil
Bottom nil has no elements at all
Union (or τ₀ τ₁ … τₙ) has elements any element in any type τᵢ
Intersection (and τ₀ τ₁ … τₙ) has elements that are in all the types τᵢ
Complement (not τ) has elements that are not of type τ
Enumeration (member x₀ … xₙ) is the type consisting of only the elements xᵢ
Singleton (eql x) is the type with only the element x
Comprehension (satisfies p) is the type of values that satisfy predicate p

Let's see some examples: 

;; The universal type “t”, has everything as its value.
(typep 'x 't) ;; ⇒ true
(typep 12 't) ;; ⇒ true

;; The empty type: nil
(typep 'x 'nil) ;; ⇒ false; nil has no values.

;; The type “null” contains the one value “nil”.
(typep nil 'null) ;; ⇒ true
(typep () 'null)  ;; ⇒ true

;; “(eql x)” is the singelton type consisting of only x.
(typep 3 '(eql 3)) ;; ⇒ true
(typep 4 '(eql 3)) ;; ⇒ false

;; “(member x₀ … xₙ)” denotes the enumerated type consisting of only the xᵢ.
(typep 3 '(member 3 x "c"))  ;; ⇒ true
(typep 'x '(member 3 x "c")) ;; ⇒ true
(typep 'y '(member 3 x "c")) ;; ⇒ false

;; “(satisfies p)” is the type of values that satisfy predicate p.
(typep 12 '(satisfies (lambda (x) (oddp x)))) ;; ⇒ false
(typep 12 '(satisfies evenp) )                ;; ⇒ true

;; Computation rule for comprehension types.
;; (typep x '(satisfies p)) ≈ (if (p x) t nil)

Here's a convenient one: (booleanp x) ≈ (typep x '(member t nil)). 

(booleanp 2)   ;; ⇒ false
(booleanp nil) ;; ⇒ true

Strongly typed languages like Haskell allow only a number of the type formers listed above. For example, Haskell does not allow unions but instead offers so-called sum types. Moreover, unlike Haskell, Lisp is non-parametric: We may pick a branch of computation according to the type of a value. Such case analysis is available in languages such as C# —c.f., is is as or is as is. Finally, it is important to realise that cons is a monomorphic type —it just means an (arbitrary) element consisting of two parts called car and cdr— we show how to form a polymorphic product type below.

We may ask for the ‘primitive type’ of an object; which is the simplest built-in type that it belongs to, such as integer, string, cons, symbol, record, subr, and a few others. As such, Lisp objects come with an intrinsic primitive type; e.g., '(1 "2" 'three) is a list and can only be treated as a value of another type if an explicit coercion is used. In Lisp, rather than variables, it is values that are associated with a type. One may optionally declare the types of variables, like in OCaml.

Lisp (primitive) types are inferred!

“Values have types, not variables.” —Paul Graham, ANSI Common Lisp

Let's review some important features of type systems and how they manifest themselves in Lisp.

2.1 Obtaining & Checking Types

The typing relationship “:” is usually deterministic in its second argument for static languages: e : τ ∧ e : τ′ ⇒ τ ≈ τ′. However this is not the case with Lisp's typep.

Table 2: Where are the types & when are they checked?
Style Definition Examples
Static Variables have a fixed type; compile time Haskell & C#
Dynamic Values have a fixed type; runtime Lisp & Smalltalk

In some sense, dynamic languages make it easy to produce polymorphic functions. Ironically, the previous sentences is only meaningful if you acknowledge the importance of types and type variables.

In Lisp, types are inferred and needn't be declared. However, the declaration serves as a nice documentation to further readers ;-) 

(setq ellew 314)
(type-of ellew) ;; ⇒ integer

(setq ellew "oh my")
(type-of ellew) ;; ⇒ string
  • The type-of function returns the type of a given object.
  • Re variables: Static ⇒ only values can change; dynamic ⇒ both values and types change.

We may check the type of an item using typep, whose second argument is a “type specifiers” —an expressions whose value denotes a type; e.g., the or expression below forms a ‘union type’.

There's also check-type: It's like typep but instead of yielding true or false, it stays quiet in the former and signals a type error in the latter. 

(check-type 12 integer)               ;; ⇒ nil, i.e., no error
(check-type 12   (or symbol integer)) ;; nil; i.e., no error
(check-type "12" (or symbol integer)) ;; Crash: Type error!

In summary:

(equal τ (type-of e)) ≈ (typep e τ)
(check-type e τ) ≈ (unless (typep e 'τ) (error "⋯"))

( Note: (unless x y) ≈ (when (not x) y) .)

2.2 Statics & Dynamics of Lisp

Types are the central organising principle of the theory of programming languages. Language features are manifestations of type structure. The syntax of a language is governed by the constructs that define its types, and its semantics is determined by the interactions among those constructs.

— Robert Harper, Practical Foundations for Programming Languages

Besides atoms like numbers and strings, the only way to form new terms in Lisp is using “modus ponens”, or “function application”. Here's a first approximation: 

f : τ₁ → ⋯ → τₙ → τ   e₁ : τ₁  …  eₙ : τₙ
-----------------------------------------------------------------------------------------
           (f e₁ … eₙ) : τ

One reads such a fraction as follows: If each part of the numerator —the ‘hypothesises’— is true, then so is the denominator —the ‘conclusion’.

An abstract syntax tree, or ‘AST’, is a tree with operators for branches and arguments for children. A tree is of kind τ if the topmost branching operator has τ as its resulting type. Here's an improved rule: 

f : τ₁ → ⋯ → τₙ → τ   e₁ : AST τ₁  …  eₙ : AST τₙ
-----------------------------------------------------------------------------------------
              (f e₁ … eₙ) : AST τ

A Lisp top-level then may execute or interpret such a form to obtain a value: When we write e at a top-level, it is essentially (eval e) that is invoked. 

   e : AST τ
-----------------------------------------------------------------------------------------
  (eval e) : τ

However, we may also protect against evaluation. 

     e : AST τ
-----------------------------------------------------------------------------------------
  (quote e) : AST τ

We have the following execution rules, where ‘⟿’ denotes “reduces to”. 

(eval a)         ⟿ a                        ;; for atom ‘a’
(eval (quote e))   ⟿ e
(eval (f e₁ … eₙ)) ⟿ (f (eval e₁) ⋯ (eval eₙ)) ;; Actually invoke ‘f’

A conceptual model of Lisp is eval.

2.3 Variable Scope

There's also the matter of “scope”, or ‘life time’, of a variable.

Table 3: Local variables temporarily mask global names …
Style Definition Examples
Lexical … only in visible code Nearly every language!
Dynamic … every place imaginable Bash, Perl, & allowable in some Lisps

That is, dynamic scope means a local variable not only acts as a global variable for the rest of the scope but it does so even in the definitions of pre-defined methods being invoked in the scope. 

(setq it "bye")
(defun go () it)
(let ((it 3)) (go)) ;; ⇒ 3; even though “it” does not occur textually!

;; Temporarily enable lexical binding in Emacs Lisp
(setq lexical-binding t)
(let ((it 3)) (go)) ;; ⇒ bye; as most languages would act

Dynamic scope lets bindings leak down into all constituents in its wake.

That is fantastic when we want to do unit tests involving utilities with side-effects: We simply locally re-define the side-effect component to, say, do nothing. (─‿‿─)

2.4 Casts & Coercions

Table 4: The frequency of implicit type coercions
Style Definition Examples
Strong Almost never Lisp & Haskell
Weak Try as best as possible JavaScript & C

Strong systems will not accidentally coerce terms.

Lisp has a coerce form; but coercion semantics is generally unsound in any language and so should be used with tremendous caution. ( Though Haskell has some sensible coercions as well as unsafe one. ) 

     e : α
----------------------------------------------------------------------------------------
(coerce e β) : β

We have a magical way to turn elements of type α to elements of type β. Some languages call this type casting.

Here's a cute example. 

(coerce '(76 105 115 112) 'string) ;; ⇒ Lisp

2.5 Type Annotations

We may perform type annotations using the form the; e.g., the Haskell expression (1 :: Int) + 2 checks the type annotation, and, if it passes, yields the value and the expression is computed. Likewise, (the type name) yields name provided it has type type. 

(+ (the integer 1)
   (the integer 2)) ;; ⇒ 3

(+ (the integer 1)
   (the integer "2")) ;; ⇒ Type error.

Computationally, using or as a control structure for lazy sequencing with left-unit nil:

(the τ e) ≈ (or (check-type e τ) e)

2.6 Type-directed Computations

Sometimes a value can be one of several types. This is specified using union types; nested unions are essentially flattened —which is a property of ‘or’, as we shall come to see. 

(typep 12 'integer)  ;; ⇒ t
(typep 'a 'symbol)   ;; ⇒ t

(setq woah 12)
(typep woah '(or integer symbol)) ;; ⇒ t

(setq woah 'nice)
(typep woah '(or integer symbol)) ;; ⇒ t

When given a union type, we may want to compute according to the type of a value.

  • Case along the possible types using typecase.
  • This returns a nil when no case fits; use etypecase to have an error instead of nil.
(typecase woah
  (integer  (+1 woah))
  (symbol  'cool)
  (t       "yikes"))

2.7 Type Specifiers: On the nature of types in Lisp

Types are not objects in Common Lisp. There is no object that corresponds to the type integer, for example. What we get from a function like type-of, and give as an argument to a function like typep, is not a type, but a type specifier. A type specifier is the name of a type. —Paul Graham, ANSI Common Lisp

Type specifiers are essentially transformed into predicates as follows. 

(typep x 'τ)                ≈ (τp x)  ;; E.g., τ ≈ integer
(typep x '(and τ₁ … τₙ))    ≈ (and (typep x τ₁) … (typep x τₙ))
(typep x '(or τ₁ … τₙ))     ≈ (or (typep x τ₁) … (typep x τₙ))
(typep x '(not τ))          ≈ (not (typep x τ))
(typep x '(member e₁ … eₙ)) ≈ (or (eql x e₁) … (eql x eₙ))
(typep x '(satisfies p))    ≈ (p x)

Type specifiers are thus essentially ‘characteristic functions’ from mathematics.

2.8 Making New Types with deftype

If we use a type specifier often, we may wish to abbreviate it using the deftype macro —it is like defmacro but expands into a type specifier instead of an expression.

We can define new types that will then work with typecase and friends as follows:

  1. Define a predicate my-type-p.
  2. Test it out to ensure only the elements you want satisfy it.

  3. Register it using deftype.

    You could just do number 3 directly, but it's useful to have the predicate form of a type descriptor.

For example, here's the three steps for a type of lists of numbers drawn from (-∞..9]. 

;; Make the predicate
(defun small-number-seq-p (thing)
  (and (sequencep thing)
       (every #'numberp thing)
       (every (lambda (x) (< x 10)) thing)))

;; Test it
(setq yes '(1 2  4))
(setq no  '(1 20 4))
(small-number-seq-p yes) ;; ⇒ t

;; Register it
(deftype small-number-seq ()
  '(satisfies small-number-seq-p))

;; Use it
(typep yes 'small-number-seq) ;; ⇒ true
(typep no 'small-number-seq)  ;; ⇒ false

Arguments are processed the same as for defmacro except that optional arguments without explicit defaults use * instead of nil as the default value. From the deftype docs, here are some examples: 

(cl-deftype null () '(satisfies null))    ; predefined
(cl-deftype list () '(or null cons))      ; predefined

(cl-deftype unsigned-byte (&optional bits)
  (list 'integer 0 (if (eq bits '*) bits (1- (lsh 1 bits)))))

;; Some equivalences
(unsigned-byte 8)  ≡  (integer 0 255)
(unsigned-byte)    ≡  (integer 0 *)
unsigned-byte      ≡  (integer 0 *)
  • Notice that type specifiers essentially live in their own namespace; e.g., null is the predicate that checks if a list is empty yet null is the type specifying such lists.

Let's form a type of pairs directly —which is not ideal! This is a polymorphic datatype: It takes two type arguments, called a and b below. 

(deftype pair (a b &optional type)
  `(satisfies (lambda (x) (and
      (consp x)
      (typep (car x) (quote ,a))
      (typep (cdr x) (quote ,b))))))

(typep '("x" . 2) '(pair string integer)) ;; ⇒ true
(typep '("x" . 2) '(pair symbol integer)) ;; ⇒ false
(typep nil '(pair integer integer))       ;; ⇒ false
(typep 23 '(pair integer integer))        ;; ⇒ false

(setq ss "nice" nn 114)
(typep `(,ss . ,nn) '(pair string integer)) ;; ⇒ true
(typep (cons ss nn) '(pair string integer)) ;; ⇒ true

;; The following are false since ss and nn are quoted symbols!
(typep '(ss . nn)    '(pair string integer)) ;; ⇒ false
(typep `(cons ss nn) '(pair string integer)) ;; ⇒ false

Exercise: Define the polymorphic maybe type such that (maybe τ) has elements being either nil or a value of τ.

Let's define type list-of such that (list-of τ) is the type of lists whose elements are all values of type τ. 

;; Make the predicate
(defun list-of-p (τ thing)
  (and (listp thing) (every (lambda (x) (typep x τ)) thing)))

;; Test it
(list-of-p 'integer '(1 2   3)) ;; ⇒ true
(list-of-p 'integer '(1 two 3)) ;; ⇒ false
(list-of-p 'string '())         ;; ⇒ true
(list-of-p 'string '(no))       ;; ⇒ false

;; Register it
(deftype list-of (τ)
  `(satisfies (lambda (thing) (list-of-p (quote ,τ) thing))))

;; Use it

(typep '(1 2  ) 'list) ;; ⇒ true
(typep '(1 two) 'list) ;; ⇒ true

(typep '(1 2)   '(list-of integer)) ;; ⇒ true
(typep '(1 "2") '(list-of string))  ;; ⇒ false
(typep '(1 "2") '(list-of (or integer string)))  ;; ⇒ true

Notice that by the last example we can control the degree of heterogeneity in our lists! So cool!

Here's some more exercises. The first should be nearly trivial, the second a bit more work, and the last two have made me #sad.

  1. Define a type (rose τ) whose elements are either τ values or rose trees of type τ.
  2. Define a type record so that (record τ₁ … τₙ) denotes a record type whose iᵗʰ component has type τᵢ.

  3. Define a type constructor ∃ such that, for example, (∃ τ (pair integer τ) denotes the type of pairs where the first components are integers and the second components all have the same type τ, but we do not know which one.

    My idea was to let τ denote the type of the first occurrence of a value at that location, then all subsequent checks now refer to this value of τ.

    Sadly, I could not define this type :'(

    Upon further reading, this may be doable using a variable watcher.

  4. Produce a record for monoids and keep-track of the monoid instances produced. Define a the predicate (monoid τ) to check if any of the monoid instances has τ as its carrier type. In this way we could simulate Haskell typeclasses.

Let me know if you do cool things!

2.9 Algebraic Data Types a la Haskell

Consider the Haskell expression type, example, and integer evaluator. 

data Expr a = Var a | Expr a :+: Expr a | Neg (Expr a) deriving Show

ex :: Expr Int
ex = Var 5 :+: (Var 6 :+: Neg (Var 7))

int :: Expr Int -> Int
int (Var n)    = n
int (l :+: r)  = int l + int r
int (Neg e)    = - (int e)

{- int ex ⇒ 4 -}

If we view a constructor declaration C a₁ … aₙ with superfluous parenthesis as (C a₁ … aₙ), then a translation to Lisp immediately suggests itself:

Haskell constructors ≅ Lisp lists whose car are constructor names

A nearly direct translation follows. 

(defun exprp (τ thing)
    (pcase thing
       (`(var ,n)    (typep n τ))
       (`(add ,l ,r) (and (exprp τ l) (exprp τ r)))
       (`(neg ,e)    (exprp τ e))))

(setq ex '(add (var 5) (add (var 6) (neg (var 7)))))
(exprp 'integer ex) ;; ⇒ true

; This declarion “declare-type” is defined near the end of this article.
(declare-type int : (expr-of integer) integer)
(defun int (thing)
    (pcase thing
       (`(var ,n)    n)
       (`(add ,l ,r) (+ (int l) (int r)))
       (`(neg ,e)    (- (int e)))))

(int ex) ;; ⇒ 4

There are of-course much better ways to do this in Lisp; e.g., use identity, +, - in-place of the var, add, neg tags to produce “syntax that carries its semantics” or express the interpreter int as a one liner by replacing the formal tags with their interpretations then invoking Lisps eval. I doubt either of these are new ideas, but the merit of the former seems neat —at a first glance, at least.

Support for ADTs in Common Lisp along with seemingly less clunky pattern matching can be found here —which I have only briefly looked at.

The Haskell presentation has type-checking baked into it, yet our Lisp interpreter int does not! This seems terribly worrying, but that declare-type declaration actually handles type checking for us! 

;; Register the type
(deftype expr-of (τ)
  `(satisfies (lambda (thing) (exprp (quote ,τ) thing))))

;; Try it out
(typep '(1 2)   '(expr-of integer)) ;; ⇒ nil
(typep ex   '(expr-of integer))     ;; ⇒ true

;; This invocation, for example, now yields a helpful error message.
(int '(var 6 4))
;;
;; ⇒ int: Type mismatch! Expected (expr-of integer) for argument 0 ≠ Given cons (var 6 4).
;;
;; Which is reasonable since the ‘var’ constructor only takes a single argument.

Notice that invalid cases yield a helpful (run-time) error message!

3 In Defence of Being Dynamically Checked

Lisp gets a bad rap for being untyped; let's clarify this issue further!

It is important to realise that nearly every language is typed —albeit the checking may happen at different stages— and so, as Benjamin Pierce says: Terms like “dynamically typed” are arguably misnomers and should probably be replaced by “dynamically checked,” but the usage is standard.

In particular, dynamically typed is not synonymous with untyped, though some people use it that way since nearly every language is typed —possibly with a single anonymous type.

Some people in the Haskell community, which I love, say things like “if it typechecks, ship it” which is true more often than not, but it leads some people to avoid producing unit tests. For example, the following type checks but should be unit tested. 

mcbride :: [Int] -> Int
mcbride xs = if null xs then head xs else 666

Regardless, I love static type checking and static analysis in general. However, the shift to a dynamically checked setting has resulted in greater interest in unit testing. For example, Haskell's solution to effectful computation is delimited by types, as any Haskeller will proudly say (myself included); but ask how are such computations unit tested and the room is silent (myself included).

Interestingly some unit tests check the typing of inputs and output, which is a mechanical process with no unknowns and so it should be possible to produce a syntax for it using Lisp macros. This is one of the goals of this article and we'll return to it later.

Even though I like Lisp, I'm not sure why dynamic typing is the way to go —c.f. Dynamic Languages are Static Languages which mentions the unjust tyranny of unityped systems. Below are two reasons why people may dislike static types.

First: The de-facto typing rule do binary choice is usually: 

     T : 𝔹     E : α     B : α -----------------------------------------------------------------------------------------
     if T then E else B : α

That means valid programs such as if True then 1 else "two" are rejected; even though the resulting type will always be an integer there is no way to know that statically —the choice needs to be rewritten, evaluated at run time.

Indeed, in Haskell, we would write if True then Left 1 else Right "two" which has type Either Int String, and to use the resulting value means we need to pattern match or use the eliminator (|||) —from Haskell's Control.Arrow.

Second: Some statically typed languages have super weak type systems and ruin the rep for everyone else. For example, C is great and we all love it of-course, but it's a shame that we can only express the polymorphic identity function \(id : ∀{α}. α → α \;=\; λ x → x\), by using the C-preprocessor —or dismiss the types by casting pointers around.

Maybe this video is helpful, maybe not: The Unreasonable Effectiveness of Dynamic Typing for Practical Programs

( For the algebraist: Dynamic typing is like working in a monoid whose composition operation is partial and may abruptly crash; whereas static typing is working in a category whose composition is proudly typed. )

Overall I haven't presented a good defence for being dynamically checked, but you should ignore my blunder and consider trying Lisp yourself to see how awesome it is.

4 With its hierarchy of types, why isn't Lisp statically typed?

I haven't a clue. Here are two conjectures.

First: Code that manipulates code is difficult to type.

Is the type of '(+ x 2) a numeric code expression? Or just an arbitrary code expression? Am I allowed to “look inside” to inspect its structure or is it a black box? What about the nature of its constituents? If I'm allowed to look at them, can I ask if they're even defined?

What if c is a code element that introduces an identifier, say it. What is type of c? What if it doesn't introduce and thus avoids accidentally capturing identifiers? Are we allowed only one form or both? Which do we select and why?

I may be completely wrong, but below I mention a bunch of papers that suggest it's kind hard to type this stuff.

Second: The type theory just wasn't in place at the time Lisp was created.

Here's a probably wrong account of how it went down.

1913ish
Bertrand Russel introduces a hierarchy of types to avoid barber trouble; e.g., Typeᵢ : Typeᵢ₊₁.
1920s
A Polish guy & British guy think that's dumb and collapse the hierarchy.
1940s
Alonzo Church says arrows are cool.
1958

With his awesome hairdo, John McCarthy gifts the world an elegant piece of art: Lisp (•̀ᴗ•́)و

  • Lisp is currently the 2ⁿᵈ oldest high-level language still in use after Fortran.
  • Maxwell's equations get jealous.

Lisp introduces a bunch of zany ideas to CS:

  • Introduced if-then-else “McCarthy's Conditional”; 1ˢᵗ class functions & recursion
  • macros ≈ compiler plugins
  • symbols ≈ raw names which needn't have values
  • variables ≈ pointers
  • code ≈ data; statements ≈ expressions
  • read, eval, load, compile, print are all functions!
1959
My man JM thinks manual memory is lame —invents garbage collection!
1960s
Simula says OOPs!
1970s
Smalltalk popularises the phrase “oop”. ( B has a child named C. )
1970s
Simple λ-calculus is a fashion model for sets and functions.
1970s
Milner and friends demand variables are for types too, not just terms!
1970s
Per Martin-Löf tells us it's okay to depend on one another; Π, Σ types.
1982
A Lisp ummah is formed: “Common Lisp the Language” ♥‿♥
  • In order to be hip & modern, it's got class with CLOS.
  • Other shenanigans: Scheme 1975, Elisp 1985, Racket 1995, Clojure 2007
1984
A script of sorcerous schemes lords lisp over mere mortals
1990s
A committee makes a sexy camel named Haskell; Professor X's school make their own camel.
  • Their kids get on steroids and fight to this day; Agda ↯↯↯ Coq.
2000s

X's camel .<becomes .~(self .<aware>.)>. —the other camel [does| the same].

  • In 2015, the cam ls married Lisp and Lux was born.
  • In 2016, Haskell & Lisp get involved with Prolog; Shen is born.

2019: Coq is self-aware; Agda is playing catch-up.

A more informative historical account of Lisp & its universal reverence can be read at: How Lisp Became God's Own Programming Language.

lisp.jpg
Figure 3: xkcd

5 Lisp Actually Admits Static Typing!

Besides Common Lisp, “Typed Lisps” include an optional type system for Clojure —see also Why we're no longer using Core.typed— Typed Racket, and, more recently, Lux ≈ Haskell + ML + Lisp and Shen ≈ Haskell + Prolog + Lisp.

For example, Common Lisp admits strong static typing, in SBCL, as follows. 

  ; Type declaration then definition.
  (declaim (ftype (function (fixnum)) num-id))
  (defun num-id (n) n)

  (defun string-id (s) (declare (string s)) (num-id s))
  ; in: DEFUN STRING-ID
  ;     (NUM-ID S)
  ;
  ; caught WARNING:
  ;   Derived type of S is
  ;     (VALUES STRING &OPTIONAL),
  ;   conflicting with its asserted type
  ;     FIXNUM.

Such annotations mostly serve as compiler optimisation annotations and, unfortunately, Emacs Lisp silently ignores Common Lisp declarations such as ftype —which provides function type declarations. However, Emacs Lisp does provide a method of dispatch filtered by classes rather than by simple types. Interestingly, Lisp methods are more like Haskell typeclass constituents or C# extensible methods rather than like Java object methods —in that, Lisp methods specialise on classes whereas Java's approach is classes have methods.

Here's an example. 

(defmethod doit ((n integer)) "I'm an integer!")
(defmethod doit ((s string)) "I'm a string!")
(defmethod doit ((type (eql :hero)) thing) "I'm a superhero!")

(doit 2)             ;; ⇒ I'm an integer!
(doit "2")           ;; ⇒ I'm a string!
(doit 'x)            ;; ⇒ Error: No applicable method
(doit :hero 'bobert) ;; ⇒ I'm a superhero!

;; C-h o cl-defmethod ⇒ see extensible list of specialisers Elisp supports.

We can of-course make our own classes: 

(defclass person  () ((name)))
(defmethod speak ((x person)) (format "My name is %s." (slot-value x 'name)))
(setq p (make-instance 'person))
(setf (slot-value p 'name) "bobert")
(speak p) ;; ⇒ My name is bobert.

;; Inherits from ‘person’ and has accessor & constructor methods for a new slot
(defclass teacher (person) ((topic :accessor teacher-topic :initarg :studying)))

(defmethod speak ((x teacher))
  (format "My name is %s,and I study %s." (slot-value x 'name) (teacher-topic x)))

(setq ins (make-instance 'teacher :studying "mathematics"))
(setf (slot-value ins 'name) "Robert")
(speak ins) ;; ⇒ My name is Robert, and I study mathematics.

Later in this article, we'll make something like the declaim above but have it be effectful at run-time. Typing as Macros!

( If you happen to be interested in looking under the hood to see what compiler generated code looks like use disassemble. For example, declare (defun go (x) (+ 1 x) 'bye) then invoke (disassemble 'go) to see something like varref x⨾ add1⨾ discard ⨾ constant bye⨾ return. )

6 ELisp's Type Hierarchy

⇨ Each primitive type has a corresponding Lisp function that checks whether an object is a member of that type. Usually, these are the type name appended with -p, for multi-word names, and p for single word names. E.g., string type has the predicate stringp.

Type Descriptor

Objects holding information about types.

This is a record; the type-of function returns the first slot of records.

This section is based GNU Emacs Lisp Reference Manual, §2.3 “Programming Types”.

6.1 Number

Numbers, including fractional and non-fractional types.

integer float number natnum zero plus minus odd even

The relationships between these types are as follows:

(numberp x) ≈ (or (integerp x) (floatp x))
(natnump x) ≈ (and (integerp x) (≤ 0 x))
(zerop x) ≈ (equal 0 x)
(plusp x) ≈ (< 0 x)
(minusp x) ≈ (> 0 x)
(evenp x) ≈ (zerop (mod x 2))
(oddp x) ≈ (not (oddp x))

  • Integer: Numbers without fractional parts.

    There is no overflow checking. 

    (expt 2 60) ;; ⇒ 1,152,921,504,606,846,976
(expt 2 61) ;; ⇒ -2,305,843,009,213,693,952
(expt 2 62) ;; ⇒ 0

    Numbers are written with an optional sign ‘+’ or ‘-’ at the beginning and an optional period at the end.

    -1 ≈ -1. 1 ≈ +1 ≈ 1.

    They may also take inclusive (and exclusive) ranges: The type list (integer LOW HIGH) represents all integers between LOW and HIGH, inclusive. Either bound may be a list of a single integer to specify an exclusive limit, or a * to specify no limit. The type (integer * *) is thus equivalent to integer. Likewise, lists beginning with float, real, or number represent numbers of that type falling in a particular range. ( The Emacs Common Lisp Documentation ) 

        (typep 4 '(integer 1 5)) ;; ⇒ true since 1 ≤ 4 ≤ 5.
    (typep 4 '(integer 1 3)) ;; ⇒ nil  since 1 ≤ 4 ≰ 3.

    (typep 12 'integer) ;; ⇒ t
    (typep 12 'number) ;; ⇒ t

    (typep 23 'odd)  ;; ⇒ t

    (typep 12 '(integer * 14)) ;; ⇒ t, since 12 ≤ 14, but no lower bound.
    (typep 12 '(integer 0 *)) ;; ⇒ t; the ‘*’ denotes a wild-card; anything.

   (typep -1 '(not (integer 0 *))) ;; ⇒ t
   (typep  1 '(not (integer 0 *))) ;; ⇒ nil

   (typep 1 '(integer  1 2))   ;; ⇒ t, including lower bound
   (typep 1 '(integer (1) 2))  ;; ⇒ nil, excluding lower bound

   (typep 1.23 '(float 1.20 1.24)) ;; ⇒ t

   ;; Here's a slighly organised demonstration:

   (typep 1.23 'number) ;; ⇒ t
   (typep 123  'number) ;; ⇒ t
   (typep 1.23 'real) ;; ⇒ t
   (typep 123  'real) ;; ⇒ t

   (typep 1.23 'integer) ;; ⇒ nil
   (typep 123  'integer) ;; ⇒ t
   (typep 1.23 'fixnum) ;; ⇒ nil
   (typep 123  'fixnum) ;; ⇒ t

   (typep 1.23 'float) ;; ⇒ t
   (typep 123 'float) ;; ⇒ nil
   (typep 123.0 'float) ;; ⇒ t
  • Floating-Point: Numbers with fractional parts; expressible using scientific notation. For example, 15.0e+2 ≈ 1500.0 and -1.0e+INF for negative infinity.
  • Aliases: The type symbol real is a synonym for number, fixnum is a synonym for integer, and wholenum is a synonym for natnum.

  • The smallest and largest values representable in a Lisp integer are in the constants most-negative-fixnum and most-postive-fixnum 

    ;; Relationship with infinities
(< -1e+INF most-negative-fixnum most-positive-fixnum 1e+INF) ;; ⇒ t

6.2 Character

Representation of letters, numbers, and control characters.

A character is just a small integers, up to 22 bits; e.g., character A is represented as the integer 65.

One writes the character ‘A’ as ?A, which is identical to 65. Punctuations ()[]\;"|'`# must be ­escaped; e.g.,

?\( ≈ 40 ?\\ ≈ 92

Whereas ?. ≈ 46. 

(characterp ?f) ;; ⇒ t
(characterp t)  ;; ⇒ nil

Emacs specfic characters control-g C-g, backspace C-h, tab C-i, newline C-j, space, return, del, and escape are expressed by ?\a, ?\b, ?\t, ?\n, ?\s, ?\r, ?\d, ?\e.

Generally, control characters can be expressed as ?\^𝓍 ≈ ?\C-𝓍, and meta characters by ?\M-𝓍; e.g., C-M-b is expressed ?\M-\C-b ≈ ?\C-\M-b.

Finally, ?\S-𝓍 denotes shifted-𝓍 characters. There are also ?\H-𝓍, ?\A-𝓍, ?\s-𝓍 to denote Hyper- Alt- or Super-modified keys; note that lower case ‘s’ is for super whereas capital is for shift, and lower case with no dash is a space character.

6.3 Symbol

A multi-use object that refers to functions and variables, and more.

A symbol is an object with a name; different objects have different names. 

(typep 'yes 'symbol) ;; ⇒ true
(symbolp 'yes)       ;; ⇒ true

(typep 12   'symbol) ;; ⇒ false
(symbolp 12)         ;; ⇒ false
symbol ≈ Is it a symbol?
bound ≈ Does it refer to anything? 
(typep 'xyz 'bound) ;; ⇒ nil

(setq xyz 123)
(typep 'xyz 'bound) ;; ⇒ t

See this short docs page for more info on when a variable is void.

Names have a tremendously flexible syntax. 

(setq +*/-_~!@$%^&:<>{}? 23)
(setq \+1            23) ;; Note +1 ≈ 1, a number.
(setq \12            23)
(setq this\ is\ woah 23) ;; Escaping each space!
(+ this\ is\ woah 1)     ;; ⇒ 24

If the symbbol name starts with a colon ‘:’, it's called a keyword symbol and automatically acts as a constant. 

(typep :hello 'keyword) ;; ⇒ t

Symbols generally act as names for variables and functions, however there are some names that have fixed values and any attempt to reset their values signals an error. Most notably, these include t for true or the top-most type, nil for false or the bottom-most type, and keywords. These three evaluate to themselves. 

t      ;; ⇒ t
nil    ;; ⇒ nil
:hello ;; ⇒ :hello

(setq t   12) ;; ⇒ Error: Attempt to set a constant symbol
(setq nil 12) ;; ⇒ Error: Attempt to set a constant symbol
(setq :x  12) ;; ⇒ Error: Attempt to set a constant symbol

;; :x ≠ 'x
(set 'x 12) ;; ⇒ 12
x           ;; ⇒ 12

;; They're self-evaluating
(equal t   't)   ;; ⇒ t
(equal nil 'nil) ;; ⇒ t
(equal :x  ':x)  ;; ⇒ t

(equal :x 'x)  ;; ⇒ nil

In particular, :x ≠ 'x!

6.4 Sequence

The interface for ordered collections; e.g., the (elt sequence index) function can be applied to any sequence to extract an element at the given index.

sequence seq

The latter is an extensible variant of the former —for when we declare our own sequential data types. 

(typep '(1 2 3) 'sequence) ;; ⇒ t

There are two immediate subtypes: array and cons, the latter has list as a subtype. 

(typep  [1 2 3] 'array)       ;; ⇒ t
(typep '(1 2 3) 'cons)        ;; ⇒ t
(typep '(1 "2" 'three) 'list) ;; ⇒ t
Array

Arrays include strings and vectors.

Vector
One-dimensional arrays.
Char-Table
One-dimensional sparse arrays indexed by characters.
Bool-Vector
One-dimensional arrays of t or nil.
Hash Table
Super-fast lookup tables.
(typep "hi" 'string) ;; ⇒ true
(typep 'hi  'string) ;; ⇒ false
Cons cell type

Cons cells and lists, which are chains of cons cells.

These are objects consisting of two Lisp objects, called car and cdr. That is they are pairs of Lisp objects. 

      '(x₀ x₁ x₂)
    ≈ '(x₀ . (x₁ . (x₂ . nil)))
    ≠ '(x₀ x₁ . x₂)
    ≈ '(x₀ . (x₁ . x₂))

Notice that when there is no ‘.’, then a list is just a nested cons chain ending in ‘nil’. Note that '(x₀ . x₁ . x₂) is meaningless.

Cons cells are central to Lisp and so objects which are not a cons cell are called atoms. 

;; An atom is not a cons.
(typep 123 'atom) ;; ⇒ t
(typep 'ni 'atom) ;; ⇒ t

Computationally:

  (atom x)
≈ (typep x 'atom)
≈ (not (consp x))
≈ (not (typep x 'cons))
≈ (typep x '(not cons))

Interestingly, one writes atom, not atomp.

6.5 Function

Piece of executable code.

A non-compiled function in Lisp is a lambda expression: A list whose first element is the symbol lambda. 

(consp     (lambda (x) x))        ;; ⇒ true
(functionp (lambda (x) x))        ;; ⇒ true

(functionp (lambda is the first)) ;; ⇒ true
(typep (lambda stuff) 'function)  ;; ⇒ true

It may help to know that a defun just produces an alias for a function: 

  (defun name (args) "docs" body)
≈ (defalias (quote name) (function (lambda (args) docs body)))

Here's some more examples. 

(typep #'+   'function) ;; ⇒ true
(typep 'nice 'function) ;; ⇒ false

(defun it (x) (format "%s" (+1 x)))
(typep #'it   'function) ;; ⇒ true
(functionp #'it)         ;; ⇒ true

6.6 Macro

A method of expanding an expression into another expression.

Like functions, any list that begins with macro, and whose cdr is a function, is considered a macro as long as Emacs Lisp is concerned. 

(macrop '(macro (lambda (x) x))) ;; ⇒ true

Since defmacro produces an alias, as follows, 

  (defmacro name (args) "docs" body)
≈ (defalias (quote name) (cons (quote macro) (function (lambda (args) docs body))))

You may be concerned that (macrop x) ≟ (equal 'macro (car x)), and so if a user gives you a macro you might think its a cons cell of data. Fortunately this is not the case: 

(defmacro no-op () )

(macrop #'no-op)    ;; ⇒ true
(consp  #'no-op)    ;; ⇒ false; whence it's also not a list.
(functionp #'no-op) ;; ⇒ false

(typep #'no-op '
       (satisfies (lambda (x) (and (listp x) (equal 'macro (car x)))))) ;; ⇒ false

Why not? Well, you could think of a macro as a ‘record’ whose label is macro and its only element is the associated function.

6.7 Record

Compound objects with programmer-defined types.

They are the underlying representation of defstruct and defclass instances.

For example: 

(defstruct person
  name age)

The type-of operator yields the car of instances of such declartions.

(record τ e₀ … eₙ) ≈ #s(τ e₀ … eₙ) 
(setq bobert (make-person :name "bobby" :age 'too-much))
(type-of bobert) ;; ⇒ person

Componenets may be indexed with aref. 

(aref bobert 1)      ;; ⇒ bobby
(person-name bobert) ;; ⇒ bobby

A record is considered a constant for evaulation: Evaluating it yields itself. 

(type-of #s(person "mark" twelve)) ;; ⇒ person
(recordp #s(nice))                 ;; ⇒ t

7 Typing via Macros & Advice

Checking the type of inputs is tedious and so I guessed it could be done using macros and advice. Looking at Typed Racket for inspiration, the following fictitious syntax would add advice to f that checks the optional arguments xᵢ have type σᵢ and the mandatory positional arguments have type τᵢ according to position, and the result of the computation is of type τ. To the best of my knowledge, no one had done this for Emacs Lisp —I don't know why. 

(declare-type 'f ((:x₁ σ₁) … (:xₘ σₘ)) (τ₁ … τₙ τ))

To modify a variable, or function, we may simply redefine it; but a much more elegant and powerful approach is to “advise” the current entity with some new behaviour. In our case of interest, we will advise functions to check their arguments before executing their bodies.

Below is my attempt: declare-type. Before you get scared or think it's horrendous, be charitable and note that about a third of the following is documentation and a third is local declarations. 

(cl-defmacro declare-type (f key-types &rest types)
  "Attach the given list of types to the function ‘f’
   by advising the function to check its arguments’ types
   are equal to the list of given types.

   We name the advice ‘⟪f⟫-typing-advice’ so that further
   invocations to this macro overwrite the same advice function
   rather than introducing additional, unintended, constraints.

   Using type specifiers we accommodate for unions of types
   and subtypes, etc ♥‿♥.

   ‘key-types’ should be of the shape (:x₀ t₀ ⋯ :xₙ tₙ);
    when there are no optional types, use symbol “:”.

    E.g., (declare-type my-func (:z string :w integer) integer symbol string)
  "

  ;; Basic coherency checks. When there aren't optional types, key-types is the “:” symbol.
  (should (and (listp types) (or (listp key-types) (symbolp key-types))))

  (letf* ((pairify (lambda (xs) (loop for i in xs by #'cddr         ;; Turn a list of flattenned pairs
                                      for j in (cdr xs) by #'cddr   ;; into a list of explicit pairs.
                                      collect (cons i j))))         ;; MA: No Lisp method for this!?
         (result-type  (car (-take-last 1 types)))
         (types        (-drop-last 1 types))
         (num-of-types (length types))
         (key-types-og (unless (symbolp key-types) key-types))
         (key-types    (funcall pairify key-types-og))
         (advice-name  (intern (format "%s-typing-advice" f)))
         (notify-user  (format "%s now typed %s → %s → %s."
                               `,f key-types-og types result-type)))

      `(progn
         (defun ,advice-name (orig-fun &rest args)

           ;; Split into positional and key args; optionals not yet considered.
           (letf* ((all-args
                     (-split-at
                       (or (--find-index (not (s-blank? (s-shared-start ":" (format "%s" it)))) args) ,num-of-types)
                        args)) ;; The “or” is for when there are no keywords provided.
                  (pos-args  (car all-args))
                  (key-args  (funcall ,pairify (cadr all-args)))
                  (fun-result nil)
                  ((symbol-function 'shucks)
                     (lambda (eτ e g)
                       (unless (typep g eτ)
                         (error "%s: Type mismatch! Expected %s %s ≠ Given %s %s."
                                (function ,f) eτ e (type-of g) (prin1-to-string g))))))

         ;; Check the types of positional arguments.
         (unless (equal ,num-of-types (length pos-args))
           (error "%s: Insufficient number of arguments; given %s, %s, but %s are needed."
                  (function ,f) (length pos-args) pos-args ,num-of-types))
         (loop for (ar ty pos) in (-zip pos-args (quote ,types) (number-sequence 0 ,num-of-types))
               do (shucks ty (format "for argument %s" pos) ar))

         ;; Check the types of *present* keys.
         (loop for (k . v) in key-args
               do (shucks (cdr (assoc k (quote ,key-types))) k v))

         ;; Actually execute the orginal function on the provided arguments.
         (setq fun-result (apply orig-fun args))
         (shucks (quote ,result-type) "for the result type (!)" fun-result)

         ;; Return-value should be given to caller.
         fun-result))

      ;; Register the typing advice and notify user of what was added.
      (advice-add (function ,f) :around (function ,advice-name))
      ,notify-user )))

declare-type

There are some notable shortcomings: Lack of support for type variables and, for now, no support for optional arguments. Nonetheless, I like it —of course. ( Using variable watchers we could likely add support for type variables as well as function-types. )

We accidentally forgot to consider an argument. 

(declare-type f₁ (:z string :w list) integer symbol string)
;; ⇒ f₁ now typed (:z string :w integer) → (integer symbol) → string.

(cl-defun f₁ (x y &key z w) (format "%s" x))
;; ⇒ f₁ now defined

(f₁ 'x) ;; ⇒ f₁: Insufficient number of arguments; given 2, (x), but 3 are needed.

The type declaration said we needed 3 arguments, but we did not consider one of them.

We accidentally returned the wrong value. 

(declare-type f₂ (:z string :w list) integer symbol string)
(cl-defun f₂ (x y &key z w) x)

(f₂ 144 'two)
;; ⇒ f₂: Type mismatch! Expected string for the result type (!) ≠ Given integer 144.

We accidentally forgot to supply an argument. 

(declare-type f₃ (:z string :w list) integer symbol string)
(cl-defun f₃ (x y &key z w) (format "%s" x))

(f₃ 144)
;; ⇒ f₃: Insufficient number of arguments; given 1, (144), but 2 are needed.

A positional argument is supplied of the wrong type. 

(f₃ 'one "two")
;; ⇒  f₃: Type mismatch! Expected integer for argument 0 ≠ Given symbol one.

(f₃ 144 "two")
;; ⇒ f₃: Type mismatch! Expected symbol for argument 1 ≠ Given string "two".

Notice: When multiple positional arguments have type-errors, the errors are reported one at a time.

A keyword argument is supplied of the wrong type. 

(f₃ 1 'two :z 'no₀ :w 'no₁)
;; ⇒ f₃: Type mismatch! Expected string :z ≠ Given symbol no₀.

(f₃ 1 'two :z "ok" :w 'no₁)
;; ⇒ f₃: Type mismatch! Expected string :w ≠ Given symbol no₁.

(f₃ 1 'two :z "ok" :w 23)
;; ⇒ f₃: Type mismatch! Expected string :w ≠ Given integer 23.

(f₃ 1 'two :z "ok" :w '(a b 1 2)) ;; ⇒ okay; no type-error.

We have no optional arguments. 

(declare-type f₄ : integer symbol string)
(cl-defun f₄ (x y &key z w) (format "%s" x))

(f₄ 144 'two :z "bye")
;; ⇒  f₄: Type mismatch! Expected nil :z ≠ Given string "bye".
;; ( We shouldn't have any keyword :z according to the type declaration! )

(f₄ 144 'two) ;; ⇒ "144"

We can incorporate type specfiers such as unions! 

(declare-type f₅ : (or integer string) string)
(cl-defun f₅ (x) (format "%s" x))

(f₅ 144)     ;; ⇒ "144"
(f₅ "neato") ;; ⇒ "neato"

(f₅ 'shaka-when-the-walls-fell)
;; ⇒ f₅: Type mismatch! Expected (or integer string) for argument 0
;;       ≠ Given symbol shaka-when-the-walls-fell.

No positional arguments but a complex optional argument! 

(declare-type f₆ (:z (satisfies (lambda (it) (and (integerp it) (= 0 (mod it 5))))))
                 character)
(cl-defun f₆ (&key z) ?A)

(f₆ 'hi)     ;; ⇒  Keyword argument 144 not one of (:z)
(f₆)         ;; ⇒ 65; i.e., the character ‘A’
(f₆ :z 6)
;; ⇒  f₆: Type mismatch!
;;    Expected (satisfies (lambda (it) (and (integerp it) (= 0 (mod it 5))))) :z
;;    ≠ Given integer 6.

(f₆ :z 10) ;; ⇒ 65; i.e., the expected output since 10 mod 5 ≈ 0 & so 10 is valid input.

Preconditions! The previous example had a complex type on a keyword, but that was essentially a pre-condition; we can do the same on positional arguments. 

(declare-type f₇ : (satisfies (lambda (it) (= it 5)))
                   integer)
(cl-defun f₇ (n) n)
;; The identity on 5 function; and undefined otherwise.

(f₇ 4)
;; ⇒ f₇: Type mismatch! Expected (satisfies (lambda (it) (= it 5))) for argument 0
;;       ≠ Given integer 4.

(f₇ 5) ;; ⇒ 5

Postconditions! Given an integer greater than 5, we present an integer greater than 2; i.e., this is a constructive proof that \(∀ n • n > 5 ⇒ n > 2\). 

(declare-type f₈ : (satisfies (lambda (in)  (> in 5)))
                   (satisfies (lambda (out) (> out 2))))
(cl-defun f₈ (n) n)
;; The identity on 5 function; and undefined otherwise.

(f₈ 4)
;; ⇒  f₈: Type mismatch! Expected (satisfies (lambda (in) (> in 5))) for argument 0
;;        ≠ Given integer 4.

(f₈ 72) ;; ⇒ 72; since indeed 72 > 5 for the input, and clearly 72 > 2 for the output.

As it currently stands we cannot make any explicit references between the inputs and the output, but that's an easy fix: Simply add a local function old to the declare-type macro which is intentionally exposed so that it can be used in the type declarations to refer to the ‘old’, or initial, values provided to the function. Additionally, one could also add keyword arguments :requires and :ensures for a more sophisticated pre- and post-condition framework. Something along these lines is implemented for Common Lisp.

Here's a fun exercise: Recast the Liquid Haskell examples in Lisp using this declare-type form.

8 Closing

I have heard more than one LISP advocate state such subjective comments as, "LISP is the most powerful and elegant programming language in the world" and expect such comments to be taken as objective truth. I have never heard a Java, C++, C, Perl, or Python advocate make the same claim about their own language of choice.

---A guy on slashdot

I learned a lot of stuff, hope you did too ^_^

9 References

Neato web articles:

Tags: types lisp program-proving emacs
Generated by Emacs and Org-mode (•̀ᴗ•́)و
 
]]> https://alhassy.github.io/TypedLisp.html https://alhassy.github.io/TypedLisp.html Wed, 21 Aug 2019 19:29:00 -0400 <![CDATA[Have you ever packaged anything?]]>
12 Mar 2019
Article image

Abstract

Herein I try to make my current doctoral research accessible to the average person: Extending dependently-typed languages to implement module system features in the core language. It's something I can direct my family to, if they're inclined to know what it is I've been doing lately.

The technical matter can be seen at the associated website ─The Next 700 Module Systems─ which includes a poster, slides, and a demo.

Excluding the abstract, this is my thesis proposal in three minutes (•̀ᴗ•́)و

( Photo by Vitor Santos on Unsplash )

1 Part I ─Getting the mail

  • Have you ever been confused by packages?

  • There are so many parts when it comes to packaging:

    1. There's the stamps,
    2. the addresses,
    3. the contents,
    4. the damage insurance,
    5. the package weight,
    6. customs declarations!

    There's so many parts!

  • Look at them! ⟪ gesture to screen ⟫
    • There's so many! The place is a mess!
    • This could be you parents' basement!
    • It could be your work desk!
    • In computing, this is your code! Mish-mashed from smaller pieces!
    • Eek!
  • Unlike the day-to-day mail we receive, in computing, packages take the form of modules and each of these separate, yet crucial, aspect of packaging corresponds to a different language! ⟪Pause⟫

  • Think about it: On average, a ‘coding language’ actually consists of at least 4 different languages! That's like if your package in the mail had

    • a stamp in English,
    • an address in Spanish,
    • contents in Latin,
    • the insurance policy in German,
    • package weight in Gaelic.

    What a headache!

  • You shouldn't have to go to college to understand how your mail works!

2 Part II ─Building blocks

  • Just as a clingy boyfriend, or a puppy that follows you around, is called a ‘dependent type’ we have those in computing too and they're essentially the same thing!
    • Software that uses dependent types lets us treat the different pieces as if they were the same –except packages, they still live in their own language.
  • Packages are a building block of computing, like Lego(!): You can build better, compact, software using pre-built blocks. ⟪ Gesture hands together. ⟫
  • Since computing is so young as a science, we don't really know how pieces should be glued together.
    • You'd think otherwise since you have a brick in your pocket that can access all knowledge of humanity.
  • For the most part, we cope by ad hoc methods – “it works good enough”.
    • Unfortunately this does not scale!
    • ⟪wave at slide⟫ package maintenance can get out of hand rather quickly for any large piece of software!

3 Part III ─Arithmetic

  • Just as the clingy boyfriend and the puppy dog that follows you around can be seen as just more family; with dependent types, packages too can be treated as just normal blocks.

  • I'm researching the arithmetic of packages to help software developers manage large projects and reduce complexity & maintenance costs.

    My research suggests that packaging can be treated in the same way we treat numbers.

    • We can combine numbers by adding them, likewise we can combine packages by putting their pieces together in a new package!
    • In grade school, “2 + 3 and 3 + 2 are both 5”, yet with packages “2 + 3 might be 5, but 3 + 2 might not even exist!”

So next time you send a package, think of what it means to me and how many languages are involved!

Tags: packages dependent-types
Generated by Emacs and Org-mode (•̀ᴗ•́)و
 
]]> https://alhassy.github.io/three-minute-thesis.html https://alhassy.github.io/three-minute-thesis.html Tue, 12 Mar 2019 19:29:00 -0400 <![CDATA[An Interactive Way To C]]>
12 Jan 2019
Article image

Abstract

Do you know what the above program accomplishes? If you do, did you also spot a special edge case?

We aim to present an approach to program proving in C using a minimal Emacs setup so that one may produce literate C programs and be able to prove them correct –or execute them– using a single button press; moreover the output is again in Emacs.

The goal is to learn program proving using the Frama-C tool –without necessarily invoking its gui– by loading the source of this file into Emacs then editing, executing, & proving as you read along. One provides for the formal specification of properties of C programs –e.g., using ACSL– which can then be verified for the implementations using tools that interpret such annotation –e.g., Frama-C invoked from within our Emacs setup.

Read on, and perhaps you'll figure out how to solve the missing FixMe pieces 😉

The intent is for rapid editing and checking. Indeed, the Frama-c gui does not permit editing in the gui, so one must switch between their text editor and the gui. Org mode beginning at the basics is a brief tutorial that covers a lot of Org and, from the get-go, covers “the absolute minimum you need to know about Emacs!”

If anything, this effort can be construed as a gateway into interactive theorem proving such as with Isabelle, Coq, or Agda.

The article aims to be self-contained –not even assuming familiarity with any C!

The presentation and examples are largely inspired by

Another excellent and succinct tutorial is Virgile Prevosto's ACSL Mini-Tutorial. In contrast, the tutorial ACSL By Example aims to provide a variety of algorithms rendered in ACSL.

There are no solutions since it's too easy to give up and look at the solutions that're nearby. Moreover, I intend to use some of the exercises for a class I'm teaching ;-)

1 Introduction

Despite its age, C is a widely used language and so is available on many platforms. Moreover, many systems rely on code historically written in C that needs to be maintained.

The traditional way to obtain confidence that a program correctly works is to provide inputs we believe to be representative of the actual use of the program and verify the results we get are correct. Incidentally, the unexpected cases are often not considered whereas they are generally the most dangerous ones. Since we cannot test everything, we need to employ great care in selecting good tests.

Since it is hard to answer “Is our software tested enough?”, we consider mathematically proving that there cannot be problems at runtime. That is, a specification of the expected behaviour is provided, which is satisfied by the resulting program –note the order: Specify then obtain code! This two-stage process can produce errors in either stage, yet whereas testing ensures “the program avoids the bugs we tested against” this approach is a big step ensuring “the program doesn't contain bugs that don't exist in the specification.”

The goal here is to use a tool to learn the basics of C program proof –Frama-C: FRAmework for Modular Analysis of C code. In particular, to demonstrate the ability to write programs without any error by emphasising the simple notions needed to write programs more confidently.

Testing is ‘dynamic analysis’ since it requires the actual execution of programs, whereas our program proof approach is ‘static’ since no execution is performed but instead we reason on a semantic model of the reachable states. The semantics associated with the C language control structures and statements we will use is known as Hoare Logic. One writes a “Hoare Triple” {G} S {R} to express that “Starting in a given state (satisfying) G, the execution of S terminates such that the resulting state (satisfies) R”.

How does one prove such a triple? Programs are constructed from a variety of pieces, so it suffices to look at each of those. That is, {G} S {R} has the code S transform the required predicate R to the given G –since we usually know what is required and it is the goal of the program. In general, we find the weakest precondition that works since then it allows the largest possible number of inputs; if G is at least as strong as the weakest precondition, then our program is correct but may allow less then the largest amount of possible inputs.

For example, {5 ≤ x ≤ 10} x ≔ x + 1 { 3 ≤ x ≤ 11} is a correct program that ends in state 3 ≤ x ≤ 11, however its precondition could be weakened to 2 ≤ x ≤ 10 thereby allowing many more valid inputs.

In Frama-C, we do not use curly braces like this for such assertions but instead express our properties as code annotations using the ANSI C Specification Language –ACSL or “axel”. The weakest precondition plugin uses the annotation and the code to automatically ensure the program is correct according to the Hoare Logic fashion mentioned earlier.

1.1 Getting Started

The aim of this section is to introduce the Emacs controls that bring C to life within literate code.

Key Press Elisp Command Description
Enter <s then TAB ─ Produces a “Hello World” C template program.
F6 (interpret) Execute currently focused code blocks in a new buffer.
F7 (show-code) Shows currently focused code blocks in a new buffer.
F8 (frama-c) Open the Frama-C gui on the currently focused code blocks.
F9 (frama-c-no-gui) Invoke Frama-C on the currently focused code blocks in a new buffer.

Which code blocks are currently under focus is controlled by the command (currently-working-with "nameHere"), which produces a file nameHere.c that is used for the utility functions. If multiple blocks use the same filename, then the file is appended to. While reading this tutorial, bring/take code blocks in/out of focus by toggling between (currently-working-with "nameHere") and (not-currently-working-with "nameHere") —that is, simply prepend not-. Remember to undo such a toggle when you're done with a code block.

When no name is provided to [not-]currently-working-with, the name of the buffer is used.

1.1.1 Exercise: Hello World

  1. Insert the text <s then press the TAB key.
  2. A new C program template has appeared.
  3. Press F6 to execute the code in another buffer.
  4. Press F7 to inspect the code in another buffer.
  5. Alter the program to output your name, press F6.

Now toggle that code block so that you are not currently working with it.

  • Make a change to the code block, such as printing 42. Notice that F6 refers to the old file on disk since there is no currently focused block.

1.1.2 Exercise: Verifying Swap

Consider the fully annotated swap algorithm, i.e., remove the not- prefix, 

// #include<stdio.h> // for IO

/*@
requires \valid(a) && \valid(b);
assigns *a, *b;
ensures *a == \old(*b);
ensures *b == \old(*a);
*/
void swap(int* a, int* b)
{
  int tmp = *a;
  *a = *b;
  *b = tmp;
}

int main()
{
  // printf("Hello World!\n");

  int a = 42;
  int b = 37;

  //@ assert Before_Swap: a == 442 && b == 37;
  swap(&a, &b);
  //@ assert After_Swap: a == 37 && b == 42;

  return 0;
}

We can see that Frama-C proves these assertions by obtaining “green bullets” beside them if we execute 

frama-c-gui -wp -rte myfile.c

Or check-boxes beside them if we instead execute 

frama-c-gui -gui-theme colorblind -wp -rte myfile.c

The best way to know which options are available is to use 

frama-c -wp-help

We will however use the special Emacs calls defined at the bottom of this file, frama-c and frama-c-no-gui, to avoid having to switch between a terminal and a text editor. Thank-you extensible editor Emacs ⌣̈ ♥

  • Press F8 to invoke the Frama-C gui.
  • Press F9 to invoke Frama-C within Emacs and obtain status about the program proof.

If you uncomment the IO matter, Frama-C may yield an error. Separate your IO into its own driver file! Invoke Frama-C only on programs you want to prove –without any IO.

Go back to the above example, and change the first assertion in main, ~a == 42, to assert that a equals 432. Now invoke M-x framac-no-gui, or press F9, to obtain the message, 

Frama-C: 90﹪ of proof complete!

Moreover, another buffer will be open and in red will be highlighted, 

[wp] [Alt-Ergo] Goal typed_main_assert_Before_Swap : Unknown (Qed:0.63ms) (57ms)

This indicates that, in method main, the named assertion Before_Swap could not be proven.

Now revert all alterations and in the specification of swap, alter ensures *a ==== \old(*b); to become ensures *a == \old(*a);, thereby expressing that the value of a is unaltered by the program. Checking this yields a false assertion! Neato.

As such, I suggest the following literate process:

  1. Write your code in Org-mode code blocks,
  2. Check it works with frama-c-no-gui (F9) or frama-c (F8).
    • If we open the gui, we may right-click on a function name and select Prove function annotations by WP to have our assertions checked.
    • Remember that the frama-c gui does not allow source code edition.
  3. Investigate output, then make changes in source file and re-check.

Observe

  • Program proof is a way to ensure that our programs only have correct behaviours, described by our specification;
  • It is still our work to ensure that this specification is correct.

1.2 A Prelude

Since C's #include is essentially a copy-paste, we can re-export other libraries from a make-shift ‘Prelude’. 

// Artefacts so that exercises let the system progress as much as possible.
//
//@ predicate Exercise = \false;
//@ predicate FixMe = \false;
#define FixMeCode

// Tendency to require this header file to specfiy avoidance of overflow.
//
#include<limits.h>

We will continue to be (currently-working-with "Prelude") in the future to add more content. For now, we put the artefacts needed to let the exercises pass.

The use of \false is not the most appropriate, since its occurrence in a precondition vacuously makes everything true! This is something that should change.

The current setup produces only .c files, whence we use the prelude by declaring #include "Prelude.c". Forgive my use of a .c file in-place of a header file. The alternative is to force all code block names to end in a .c.

2 Basic Constructs

Recall that a Hoare Triple {G} S {R} expresses that if execution of program S is begun in a state satisfying proposition G then it terminates in a state satisfying proposition R. We usually know R –it is the required behaviour on S after all– but otherwise we usually only have a vague idea of what G could possible be. Dijkstra's weakest precondition operator ‘wp’ tells us how to compute G from R –in the process we usually discover S.

Hence, all in all, programming begins with the required goal from which code is then derived.

Details

Post-conditions R are expressed using the ensures clause, and dually pre-conditions G are expressed using requires clauses. These G are properties assumed for the input and it is the callers responsibility to ensure that they are true –recall that when a contract is breached, the implementation may behave arbitrarily.

Since ‘wp’ is intended to compute the weakest precondition establishing a given postcondition R for a statement S, it necessarily satisfies 

    { G } S { R }   ≡   G ⇒ wp S R

The left side may be rendered using ACSL, 

// @ assert G;
S;
// @ assert R;

The WP plugin for Frama-C essentially works by computing wp S R then attempts to obtain a proof for G ⇒ wp S R. In particular, by the reflexivity of implication, ‘wp’ guarantees to produce a precondition so that the following Hoare triple is valid. 

   { wp S R } S { R }

Most programming languages have, among others, five constructs: Assignment, variable declaration, sequence, test, and loop. These constructs from the imperative core of the language. Since programs are built using such primitive control structures, it suffices to define wp “by induction” on the shape of S.

One reasonable property we impose on wp from the outset is:
If S establishes R which implies R′, then S also establishes R′. 

Monotonicity: R ⇒ R′   implies  wp S R ⇒ wp S R′
                       That is, {wp S R} S {R′}

Whence for each definitional clause of wp, we must ensure this desirable property is held.

Details

Imperative programs alter state, as such a statement S is essentially a function that transforms the memory state of the computer. Expressing in English what happens when a statement is executed is possible for simple examples, but such explanations quickly become complicated and imprecise. Therefore, one introduces a theoretical framework reifying statements as state transformers.

The two popular notions are the “forwards” ⟦S⟧ moves current state to a new state, whereas we are working with “backwards” wp S which takes a desired state and yields a necessary previous state. The forward notion ‘executes’ a program by starting in the empty state and stepping through each command to result in some final state. Whereas the backwards notion takes an end goal and suggests which programming constructs are needed to obtain it. Hence, ‘forwards’ is verification whereas ‘backwards’ is correct-by-construction programming.

Suppose there is an infinite set Var of variables and an infinite set Val of values, which are integers, booleans, etc. In the ‘forwards’ notion, a state is a partial function from variables to values –`partial' since it may be undefined at some variables, since we usually use only finitely many in our programs anyways. E.g., state {x ↦ 5, y ↦ 6} associates the value 5 to variable x but is undefined for variable z. Dually, in the ‘backwards’ notion, a state is a predicate of the variables and their values that satisfy the predicate; e.g., the previous example state corresponds to the predicate x = 5 ∧ y = 6, where z can have any value. Hence the predicate formulation is more relaxed and we shall refer to it instead.

2.1 Assignment

The assignment construct allows the creation of a statement with a variable x and an expression E. The assignment statement is written x = E;.

  • Variables are identifiers which are written with one or more letters.
  • Expressions are composed of variables, constants, and operator calls.
  • Sometimes one notates assignment by x ≔ E even though it is invalid C code.

To understand the execution of an assignment, suppose that within the recesses of your computer's memory, there is a compartment labelled x. Obtain the value of E –possibly having to look up values of variables that E mentions– then erase the contents of x and fill the compartment with the newly obtained value.

The whole of the contents of the computer's memory is called a state. We also say “predicate R is the current state” as shorthand for: The current state is (non-deterministically) any variable-value assignment such that predicate R is true.

All in all, executing x ≔ E loads memory location x with the value of expression E; hence state R is satisfied after an assignment precisely when it is satisfied with variable x replaced by expression E. For example, wp (x ≔ x+1) (x = 5) ≡ (x+1 = 5). 

wp (x ≔ E) R  ≡  R[x ≔ E]

Before being able to assign values to a variable x, it must be declared, which associates the name x to a location in the computer's memory. Variable declaration is a construct that allows the creation of a statement composed of a variable, an expression, and a statement. This is written {T x = e; p}, then variable x can be used in statement p, which is called the scope of variable x. ( When p has no assignments, functional programmers would call this statement a let statement since it lets x take on the value e in p. )

Details
  • Division: If both arguments are integers, then the operation rounds down; write, e.g., 5 / 2.0 to mark the result as floating point.
  • Modulo: The number a % b is a - b * (a / b).
  • Ternary Conditional: For all types, the expression (c) ? t : f yields t if boolean c holds and is f otherwise.
  • A useful inclusion: 2*109 <= 232 <= 2*1010

2.1.1 Overshadowing & Explicit Scope Delimitation

Imperative languages generally do not allow the declaration of the same variable multiple times, e.g., the following program crashes with error: redefinition of ‘x’. 

#include<stdio.h> // for IO

int main()
{
  int x = 3;
  printf("x has value: %d", x);

  int x = 4;
  printf("x has value: %d", x);

  return 0;
}

However, if we explicitly delimit the scope of a variable by using braces, then we can obtain multiple declarations: 

#include<stdio.h> // for IO

int main()
{
  int x = 3;
  printf(" x has value: %d", x);  // 3

  { int x = 4;
    printf("\n x has value: %d", x); // 4
  }
  return 0;
}

When explicitly delimiting scope, it is the most recent declarations that are used. We say that earlier declarations are hidden, or overshadowed, by the later declarations.

Details 
int main()
{
  int x = 3;

  //@ assert x == 3;

  { // Begun new scope

    // Old facts are still true.
    //@ assert x == 3;

    // Now overshadowing ‘x’
    int x = 4;

    // This new ‘x’ is equal to 4.
    //@ assert x == 4;
  }

  // Back to the parent scope.
  // In this scope, ‘x’ still has its orignal value.
  //@ assert x == 3;

  return 0;
}

2.1.2 Constant Variables

Constant variables are variables which may have only one initial value that can never be changed. A non-constant variable is called mutable, which is the default in imperative languages. For example, the following crashes with error: assignment of read-only variable ‘x’. 

#include<stdio.h> // for IO

int main()
{
  const int x = 3;
  x = 4;
  printf("x has value: %d", x);

  return 0;
}

2.2 Sequence

A sequence is a construct that allows a single statement to be created out of two statements p and q; it is written {p q}. The sequence is executed in state s by first executing p in state s thereby producing a new state s' in which statement q is then executed.

  • The statement {p₁ {p₂ { ... pₙ } ...}} can also be written {p₁ p₂ ... pₙ}.

Usually a ‘;’ symbol is used in favour of a space, with braces, to yield, 

wp (S₁;S₂) R  ≡  wp S₁ (wp S₂ R)

The pre-condition of the second statement becomes the post-condition of the first statement. Hence, we “push” along the post-condition into a sequence: In the upcoming swapping example, we read the proof steps from bottom to top!

Rendered pointfree, i.e., ignoring R, this rule becomes: wp (S₁;S₂) = wp S₁ ∘ wp S₂.

Recall that we need to ensure monotonicity is satisfied, and indeed: If R ⇒ R′, then 

  wp (S₁;S₂) R
≡ wp S₁ (wp S₂ R)    -- Definition of wp on sequence
⇒ wp S₁ (wp S₂ R′)   -- Monotoncity for Sᵢ, twice; with assumption R ⇒ R′
≡ wp (S₁;S₂) R      -- Definition of wp on sequence

Neato!

Moreover, notice we have the useful ‘transitivity’ property for Hoare triples: 

   {G} S₁ {R′}  ∧  {R′} S₂ {R}
≡  (G ⇒ wp S₁ R′)  ∧  (R′ ⇒ wp S₂ R)              -- Characterisation of wp
⇒ (G ⇒ wp S₁ R′)  ∧  (wp S₁ R′ ⇒ wp S₁ (wp S₂ R)) -- Monotonicity of wp
⇒ (G ⇒ wp S₁ (wp S₂ R))                           -- Transitivity of implication
≡  G ⇒ wp (S₁;S₂) R                               -- Definition of wp on sequence
≡  {G} S₁;S₂ {R}                                  -- Characterisation of wp

Exercise: Show that wp (x ≔ E; S) R ≡ (wp S R)[x ≔ E].

2.3 Skip

The “empty sequence” is denoted {} or just ; in the C language. It is also commonly known as the skip construct and its importance is akin to that of zero to addition. 

wp skip R  ≡  R

The “do nothing” program skip is rendered as simple ; or as whitespace in the C language. This program does not alter the state at all, thus it truthifies R precisely when R was true to begin with.

Most often this appears in a weakening/strengthening form, 

...code here...
//@ assert P;
//@ assert Q;
...code here...

Where P ⇒ Q is provable.

More concretely, 

/*@ requires 3 < a < 9;
  @ ensures  -20 <= \result <= 99;
  */
int using_skip(int a)
{
  //@ assert our_strong_pre:         3 < a < 9;
  //@ assert weakened_intermediary: -7 <= a <= 14;
  //@ assert weakening_futher:     -20 <= a <= 99;
  return a;
}

Woah! It looks like the identity function somehow transforms input satisfying 3 < x < 9 to input satisfying -20 ≤ x ≤ 99. Wait, the former implies the latter and that's just the definition of wp on skip.

The above example suggests the following calculation, 

   (G′ ⇒ G)  ∧  {G} S {R}  ∧  (R ⇒ R′)
≡  (G′ ⇒ G)  ∧  (G ⇒ wp S R)  ∧  (R ⇒ R′) -- Characterisation of wp
⇒ (G′ ⇒ wp S R)  ∧  (R ⇒ R′)              -- Transitivity of implication
⇒ (G′ ⇒ wp S R)  ∧  (wp S R ⇒ wp S R′)    -- Monotonicity of wp
⇒ (G′ ⇒ wp S R′)                          -- Transitivity of implication
≡  {G′} S {R′}                            -- Characterisation of wp

That is, strengthening the precondition or weakening the post-condition leaves a Hoare triple valid. In some industry circles –e.g., C#–, this is referred to as contravariance (antitone) in the input and covariance (monotone) in the output.

For example, if G′, G, R, R′ were classes such that G′ is a subclass of G and R is a subclass of R′, then the program S takes an input of type G yielding an output of type R′. However, any input of type G′ can be cast into the parent-class type G and, likewise, R objects can be cast into the parent-type R′. Thus, program S can also take the type of G′ to R′.

Writing <: for ‘sub-type’, or ‘sub-class’, we have argued, 

Provided    G′ <: G  and R <: R′
Then
       G → R  <:  G′ → R′

It is now easier to see that the second argument of function-type former ‘→’ stays on the same side of the <: symbol, whereas it is flipped for the first argument.

Completely unrelated –or not– a nearly identical property holds for implication: If G′ ⇒ G and R ⇒ R′ then (G ⇒ R) ⇒ (G′ ⇒ R′). How coincidental … or not! \\ ( Foreshadowing: Curry-Howard Correspondence! )

Anyhow, this strengthening-weakening law will be useful when computing the wp of a statement directly is difficult –and possibly unhelpful– but we have a stronger precondition and so it suffices to use that. ( Foreshadowing: Loops! )

Before we close, here is an exercise to the reader: An alternate proof of the above law. 

   (G′ ⇒ G)  ∧  {G} S {R}  ∧  (R ⇒ R′)
≡  {G′} skip {G} ∧ {G} S {R} ∧ {R} skip {R′}    -- ???
⇒ {G′} skip; S {R} ∧ {R} skip {R′}             -- ???
⇒ {G′} skip; S; skip {R′}                      -- ???
≡  {G′} S {R′}                                  -- skip is no-op & can be removed.

The last hint in the above calculation deserves some attention.

  1. Rendered pointfree, i.e., ignoring R, the skip rule becomes: wp skip = id.
    • Where id is the identity function: id(x) = x.
  2. “Program Equality”: Say S ≈ T precisely when wp S = wp T.
    • Two programs are considered equal precisely when they have the same observational behaviour –i.e., can satisfy the same set of post-conditions R.
  3. Identity of Sequence Theorem: S ; skip ≈ S ≈ skip ; S.
  4. Likewise, define wp abort R ≡ false – i.e., abort is a program that crashes on any input.
  5. Zero of Sequence Theorem: S ; abort ≈ abort ≈ abort ; S.

2.4 Examples Using the Assignment, Sequence, Skip Rules

To avoid having to write the verbose \at(x, Pre) to refer to the value of a variable x before method execution, we may use a ghost variable: A variable whose purpose is only to make the assertions provable, and otherwise is not an execution-relevant variable. 

#include<limits.h>

/*@ requires \valid(x) && \valid(y);
  @ requires INT_MIN < *x + *y < INT_MAX;
  @ requires \separated(x, y); // Exercise: It's a swap, why is this needed?
  @ assigns *x, *y;
  */
void swap(int *x, int *y)
{
  //@ ghost int X = *x;
  //@ ghost int Y = *y;

  //@ assert  *y == Y  && *x == X;
  //@ assert  *y == Y  && (*x + *y) - *y == X;
  *x = *x + *y;
  //@ assert  *y == Y  && *x - *y == X;
  //@ assert  *x - (*x - *y) == Y  && *x - *y == X;
  *y = *x - *y;
  //@ assert  *x - *y == Y  && *y == X;
  *x = *x - *y;
  //@ assert  *x == Y  && *y == X;

  // 𝓢𝓽𝓪𝓻𝓽 upwards reading from here;
  // each assertion is obtained by the assigment, skip, and sequence rules.
}

Here is a more complicated exercise that also makes use of external functions…

Details 

#include "Prelude.c"

#define RAND_MAX 32767

/*@
  @ assigns \nothing;
  @ ensures 0 <= \result <= RAND_MAX;
*/
int rand();

/*@ requires min <= max;
  @ requires min + RAND_MAX < INT_MAX;
  @ requires max - min < INT_MAX;
  @ assigns \nothing;
  @ ensures min <= \result <= max;
*/
int random_between(int min, int max)
{
  int it = rand();
  //@ assert weakening: 0 <= it <= RAND_MAX;
  //@ assert assignment_rule_again: FixMe;
  it = it % (max - min + 1);
  // @ assert simplify: FixMe;
  // @ assert assignment_rule: FixMe;
  it = it + min;
  // @ assert min <= it;

  // Start at the bottom, and push assertion upwards!
  // The assertion names are also intended to be read upwards;
  // Each justifies how it was obtained.

  return it;

  // That is,
  // return (rand() % (max - min + 1)) + min;
}

2.5 Test; Conditional

A test is a statement formed from a Boolean expression and two statements; it is written \\ if (b) p else q –sometimes a ‘then’ keyword is used for readability, but such is not valid C code. This is executed in a state by evaluating the Boolean then deciding which branch to execute in the same state. 

wp (if B then S₁ else S₂) R  ≣  if B then wp S₁ R else wp S₂ R
                             ≡ (B ⇒ wp S₁ R) ∧ (¬ B ⇒ wp S₂ R)

A conditional ensures R precisely when its branches each ensure R.

Observe the following calculation, 

   { G } if B then S₁ else S₂ { R }
≡  G ⇒ wp (if B then S₁ else S₂) R         -- Characterisation of wp
≡  G ⇒ (B ⇒ wp S₁ R) ∧ (¬ B ⇒ wp S₂ R)     -- Definition of wp on conditional
≡  (G ⇒ B ⇒ wp S₁ R) ∧ (G ⇒ ¬ B ⇒ wp S₂ R) -- Characterisation of meets
≡  (G ∧ B ⇒ wp S₁ R) ∧ (G ∧ ¬ B ⇒ wp S₂ R) -- Shunting
≡  {G ∧ B} S₁ {R}  ∧  {G ∧ ¬ B} S₂ {R}     -- Characterisation of wp

That is, Hoare triples on a conditional ‘distribute’ into the branches with each branch precondition obtaining the branch guard.

2.6 Loop

A loop is a construct formed from a Boolean expression and a statement; it is written while (b) p. A loop is one of the ways in which we can express an infinite object –which may fail to terminate– using a finite expression. Indeed, its executional behaviour can be understood by realising it as a shorthand for the expression 

if (b) {p if (b) {p if (b) ...
                    else skip}
          else skip}
else skip

Where skip is the fictional statement that performs no action when executed.

To understand the semantics of the loop:

  1. Let giveup, terminate be aliases for abort and skip.

  2. Recalling that a loop is a shorthand for an infinite nesting of conditionals, we try to approach it as a limit of finite approximations. 

         while (b) q  ≈  limₙ pₙ

  Where:
  p₀ = if (b) giveup else terminate
  p₁ = if (b) {q ; if b giveup else terminate} else terminate
  ⋯
  pₙ₊₁ = if (b) {q; pₙ} else terminate;
  3. The statement pₙ tries to execute the statement while (b) q by completing a maximum of n trips through the loop. If, after n loops, it has not terminated on its own, it gives up.

  4. If the loop terminates in m trips, it also terminates in n ≥ m trips.

    • ∀ m. pₘ defined ⇒ ∀ n ≥ m. pₙ defined
    • ∀ m. pₘ defined ⇒ ∀ n ≥ m. pₙ ≈ pₘ

    Where ‘defined’ means it terminates without aborting.

  5. Hence, by these two claims, we know that the sequence pₙ either never defined or it is defined beyond a certain point, and in this case, it is constant over its domain.
  6. Hence: while(b) q ≈ limₙ pₙ.

The definition of ‘wp’ for loops is complicated and generally unhelpful, however from it we can prove the so called “Invariance Theorem”: If a property is maintained by the body of the loop and there is an integral value expressed using the body's variables that starts out non-negative and is decreased by each loop pass, then the loop will terminate and the property it maintained will be true. 

   {Inv ∧ B ∧ bf = c} S {Inv ∧ bf < c}
⇒
   {Inv ∧ bf ≥ 0}  while(B) S  {¬B ∧ Inv}

A property that is maintained to be true throughout the loop is referred to as an invariant. In contrast, a value that changes through every pass –such as the number of passes remaining, the bf– is known as a variant.

In Frama-C rendition, 

/*@ loop invariant ⋯  // property that is maintained by the loop body
  @ loop assigns ⋯    // variables that are altered by the loop body
  @ loop variant ⋯    // a bound on the total number of loops
  */
while(B) S;

Incidentally the primary function of the assigns clause is that variables its does not mention essentially have the invariant property of being equal to their value before the loop. That is, the assigns clause reduces clutter regarding constants from the invariant!

Details 
#include<limits.h>
/*@ requires N >= 0;
  @ requires N * (N + 1) /2 < INT_MAX;
  @ assigns \nothing;
  @ ensures \result == N * (N + 1) / 2;
  */
int euclid(int N)
{
  int sum = 0; int n = 0;
  //@ assert invariant_intially_estabished: 2 * sum == 0 * (0 + 1);

  /*@ loop invariant main_item: sum == n * (n + 1) / 2;
    @ loop invariant always_in_range: 0 <= n <= N;
    @ loop invariant range_for_sum: 0 <= sum;
    // Exercise: Why can we comment out the following two lines?
    @ loop invariant no_overflow1: n < INT_MAX;
    @ loop invariant no_overflow2: sum <= INT_MAX;
    @ loop assigns n, sum;
    @ loop variant N - n;
   */
  while(n != N)
  {
    //@ assert sum + n < INT_MAX;
    n   = n + 1;
    //@ assert sum + n <= INT_MAX;
    sum = sum + n;
    //@ assert sum <= INT_MAX;
  }
  //@ assert invariant_and_not_guard: n == N  &&  sum == n * (n + 1) / 2;
  //@ assert post_condition:    sum == N * (N + 1) / 2;
  //         rewrite_post:  2 * sum == N * (N + 1);  // Not true, due to ‘rounding’!

  return sum;
}

Exercise: Why is sum ≤ INT_MAX true at the end of the loop body? Fill in the proof: 

   sum ≤ INT_MAX
≡  n * (n + 1) / 2 ≤ INT_MAX                     --  ???
⇐ n * (n + 1) / 2 ≤ N * (N + 1) / 2 ≤ INT_MAX   --  Transtivitity of ≤
≡  N * (N + 1) / 2 ≤ INT_MAX                     --  ???
≡  true                                          --  ???

Here's a simple exercise,

Details 
#include<limits.h>

/*@ requires a + 10 < INT_MAX;
  @ ensures \result == \old(a) + 10;
 */
int look_ma_no_new_locals(int a)
{
  //@ ghost const int A = a;

  int i;                   // So we can refer to this ‘i’ *after* the loop.
  /* // @ loop assigns ???;         // Fix me.
    @ loop invariant a == 666;      // Fix me.
    @ loop invariant 0 <= i <= 10;
    @ loop variant   666;           // Fix me.
    @*/
  for(i = 0; i != 10; i++) a++;
//@ assert after_loop_guarantees: i == 10  && a == A + i;
//@ assert weakening_previous_gives: a == A + 10;
  return a;
}

Warning Without the loop assigns, you are more likely to have trouble proving a loop is correct!

Now a bit harder…

Details 

#include<limits.h>

/*@ assigns \nothing;
  @ ensures 0 <= \result <= 1;
 */
int random_bool(); // { return random_between(0, 1); }

/*@ requires \valid(it);
  @ requires *it + max <= INT_MAX;
  // @ requires FixMe -- a property on `max`;
  // @ assigns FixMe;
  @ ensures  \old(it) <= it <= it + max;
  */
void increment_randomly(int *it, int max)
{
   /*@ loop assigns i, *it;
     @ loop invariant *it == \at(*it, Pre) + i;
     // @ loop invariant range_of_i: FixMe;
     // @ loop variant FixMe;
    */
   for(int i = 0; i != max && random_bool(); i++) (*it)++;
}

3 ACSL Properties

3.1 Predicates

Our invaraints were getting out of hand, the trouble can be mitigated by defining our own predicates rather than just using the built in ones. However, such definitions must be functional in nature: They do not produce side-effects, such as altering state. Moreover, they are generally parameterised by a label that refers to the C memory state in which they would be invoked –within the definition we cannot however reference the special labels Here, Pre, Post. Otherwise parameter passing is by value as in C.

The predicate keyword declares Boolean values functions: 

/*@ predicate name_here {Label₀, …, Labelₖ} (type₀ arg₀, …, typeₘ argₘ) =
  @ // A Boolean valued relationship between all these things.
  */

// An integer memory location remains unaltered between given program points.
//
/*@ predicate unchanged{L0, L1} (int *i)   =  \at(*i, L0) == \at(*i, L1);
 */

int main()
{
  int i = 13, j = 12;

  DoSomeWork:
  j = 32;

  //@ assert unchanged{DoSomeWork, Here}(&i);

  return 0;
}

More usefully, there is the need to ensure a given integer is indeed a non-negative length of an array. 

/*@ predicate valid_array(int* arr, integer len) =
  @ 0 <= len && \valid(arr + (0 .. len - 1));
 */

Notice that we did not specify a memory label. That's okay, one is provided for us and the entire definition is considered to transpire at that memory location. In particular, unlike the previous example, we cannot refer to distinct memory locations –after all we haven't named any! At the call site, the implicit memory location would be Here thereby referring to the current memory state –however we may still explicitly provide a different label at the call site.

3.2 Logic Functions

Predicates must be either true or false, but logic functions are methods that can be invoked in our specifications –you may have noticed that C methods cannot be called in a specification, which is reasonably since they may produce side-effects! Since assignment, sequence, and loops rely on side effects they now suddenly become useless and our definitions must rely on recursion. Such logical functions generally need not worry about runtime issues such as overflow –which however must be handled at the call site, if need be. 

/*@ logic return_type function_name {Label₀, …, Labelₖ} (type₀ arg₀, …, typeₘ argₘ) =
  @  // A formula using the arguments argᵢ, possibly at labels Labelᵢ
 */

//@ logic integer factorial(integer n)  =  (n <= 0) ? 1 : n * factorial(n-1);

If we wrote a program that contained many occurrences to factorial then the definition would need to be invoked each time. If the occurrences all happened, for example, on the same input, say 12 –any larger would be an unsigned int overflow– then it might make matters faster if we simply had that as a lemma that is proven once and used many times by the underlying provers. Indeed this can be accomplished by using the lemma phrase, and this can be done for any property. 

//@ lemma name_of_property {Label₀, …, Label₀}:  property_here ;

For example, 

//@ lemma lt_plus_lt: \forall integer i,j; i < j ==> i + 1 < j + 1;

3.3 Axiomatic Definitions

Sometimes a proof may take too long to be proven, or it cannot be proven with the back-end provers, and, moreover, we do not wish to bother with its proof directly. In such cases, we may tell Frama-C to trust our judgement and take our word for it –if we're not careful, our ‘word’ may lead us to conclude false = true! 

/*@ axiomatic my_axioms {
  @ axiom antisymmetry: \forall integer i, j; i <= j <= i  ==>  i == j;
  @ }
*/

Unlike lemmas, which require a proof, axioms are simply assumed to be true. It is the responsibility of the user to ensure no inconsistencies arise, as in: 

//@ axiomatic UhOh{ axiom false_is_true: \false; }

int main()
{
  // Examples of proven properties

  //@ assert \false;
  //@ assert \forall integer x; x == 31;
  //@ assert \false == \true;
  return 0;
}

However, axiomatic definitions of recursive functions are useful since the underlying provers do not unroll the recursion when possible –after all, we are simply declaring the type of a function and some properties about it, which incidentally, happen to be its defining equations. 

/*@ axiomatic Factorial
  {
     logic integer factorial(integer n);

     axiom factorial_base: \forall integer i;  i <= 0  ==>  factorial(i) == 0;
     axiom factorial_inductive:
          \forall integer i; i >  0  ==>  factorial(i) == i * factorial(i - 1);
  }
*/

A small subtlety is that access to memory locations must be specified in the function headers, for example: 

/*@ axiomatic is_constant
  {
     predicate constant{L}(int * a, integer b, integer e, integer val) reads a[b .. e-1];

     axiom constant_empty{L}:
       \forall int * a, integer b, e, val; b >= e  ==> constant{L}(a, b, e, val);

     axiom constant_non_empty{L}:
       \forall int * a, integer b, e, val; b < e ==>
          ( constant{L}(a,b,e, val)  <==>  constant{L}(a,b,e-1, val) && a[e-1] == val );
  }
*/

4 Functions

We will be proving code blocks satisfy Hoare triples, but code blocks are essentially methods with the given predicate acting as a pre-condition and the required predicate acting as post-condition. As such, we investigate Hoare triples by using methods.

A contract stipulates under what conditions a method will behave –if those conditions are not met, then it's behaviour may be arbitrary. For example, a method may behave in a manner ensuring \\ x > 1/y under the condition y > 0, and it may do anything it wants –such as aborting the system or setting x = -1– when that condition is not met.

All in all, a function call establishes property R precisely when evaluating its arguments then executing the function body together establish the property. 

wp ℱ(t₁, …, tₙ) R  ≡  wp (x₁ ≔ t₁; ⋯ ; xₙ ≔ tₙ; ℬ) R

where ℱ(x₁, …, xₙ) = ℬ  -- Definition of ℱ

4.1 What are Functions?

Functions permit abstraction over program design since parts may be constructed independently and also promotes avoidance of repetition.

Unlike functional languages where the result of a function is the final term in its body, imperative languages signal result values by the return keyword; which immediately stops execution of the function regardless of the keyword's position.

Functions which return no value but instead perform some effectful action, i.e., are procedures, are marked with the void keyword in-place of a return type –surprisingly, this ‘return type’ is not a type at all! One cannot declare a variable of type void.

Function calls that yield a value are terms whereas those that do not constitute statements.

Details 
#include<stdio.h> // for IO

int  f(){ return 3;}
void g(){ printf("g(): Hello There!"); }

int main()
{
  // Valid invocations
  int x = f();
  f();           // Bad form! Result is discarded.
  g();

  // T y = g(); // Type error! No possible type T!
  return 0;
}

A program is an sequence of global variables, function declarations, then a special function called main. Since sequences are ordered, all names are declared before use! In C, main usually exits with return 0. Global variables tend to pollute the namespace and are more trouble than they're worth, so we shall ignore them –however they are already included by default since assignment is a top-level construct. Incidentally, function declarations with no arguments may be used to simulate global constants.

Note that C does not permit function overloading. Moreover, C uses the same namespace for methods as well as simple variables –which in is not the case in, say, Java which permits naming a method f and a variable f to obtain the valid invocation f(f)!

Details 
int it(int x){ return x; }
int it = 5;
int maybe = it(it);

4.1.1 Effectful Expressions

In C, any expression followed by a semicolon is a statement: The value of the expression is simply ignored when it is used as a statement.

Conversely, statements may be regarded as an effectful expression. For example, assignment x ≔ E assigns the value of E to x and returns the value of E. Whence, the notion of

Details 
void continued_assgns()
{
  int x = 1, y = 2, z = 4;

  //@ assert x == 1  &&  y == 2  && z == 4;

  x -= y += z;         // Assignments are right-associative!

  //@ assert z == 4  &&  y == 2+4  && x == 1-(2+4);
  //@ assert z == 4  &&  y == 6    && x == -5;
}

4.2 An Example Functional Contract

Look at the definition of abs below and notice:

  • Frama-C contracts are comments beginning with an @ symbol and concluded with a ; symbol.
  • The post-condition is introduced with the ensures clause; which may contain the \result keyword to refer to the returned value of the method.
  • We may combine multiple ensures clauses by using conjunction &&, or have them on separate lines. We may also use implication ==>, disjunction ||, negation !, value equality ==, and Boolean equivalence <==>.
    • Notice that implication: A ==> B informs that when A is true then so is B, and if A is false then we don't care and consider the whole thing to be true.
  • Notice that we may name our conditions, which is helpful to remind us of their purpose as well as being helpful in the frama-c output.
/*@ ensures always_nonnegative: \result >= 0;
  @ ensures val > 0  ==>  \result == val;
  @ ensures val < 0  ==>  \result == -val;
 */
int abs(int val)
{
  return (val < 0) ? -val : val;
}

Pressing F9, you will notice that we are also checking for runtime errors by using the RTE plugin whose goal is to ensure the program cannot create runtime errors such as integer overflow, invalid pointer dereferencing, division by 0, etc.

In our case, we have runtime problems that do not crash but instead produce logical errors: The return value of abs is not positive! Indeed, in addition to the above block, add focus to the following block by removing the prefix -not, then run the code with F6 to see the output. –Remember to undo this alteration when you're done, otherwise the next invocation to frama-c will take a while dealing with printf! 

#include<stdio.h>   // for IO
#include<limits.h>  // bounds on integers
#include<math.h>

int main()
{
  // Our implementation is faulty..
  printf("    INT_MIN      = %d\n", INT_MIN);
  printf("abs(INT_MIN)     = %d\n\n", abs(INT_MIN));

  printf("    INT_MIN + 1  = %d\n", INT_MIN+1);
  printf("abs(INT_MIN + 1) = %d\n\n", abs(INT_MIN+1));

  // Using standard library works..
  printf("fabs(INT_MIN)    = %.0f", fabs(INT_MIN));

  return 0;
}

The WP plugin forms the necessary proof obligations to ensure the program meets its specification, simplifies them using a module called Qed, then asks a prover such as Alt-Ergo whether the obligation is provable or not. Sometimes a property is not verified for two possible reasons:

  1. There is not enough information –e.g., given assumptions– for the proof to go through.
  2. The proof search timed-out –which can be configured.

4.2.1 Exercise: Fixing abs

  1. Remove focus from the main() code block.
  2. Go back to the Incomplete Absolute Value code block.
  3. Include the limits header file.
  4. Add @ requires INT_MIN < val; to the top of the function contract.
  5. Check that the contract passes by pressing F9.
  6. What bound conditions can you place on the result?
  7. Experiment by altering the conditions or method body.

4.2.2 Behaviours

Notice that our absolute value function has two disjoint behaviours –depending on whether the input is positive or negative. Each behaviour has some assumptions and some conclusions. Moreover, our behaviours are

  • disjoint: Every input can only satisfy the assumptions of at most one of the behaviours. As such, the program is ‘deterministic’: At most one of the behaviours is possible. –The program is really a relation and this ensures it is univalent; i.e., a partial function–
  • complete: Every input satisfies the assumptions of at least one of the behaviours. As such, the program is ‘total’: At least one behaviour is possible. –The program is really a relation and this ensures it is total; i.e., defined on all inputs–

We expressed our behaviours in the forms ensures ⟨assumptions⟩ ==> ⟨consequences⟩. However this can get unruly when there are many assumptions and many consequences. Moreover, expressing disjointness is tedious and error-prone even in our little example, below, where it becomes the assertion: (val < 0 && val >= 0) <==> \false. As such there is the alternative behavior syntax –note the American spelling! Using this syntax, we can ask WP to verify that the behaviours are complete or disjoint, or both. 

#include<limits.h>
/*@ requires INT_MIN < val;
  @ ensures always_nonnegative: \result >= 0;
  @
  @ behavior positive_input:
  @    assumes val > 0;
  @    ensures \result == val;
  @
  @ behavior negative_input:
  @    assumes val <= 0;
  @    ensures \result == -val;
  @
  @ complete behaviors;
  @ disjoint behaviors;
 */
int abs(int val)
{
  return (val < 0) ? -val : val;
}
Details

Exercise Replace each FixMe so that the program is proven correct. 

#include "Prelude.c"
/*@ requires INT_MIN < val;
  @ ensures always_nonnegative: \result >= 0;
  @ ensures Exercise:
  @      FixMe                             // Positive case
  @   && (val <= 0  ==> \result == -val)   // Negative or 0 case
  @   && !(val > 0 && val <= 0)            // Disjointness condition
  @   && FixMe                             // Completeness condition
  @   ;
 */
int abs(int val)
{
  return (val < 0) ? -val : val;
}

Exercise Replace each FixMe with the weakest proposition so that the program is proven correct. 

#include "Prelude.c"
/*@ requires INT_MIN < val;
  @ ensures always_nonnegative: \result >= 0;
  @
  @ behavior positive_input:
  @    assumes Exercise: FixMe;
  @    ensures \result == val;
  @
  @ behavior negative_input:
  @    assumes Exercise: FixMe;
  @    ensures \result == -val;
  @
  @ complete behaviors;    // Frama-C complain here, but please fix the “Exercises”!
 */
int abs(int val)
{
  return (val < 0) ? -val : val;
}

Exercise Replace each FixMe with the strongest proposition so that the program is proven correct. 

#include "Prelude.c"
/*@ requires INT_MIN < val;
  @ ensures always_nonnegative: \result >= 0;
  @
  @ behavior positive_input:
  @    assumes Exercise: FixMe;
  @    ensures \result == val;
  @
  @ behavior negative_input:
  @    assumes Exercise: FixMe;
  @    ensures \result == -val;
  @
  @ disjoint behaviors;
 */
int abs(int val)
{
  return (val < 0) ? -val : val;
}

// This program passes 100%, but that is because it assumes false, the “FixMe”.

4.3 Proving is Programming

In this section we step back a little to get more comfortable with requires preconditions and ensures postconditions. Moreover, we use this time to remind ourselves of some elementary logic. After all, we use logic to express properties and hope Frama-C can verify them.

In some sense false, true behave for the 𝔹ooleans as -∞, +∞ behave for the ℕumbers.

𝔹ooleans ℕumbers
p ⇒ true n ≤ +∞
false ⇒ p -∞ ≤ n
Implication ⇒ Inclusion ≤
Conjunction ∧ Minimum ↓
Disjunction ∨ Maximum ↑

Using this correspondence we can rephrase the “Golden Rule” p ∧ q ≡ p ≡ q ≡ p ∨ q as the following trivial property x ↓ y = x ≡ y = x ↑ y –“The minimum of two numbers is the first precisely when the second is their maximum.” Neat Stuff!

Details

Ex falso quodlibet From false, anything follows: false ⇒ p, for any p. Edit FixMe in the following snippet so that it ensures the result is equal to 42. 

#include "Prelude.c"
/*@ requires uhOh: a < 0 && a > 0;
  @ ensures  what: Exercise: FixMe;
  */
int id(int a){ return a;}

Right Identity of Implication Everything implies true; that is p ⇒ true, for any p. Edit FixMe in the following snippet so that it there are no errors. 

#include "Prelude.c"
/*@ requires Exercise: FixMe;   // <-- Change this false positive.
  @ ensures \true;
  */
int id(int a){ return a; }

Exercise Replace each FixMe with the weakest possible predicate so that it passes. 

#include "Prelude.c"
/*@ requires \true;
  @ ensures UpperBound: a <= \result  &&  b <= \result;
  @ ensures Exercise: Selection1: FixMe  ==> \result == b;
  @ ensures Exercise: Selection2: FixMe  ==> \result == a;
  @*/
int max(int a, int b)
{
  return a < b ? b : a;
}

Conversely, that maximum is the least upper bound, x ≤ z ∧ y ≤ z ≡ x ↑ y ≤ z, corresponds to the characterisation of disjunction (p ⇒ r) ∧ (q ⇒ r) ≡ (p ∨ q) ⇒ r –incidentally this is also known as “case analysis” since one proves p ∨ q ⇒ r by providing a proofs that if p ∨ q is true due to p then with p in hand we need to show r, and likewise if p ∨ q is true due to q.

Exercise Replace FixMeCode with the least amount of code so that the following passes. 

#include "Prelude.c"
#define max(a,b) (a < b ? b : a)   // Ignore me.

/*@ requires max(a, b) <= c;
  @ ensures a <= c  &&  b <= c;
  @*/
void case_analysis(int a, int b, int c)
{
  FixMeCode;
}

4.4 Maintaining The Sequence Rule

Since function calls may alter memory state, the computation of a term may now not only produce a value, as before, but also alter the state altogether. ( Foreshadowing: The assigns ACSL keyword! )

Since a return interrupts executation, the sequence computation rule wp (S₁;S₂) = wp S₁ ∘ wp S₂ is no longer valid when the execution of S₁ causes the execution of a return thereby necessitating that S₂ is not executed. As we have already seen, we keep the rule valid by simply defining wp U R ≡ true for any unreachable code U –as is S₂ when S₁ has a return.

That is, unreachable assertions are always ‘true’: They are never in a memory state, and so cannot even be evaluated, let alone be false! 

int main()
{
  goto End;
  //@assert my_cool_nonsense: 0 == 1;    // This is unreachale but ‘true’.

  End:
  return 0;
}

Likewise with infinite loops, 

int main()
{
  while(1 > 0);
  //@assert my_cool_nonsense: 0 == 1;    // This is unreachale but ‘true’.
  return 0;
}

That is, Frama-C considers ‘partial correctness’: A specification is satisfied, provided it terminates.

In addition, since imperative expressions can modify memory, considerations must be given to the fact arguments of a function are evaluated from left to right. For example, suppose x,y are imperative constructions yield integers, then x + y and y + x are not guaranteed to produce the same behaviour!

Details 
#include<stdio.h> // for IO

int f(){ printf("\nf(): Hello with Four!");  return 4;}
int g(){ printf("\ng(): Hello with Three!"); return 3;}

int main()
{
  int result;

  // The output to the screen changes,
  // even though the *value* of result does not.
  result = f() + g();
  printf("\n---");
  result = g() + f();

  return 0;
}

The C language does not specify the order of evaluation of function arguments –albeit it is usually left-to-right–, and it is up to the programmer to write programs whose result does not depend on the order of evaluation.

Exercise: Produce a Frama-C checked variant of this example. Remember to remove all printf's!

4.5 Passing Arguments by Value and by Reference

Applying the definition of wp to the body of the following swap gives us wp swap = id, thereby demonstrating that this swap does not change the values of two variables! 

void swap(int a, int b){ int c; c = a; a = b; b = c; }

The default mechanism of argument passing is that of pass by value: Only values are sent to function bodies, which cannot alter the original variables. Indeed, what should swap(x+y, 2) perform if it were to “alter the given variables”?

To say that two distinct variables share the same location in memory requires us to formally introduce a notion of location that variables may reference. Rather than introduce a new such type, C makes the convention that certain numeric values act –possibly dual roles– as reference locations.

Hence we can associate variables to references which are then associated to values. That is, a state now consists of two pieces: An environment mapping variables to references and a memory state mapping references to values. The key insight is that the environment may be non-injective thereby associating distinct variables to the same reference thereby permitting them to alter the shared value. Incidentally, the shared value can be thought of as a buffer for message passing between the two variable agents. Neato!

In C, passing by reference is not a primitive construct, but it can be simulated. The type of references that can be associated with a value of type T in memory is written T* in C. Incidentally, the dereference operator is written * in C. For example, in environment u ↦ r₁ and memory state r₁ ↦ r₂, r₂ ↦ 4 we have that u has value r₂ whereas *u has value 4. That is, u is a reference value at location r₁ having contents r₂, which when dereferenced refer to the value contained in location r₂ which is 4.

The reference associated with variable x in a C environment is written &x. E.g., in environment x ↦ r and memory state r ↦ 4, the value of x is the integer 4 whereas the value of &x is the reference r. Moreover, the value of *&x is the integer 4. 

&_ : ∀{T} →  Variable T → Reference T   -- “address of”
*_ : ∀{T} → Reference T → T             -- “value of”

-- Using ‘value equality’:
Inverses:  ∀ a : Var T.  *&a   ≈ a
Inverses:  ∀ r : Ref T.  &(*r) ≈ r
Details 
void understanding_references()
{
  int  a = 4;    // integer a refers to 4
  int* x = &a;   // integer reference x refers to the location of a

  // Facts thus far
  //
  //@ assert a_is_a_number: a == 4;
  //@ assert x_points_to_a: *x == a == 4;
  //@ assert x_is_a_location: x == &a;

  // The inverse law: a == *(&a).
  //
  //@ assert x_points_to_a: *x == a == 4;
  //@ assert x_is_a_location: x == &a;
  //@ assert equals_for_equals: *(&a) == *x == a;

  // The inverse law: &(*x) == x
  //
  //@ assert x_points_to_a: *x == a == 4;
  //@ assert x_is_a_location: x == &a;
  //@ assert equals_for_equals: &(*x) == &a == x;

}

If t is an expression of type T* then the C language has the assignment construct *t = u: The reference of t is now associated with the value of u. The notation alludes to this executional behaviour: The contents of t, i.e., *t, now refer to the value of u.

For example, *&x = u has the same behaviour as the assignment x = u.

Details 
#include<stdio.h> // for IO

// x and y themselves cannot be assigned to: They're constant.
// I.e., assignments “x = t” are forbidden, but “*x = t” are permitted.
// This makes the compiler complain if we accidently made that assignment instead.
//
// However, “const int* x” works in the opposite: x=t okay, but not *x=t.
// Declaration “const int* const x” prevents both types of assignments.
void swap(int* const x, int* const y)
{
  int z;
  z  = *x; // z gets the value referenced to by x
  *x = *y; // the location x references now gets the value referenced by y
  *y =  z; // the location y references now gets the value z
}

int main()
{
  int x = 5, y = 10;
  swap(&x, &y);         // Note that the function is applied to the references.
  printf("x = %d, y = %d", x , y);
  return 0;
}

4.5.1 Dangling References: Segmentation Faults

In C, we may look for references that do not exist: C removes from memory the reference associated with a variable when that variable is removed from the environment.

Details 
#include<stdio.h> // for IO

int* f(const int p)
{
  int n = p;
  return &n;

  // n only exists locally,
  // whence its reference is removed when it no longer exists.
}

int main()
{
  int* u = f(5);
  int* v = f(10);
  printf("u = %d, v = %d", *u , *v); // Segmentation fault!
  return 0;
}

The compiler gives us warning: function returns address of local variable [-Wreturn-local-addr]. We may thus turn on that warning –and all warnings really!– so that it becomes an error at compile time.

Since we used a reference that is not declared in memory, C does not produce a compile error but the runtime result is unpredictable. Execute the above snippet to see different kinds of segmentation fault codes.

4.5.2 Pointers in ACSL

The \old function is a built-in logical operation of ACSL. It can only be used in the post-condition and it denotes the value before execution of the method body. If we want to access the value at a particular memory state, we simply refer to a label at that time frame using the \at construct –see below. 

/*@ requires \valid(a);
  @ ensures *a == \old(*a);
  @ ensures \at(*a, Post) == \at(*a, Pre); // Alternative way to say the same thing.
  */
void at_example(int *a)
{
  int tmp = *a;
  AfterLine1:
  *a = 23;
  AfterLine2:
  *a = 42;
  AfterLine3:
  *a = tmp;

  // We are now in the memory state after the fourth line.
  //
  // Here are some true facts about the memory states:
  //@ assert *a == \at(*a, Pre);     // Current value of *a is same as before method.
  //@ assert \at(*a, Here) == \at(*a, Pre);     // More explicitly.
  //@ assert 42 == \at(*a, AfterLine3);
  //@ assert 23 == \at(*a, AfterLine2);
}

Besides user-defined labels, \at can also be used with the built-in labels:

  • Pre : Value before function call.
  • Post: Value after function call. –Can only be used in the post-condition.
  • Here: Value at the current program point. –This' the default for stand-alone variables.

Whereas \old can only be used in the post-condition, \at can be used anywhere.

Notice that we used the built-in \valid to ensure that access to pointers is safe –i.e., pointing to a real memory location– thereby avoiding runtime errors. We may also write \valid(p + (l .. u)) to express the validity of pointers p + i for l ≤ i ≤ u –this will be helpful when working with arrays. Moreover, when working with constant, non-mutable, pointers, or if we wish to be more accurate, we may use \valid_read(p) to express that the pointer p is valid for read-access only –no writing permitted.

4.6 Side-effects: assigns

Since methods may alter state, thereby producing side-effects, it becomes important to indicate which global and local variables a method assigns to –that way its effects are explicit. We use the assigns clause to declare this. Unless stated otherwise, WP assumes a method can modify anything in memory; as such, the use of assigns becomes almost always necessary. When a method has no side-effects, thereby not assigning to anything, we may declare assigns \nothing. 

/*@ requires \valid(a) && \valid(b);
  // @ assigns *a, *b;
  @ ensures *a == \old(*b);
  @ ensures *b == \old(*a);
  */
void swap(int *a, int *b)
{
  int tmp = *a;
  *a = *b;
  *b = tmp;
}

Notice that the following block fails to prove all goals –comment out the assigns clause below and re-check … still no luck! This can be fixed by un-commenting the assigns clause above. 

int h = 12; // new global variable!

//@ assigns \nothing;  // In particular, this method does not alter “h”.
int main()
{
  int a = 1; int b = 2;

  //@ assert h == 12;
  swap(&a, &b);
  //@ assert h == 12;
  return 0;
}

Finally it is to be noted that assigns do not occur within a behavior –it occurs before by declaring all variables that may be altered, then each behavior would include a clause for the unmodified variables by indicating their new value is equal to their \old one.

4.7 Pointer Aliasing: separated

The raison d'être of pointers is to be able to have aliases for memory locations. When the pointers refer to simple data, we may act functionally in that we copy data to newly allocated memory locations. However, sometimes –such as when we program with linked lists– copying large amounts of data is unreasonable and we may simply want to alter given pointers directly. When the given pointers are identical then an alteration to one of them is actually an alteration to the rest!

When we program with lists, we shall see that if we catenate two lists by altering the first to eventually point to the second then it all works. However, if we catenate a list with itself then the resulting alteration is not the catenation of the list with itself but instead is an infinite cycle of the first list! –We'll see this later on.

Here is a simpler example, 

#include<limits.h>

/*@ requires \valid(fst) && \valid_read(snd);
  @ requires no_flow: INT_MIN <= *fst + *snd <= INT_MAX;
  // @ requires \separated(fst, snd);
  @ assigns *fst;
  @ ensures uhOh: *fst == \old(*fst) + *snd;
  */
void increment_first_by_second(int *fst, int const *snd)
{
  *fst += *snd;
}

Notice since we're only assigning to *fst, we need not explicitly state ensures *snd == \old(*snd). However, in the event that fst and snd both point to the same memory location, then we actually are assigning to both! As such the final ensures is not necessarily true either!

We need to uncomment the separated declaration: The memory locations are distinct.

Notice that in the final call below, since the pre-condition to increment_first_by_second fails, we have breached its contract and therefore no longer guarenteed the behaviour it ensures. Since the contract does not tells what happens when we breach it, anything is possible and so anything is “true”! 

int main()
{
  int life = 42, universe = 12;

  int *this = &life;
  int *new  = &universe;

  //@ assert *this == 42  && *new == 12;
  increment_first_by_second(this, new);
  //@ assert *this == 42 + 12  && *new == 12;   // Yay!

  int *that = &life;  // uh-oh!

  //@ assert *this == 54  && *that == 54;
  increment_first_by_second(this, that);
  //@ assert *this == 54 + 54  && *that == 54;   // Nope...?
  //@ assert 1 == 0;                             // Notice everything is now “true”!

  return 0;
}

We may invoke \separated(p₁, …, pₙ) to express the pointers pᵢ should refer to distinct memory locations and therefore are non-overlapping.

4.8 Functional Composition

As a matter of abstraction, or separation of concerns, a program may be split up into an interface of declarations –a ‘header’ file– and an implementation file. Frama-C permits this approach by allowing us to use a specification of a declared method, which it assumes to be correct, and so we need to verify its precondition is established whenever we call it. In some sense, for proof purposes, this allows us to ‘postulate’ a correct method and use it elsewhere –this idea is very helpful when we want to use an external libary's methods but do not –or cannot– want to prove them.

Details 

#include<limits.h>

/*@ requires val > INT_MIN;
  @ assigns \nothing;
  @ ensures always_non_negative: \result >= 0;
  @ ensures non_negative: 0 <= val ==> \result == val;
  @ ensures negative: val < 0  ==> \result == -val;
  @ */
int abs(int val);

/*@ assigns \nothing;
  @ ensures UpperBound: a <= \result  &&  b <= \result;
  @ ensures Selection1: a <= b  ==>  \result == b;
  @ ensures Selection2: b <= a  ==>  \result == a;
  @*/
int max(int a, int b);

// Uncomment this to observe proof obligations failing.
//
// int max(int a, int b){ return 5; }

/*@ requires inherited_from_abs: a > INT_MIN  && b > INT_MIN;

  @ assigns \nothing;

  @ ensures always_non_negative: inherited_from_abs: \result >= 0;

  @ ensures upper_bound: inherited_from_max:
         \result >= a && \result >= -a    // ≈ result ≥ |a|
      && \result >= b && \result >= -b;   // ≈ result ≥ |b|

  @ ensures selection: inherited_from_max:
          \result == a || \result == -a
       || \result == b || \result == -b;
*/
int abs_max(int a, int b)
{
  return max(abs(a), abs(b));
}

If we press F8, the frama-c gui shows green bullets for the declarations' specifications. They have no implementation and so are assumed to be true. Then the abs_max operation ‘inherits’ the preconditions and postconditions of the methods it calls along the variables it uses.

5 Records

Thus far we have only considered built-in types, we now turn to considering user-defined types that are more complex and are composites of simpler types by using the record construct.

  • Record ≈ Tuple with named fields

A tuple x = (x₀, x₁, …, xₙ) is a function over the domain 0..n, but in programming the domain is usually of named fields, labels, and then it is called a record. E.g., {name = "Jasim", age = 27, language = "ar"} is a record. In the case that the labels are numbers, we obtain the notion of an array.

In other languages, this may be known as a class. In Haskell this is the data keyword with ‘record syntax’, and in Agda we may go on to use the record keyword.

C records are known as structures and they are just a list of labels with their types. In using struct types, the struct keyword must precede the type name in all declarations. 

struct Pair
{
  int fst;
  int snd;
};

// Note that “struct” always precedes the type name “Pair”.

// Structs are passed in by value: They are copied locally.
//
//@ assigns \nothing;
void doesNothing(struct Pair p)
{
  p.fst = 666;
}

// As usual, we use pointers to pass values by reference.
//
/*@ requires \valid(p);
  @ assigns (*p).fst;
*/
void woah(struct Pair* p)
{
  (*p).fst = 313;
}

#include<stdio.h> // for IO

int main()
{

  struct Pair p; // no initalisation

  // Composite type without a name.
  struct {int one; int two;} q;

  // Initialisation with declaration.
  struct Pair r = {11, 13};

  // Note that in C, non-initialised variables have “arbitrary” values
  // which may change according to each new compilation!

  printf("\n p = ⟨fst: %d, snd: %d⟩", p.fst, p.snd);

  // Set only first field.
  p.fst = 3;
  printf("\n p = ⟨fst: %d, snd: %d⟩", p.fst, p.snd);

  // Zero-out all fields.
  struct Pair s = {};
  printf("\n s = ⟨fst: %d, snd: %d⟩", s.fst, s.snd);

  // Invoke functions

  doesNothing(s);
  printf("\n s = ⟨fst: %d, snd: %d⟩", s.fst, s.snd);

  woah(&s);
  printf("\n s = ⟨fst: %d, snd: %d⟩", s.fst, s.snd);

  return 0;
}

5.1 Allocation of a Record

  • Recall that a variable declaration associates the variable with a reference to the variable in memory –i.e., it's address–, moreover this reference is associated a value for the variable.
  • Record variables declared without a value are given the special default value null.
  • In Java, a record variable's reference is not directly associated with a record in memory! It is usually associated with null or another reference.

To associate a record with a variable, we need to create memory large enough to contain the record contents. Some languages use the keyword new to accomplish this task: Create a new reference and associated it with the record variable being defined.

For example, in Java, 

class Pair
{
  int fst;
  int snd;
}

Pair p = new Pair();

The resulting environment is p ↦ r and the resulting memory state is r ↦ r', r' ↦ {fst = 0, snd = 0}. Note that default values are used.

  • A reference that was added to memory by the construct new is called a cell.
  • The set of memory cells is called a heap.
  • The operation that adds a new cell to the memory state is called allocation.

Interestingly in C the creation of records does not allocate cells and so there is no need for the new keyword. Indeed record variables cannot ever have the value null. C directly associates a variable with a reference which has the record contents as its value. That is, C has one less level of indirection than is found in Java. E.g., struct Pair p = {2, 3}; gives us environment p ↦ r and memory state r ↦ {fst = 2, snd = 3}, whereas Java would have p ↦ r′ in the environment and r′ ↦ r additionally in the memory state That is to say, records in Java correspond to references to records in C and so Java access notation r.f is rendered in C as (*r).f.

Remember that references are themselves first-class values and it is possible for a reference to be associated to another reference.

5.2 The Four Constructs of Records

Records are usually handled using four constructs:

  • Defining a record type; e.g., using class or struct.
  • Allocating a cell; e.g., using new or malloc.
  • Accessing a field; e.g., myRecord.myField.
  • Assigning to a field; e.g., myRecord.myField = myValue.

Understanding records in a language is thus tantamount to understanding these fundamental basics. E.g., in functional languages, assignment to a field is essentially record copying or, more efficiently, reference redirection. Incidentally, neither Haskell nor Agda make use of the new keyword: Declarations must be accompanied by initialisation which indicate the need for cell allocation –consequently there is no need for a null value. The use of new may be used for careful efficiency optimisations, or memory management –which is rarely brought to the forefront in functional languages.

The act of assigning to each field of a record is so common that they are usually placed into a so-called constructor method.

5.3 Sharing, Equality, & Garbage

5.3.1 Assignment

Suppose x and y are variables of type Pair, with environment and memory state: 

locations  =  x ↦ r₁, y ↦ r₂
values     =  r₁ ↦ r₃, r₂ ↦ r₄, r₃ ↦ {fst = 3, snd = 5}, r₄ ↦ {fst = 7, snd = 9}

Then assignment y ≔ x results in: 

locations  =  x ↦ r₁, y ↦ r₂
values     =  r₁ ↦ r₃, r₂ ↦ r₃, r₃ ↦ {fst = 3, snd = 5}, r₄ ↦ {fst = 7, snd = 9}
                      -Change Here-

That is, the value of x is computed which is the reference r₃ –since value (location x) ≈ value r₁ ≈ r₃– and we associate this value with the location of y, that is, reference r₂.

Notice that now no variable has the value of r₄ and so it is considered garbage in our state. Moreover, nothing can get to it since values are only associated with locations, none of which have address r₄. Hence there is no observable affect to their absence or presence. We want to recycle the physical memory or else we would quickly run out of memory. A garbage collector is an automated system that collects and recycles such cells. Older languages like C do not have such a system and so memory must be managed by hand.

Anyhow, henceforth x and y share the values of the record thereby all alterations, through either variable, are observable by the other.

Since x and y are reference values, the assignment makes x == y a true statement since they share the same cell. This is known as physical equality.

Sometimes we wish for two variables to share a single integer, which may not be possible with built-in types, but can be accomplished by using wrapper record types: Records that have a lone single field. This idea of `boxing up' primitive types allows us, for example, to define functions with arguments that are passed by reference thereby modifying their arguments; such as the swap function that swaps the contents of its arguments.

5.3.2 Copy

If we instead execute y.fst ≔ x.fst; y.snd ≔ x.snd Then the resulting state is: 

locations  =  x ↦ r₁, y ↦ r₂
values     =  r₁ ↦ r₃, r₂ ↦ r₄, r₃ ↦ {fst = 3, snd = 5}, r₄ ↦ {fst = 3, snd = 5}
                                                                    -Change Here-

In this case, any alteration to x's values are not observable by y.

Moreover, in this case, all fields are equal and so we have x and y are structurally equal. This notion is sometimes called equals method and the previous is equals equals (==).

5.4 Arrays

Arrays are essentially records whose labels are numeric and all labels have the same type. The number of fields of an array is determined during allocation of the array, and not during the declaration of its type, as is the case with records. This trade-off makes arrays more desirable in certain contexts.

The fields are usually numbered 0 to n-1, where n is the number of fields.

Once an array is allocated, its size cannot be changed. –Stop & think: Why not?

  • Arrays of type T are denoted by T[] in C/Java.
    • Matrices, or arrays of arrays, are denoted by T[][] with access by T[i][j].

C arrays, like records, are not allocated. Consequently, their size cannot be determined by allocation and so must be a part of their type.

C arrays of type T of length n are declared using the mixfix syntax: T x[n]; Each element of the array is arbitrary –with no designated defaults– so it is best to initialise them. E.g., int x[10] = {}; sets all elements of the array to 0. 

#include<stdio.h> // for IO

int makeFive(int x[], int length)
{
  for(int i=0; i != length; i++)
    x[i] = 5;
}

int main()
{
  int x[3] = {};
  printf("\n x = [%d, %d, %d]", x[0], x[1], x[2]);

  makeFive(x, 3);
  printf("\n x = [%d, %d, %d]", x[0], x[1], x[2]);

  return 0;
}

However, C arrays differ from C records in that array variables are actually references that are associated in memory with an array. Consequently, array arguments to methods are automatically pass by reference!

Moreover this means the assignment t[k] = u works in a rather general sense: t suffices to be any expression whose value is a reference associated in memory with an array.

6 Arrays – \forall, \exists

Arrays are commonly handled using loops; let's look at some examples. 

/*@ requires 0 < N;
  @ requires \valid_read(array + (0 .. N - 1));  // N is the length of the array
  @
  @ assigns \nothing;
  @
  @ behavior found_element:
  @    assumes \exists integer i; 0 <= i < N  &&  array[i] == element;
  @    ensures 0 <= \result < N;
  @
  @ behavior did_not_find_element:
  @    assumes \forall integer i; 0 <= i < N  ==> array[i] != element;
  @    ensures \result == N;
  @
  @ disjoint behaviors;
  @ complete behaviors;
  */
int linear_search(int* array, int N, int element)
{
  int n = 0;

  /*@ loop assigns n;
    @ loop invariant 0 <= n <= N;
    @ loop invariant not_found_yet: \forall integer i; 0 <= i < n  ==>  array[i] != element;
    @ loop variant N - n;
    */
  while( n != N  && array[n] != element ) n++;
  return n < N ? n : N;
}

Some remarks are in order.

  • \valid_read(array + (0 .. N - 1)) ensures that the memory addresses array + 0, ..., array + N-1 can be read –as discussed when introducing \valid.
  • The loop continues as long as we have not yet found the element.
    • As such, every index thus far differs from the element sought after.
    • That is, forall index i in the array bounds, we have array[i] ≠ element.
    • This invariant is stated using the forall syntax.
  • The variable naming n, N is intended to be suggestive: When n = N then we have traversed the whole array.
    • We began at 0 and are working upward to N.
    • At each step, we traverse the array by one more item thereby decreasing the amount of items remaining –which is N - n.
  • If it is provable that some index contains the desired element, then in that case our program ensures the output result is a valid index.
  • The ACSL type integer is preferable to the C type int since it is not constrained by any representation limitations and instead acts more like its pure mathematical counterpart ℤ.

It is important to note that the universal ‘∀’ uses ==> to delimit the range from the body predicate, whereas the existential ‘∃’ uses && –this observation is related to the “trading laws” for quantifiers.

\forall type x; r(x) ==> p(x) Every element x in range r satisfies p
\exists type x; r(x) && p(x) Some element x in range r satisfies p

Notice the striking difference between the \exists integer x; \false && even x –which is unprovable since false is never true!– and \exists integer x; \false ==> even x –which can be satisfied by infinitely many x, since false implies anything.

Of course we could start at the end of the array and “work down” until we find the element, or otherwise, say, return -1. Let's do so without using a new local variable n.

Details 
#include "Prelude.c"

/*@ requires 0 < N;
  // @ requires Exercise: read access to a[0], ..., a[N-1];
  @
  // @ assigns FixMe;
  @
  @ behavior found_element:
  @    assumes Exercise: FixMe;  // “element ∈ array”
  @    ensures Exercise: FixMe;  // Output is valid index in array
  @
  @ behavior did_not_find_element:
  @    assumes Exercise: FixMe;     // “element ∉ array”
  @    ensures \result == -1;
  @
  @ disjoint behaviors;
  @ complete behaviors;
  */
int linear_search_no_local(int* array, int N, int element)
{
  /*@ loop assigns N;
    @ loop invariant 0 <= N <= \at(N, Pre);
    // @ loop invariant not_found_yet: Exercise: FixMe;
    // @ loop variant Exercise: FixMe: 666;
    */
  while( 0 != N  && array[N-1] != element ) N--;
  return N - 1;
}
Details 
#include "Prelude.c"

/*@ requires Exercise: FixMe; // array[0], ..., array[N-1] are accessible
  @ requires element < INT_MAX;
  @ assigns array[0 .. N-1];
  @
  @ ensures Exercise: all_array_equals_element: FixMe;
  */
void make_constant(int* array, int N, int element)
{
  /*@ loop assigns N, array[0 .. \at(N,Pre)-1];
    @ loop invariant range_on_N: FixMe;
    @ loop invariant constant_so_far: FixMe;
    @ loop variant N;
    */
  for (; 0 != N; N--) array[N-1] = element;
}

Notice that the invariants are getting way too long –and worse: Repetitive! We can abstract common formulae into more general and reusable shapes by declaring them as ACSL logical functions –keep reading!

On an unrelated note, sometimes we try to prove a program that we just coded incorrectly, so if things are going nowhere then maybe try a few tests to ensure you're on the right track.

7 Recursion

The definition of wp for function calls is correct provided the function body itself only contains invocations to previously defined functions?

What about recursive function definitions: Definitions invoking the function being defined or invoking functions that invoke functions that eventually invoke the function currently being defined?

Since invocations are delegated to the state, which handles all defined names, we may invoke whatever function provided its name is found. Since C requires names to be declared before use, we may have mutually recursive functions by ‘prototyping’: Declaring the function signature, then at some point providing the actual implementation.

Details 
#include<stdio.h> // for IO
#include<stdbool.h>

bool odd(int); // protoyping the odd function

bool even(int n) // using odd here, even though it's not yet defined
{
  if (n == 0) return true;
  else        return odd(n - 1);
}

bool odd(int n)
{
  if (n == 0) return false;
  else        return even(n - 1);
}

int main()
{
  printf("\n 7 is even? ... %d", even(7));
  printf("\n 7 is odd? ... %d", odd(7));
  return 0;
}

Anyhow, e.g., void f(int x){ f(x); } has the definition of wp f(x) using the value of wp f(x) and so is circular. How can this be avoided?

Note that a recursive definition is not just a definition that uses the object which it is defining. Otherwise, the previous f might as well have been the definition of the factorial function that on input x simply invokes itself; then again it could have been any function!

Details

We generally think of recursive definitions as definitions by usual ℕ-induction, however this is not absolutely true. E.g., the following function at n not only relies on values on smaller inputs but also on values at larger inputs to compute the value at n! 

#include<stdio.h> // for IO

int iterations = 0;
#define RETURN(i, n) { printf("\n **Computed value for input %d is %d**", i, n); \
                       iterations++; return n; }

// Uses smaller as well as larger values just to compute current value!
int f(int n)
{
  printf("\n Computing value for: %d", n);

  if (n <= 1)     RETURN(n, 1)
  if (n % 2 == 0) RETURN(n, 1 + f(n / 2))
  else            RETURN(n, 2 * f(n + 1))
}

int main()
{
  f(12);
  printf("\n\n The function was invoked for a total of %d times!", iterations);
  return 0;
}

Similarly the Ackermann function is a recursive function that has been proven to be undefinable using only nested definitions by ℕ-induction. ( However, since ℕ×ℕ is well-ordered, it is a valid definition. )

We may try to remove recursive calls by replacing every recursive call with the function body itself, which then has a new recursive call. We may continue to expand forever by replacing recursive calls with the original function body. The “result” will be an non-recursive program that is infinitely long.

Thus, recursive programs, like while loops, are a means of expressing infinite programs and, like while loops, they introduce the possibility of non-termination.

As for while loops, we can approximate the infinitely long non-recursive program by simply giving-up on the n-th expansion, not making any more recursive calls. Essentially, we do n recursive calls then give-up if the program has not completed. Hence, we again consider the limit.

7.1 Recursive Definitions and Fixed Point Equations

A recursive function such as the factorial function can be seen as an equation where the unknown variable is the function currently being defined. For example, the factorial function is the unique partial function f satisfying the equation 

f  ≈ (x ↦ if x ≈ 0 then 1 else x * f(x-1))

This equation has the form f ≈ F(f), so it is a “fixed point equation”.

Since recursive functions may not terminate, the functions they describe are partial. It can be proven that any fixed point equation always has at least one solution; i.e., it defines at least one partial function on the integers. For example, the equation f ≈ (x ↦ 1 + f(x)) corresponding to 

int loop(int n){ return 1 + loop(n); }

Has one solution: The empty function, which is not defined on any input.

The set of possible solutions can be ordered by inclusion of their graphs and so one of them is the smallest. Incidentally, this least solution is also obtained by the aforementioned limit!

E.g., every function is a solution to the equation f ≈ (x ↦ f x).

7.2 Programming without Assignment –the Functional Core

Notice that the factorial function can be written without using assignments:

Details 
/*@ axiomatic Factorial
  @ {
  @    logic integer factorial(integer n);
  @
  @    axiom fact_zero:  \forall integer n;    factorial(0) == 1;
  @
  @    axiom fact_succ:  \forall integer n; 0 <= n
  @                 ==>  factorial (n + 1) == n * factorial (n);
  @
  @    axiom fact_monotone : \forall integer m,n; 0 <= m <= n
  @          ==> factorial(m) <= factorial(n);
  @ }
  */

#include "Prelude.c"

/*@ requires Exercise: FixMe;
  @ assigns \nothing;
  @ ensures Exercise: FixMe;
  */
int fact_imp(int n)
{
  int r = 1;

  /*@ loop assigns i, r;
    @ loop invariant range_on_i: FixMe;
    @ loop invariant relationship_between_r_i_n: FixMe;
    @ loop variant FixMe: 666;
  */
  for(int i = 1; i <= n; i++)
    r = r * i;

  return r;
}

// ≈

/*@ requires 0 <= n;
  @ requires factorial(n) <= INT_MAX;
  @ assigns \nothing;
  @ ensures \result == factorial(n);
  */
int fact_functional(int n)
{
  if (n == 0) return 1;
  return n * fact_functional(n - 1);
}

( Notice that ¬(i ≤ n)[i ≔ 1] ≡ n = 0 when considering n : ℕ. )

Hence if we remove assignments, then the memory state for computation is always empty and so sequences and loops become useless. We are left with only variable declarations, function calls, and the built-in operations. This is the functional core of the language and it is surprisingly as powerful as the imperative core. Why? Recall that a term, or statement, can be thought of as a (partial) function of its free variables; now the functions obtained this way using only the functional core are the same as those obtained by also using the whole of the imperative core! Note that omitting recursion falsifies this result.

8 Hehner's Problem

We have now covered enough material to tackle the problem posed at the very beginning —that of whatDo.

Details 
#include "Prelude.c"

/*@  requires \valid(x) && \valid(y);
     requires 0 <= *x < 31;
     requires Exercise: FixMe;
     assigns *x, *y;
     ensures Exercise: FixMe;
 */
void whatDo(int* x, int* y)
{
  if (*x == 0)
    {
      *y = 1; *x = 3;
    }
  else
    {
      *x -= 1; *y = 7;
      whatDo(x, y);
      *y *= 2; *x = 5;
    }
}

Running a few test inputs, it can be seen that this program sets y to be the power of x. Further testing may reveal interesting issues when x and y refer to the same memory location!

Details 
⟨x = 0, y = 0⟩ ↦ ⟨x = 3, y = 1⟩
⟨x = 1, y = 2⟩ ↦ ⟨x = 5, y = 2⟩
⟨x = 3, y = 4⟩ ↦ ⟨x = 5, y = 8⟩
⟨x = 5, y = 6⟩ ↦ ⟨x = 5, y = 32⟩
⟨x = 7, y = 8⟩ ↦ ⟨x = 5, y = 128⟩
⟨x = 0, y = 99⟩ ↦ ⟨x = 3, y = 1⟩

x == y  ⇒  Segmentation Fault

With this guidance in hand, we aim to axiomatise the power function: 

/*@ axiomatic Pow
  @ {
  @    logic integer pow(integer b, integer n);
  @
  @    axiom pow_zero:  \forall integer b;        pow(b, 0) == 1;
  @
  @    axiom pow_one:  \forall integer b;        pow(b, 1) == b;
  @
  @    axiom pow_homomorphism:  \forall integer b, m, n;
  @                 pow(b, m + n) == pow(b, m) * pow(b, n);
  @
  @    axiom pow_monotone : \forall integer b,m,n; b >= 0  &&  0 <= m <= n
  @          ==> pow(b,m) <= pow(b,n);
  @ }
  */

Notice that there are infinitely many solutions f to the equations

  • pow_zero: f(0) = 1
  • pow_homomorphism: f(m + n) = f(m) * f(n)

Which ones? Since every natural number is of the form 1 + 1 + ⋯ + 0 the second requirement yields \\ f(n) = f (1 + 1 + ⋯ + 0) = f 1 * f 1 * ⋯ f 1 * f 0; which by the first requirement simplifies to f(n) = (f 1)ⁿ. Hence for any choice of number f(1) : ℕ, we obtain a function f that satisfies these definitions. If we want f to be the n product of a number b then we need to insist f 1 = b –which is just pow_one!

From the axioms, we obtain some useful lemmas. 

//@ lemma pow_succ:  \forall integer b, n; n >= 0  ==>     pow(b, n + 1) == pow(b, n) * b;
//@ lemma powNonNeg : \forall integer b,n; b >= 0 ==> n >= 0 ==> pow(b,n) >= 0;
//@ lemma pow2bound : \forall integer n; 0 <= n < 31 ==> pow(2, n) < INT_MAX;
/*@ lemma powPredT : \forall integer b,n,m;  b >= 0  &&  n > 0
                                &&  pow(b, n) <= m  ==>  b * pow(b, n-1) <= m; */

With this setup, the reader should now be able to solve the FixMe's in whatDo –which I've renamed to “hehner”, after the fellow who showed it as an example in his excellent specifications and correctness text, A Practical Theory of Programming. 

#include "Prelude.c"

/*@  requires \valid(x) && \valid(y);
     requires 0 <= *x < 31;
     requires Exercise: FixMe;      // Assuming \false, gives us anything!
     assigns *x, *y;
     ensures Exercise: FixMe;
 */
void hehner(int* x, int* y)
{
  // Introduce a local for reasoning, to avoid having to write \at(*x, Pre).
  // ghost const int X = *x;

  // assert given: 0 <= X < 31;
  // assert taking_powers_with_monotonicity: 1 <= pow(2,X) <= INT_MAX;
  if (*x == 0)
    {
      // assert condition: X == 0;
      // assert taking_powers: pow(2,X) == 1;
      *y = 1; *x = 3;
      // assert *y == pow(2,X);
    }
  else
    {
      // assert condition: 0 < X < 31;
      // assert pow_with_monotonicity: 1 < pow(2, X) <= INT_MAX;
      // assert factoring: 2 * pow(2, X-1) <= INT_MAX;

      *x -= 1; *y = 7;
      hehner(x, y);

      // assert function_ensures: *y == pow(2, X - 1);
      // assert pow(2, X) == 2 * pow(2, X - 1);
      // assert     pow(2, X    ) ≤ INT_MAX;
      // assert 2 * pow(2, X - 1) ≤ INT_MAX;
      // assert y2_no_overflow: *y * 2 ≤ INT_MAX;

      *y *= 2; *x = 5;

      // assert our_goal: *y == pow(2, X);
      // assert incidentally: *y <= INT_MAX;
    }
}

I've left the assert's since they may make the program proof more comprehensible to the reader –yet notice that I did not use @ and so they are not visible, nor necessary, to Frama-C.

9 Advanced Data Structures

This is what I have so far, yet I look forward to including material utilising linked lists as well as making more of the Curry-Howard Correspondence.

Anyhow, I hope you've enjoyed yourself and hopefully learned something neat! Byebye!

10 The Underlying Elisp

The following utilities are loaded when this file is opened. After the first time the file InteractiveWayToC.el is created and this section may be deleted, or COMMENT-ed, as it is loaded in the footer section at the end of this file.

  1. Make some changes, look at them with f7.
    • Or execute with f6 if there is a main method.
  2. Check your progress with f9, within Emacs.
  3. If confused, open the Frama-C gui with f8.

Note: There is a 10 second time limit on the proof search.

Every source block is in ‘focus’ when the variables NAME and NAMECode refer to it.

Details 
(setq Language "c" LanguageExtension "c")
(setq NAMEEXT (buffer-name) NAME (file-name-sans-extension NAMEEXT))
(setq NAMECode (concat NAME "." LanguageExtension))

We explicitly change focus using [not-]currently-working-with methods.

Details 
(defun buffer-name-sans-extension () ""
  (file-name-sans-extension (buffer-name))
)

(defun currently-working-with (&optional name)
  "Provide the name (without extension) of the source block's resulting file.
   The name is then tied to the “NAMECode” global variable utilised
   by the “show-code” method, <f7>, and the “interpret” command's global variable “NAME”.

   If no argument is provided, we use “⟪BufferName⟫.c” as default file name.
  "
  (unless name (setq name (buffer-name-sans-extension)))
  (setq NAME name)
  (setq NAMECode (concat name ".c"))
)

(defun not-currently-working-with (&optional name)
  "When “:tangle fn” has “fn” being the empty string, the tangle does not transpire.
   As such, it is as if we are not actually generating the source block.

   This operation only returns the empty string and does not alter any existing state.
   If we alter state, then earlier invocations to (currently-working-with) are rendered
   useless!
  "

  ""   ;; Our return value.
)

Notice that the InteractiveWayToC.el methods –<F6> to <F9>– target the source block(s) with (currently-working-with name) where name is the most recent name. Note that the name component need not be unique: Blocks having the same one write to the same file.

In a new line enter <s then at the end press TAB to obtain a nice hello-world template. Some code will be generated for you –free of charge–, edit it as you like.

Details 
(make-variable-buffer-local 'org-structure-template-alist)
(setq TEMPLATE
  (concat
   "#+NAME: ???? -- goal of this code block"
   "\n#+BEGIN_SRC " Language " :tangle (currently-working-with \"HelloWorld\") \n"
   "#include<stdio.h> // for IO"
   "\nint main() \n{\n  printf(\"--Hello, World!--\");\n  return 0; \n}"
   "\n#+END_SRC"))
(add-to-list 'org-structure-template-alist `("s" ,TEMPLATE))

Then to see the code generated by this file press M-x then enter show-code then enter; alternatively, press C-x C-e after the final parenthesis: (show-code).

My definition of (show-code) begins with closing the code buffer if it exists, then continue by extracting the most recent code and displaying it below the current buffer. The definition of (interpret) is nearly the same except we switch to an output buffer, and create it if it doesn't exist. Note that our interpretation command is essentially the following command line invocation: NAME=myfilename ; gcc $NAME.c -o $NAME.exe ; ./$NAME.exe

Details 
(defun show-code () "Show focused source blocks in a new buffer."
  (interactive)
  (ignore-errors (kill-buffer NAMECode))
  (save-buffer)
  (org-babel-tangle)
  (split-window-below)
  (find-file NAMECode)
  (other-window 1))

;; Since there are many generated files, let's mention the name
;; of the program file currently being executed, or proven.
;;
(defun insert-focused-name ()
   "Insert the name of the focused source blocks at the beginning of the buffer."
  (beginning-of-buffer)
  (insert "================\n⟪ " NAME ".c ⟫\n================\n\n"))

(defun interpret () "Execute focused source blocks in a new buffer."
  (interactive)
  (save-buffer)
  (org-babel-tangle)
  (switch-to-buffer-other-window "*Shell Command Output*")
  (shell-command
    (concat "cd " default-directory "; NAME=" NAME " ; gcc $NAME.c -o $NAME.exe ; ./$NAME.exe"))
  (insert-focused-name)
  ;; Go back to the literate buffer.
  (other-window 1))

(defun frama-c () ""
  (interactive)
  (save-buffer)
  (org-babel-tangle)
  (shell-command (concat "frama-c-gui " NAMECode " -wp -rte &")))

(defun try (this that) ""
  (condition-case nil (eval this) (error (eval that))))

The frama-c-no-gui command tries to find where an error happens by placing the cursor near an unproven assertion. It does so by looking for the phrase false in the shell output buffer after the frama-c program is invoked. If it cannot find it, you are placed at the end of the buffer and, ideally but not necessarily, should see all goals have passed.

Details 
(defun frama-c-no-gui () ""
  (interactive)
  (org-babel-tangle)
  ;; Avoid generating proof goal statements --for now.
  ;; (shell-command (concat "frama-c " NAMECode " -wp -wp-msg-key=print-generated -rte"))
  (shell-command (concat "frama-c " NAMECode " -wp -wp-timeout 10 -rte"))

  (switch-to-buffer-other-window "*Shell Command Output*")
  (insert-focused-name)
  (hl-line-mode)

  (setq frama-c-state (catch 'state   ;; Global variable indicating current state
  (dolist (elem '("Exercise" "unknown" "user error" "false" "Timeout" "Proved goals"))
    (beginning-of-buffer)
    (try '(and (search-forward elem) (throw 'state elem)) 'nil)
  )))

  ;; global variable about status
  (setq frama-c-status (format "Frama-C: %d﹪ of proof complete!" (frama-c-progress)))

  ;; Use the red colour of failure.
  (set-face-background 'hl-line "pink")

  ;; Or did we succeed?
  ;; We might have halted a “false” *constant* even though all goals pass.
  ;; ⟨ This is not an issue when proofs are not being generated. ⟩
  (if (equal frama-c-state "Exercise")
        (setq frama-c-status (concat frama-c-status " ⟪There are holes!⟫"))
        (when (or (equal frama-c-state "Proved goals")
                  (eq (frama-c-progress) 100))
              (set-face-background 'hl-line "pale green")
              (try '(search-forward "Proved goals") t)))
  (message frama-c-status)
  (minimize-window) ;; Make current buffer roughly 3 lines in height.
)

Where the frama-c-progress command yields the percentage denoting the number of goals proven.

Details 
(defun frama-c-progress () ""
  (let ( (here (point)) )
  (beginning-of-buffer)
  (try '(search-forward "Proved goals:") 0)
  ;; (kill-line)
    (copy-region-as-kill (point) (point-at-eol))
    (goto-char here)
    (* 100 (string-to-number (calc-eval (current-kill 0))))
  ))

Finally,

Details 
(local-set-key (kbd "<f6>") 'interpret)
(local-set-key (kbd "<f7>") 'show-code)
(local-set-key (kbd "<f8>") 'frama-c)
(local-set-key (kbd "<f9>") 'frama-c-no-gui)

It is to be noted: I only know enough Elisp to get by.

Again: Hope you had fun!

Tags: program-proving c emacs frama-c
Generated by Emacs and Org-mode (•̀ᴗ•́)و
 
]]> https://alhassy.github.io/InteractiveWayToC.html https://alhassy.github.io/InteractiveWayToC.html Sat, 12 Jan 2019 19:29:00 -0500 <![CDATA[Graphs are to categories as lists are to monoids]]>
24 Dec 2018
Article image

Abstract

Numbers are the lengths of lists which are the flattenings of trees which are the spannings of graphs. Unlike the first three, graphs have two underlying types of interest –the vertices and the edges– and it is getting to grips with this complexity that we attempt to tackle by considering their ‘algebraic’ counterpart: Categories.

In our exploration of what graphs could possibly be and their relationships to lists are, we shall mechanise, or implement, our claims since there will be many details and it is easy to make mistakes –moreover as a self-learning project, I'd feel more confident to make bold claims when I have a proof assistant checking my work ;-)

Assuming slight familiarity with the Agda programming language, we motivate the need for basic concepts of category theory with the aim of discussing adjunctions with a running example of a detailed construction and proof of a free functor. Moreover, the article contains a host of exercises whose solutions can be found in the literate source file. Raw Agda code can be found here.

Since the read time for this article is more than two hours, excluding the interspersed exercises, it may help to occasionally consult a some reference sheets:

Coming from a background in order theory, I love Galois Connections and so our categorical hammer will not be terminal objects nor limits, but rather adjunctions. As such, everything is an adjunction is an apt slogan for us :-) 

-- This file has been extracted from https://alhassy.github.io/PathCat/
-- Type checks with Agda version 2.6.0.

( Photo by Mikhail Vasilyev on Unsplash )

1 Introduction

Lists give free monoids \(ℒ\, A = (\List\, A, +\!+, [])\) —a monoid \(𝒮 = (S, ⊕, 0_⊕)\) is a triple consisting of a set \(S\) with a binary operation \(⊕\) on it that is associative and has a unit, \(0_⊕\). That it is ‘free’ means that to define a structure-preserving map between monoids \((\List\, A, +\!+, []) \,⟶\, (S, ⊕, 0_⊕)\) it suffices to only provide a map between their carriers \(\List\, A → S\) —freedom means that plain old maps between types freely, at no cost or effort, give rise to maps that preserve monoid structure. Moreover, the converse also holds and in-fact we have a bijection: \[ (ℒ\, A ⟶ 𝒮) \qquad≅\qquad (A ⟶ 𝒰\, 𝒮) \] Where we write \(𝒰\, (S, ⊕, 0_⊕) = S\) for the operation that gives us the 𝒰nderlying carrier of a monoid.

Loosely put, one says we have an ‘adjunction’, written \(ℒ ⊣ 𝒰\).

Observe that natural numbers ℕ ≅ List Unit are a monoid whose operation is commutative. By using different kinds of elements A –and, importantly, still not imposing any equations– we lose commutativity with List A. Then by generalising further to binary trees BinTree A, we lose associtivity and identity are are only left with a set and an operation on it —a structure called a ‘magma’.

This is the order that one usually learns about these inductively built structures. One might be curious as to what the next step up is in this hierarchy of generalisations. It is a non-inductive type called a ‘graph’ and in this note we investigate them by comparison to lists. Just as we shifted structures in the hierarchy, we will move to a setting called a ‘category’ —such are more structured than magmas but less restrictive than monoids.

For those who know category theory, this article essentially formalises the often seen phrase “consider the category generated by this diagram, or graph”. Indeed every category is essentially a free category over a graph but with additional equations that ‘confuse’ two paths thereby declaring, e.g., that one edge is the composition of two other edges.

Imports

In our exploration of what graphs could possibly be and their relationships to lists are, we shall mechanise or implement our claims since there will be many details and it is easy to make mistakes –moreover as a self-learning project, I'd feel more confident to make bold claims when I have a proof assistant checking my work ;-)

Before reading any further please ingrain into your mind that the Agda keyword Set is read “type”! This disparity is a historical accident.

Since the Agda prelude is so simple, the core language doesn’t even come with Booleans or numbers by default —they must be imported from the standard library. This is a pleasant feature. As a result, Agda code tends to begin with a host of imports. 

module PathCat where

open import Level using (Level) renaming (zero to ℓ₀ ; suc to ℓsuc ; _⊔_ to _⊍_)

-- Numbers
open import Data.Fin
  using (Fin ; toℕ ; fromℕ ; fromℕ≤ ; reduce≥ ; inject≤)
  renaming (_<_ to _f<_ ; zero to fzero ; suc to fsuc)
open import Data.Nat
open import Relation.Binary using (module DecTotalOrder)
open import Data.Nat.Properties using(≤-decTotalOrder ; ≤-refl)
open DecTotalOrder Data.Nat.Properties.≤-decTotalOrder

-- Z-notation for sums
open import Data.Product using (Σ ; proj₁ ; proj₂ ; _×_ ; _,_)
Σ∶• : {a b : Level} (A : Set a) (B : A → Set b) → Set (a ⊍ b)
Σ∶• = Σ
infix -666 Σ∶•
syntax Σ∶• A (λ x → B) = Σ x ∶ A • B

-- Equalities
open import Relation.Binary.PropositionalEquality using (_≗_ ; _≡_)
  renaming (sym to ≡-sym ; refl to ≡-refl ; trans to _⟨≡≡⟩_
           ; cong to ≡-cong ; cong₂ to ≡-cong₂
           ; subst to ≡-subst ; subst₂ to ≡-subst₂ ; setoid to ≡-setoid)

Notice that we renamed transitivity to be an infix combinator.

Let us make equational-style proofs available for any type. 

module _ {i} {S : Set i} where
    open import Relation.Binary.EqReasoning (≡-setoid S) public

We intend our proofs to be sequences of formulae interleaved with justifications for how the formulae are related. At times, the justifications are by definition and so may be omitted, but we may want to mention them for presentational –pedagogical?– purposes. Hence, we introduce the combinator notation lhs ≡⟨" by definition of something "⟩′ rhs. 

open import Agda.Builtin.String

defn-chasing : ∀ {i} {A : Set i} (x : A) → String → A → A
defn-chasing x reason supposedly-x-again = supposedly-x-again

syntax defn-chasing x reason xish = x ≡⟨ reason ⟩′ xish

infixl 3 defn-chasing

While we’re making synonyms for readability, let’s make another: 

_even-under_ : ∀ {a b} {A : Set a} {B : Set b} {x y} → x ≡ y → (f : A → B) → f x ≡ f y
_even-under_ = λ eq f → ≡-cong f eq

Example usage would be to prove mor G (mor F Id) ≡ mor G Id directly by ≡-cong (mor G) (id F) which can be written more clearly as functor F preserves-identities even-under (mor G), while longer it is also much clearer and easier to read and understand –self-documenting in some sense.

Interestingly, our first calculational proof is in section 5 when we introduced an large 𝒞𝒶𝓉egory.

2 Graph me to the moon!

What's a graph? Let's motivate categories!

A ‘graph’ is just a parallel-pair of maps, 

record Graph₀ : Set₁ where
  field
    V   : Set
    E   : Set
    src : E → V
    tgt : E → V

This of-course captures the usual notion of a set of nodes V and a set of directed and labelled edges E where an edge e begins at src e and concludes at tgt e.

What is good about this definition is that it can be phrased in any category: V and E are any two objects and src, tgt are a parallel pair of morphisms between them. How wonderful! We can study the notion of graphs in arbitrary categories! —This idea will be made clearer when categories and functors are formally introduced.

However, the notion of structure-preserving map between graphs, or ‘graph-maps’ for short, then becomes: 

record _𝒢⟶₀_ (G H : Graph₀) : Set₁ where
  open Graph₀
  field
    vertex : V(G) → V(H)
    edge   : E(G) → E(H)
    src-preservation : ∀ e → src(H) (edge e) ≡  vertex (src(G) e)
    tgt-preservation : ∀ e → tgt(H) (edge e) ≡  vertex (tgt(G) e)

( The fancy 𝒢 and ⟶ are obtained in Agda input mode by \McG and \-->, respectively. )

This is a bit problematic in that we have two proof obligations and at a first glance it is not at all clear their motivation besides ‘‘structure-preserving’’.

However, our aim is in graphs in usual type theory, and as such we can use a definition that is equivalent in this domain: A graph is a type V of vertices and a ‘type’ v ⟶ v’ of edges for each pair of vertices v and v’. 

-- ‘small graphs’ , since we are not using levels
record Graph : Set₁ where
  field
    V    : Set
    _⟶_ : V → V → Set

-- i.e., Graph ≈ Σ V ∶ Set • (V → V)
-- Graphs are a dependent type!

Now the notion of graph-map, and the meaning of structure-preserving, come to the forefront: 

record GraphMap (G H : Graph) : Set₁ where
    private
      open Graph using (V)
      _⟶g_ = Graph._⟶_ G
      _⟶h_ = Graph._⟶_ H
    field
      ver  : V(G) → V(H)                                -- vertex morphism
      edge : {x y : V(G)} → (x ⟶g y) → (ver x ⟶h ver y) -- arrow preservation

open GraphMap

Note edge essentially says that mor ‘shifts’, or ‘translates’, types x ⟶g y into types ver x ⟶h ver y.

While equivalent, this two-piece definition is preferable over the four-piece one given earlier since it means less proof-obligations and less constructions in general, but the same expressiblity. Yay!

Before we move on, let us give an example of a simple chain-graph. For clarity, we present it in both variations. 

-- embedding: j < n ⇒ j < suc n
`_ : ∀{n} → Fin n → Fin (suc n)
` j = inject≤ j (≤-step ≤-refl) where open import Data.Nat.Properties using (≤-step)

This' an example of a ‘forgetful functor’, keep reading! 

[_]₀ : ℕ → Graph₀
[ n ]₀ = record
    { V = Fin (suc n)                  -- ≈ {0, 1, ..., n - 1, n}
    ; E = Fin n                        -- ≈ {0, 1, ..., n - 1}
    ; src = λ j → ` j
    ; tgt = λ j → fsuc j
    }

That is, we have n+1 vertices named 0, 1, …, n and n edges named 0, 1, …, n-1 with one typing axiom being j : j ⟶ (j+1). Alternatively, 

[_] : ℕ → Graph
[ n ] = record {V = Fin (suc n) ; _⟶_ = λ x y → fsuc x ≡ ` y }

2.1 Types Require Casting

However, we must admit that a slight downside of the typed approach –the two-piece definition– is now we may need to use the following ‘shifting’ combinators: They shift, or slide, the edge types. 

-- casting
_⟫_ : ∀{x y y’} →  (x ⟶ y) → (y ≡ y’) → (x ⟶ y’)
e ⟫ ≡-refl = e

-- Casting leaves the edge the same, only type information changes
≅-⟫ : ∀{x y y’} {e : x ⟶ y} (y≈y’ : y ≡ y’) → e ≅ (e ⟫ y≈y’)
≅-⟫ ≡-refl = ≅-refl

Such is the cost of using a typed-approach.

Even worse, if we use homogeneous equality then we’d have the ghastly operator 

≡-⟫ : ∀{x y y’} {e : x ⟶ y} (y≈y’ : y ≡ y’) → e ⟫ y≈y’ ≡ (≡-subst (λ ω → x ⟶ ω) y≈y’ e)

However, it seems that our development does not even make use of these. Lucky us! However, it is something to be aware of.

2.2 Signatures

A signature consists of ‘sort symbols’ and ‘function symbols’ each of which is associated source-sorts and a target-sort –essentially it is an interface in the programming sense of the word thereby providing a lexicon for a language. A model or algebra of a language is an interpretation of the sort symbols as sets and an interpretation of the function symbols as functions between those sets; i.e., it is an implementation in programming terms. Later you may note that instead of sets and functions we may use the objects and morphisms of a fixed category instead, and so get a model in that category.

Math ≅ Coding
Signature   Interface, record type, class
Algebra   Implementation, instance, object
Language Term   Syntax
Interpretation   Semantics, i.e., an implementation

Formally, one-sorted signatures are defined: 

open import Data.Vec
  using (Vec)
  renaming (_∷_ to _,,_ ; [] to nil) -- , already in use for products :/

-- one sorted
record Signature : Set where
    field
     𝒩 : ℕ        -- How many function symbols there are
     ar : Vec ℕ 𝒩 -- Their arities: lookup i ar == arity of i-th function symbol

open Signature ⦃...⦄ -- 𝒩 now refers to the number of function symbols in a signature

For example, the signature of monoids consists of a single sort symbol C –which can be interpreted as the carrier of the monoid– and two function symbols m , u –which can be interpreted as the monoid multiplication and unit– with source-target sort lists ((),C) , ((C,C), C) —some would notate this by u :→ C , m : C × C → C. 

MonSig : Signature
MonSig = record { 𝒩 = 2 ; ar = 0 ,, 2 ,, nil }
-- unit u : X⁰ → X and multiplication m : X² → X

Generalising on monoids by typing the multiplication we obtain the signature of categories which consists of three sort symbols O, A, C –which can be interepreted as objects, arrows, and composable pairs of arrows– and four function symbols ⨾ , src, tgt, id with source-target sort lists (C,A) , (A,O) , (A,O) , (O,A) —notice that only a language of symbols has been declared without any properties besides those of typing. If we discard C, ⨾, id we then obtain the signature of graphs. Without knowing what categories are, we have seen that their signatures are similar to both the graph and monoid signatures and so expect their logics to also be similar. Moreover we now have a few slogans, \[\color{green}{\text{Categories are precisely typed monoids!}}\] \[\color{green}{\text{Categories are precisely graphs with a monoidal structure!}}\] \[\color{green}{\text{Categories are precisely coherently constructive lattices!}}\]

( The last one is completely unmotivated from our discussion, but it's a good place for the slogan and will be touched on when we look at examples of categories. )

A signature can be visualised in the plane by associating a dot for each sort symbol and an arrow for each function symbol such that the arrow has a tail from each sort in the associated function symbols source sorts list and the end of the arrow is the target sort of the sort symbol. That is, a signature can be visualised as a hyper-graph.

  • A signature whose function symbols each have only one sort symbol for source-sorts is called a ‘graph signature’ since it corresponds to —or can be visualised as— a graph.
  • Then a model of a graph (signature) 𝒢 is an interpreation/realisation of the graph’s vertices as sets and the graph’s edges as functions between said sets.
  • A model of 𝒢 is nothing more than a graph morphism 𝒢 ⟶ 𝒮e𝓉, where 𝒮e𝓉 is the graph with vertices being sets and edges being functions.

Notice that a Graph₀ is precisely a model of the graph • ⇉ •, which consists of two vertices and two edges from the first vertex to the second vertex. We will return to this point ;-)

Before we move on, it is important to note that a signature does not capture any constraints required on the symbols –e.g., a monoid is the monoid signature as well as the constraint that the 2-arity operation is associative and the 0-arity operation is its unit. More generally, a specification consists of a signature declaring symbols of interest, along with a set of sentences over it that denote axioms or constraints. In programming parlance, this is an interface consisting of types and functions that need to be provided and implemented, along with constraints that are usually documented in comments. Unsurprisingly, models of specifications also form categories.

3 Cats but no alligators

In this section we introduce the notion of a ‘‘poor-man’s category’’ along with the notion of structure preserving transformations and structure preserving transformations between such transformations. The former are called functors and the latter are known as natural transformations and are considered one of the most important pieces of the fundamentals of category theory; as such, we discuss them at length. Afterwards, we relate this section back to our motivating discussion of graphs.

3.1 Strict Categories

A category, like a monoid, is a a few types and operations for which some equations hold. However, to discuss equations a notion of equality is needed and rather than enforce one outright it is best to let it be given. This is a ‘set’ in constructive mathematics: A type with an E-quivalence relation on it —also called a setoid or an E-set. However, then the structure must have a few added axioms: The operations must be congruences, i.e., preserve the equivalence relation, and structure-preserving maps must also be congruences.

For our purposes we will use propositional equality and point-wise propositional equality, and as such most of the proofs fall out of the fact that propositional equality is an equivalence. However, this setoid structure becomes a bit of a noise, without providing any real insight for our uses, and the issues of equivalences will be a distraction from the prime focus. Instead, for our two cases where we use point-wise propositional, we will postulate two forms of extensionality. Without question this is not a general approach —then again, our aim is not to develop a library for category theory, which has already been done so elegantly by Kahl who calls it the RATH-Agda project. 

module _ where -- An anyonomous module for categorial definitions

 record Category {i j : Level} : Set (ℓsuc (i ⊍ j)) where
  infixr 10 _⨾_
  field
    Obj      : Set i
    _⟶_     : Obj → Obj → Set j
    _⨾_      : ∀ {A B C : Obj} → A ⟶ B → B ⟶ C → A ⟶ C
    assoc    : ∀ {A B C D} {f : A ⟶ B}{g : B ⟶ C} {h : C ⟶ D} → (f ⨾ g) ⨾ h ≡ f ⨾ (g ⨾ h)
    Id       : ∀ {A : Obj} → A ⟶ A
    leftId   : ∀ {A B : Obj} {f : A ⟶ B} → Id ⨾ f ≡ f
    rightId  : ∀ {A B : Obj} {f : A ⟶ B} → f ⨾ Id ≡ f

 open Category using (Obj)
 open Category ⦃...⦄ hiding (Obj)

 -- Some sugar for times when we must specify the category
 -- “colons associate to the right” ;-)

 arr = Category._⟶_
 syntax arr 𝒞 x y  =  x ⟶ y ∶ 𝒞    -- “ghost colon”

 cmp = Category._⨾_
 syntax cmp 𝒞 f g  =  f ⨾ g ∶ 𝒞    -- “ghost colon”

However, similar to nearly everything else in this document, we can leave the setoid approach as an exercise for the reader, which of course has solutions being in the literate source.

Moreover, lest you’re not convinced that my usage of extensionality is at all acceptable, then note that others have used it to simplify their presentations; e.g., Relative monads formalised. Such ‘appeal to authority’ is for the lazy reader who dares not think for him- or her-self, otherwise one ought to read up on the evils of using equality instead of equivalence relations so as to understand when one thing is really another.

The diligent reader may be interested to know that Maarten Fokkinga has written a very gentle introduction to category theory using the calculational approach; I highly recommend it!

Anyhow, in place of strict equality, one uses categorical isomorphism instead. 

 open Category using (Obj) public

 record Iso {i} {j} (𝒞 : Category {i} {j}) (A B : Obj 𝒞) : Set j where
   private instance 𝒞′ : Category ; 𝒞′ = 𝒞
   field
     to   : A ⟶ B
     from : B ⟶ A
     lid  : to ⨾ from ≡ Id
     rid  : from ⨾ to ≡ Id

 syntax Iso 𝒞 A B = A ≅ B within 𝒞

Interestingly, we shall later encounter a rather large category named 𝒞𝒶𝓉 possessing the special property of being a “2-Category”: It has morphisms between objects, as expected, which are now called “1-morphisms”, and it has morphisms between 1-morphisms, also called “2-morphisms”.

That is, it has morphisms between morphisms.

Above we argued that equality should be deferred in favour of isomorphism at the morphism level. Hence, in a 2-Category, it is only reasonable to defer an equation involving objects to be up to isomorphism of 2-morphisms —this is then called an “equivalence”. 

ℒHS ≃ ℛHS  ⇔  Σ F ∶ ℒHS ⟶ ℛHS • Σ G ∶ ℛHS ⟶ ℒHS • F ⨾ G ≅ G ⨾ F ≅ Id

Hence when it comes to categories themselves, one usually speaks in terms of equivalences rather than isomorphisms.

For example, let 𝒫𝒶𝓇 be the supercategory of 𝒮e𝓉 with morphisms being ‘partial functions’ (A ⟶ B) = (A → B + 𝟙) where the extra element of 𝟙 = { * } represents ‘undefined’ —also known as the Partial, Option, or Maybe monads. Moreover, let 𝒫𝒮ℯ𝓉 be the category of sets with an elected point. Then, 𝒫𝒶𝓇 ≃ 𝒫𝒮e𝓉 is witnessed by (A ⟶ B) ↦ ( (A + 𝟙, *) ⟶ (B + 𝟙, *) ) and conversely ( (A , a) ⟶ (B , b) ) ↦ ( A - a ⟶ B - b) where
X - x ≡ Σ y ∶ X • ¬(x ≡ y). Exercise: Work out the remaining details for the equivalence.

3.2 Familiar 𝒮ℯ𝓉-tings

Let us give some elementary examples of the notion of a category to exhibit its ubiquity.

3.2.1 𝒮ℯ𝓉's

The collection of small, say level i, types and functions between them and usual function composition with usual identity form a category and this is not at all difficult to see: 

 instance
  𝒮e𝓉 : ∀ {i} → Category {ℓsuc i} {i} -- this is a ‘big’ category
  𝒮e𝓉 {i} = record {
      Obj = Set i
    ; _⟶_ = λ A B → (A → B)
    ; _⨾_ = λ f g → (λ x → g (f x))
    ; assoc = ≡-refl
    ; Id = λ x → x
    ; leftId = ≡-refl
    ; rightId = ≡-refl
    }

Sadly, this category is traditionally used to motivate constructions in arbitrary categories and as such people usually think of objects in an arbitrary category as nothing more than sets with extra datum —which is completely false.

For example, the category Div consists of objects and arrows both being numbers ℕ and there is an arrow \(k : m → n\) precisely when k × m = n, so that an arrow is a constructive witness that \(m\) divides \(n\). Notice that besides ℕ, no sets nor functions were involved in the making of this useful number-theoretic category.

3.2.2 Sets are trivial categories

Recall that a type, or set, is nothing more than a specified collection of values.

Every set is also a category: There is a formal syntactic object associated with each element, the only morphisms are (formal) identities, and composition is constantly a syntactic identity. Some define a set to be a category with only identity morphisms; also called a ‘discrete category’ when one wants to distance themself from set theory ;) —less loosely, a discrete category over a type S has Obj = S and (x ⟶ y) = (x ≡ y), where the equivalence is classical, having two possible members true or false.

Discrete categories are quite an important space for hott people … that’s right, attractive people are interested in these things.

Observe that all arrows are invertible! —due to the symmetry of equality. Categories with this property are known as groupoids.

3.2.3 Categories are typed monoids

Recall that a monoid (M, ⊕, e) is a type M with an associative operation ⊕ : M × M → M that has a unit e.

Every monoid is also a category: There is one object, call it ★, the morphisms are the monoid elements, and composition is the monoid operation. —less loosely, for a monoid (M, ⊕, e) we take Obj = {★} , _⟶_ = M.

In fact, some would define a monoid to be a one-object category! –I'm looking at you Freyd & Scedrov =)

3.2.4 Categories are coherently preordered sets

Recall that a preordered set, or preset, is a type P with a relation ≤ on it that satisfies indirect inequality from above: \[ ∀ x , y •\qquad x ≤ y \quad⇔\quad (∀ z •\; y ≤ z ⇒ x ≤ z) \] Equivalently, if it satisfies indirect equality from below: \[ ∀ x , y •\qquad x ≤ y \quad⇔\quad (∀ z •\; z ≤ x ⇒ z ≤ y) \] If we also have \(∀ x , y •\; x ≤ y \,∧\, y ≤ x \;⇒\; x = y\), then we say (P, ≤) is a ‘poset’ or an ‘ordered set’.

Every (pre)ordered set is also a category: The objects are the elements, the morphisms are the order-relations, identities are the relfexitivity of ≤, and composition is transitivity of ≤. To see this more clearly, suppose you have a group \((M, ⊕, \_{}⁻¹, e)\) and you define \(x ≤ y \;⇔\; (∃ m : M •\; m ⊕ x = y)\) then the this is a preorder whose induced category has a morphism \(m : x → y\) precicely when \(m ⊕ x = y\) –now sit down and define the remaining categorical structure of this ‘constructive’ preorder associated to the group.

Traditionally, classically, the relation ≤ is precicely a function P × P ⟶ 𝔹 = {true, flase} and thus there is at-most one morphism between any two objects –consequently, categories with this property are called poset categories.

In the constructive setting, the relation ≤ is typed P × P → Set and then for a preset (P, ≤) we take Obj = P, _⟶_ = a ≤ b and insist on ‘proof-irrelevance’ ∀ {a b} (p q : a ≤ b) → p ≡ q so that there is at most one morphism between any two objects. The restriction is not needed if we were using actual categories-with-setoids since then we would define morphism equality to be
((a, b, p) ≈ (a’, b’, q) ) = (a ≡ a’ × b ≡ b’).

Observe that in the case we have a poset, every isomorphism is an equality: \[ ∀ x, y •\qquad x ≅ y ⇔ x ≡ y \] Categories with this property are called skeletal. Again, hott people like this; so much so, that they want it, more-or-less, to be a foundational axiom!

Poset categories are a wonderful and natural motivator for many constructions and definitions in category theory. This idea is so broad-reaching that it would not be an exaggeration to think of categories as coherently constructive lattices!

3.2.5 Groupoids

Equivalence relations are relations that are symmetric, reflexive, and transitive. Alternatively, they are preorder categories where every morphism is invertible —this is the symmetry property. But categories whose morphisms are invertible are groupoids!

Hence, groupoids can be thought of as generalized equivalence relations. Better yet, as “constructive” equivalence relations: there might be more than one morphism/construction witnessing the equivalence of two items.

Some insist that a true ‘set’ is a type endowed with an equivalence relation, that is a setoid. However, since groupoids generalise equivalence relations, others might insist on a true set to be a "groupoid". However, in the constructive setting of dependent-type theory, these notions coincide!

3.2.6 Rule of Thumb

It’s been said that the aforementioned categories should be consulted whenever one learns a new concept of category theory. Indeed, these examples show that a category is a generalisation of a system of processes, a system of compositionality, and an ordered system.

4 Endowing Structure with Functors

Now the notion of structure-preserving maps, for categories, is just that of graphs but with attention to the algebraic portions as well. 

 record Functor {i j k l} (𝒞 : Category {i} {j}) (𝒟 : Category {k} {l})
  : Set (ℓsuc (i ⊍ j ⊍ k ⊍ l)) where
  private
    instance
      𝒞′ : Category ;  𝒞′ = 𝒞
      𝒟′ : Category ;  𝒟′  = 𝒟
  field
    -- Usual graph homomorphism structure: An object map, with morphism preservation
    obj   : Obj 𝒞 → Obj 𝒟
    mor   : ∀{x y : Obj 𝒞} → x ⟶ y → obj x ⟶ obj y
    -- Interaction with new algebraic structure: Preservation of identities & composition
    id    : ∀{x   : Obj 𝒞} → mor (Id {A = x}) ≡ Id       -- identities preservation
    comp  : ∀{x y z} {f : x ⟶ y} {g : y ⟶ z} → mor (f ⨾ g) ≡ mor f ⨾ mor g

  -- Aliases for readability
  functor_preserves-composition = comp
  functor_preserves-identities  = id

 open Functor public hiding (id ; comp)

For a functor F, it is common practice to denote both obj F and mor F by F and this is usually not an issue since we can use type inference to deduce which is meant. However, in the Agda formalization we will continue to use the names mor , obj. Incidentally in the Haskell community, mor is known as fmap but we shall avoid that name or risk asymmetry in the definition of a functor, as is the case in Haskell which turns out to be pragmatically useful.

A functor can be thought of as endowing an object with some form of structure —since categories are intrinsically structureless in category theory— and so the morphism component of a functor can be thought of as preserving relations: f : a ⟶ b ⇒ F f : F a ⟶ F b can be read as, ‘‘if a is related to b (as witnessed by f) then their structured images are also related (as witness by F f)’’. Recall the category Div for constructive divisibility relationships ;-)

4.1 Examples

A functor among monoids –construed as categories– is just a monoid homomorphism; i.e., an identity and multiplication preserving function of the carriers.

  (M, ⊕, e) ⟶ (N, ⊗, d)
= Σ h ∶ M → N • ∀ x,y • h(x ⊕ y) = h x ⊗ h y ∧ h e = d

By induction, h preserves all finite ⊕-multiplication and, more generally, functors preserve finite compositions: \[ F (f₀ ⨾ f₁ ⨾ ⋯ ⨾ fₙ) \;\;=\;\; F\,f₀ ⨾ F\,f₁ ⨾ ⋯ ⨾ F\,fₙ \] Cool beans :-)

In the same way, sit down and check your understanding!

  • A functor among discrete categories is just a function of the associated sets.
  • A functor among poset categories is an order-preserving function.

Two examples of functors from a poset (category) to a monoid (category):

  • monus : (ℕ, ≤) ⟶ (ℕ,+, 0) is a functor defined on morphisms by \[ i ≤ j \quad⇒\quad \mathsf{monus}(i,j) ≔ j - i\] Then the functor laws become i - i = 0 and (k - j) + (j - i) = k - i.
  • div : (ℕ⁺, ≤) → (ℚ, ×, 1) is defined on morphisms by \[i ≤ j \quad⇒\quad \mathsf{div}(i,j) ≔ j / i\] The functor laws become i / i = 1 and (k / j) × (j / i) = k / i.

Hey, these two seem alarmingly similar! What gives! Well, they’re both functors from posets to monoids ;) Also, they are instances of ‘residuated po-monoids’. Non-commutative monoids may have not have a general inverse operation, but instead might have left- and right- inverse operations known as residuals —we’ll mention this word again when discussing adjunctions and are categorically seen as kan extensions. Alternatively, they’re are instances of ‘(Kopka) Difference-posets’.

For more examples of categories, we will need to reason by extensionality –two things are ‘equal’ when they have equivalent properties … recall Leibniz and his law of indiscernibles ;p

5 The four postulates of the apocalypse

Categories have objects and morphisms between them, functors are morphisms between categories, and then we can go up another level and consider morphisms between functors. These ‘level 2 morphisms’ are pretty cool, so let’s touch on them briefly.

Recall that a poset ordering is extended to (possibly non-monotone) functions \(f , g\) pointwise \[f \overset{.}{≤} g \quad\iff\quad (∀ x •\; f\, x \,≤\, g\, x)\] As such, with posets as our guide, we extend the notion of ‘morphism between functors’ to be a ‘witness’ of these orderings \(η : ∀ {X} → F\, X ⟶ G\, X\) –this is a dependent type, note that the second arrow notates category morphisms, whereas the first acts as a separator from the implicit parameter \(X\); sometimes one sees \(η_X\) for each component/instance of such an operation.

\(\require{AMScd}\)

\begin{CD} \color{navy}{F\, A} @>\color{fuchsia}{η_A}>> \color{teal}{G\, A} \\ @V\color{navy}{F\, f}VV \!= @VV\color{teal}{G\, f}V \\ \color{navy}{F\, B} @>>\color{fuchsia}{η_B}> \color{teal}{G\, B} \end{CD}

However, then for any morphism \(f : A ⟶ B\) we have two ways to get from \(F\, A\) to \(G\, B\) via F f ⨾ η {B} and η {A} ⨾ G f and rather than choose one or the other, we request that they are identical —similar to the case of associativity. 

 NatTrans : ∀ {i j i’ j’}  ⦃ 𝒞 : Category {i} {j} ⦄ ⦃ 𝒟 : Category {i’} {j’} ⦄
            (F G : Functor 𝒞 𝒟) → Set (j’ ⊍ i ⊍ j)
 NatTrans ⦃ 𝒞 = 𝒞 ⦄ ⦃ 𝒟 ⦄ F G =
   Σ η ∶ (∀ {X : Obj 𝒞} → (obj F X) ⟶ (obj G X))
       • (∀ {A B} {f : A ⟶ B} → mor F f ⨾ η {B} ≡ η {A} ⨾ mor G f)

The naturality condition is remembered by placing the target component η {B} after lifting f using the source functor F; likewise placing the source component before applying the target functor.

Another way to remember it: η : F ⟶̇ G starts at F and ends at G, so the naturality also starts with F and ends with G; i.e., F f ⨾ η {B} = η {A} ⨾ G f :-)

It is at this junction that aforementioned problem with our definition of category comes to light: Function equality is extensional by definition and as such we cannot prove it. Right now we have two function-like structures for which we will postulate a form of extensionality, 

 -- function extensionality
 postulate extensionality : ∀ {i j} {A : Set i} {B : A → Set j}
                              {f g : (a : A) → B a}
                          → (∀ {a} → f a ≡ g a) → f ≡ g

 -- functor extensionality
 postulate funcext : ∀ {i j k l} ⦃ 𝒞 : Category {i} {j} ⦄ ⦃ 𝒟 : Category {k} {l} ⦄
                       {F G : Functor 𝒞 𝒟}
                     → (oeq : ∀ {o} → obj F o ≡ obj G o)
                     → (∀ {X Y} {f : X ⟶ Y}
                        → mor G f  ≡  ≡-subst₂ (Category._⟶_ 𝒟) oeq oeq (mor F f))
                     → F ≡ G

 -- graph map extensionality
 postulate graphmapext : {G H : Graph } {f g : GraphMap G H}
                       → (veq : ∀ {v} → ver f v ≡ ver g v)
                       → (∀ {x y} {e : Graph._⟶_ G x y}
                          → edge g e ≡ ≡-subst₂ (Graph._⟶_ H) veq veq (edge f e))
                       → f ≡ g

 -- natural transformation extensionality
 postulate nattransext : ∀ {i j i’ j’} {𝒞 : Category {i} {j} } {𝒟 : Category {i’} {j’} }
                         {F G : Functor 𝒞 𝒟} (η γ : NatTrans F G)
                       → (∀ {X} → proj₁ η {X} ≡ proj₁ γ {X})
                       → η ≡ γ

Natural transformations are too cool to end discussing so briefly and so we go on to discuss their usage is mathematics later on.

5.1 A very big 𝒞𝒶𝓉

With the notions of categories, functors, and extensionality in-hand we can now discus the notion of the category of small categories and the category of small graphs. Afterwards we give another example of a functor that says how every category can be construed as a graph.

First the category of smaller categories,

𝒞𝒶𝓉 is a category of kind (ℓsuc m, ℓsuc m), where m = i ⊍ j, and its objects are categories of kind (i , j) and so it is not an object of itself.

Thank-you Russel and friends!

( You may proceed to snicker at the paradoxical and size issues encountered by those who use set theory. —Then again, I’ve never actually learned, nor even attempted to learn, any ‘‘formal set theory’’; what I do know of set theory is usually couched in the language of type theory; I heart LADM! ) 

 instance
  𝒞𝒶𝓉 : ∀ {i j} → Category {ℓsuc (i ⊍ j)} {ℓsuc (i ⊍ j)}
  𝒞𝒶𝓉 {i} {j} = record {
      Obj = Category {i} {j}
    ; _⟶_ = Functor
    ; _⨾_ = λ {𝒞} {𝒟} {ℰ} F G →
        let instance
                   𝒞′ : Category ; 𝒞′ = 𝒞
                   𝒟′ : Category ; 𝒟′ = 𝒟
                   ℰ′ : Category ; ℰ′ = ℰ
        in record
        { obj  =  obj F ⨾ obj G -- this compositon lives in 𝒮e𝓉
        ; mor  =  mor F ⨾ mor G
        ; id   =  λ {x} → begin
              (mor F ⨾ mor G) (Id ⦃ 𝒞 ⦄ {A = x})
            ≡⟨ "definition of function composition" ⟩′
              mor G (mor F Id)
            ≡⟨ functor F preserves-identities even-under (mor G) ⟩
              mor G Id
            ≡⟨ functor G preserves-identities ⟩
              Id
            ∎
        ; comp = λ {x y z f g} →
             begin
               (mor F ⨾ mor G) (f ⨾ g)
            ≡⟨ "definition of function composition" ⟩′
               mor G (mor F (f ⨾ g))
             ≡⟨ functor F preserves-composition even-under mor G ⟩
               mor G (mor F f ⨾ mor F g)
             ≡⟨ functor G preserves-composition ⟩
               (mor F ⨾ mor G) f ⨾ (mor F ⨾ mor G) g
             ∎
        }
    ; assoc    =  λ {a b c d f g h} → funcext ≡-refl ≡-refl
    ; Id       =  record { obj = Id ; mor = Id ; id = ≡-refl ; comp = ≡-refl }
    ; leftId   =  funcext ≡-refl ≡-refl
    ; rightId  =  funcext ≡-refl ≡-refl
    }

Some things to note,

  • First off: functor F preserves-composition even-under mor G is a real line of code! It consists of actual function calls and is merely an alias for ≡-cong (mor G) (mor F) but it sure is far more readable than this form!

  • We could have written id = ≡-cong (mor G) (id F) ⟨≡≡⟩ id G, but this is not terribly clear what is going on. Especially since we introduced categories not too long ago, we choose to elaborate the detail.

    Likewise, comp = (≡-cong (mor G) (comp F)) ⟨≡≡⟩ (comp G).

  • assoc is trivial since function composition is, by definition, associative. Likewise leftId, rightId hold since functional identity is, by definition, unit of function composition.

5.2 𝒢𝓇𝒶𝓅𝒽

In a nearly identical way, just ignoring the algebraic datum, we can show that Graph's with GraphMap's form a graph 

  𝒢𝓇𝒶𝓅𝒽 : Category
  𝒢𝓇𝒶𝓅𝒽 = {! exercise !}

5.3 𝒞𝒶𝓉's are 𝒢𝓇𝒶𝓅𝒽's

Forgive and forget: The 𝒰nderlying functor.

Let’s formalise what we meant earlier when we said graphs are categories but ignoring the algebraic data.

Given a category, we ignore the algebraic structure to obtain a graph, 

 𝒰₀ : Category → Graph
 𝒰₀ 𝒞 = record { V = Obj 𝒞 ; _⟶_ = Category._⟶_ 𝒞 }

Likewise, given a functor we ‘forget’ the property that the map of morphisms needs to preserve all finite compositions to obtain a graph map: 

 𝒰₁ : {𝒞 𝒟 : Category} → 𝒞 ⟶ 𝒟 → 𝒰₀ 𝒞 ⟶ 𝒰₀ 𝒟
 𝒰₁ F = record { ver = obj F ; edge = mor F }

This says that 𝒰₁ turns ver, edge into obj , mor --𝒰₁ ⨾ ver ≡ obj and 𝒰₁ ⨾ edge ≡ mor– reassuring us that 𝒰₁ acts as a bridge between the graph structures: ver , edge of graphs and obj , mor of categories.

Putting this together, we obtain a functor. 

-- Underlying/forgetful functor: Every category is a graph
 𝒰 : Functor 𝒞𝒶𝓉 𝒢𝓇𝒶𝓅𝒽
 𝒰 = record { obj = 𝒰₀ ; mor = 𝒰₁ ; id = ≡-refl ; comp = ≡-refl }

We forget about the extra algebraic structure of a category and of a functor to arrive at a graph and graph-map, clearly --≡-refl– such ‘forgetfullness’ preserves identities and composition since it does not affect them at all!

Those familiar with category theory may exclaim that just as I have mentioned the names ‘underlying functor’ and ‘forgetful functor’ I ought to mention ‘stripping functor’ as it is just as valid since it brings about connotations of ‘stripping away’ extra structure. I’m assuming the latter is less popular due to its usage for poor mathematical jokes and puns.

Before we move on, the curious might wonder if ‘‘categories are graphs’’ then what is the analgoue to ‘‘\(X\) are hypergraphs’’, it is multicategories.

Now the remainder of these notes is to build-up the material needed to realise the notion of ‘free’ which is, in some sense, the best-possible approximate inverse to ‘forgetful’ –however, forgetting is clearly not invertible since it can easily confuse two categories as the same graph!

6 How natural is naturality?

Recall, that a natural transformation \(η : F \natTo G\) is a family \(∀ \{X \,:\, \Obj 𝒞\} \,→\, F\, X ⟶ G\, X\) that satisfies the naturality condition: \(∀ \{A \; B\} \{f \,:\, A ⟶ B\} \,→\, F f ⨾ η {B} \;≡\; η {A} ⨾ G f\).

  • In the type of η, note that the first show arrow ‘→’ acts as a separator from the the ∀-quantified variable \(X\), whereas the second longer arrow ‘⟶’ denotes the morphism type in the category 𝒞.
  • We will freely interchange the informal mathematical rendition \((η_x : F\, X → G\, X)_{x ∈ \Obj 𝒞}\) with the aforementioned formal Agda forms ∀{X : Obj 𝒞} → F X → G → X and invocation η {X}.

\(\require{AMScd}\)

\begin{CD} \color{navy}{F\, A} @>\color{fuchsia}{η_A}>> \color{teal}{G\, A} \\ @V\color{navy}{F\, f}VV \!= @VV\color{teal}{G\, f}V \\ \color{navy}{F\, B} @>>\color{fuchsia}{η_B}> \color{teal}{G\, B} \end{CD}

Let us look at this from a few different angles; in particular, what does the adjective ‘natural’ actually mean? It’s been discussed on many forums and we collect a few of the key points here.

6.1 Identification of possible paths —contraction of choices

Given two functors \(F , G\), for any object \(~x\) we obtain two objects \(F\, x\, , \, G\, x\) and so a morphism from \(F\) to \(G\) ought to map such \(F\,x\) to \(G\, x\). That is, a morphsim of functors is a family
\(η \,:\, ∀ \{x : \Obj 𝒞\} \,→\, F \,x ⟶ G \,x\). Now for any \(f : a → b\) there are two ways to form a morphism \(F\, a → G\, b\): \(F f ⨾ η \{b\}\) and \(η \{a\} ⨾ G\, f\). Rather than make a choice each time we want such a morphism, we eliminate the choice all together by insisting that they are identical. This is the naturality condition.

This is similar to when we are given three morphisms \(f : a → b , g : b → c , h : c → d\), then there are two ways to form a morphism \(a → d\); namely \((f ⨾ g) ⨾ h\) and \(f ⨾ (g ⨾ h)\). Rather than make a choice each time we want such a morphism, we eliminate the choice all together by insisting that they are identical. This is the associativity condition for categories.

Notice that if there’s no morphism \(F\, x ⟶ G\, x\) for some \(x\), they by definition there’s no possible natural transformation \(F \natTo G\).

6.2 No Choice –free will is only an illusion

\begin{align*} & \quad\text{the natural $X$} \\ = & \quad\text{the $X$ which requires no arbitrary choices} \\ = & \quad\text{the canonical/standard $X$} \end{align*}

That is,

\begin{align*} & \quad \text{it is a natural construction/choice} \\ = & \quad \text{distinct people would arrive at the same construction;} \\ & \quad \text{ (no arbitrary choice or cleverness needed) } \\ = & \quad \text{ there is actually no choice, i.e., only one possiility, } \\ & \quad \text{ and so two people are expected to arrive at the same ‘choice’} \end{align*}

Thus, if a construction every involves having to decide between distinct routes, then chances are the result is not formally natural. Sometimes this ‘inution’ is developed from working in a field for some time; sometimes it just “feel”" natural.

Some would even say: Natural = God-given.

6.3 Natural means polymorphic without type inspection

A natural transformation can be thought of as a polymorphic function ∀ {X} → F X ⟶ G X where we restrict ourselves to avoid inspecting any X.

  • Recall that a mono-morphic operation makes no use of type variables in its signature, whereas a poly-morphic operation uses type variables in its signature.
  • For example, in C# one can ask if one type is a subclass of another thereby obtaining specific information, whereas there is no such mechanism in Haskell.

Inspecting type parameters or not leads to the distinction of ad hoc plymorphism vs. parametric polymorphism —the later is the kind of polymorphism employed in functional language like Haskell and friends and so such functions are natural transformations by default! Theorems for free!

For example, 

-- Let 𝒦 x y ≔ Id {x} for morphisms, and 𝒦 x y ≔ x for objects.

size : ∀ {X} → List X → 𝒦 ℕ X
size [x₁, …, xₙ] = n

is a polymorphic function and so naturality follows and is easily shown –show it dear reader! So we have always have \[List\; f \;⨾\; size \quad=\quad size\] Since 𝒦 ℕ f = Id, then by extensionality: size : List ⟶̇ 𝒦.

On the other hand, the polymorphic function 

whyme : ∀ {X} → List X → 𝒦 Int X
whyme {X} [x₁,…,xₙ] = If X = ℕ then 1729 else n

is not natural: The needed equation F f ⨾ η {B} = η {A} ⨾ G f for any f : A → B breaks as witnessed by f = (λ x → 0) : ℝ → ℕ and any list with length n ≠ 1729, and this is easily shown –do so!

One might exclaim, hey! this only works ’cuz you’re using Ramanujan’s taxi-cab number! 1729 is the smallest number expressible as a sum of 2 cubes in 2 ways: \(1729 = 12³ + 1³ = 10³ + 9 ³\). I assure you that this is not the reason that naturality breaks, and I commend you on your keen observation.

Notice that it is natural if we exclude the type inspected, ℕ. That is, if we only consider \(f : A → B\) with \(A ≠ ℕ ≠ B\). In general, is it the case that a transformation can be made natural by excluding the types that were inspected?

Before we move on, observe that a solution in \(h\) to the absorptive-equation \(F f ⨾ h = h\) is precisely a natural transformation from \(F\) to the aforementioned ‘diagonal functor’: \[F f ⨾ h \;=\; h \qquad⇔\qquad ∃ X : Obj \;•\; h ∈ F \overset{.}{⟶} 𝒦 X ~\]

In particular, due to the constant-fusion property \(g \,⨾\, 𝒦\, e \;=\; 𝒦\, e\), we have that \[∀ \{F\} \{X\} \{e \,:\, X\} \;→\; (𝒦\, e) \,∈\, F \overset{.}{⟶} 𝒦\, X \] Is the converse also true? If \(h ∈ F ⟶̇ 𝒦 X\) then \(h \,=\, 𝒦\, e\) for some \(e\)?

6.4 Natural means no reference to types

The idea that a natural transformation cannot make reference to the type variable at all can be seen by yet another example. 

  data 𝟙 : Set where ★ : 𝟙

  -- Choice function: For any type X, it yields an argument of that type.
  postulate ε : (X : Set) → X

  nay : ∀ {X} → X → X
  nay {X} _ = ε X

Now naturality \(\Id \, f ⨾ nay_B \;=\; nay_A ⨾ \Id \, f\) breaks as witnessed by \(f \;=\; (λ _ → εℕ + 1) \;:\; 𝟙 → ℕ\) –and provided \(εℕ ≠ 0\), otherwise we could use an \(f\) with no fix points.

From this we may hazard the following: If we have natural transformations \(ηᵢ \,:\, ∀ {X : Objᵢ} →\, F X \overset{.}{⟶} G X\) where the \(Objᵢ\) partition the objects available — i.e., \(Obj \;=\; Σ i \,•\, Objᵢ\) — then the transformation \(η_{(i, X)} \;=\; ηᵢ\) is generally unnatural since it clearly makes choices, for each partition.

6.5 Natural means uniformly and simultaneously defined

A family of morphisms is natural in x precisely when it is defined simultaneously for all x —there is no inspection of some particular x here and there, no, it is uniform! With this view, the naturality condition is thought of as a ‘simultaneity’ condition. Rephrasing GToNE.

The idea of naturality as uniformly-definable is pursued by Hodges and Shelah.

6.6 Naturality is restructure-modify commutativity

Recall that a functor can be thought of as endowing an object with structure. Then a transformation can be thought of as a restructuring operation and naturality means that it doesn’t matter whether we restructure or modify first, as long as we do both.

6.7 Natural means obvious

It may help to think of there’s a natural transformation from F to G to mean there’s an obvious/standard/canconical way to transform F structure into G structure.

Likewise, F is naturally isomorphic to G may be read F is obviously isomorphic to G. For example, TODO seq-pair or pair-seq ;-)

Sometimes we can show ‘‘F X is isomorphic to G X, if we make a choice dependent on X’’ and so the isomorphism is not obvious, since a choice must be made.

6.8 Naturality is promotion

  • I think Richard Bird refers to the naturality condition as a promotion law where the functors involved are thought of as (list) constructions.
  • The nomenclature is used to express the idea than operation on a compound structure can be ‘promoted’ into its components.
  • Reading F f ⨾ η {B} = η {A} ⨾ G f from left to right: Mapping \(f\) over a complicated structure then handling the result is the same as handling the complex datum then mapping \(f\) over the result.
    • `Handling' can be thought of as `processing' or as `reshaping'.

Lists give many examples of natural transformations by considering a categorical approach to the theory of lists.

6.9 Naturality as a rewrite rule

The naturality condition can be seen as a rewrite rule that let’s us replace a complicated or inefficient side with a simplier or more efficient yet equivalent expression. I think I first learned this view of equations at the insistence of Richard Bird and Oege de Moor –whose text can be found here, albeit the legitimacy of the link may be suspect.

For example, recall the 𝒦onstant functor now construed only as a polymorphic binary operation: 

_⟪_    :  ∀{A B : Set} → A → B → A
a ⟪ b  =  a

The above is a constant time operation, whereas the next two are linear time operations; i.e., they take n steps to compute, where n is the length of the given list. 

-- This' map for List's; i.e., the mor of the List functor
map    : ∀ {A B : Set} (f : A → B) → List A → List B
map f []         =  []
map f (x ∷ xs)  =  f x ∷ map f xs

-- Interpret syntax `x₀∷⋯∷xₙ₋₁` semantically as `x₀ ⊕ ⋯ ⊕ xₙ₋₁`, where ⊕ = cons.
fold  : ∀ {A B : Set} (cons : A → B → B) (nil : B) → List A → B
fold cons nil [] = nil
fold cons nil (x ∷ xs) = cons x (fold cons nil xs)

By Theorems for Free, or a simple proof, we have that fold is a natural transformation \(List \overset{.}{→} \Id\): \[ List\; f \;⨾\; fold \; cons_B \; nil_B \qquad=\qquad fold \; cons_A \; nil_A \;⨾\; f \] Note that here we are ranging over objects \(X\) equipped with \(nil_X : X, \; cons_X : X → X → X\); as such the equation is not valid when this is not the case.

Now we map compute, 

postulate A B : Set
postulate nil-B : B
postulate f : A → B -- possibly expensive operation

head  :  List B → B
head  =  fold _⟪_ nil-B

compute  :  List A → B
compute  =  map f  ⨾  head

That is, 

  compute [x₀, …, xₙ₋₁]
= head (map f [x₀, …, xₙ₋₁])
= head [f x₀, …, f xₙ₋₁]
= f x₀  ⟪  f x₁ ⟪ ⋯ ⟪ ⋯ f xₙ₋₁ ⟪ nil-B
= f x₀

However this approach performs the potentially expensive operation \(f\) a total of \(n = \text{“length of input”}\) times! In spite of that, it only needs the first element of the list and performs the operation only once! Indeed, by the naturality of fold we have an equivalent, and more efficient, formulation: 

compute  =  head  ⨾  f

This operation only performs the potentially costly f once!

A more concrete and realistic example is to produce an efficient version of the function that produces the average xs = div (sum xs, length xs) of a list of numbers: This operation traverses the input list twice, yet we can keep track of the length as we sum-along the list to obtain an implementation that traverses the list only once!

Indeed, 

div : ℕ × ℕ → ℕ
div (0, 0) = 0
div (m, n) = m ÷ n

average     :  List ℕ → ℕ
average xs  =  div (fold _⊕_ 𝟘 xs)
  where  𝟘 = (0 , 0)
         _⊕_  : ℕ → (ℕ × ℕ) → ℕ
         a ⊕ (b , n) = (a + b , n + 1)

6.10 Naturality is just model morphism

Given two functors \(F , G : 𝒞 ⟶ 𝒟\) let us construe them as only graph homomorphisms. Then each is a model of the graph \(𝒰₀ \; 𝒞\) —each intereprets the nodes and edges of 𝒰₀ 𝒞 as actual objects and morphisms of 𝒟— and a natrual transformation is then nothing more than a morphism of models.

6.11 Naturality yields pattern matching

In the setting of types and functions, η : F ⟶̇ G means we have η (F f x) = G f (η x) which when read left-to-right says that η is defined by pattern-matching on its argument to obtain something of the form F f x then it is defined recursively by examining x and then applying G f to the result —of course there’s some base case F definitions as well.

Alternatively, the input to η is of the form F … and its output is of the form G … –mind blown!

For example, I want to define a transformation \(\mathsf{List} ⟶̇ \mathsf{List}\).

  1. So let me suppose the input is of the shape \(\List \, f\, x\), more concretely it is of the shape
    [f x₀, f x₁, …, f xₙ₋₁] –for arbitrary \(f : A → B\).
  2. Then the output shape must be \(\List \, f\, (η \, x)\), more concretely it is of the shape
    [f y₀, f y₁, …, f yₘ₋₁] where \(y \,=\, η\,x\).

  3. So my only choices are \(y : \List A\) and \(m : ℕ\)

    Here are some possibilities and the resulting η:

    \(y, m = x, n\)
    Identity function
    \(y, m = x, 0\)
    Constantly empty list [] function
    \(y, m = x, 1\)
    The first element, ‘head’, function
    \(y, m = x, k\)
    The first \(k < n\) elements function
    \(m = n\) with \(yᵢ = xₙ₋ᵢ\)
    List reversal function
    \(y, m = \mathsf{reverse}(x), k\)
    The last \(k < n\) elements, in reverse, function
    • Here we applied an already known natural transformation and indeed the composition of naturally transformation is itself natural.

6.12 Examples

Pointwise Monotonicity
A functor among poset categories is an order-preserving function and a natural transformation \(f \natTo g\) is a proof that \(f \overset{.}{≤} g\) pointwise: \(∀ x \,•\, f\, x \;≤\; g\, x\) —all the other pieces for a natural transformation are automatic from the definition of begin a poset category.
conjugation

A functor among monoids –construed as categories– is just a monoid homomorphism:

\begin{align*} & (M, ⊕, e) ⟶ (N, ⊗, d) {{{newline}}} ≅ \quad & Σ h ∶ M → N • ∀ \{x \, y \} •\; h(x ⊕ y) = h x ⊗ h y \lands h e = d \end{align*}

A natural transformation (f, prf) ⟶ (g, prf’) is a point \(n : N\) with \(∀ x ∶ M \;•\; f x ⊗ n \,=\, n ⊗ g x\), a so-called ‘conjugation’ by \(n\) that takes \(f\) to \(g\).

fold

Recall from the introduction \(𝒰(S, ⊕, e) \;=\; S\) was the underlying functor from monoids to sets.

Let \(𝒰 × 𝒰\) be the functor that for objects \(M \;↦\; 𝒰\, M \,×\, 𝒰\, M\) and for morphisms \(h \;↦\; λ (x,y) → (h\, x, h\, y)\). Then the monoid multiplication (of each monoid) is a natural transformation \(𝒰 × 𝒰 \natTo 𝒰\), where naturality says that for any monoid homomorphism \(h\), the application of \(𝒰\, h\) to the (monoid) multiplication of two elements is the same as the (monoid) multiplication of the \(𝒰\, h\) images of the two elements, and this is evident from the homomorphism condition.

Extending to finite products, \(ℒ \;≔\; (Σ n ∶ ℕ • ∏ i ∶ 1..n • 𝒰)\), the natural transformation \(ℒ \natTo 𝒰\) is usually called fold, reduce, or cata and ℒ is known as the free monoid functor with notations \(A* \;=\; \List A \;=\; ℒ\, A\).

Loosely put, 

    ℒ₀    :  Monoid → Set
    ℒ₀ M  =  Σ n ∶ ℕ • ∏ i : 1..n • 𝒰 M   -- finite sequences of elements from M

    ℒ₁ : ∀ {M N : Monoid} → (M ⟶ N) → ℒ₀ M → ℒ₀ N
    ℒ₁ (h , prf) = λ (n , x₁, …, xₙ) → (n , h x₁ , … , h xₙ)

    fold : ∀ {M : Monoid} → ℒ₀ M → 𝒰₀ M
    fold {(M, ⊕, e)} = λ (n , x₁, …, xₙ) → x₁ ⊕ ⋯ ⊕ xₙ

–The reader would pause to consider implementing this formally using Agda's Data.Fin and Data.Vec ;-)–

Now for any monoid homomorphism h, applying induction, yields 

    h₀(x₁ ⊕ ⋯ ⊕ xₙ)  =  h₀ x₁ ⊕ ⋯ ⊕ h₀ xₙ  where  h₀ = 𝒰 (h₀, prf) = 𝒰 h

Which is easily seen to be just naturality – if we use backwards composition \(f ⨾ g \;=\; g ∘ f\) – 

    𝒰 h ∘ fold {M}  =  fold {N} ∘ ℒ h

Woah!

Every operation in any multisorted algebraic structure gives a natural transformation

This is mentioned in the Barr and Wells' Category Theory for Computing Science text, citing Linton, 1969a-b.

For example, src, tgt —from the graph signature— give natural transformations \(V \natTo E\) from the vertex functor to the edge functor … keep reading ;)

Representability

Recall that \(V(G)\) is essentially \(ℙ₀ ⟶ G\) where \(ℙₙ\) is the graph of \(n\) edges on \(n+1\) vertices named \(0..n\) with typing \(i \,:\, i-1 ⟶ i\), which I like to call the path graph of length n; and in particular \(ℙ₀\) is the graph of just one dot, called 0, and no edges. —Earlier I used the notation [n], but I’m using \(ℙ\) since I like the view point of ℙaths.

What does it mean to say that V(G) is essentially ℙ₀ ⟶ G?

It means that the vertices functor – \(𝒱 \;:\; 𝒢𝓇𝒶𝓅𝒽 ⟶ 𝒮ℯ𝓉\) that takes objects \(G ↦ V(G)\) and morphisms \(h ↦ \mathsf{ver}\, h\) – can be ‘represented’ as the Hom functor \((ℙ₀ ⟶ \_{})\), that is to say \[𝒱 \quad≅\quad (ℙ₀ ⟶ \_{}) \;\mathsf{within \; Func} \; 𝒢𝓇𝒶𝓅𝒽 \; 𝒮ℯ𝓉\] --Func-tor categories will be defined in the next section!–

Notice that we arrived at this expression by ‘eta-reducing’ the phrase V(G) is essentially ℙ₀ ⟶ G! ;)

More generally, we have the functor \(ℙₙ ⟶ \_{}\) which yields all paths of length \(n\) for a given graph.

Observe –i.e., show– that we also have an edges functor.

7 Functor Categories

With a notion of morphisms between functors, one is led inexorably to ask whether functors as objects and natural transformations as morphisms constitute a category? They do! However, we leave their definition to the reader —as usual, if the reader is ever so desperate for solutions, they can be found as comments in the unruliness that is the source file. 

 instance
  Func       :  ∀ {i j i’ j’} (𝒞 : Category {i} {j}) (𝒟 : Category {i’} {j’}) → Category _
  Func 𝒞 𝒟  =  {! exercise !}
  • A hint: The identity natural transformation is the obvious way to get from \(F\, X\) to \(F\, X\), for any \(X\) given \(F\) —well the only way to do so, without assuming anything else about the functor \(F\), is simply \(\Id_{F X}\). This is the ‘natural’ choice, any other choice would be ‘unnatural’ as it would require some ‘cleverness’.
  • Another hint: The obvious way to define \(η ⨾ γ\) to get \(F\, X ⟶ H\, X\) from \(F\, X ⟶ G\, X ⟶ H\, X\) is composition of morphisms in the category! That is, pointwise composition. Nothing ‘clever’, just using the obvious candidates!

This is a good exercise as it will show you that there is an identity functor and that composition of functors is again a functor. Consequently, functors are in abundance: Given any two, we can form [possibly] new ones by composition.

It is a common construction that when a type \(Y\) is endowed with some structure, then we can endow the function space \(X → Y\), where \(X\) is any type, with the same structure and we do so ‘pointwise’. This idea is formalised by functor categories. Alternatively, one can say we have ‘categorified’ the idea; where categorification is the process of replacing types and functions with categories and functors and possibly adding some coherence laws.

There are people who like to make a show about how ‘big’ 𝒞𝒶𝓉 or Func 𝒞 𝓓 are; these people adhere to something called ‘set theory’ which is essentialy type theory but ignoring types, loosely put they work only with the datatype 

data SET : Set where
  Elem : ∀ {A : Set} → A → SET

Such heathens delegate types-of-types into ‘classes’ of ‘small’ and ‘big’ sets and it’s not uniform enough for me. Anyhow, such people would say that functor categories ‘‘cannot be constructed (as sets)’’ unless one of the categories involved is ‘‘small’’. Such shenanigans is ignored due to the hierarchy of types we are using :-)

We must admit that at times the usage of a single type, a ‘uni-typed theory’ if you will can be used when one wants to relise types in an extrinsic fashion rather than think of data as intrinsically typed –E.g., graphs with src, tgt then deriving a notion of ‘type’ with _⟶_. Everything has its place … nonetheless, I prefer (multi)typed settings!

7.1 Examples

7.1.1 All Categories are Functor Categories

Let 𝟙 ≔ [ • ] be the discrete category of one object (and only the identity arrow on it).

Then 𝒞 ≅ Func 𝟙 𝒞.

7.1.2 Powers of Categories are Functor Categories

Let 𝟚₀ ≔ [• •] be the discrete category of two objects. Then the 𝒞-squared category can be defined 𝒞 ⊗ 𝒞 ∶≅ Func 𝟚₀ 𝒞: This category essentially consists of pairs of 𝒞-objects with pairs of 𝒞-arrows between them.

The subscript 0 is commonly used for matters associated with objects and the name 𝟚₀ is suggestive of the category of 2 objects only.

More generally, if 𝒩 is the discrete category of \(n\) objects, then the n-fold product category is defined by (∏ i ∶ 1..n • 𝒞) ∶≅ Func 𝒩 𝒞.

These are also commonly denoted \(𝒞^2\) and \(𝒞^𝒩\) since they are essentially products, and more generally Func 𝒳 𝒴 is also denoted 𝒴𝒳 and referred.

7.1.3 Arrow Categories

We can add an arrow to 𝟚₀ to obtain another category…

Let 𝟚 ≔ • ⟶ • be the category of two objects, call them 0 and 1, with one arrow between them. Then a functor 𝟚 ⟶ 𝒞 is precisely a morphism of 𝒞 and a natural transformation f ⟶ g boils down to just a pair of morphisms (h,k) with h ⨾ g = f ⨾ k.

Hence, the arrow category of 𝒞 is \(𝒞^𝟚 \;≅\; 𝒞^→ \;≅\; \mathsf{Func}\, 𝟚 𝒞\); which is essentially the category with objects being 𝒞-morphisms and morphisms being commutative squares.

Notice that a functor can be used to

  • select two arbitrary 𝒞 objects –if it's source is 𝟚₀
  • select two arbitrary 𝒞 objects with a 𝒞 arrow between them –if it's source is 𝟚
  • select an arbitrary 𝒞 arrow –if it's source is 𝟚

Likewise, a natural transformation can be used to select a commutative diagram.

7.1.4 Understand 𝒞 by looking at Functor Categories

It is a common heuristic that when one suspects the possibility of a category 𝒞, then one can make probes to discover its structure. The objects are just functors 𝟙 ⟶ 𝒞 and the morphisms are just functors 𝟚 ⟶ 𝒞.

7.1.5 Presheaves – delegating work to 𝒮ℯ𝓉

The category of presheaves of 𝒞 is the category PSh 𝒞 ≔ Func (𝒞 ᵒᵖ) 𝒮e𝓉.

This is a pretty awesome category since it allows nearly all constructions in 𝒮ℯ𝓉 to be realised! Such as subsets, truth values, and even powersets! All these extra goodies make it a ‘topos’ aka ‘power allegory’ —the first is a category that has all finite limits and a notion of powerset while the second, besides the power part, looks like a totally different beast; the exhilaration!

7.1.6 Slice Categories

The slice category of 𝒞 over B : Obj 𝒞 is the category 𝒞 / B ≔ Σ F ∶ Func 𝟚 𝒞 • (F 1 = B).

Essentially it is the category of objects being 𝒞-morphisms with target \(B\) and morphisms \(f ⟶ g\) being \((h,k)\) with \(h ⨾ g = f ⨾ k\) but a natural choice for \(k : B ⟶ B\) is \(\Id_B\) and so we can use morphism type \((f ⟶’ g) \;≔\; Σ h : \src f ⟶ \src g \;•\; h ⨾ g = f\).

This is seen by the observation \[(h, k) \;∈\; f ⟶ g \qquad⇔\qquad h \;∈\; (f ⨾ k) ⟶’ g\] Of course a formal justification is obtained by showing \[\_{}⟶\_{} \quad≅\quad \_{}⟶’\_{} \quad \mathsf{within \; Func }\; (𝒞 ᵒᵖ ⊗ 𝒞) 𝒮e𝓉 \] …which I have not done and so may be spouting gibberish!

Just as the type Σ x ∶ X • P x can be included in the type X, by forgetting the second component, so too the category Σ F ∶ 𝟚 ⟶ 𝒞 • F 1 ≈ B can be included into the category 𝒞 and we say it is a subcategory of 𝒞.

The notation Σ o ∶ Obj 𝒞 • P o defines the subcategory of 𝒞 obtained by deleting all objects not satisfying predicate P and deleting all morphisms incident to such objects; i.e., it is the category 𝒟 with \[ \Obj 𝒟 \quad≡\quad Σ o ∶ \Obj 𝒞 \,•\, P o \qquad\text{ and }\qquad (o , prf) ⟶_𝒟 (o' , prf') \quad≡\quad o ⟶_𝒞 o' \] This is the largest/best/universal subcategory of 𝒞 whose objects satisfy \(P\).
Formalise this via a universal property ;)

7.1.7 Slices of 𝒮e𝓉 are Functor Categories

\[ \Func \; S \; 𝒮e𝓉 \qquad≅\qquad 𝒮e𝓉 / S \] Where S in the left is construed as a discrete category and in the right is construed as an object of 𝒮e𝓉.

This is because a functor from a discrete category need only be a function of objects since there are no non-identity morphisms. That is, a functor \(f : S ⟶ 𝒮ℯ𝓉\) is determined by giving a set \(f\,s\) for each element \(s ∈ S\) —since there are no non-identity morphisms. Indeed a functor \(f : S ⟶ Set\) yields an S-targeted function \[ (Σ s ∶ S \,•\, f\, s) → S \quad:\quad λ (s , fs) → s \] Conversely a function \(g : X → S\) yields a functor by sending elements to their pre-image sets: \[ S ⟶ Set \quad:\quad λ s → (Σ x ∶ X \,•\, g\, x ≡ s)\]

Because of this example, 𝒞 / B can be thought of as ‘𝒞-objects indexed by B’ –extending this idea further leads to fibred categories.

7.1.8 Natural transformations as functor categories

In a similar spirit, we can identify natural transformations as functors! \[\Func \, 𝒞 \, (𝒟 ^ 𝟚) \quad≅\quad (Σ F , G ∶ 𝒞 ⟶ 𝒟 \;•\; \mathsf{NatTrans}\, F\, G)\]

A functor \(N : 𝒞 ⟶ 𝒟 ^ 𝟚\) gives, for each object \(C : \Obj 𝒞\) an object in \(𝒟 ^ 𝟚\) which is precisely an arrow in \(𝒟\), rewrite it as \(N_C : F\,C ⟶ G\,C\) where \(F\,C \,≔\, N\, C\, 0\) and \(G\, C \,≔\, N\, C\, 1\).

Likewise, for each arrow \(f : A ⟶ B\) in 𝒞 we obtain an arrow \(N\, f \,:\, N\, A ⟶ N\, B\) in \(𝒟 ^ 𝟚\) which is precisely a commutative square in 𝒟; that is, a pair of 𝒟-arrows \((F\,f , G\,f) ≔ N\,f\) with \(N_A ⨾ G\,f \;=\; F\,f ⨾ N_B\).

Notice that we have implicitly defined two functors \(F, G : 𝒞 ⟶ 𝒟\). Their object and morphism mappings are clear, but what about functoriality? We prove it for both \(F, G\) together.

Identity:

\begin{calc} (F \,\Id \, , \, G\, \Id) \step{ definition of $F$ and $G$ } N \, \Id \step{ $N$ is a functor } \Id \,∶\, 𝒟 ^ 𝟚 \step{ identity in arrow categories } (\Id , \Id) \end{calc}

Composition:

\begin{calc} ( F (f ⨾ g) , G (f ⨾ g) ) \step{ definition of $F$ and $G$ } N\, (f ⨾ g) \step{ $N$ is a functor } N\, f ⨾ N\, g \step{ definition of $F$ and $G$ } (F\, f, G\, f) ⨾ (F\,g , G\,g) \step{ composition in arrow categories } (F\,f ⨾ F\,g , G\,f ⨾ G\,g) \end{calc}

Sweet!

Conversely, given a natural transformation \(η : F \overset{.}{⟶} G\) we define a functor \(N : 𝒞 ⟶ 𝒟 ^ 𝟚\) by sending objects \(C\) to \(η_C : F\, C ⟶ G\, C\), which is an object is \(𝒟 ^ 𝟚\), and sending morphisms \(f : A ⟶ B\) to pairs \((G f , F f)\), which is a morphism in \(𝒟 ^ 𝟚\) due to naturality of η; namely \(η_A ⨾ G\, f \;=\; F\, f ⨾ η_B\). It remains to show that \(N\) preserves identities and composition –Exercise!

Now it remains to show that these two processes are inverses and the isomorphism claim is complete. Woah!

Similarly, to show \[ \Func\, (𝟚 ⊗ 𝒞) \, 𝒟 \qquad≅\qquad (Σ F₀ , F₁ ∶ 𝒞 ⟶ 𝒟 • \mathsf{NatTrans}\, F₁ \, F₂)\]

By setting \(H\, i \;=\; Fᵢ\) on objects and likewise for morphisms but with \(H(\Id, 1) \;=\; η\) where \(1 : 0 ⟶ 1\) is the non-identity arrow of 𝟚.

(Spoilers! Alternatively: Arr (Func 𝒞 𝒟) ≅ 𝟚 ⟶ 𝒞 ^ 𝒟 ≅ 𝒞 × 𝟚 ⟶ 𝒟 since 𝒞𝒶𝓉 has exponentials, and so the objects are isomorphic; i.e., natural transformations correspond to functors 𝒞×𝟚⟶𝒟)

Why are we mentioning this alternative statement? Trivia knowledge of-course!

On a less relevant note, if you’re familiar with the theory of stretching-without-tearing, formally known as topology which is pretty awesome, then you might’ve heard of paths and deformations of paths are known as homotopies which are just continuous functions \(H : X × I ⟶ Y\) for topological spaces $X, Y,$ and \(I \,=\, [0,1]\) being the unit interval in ℝ. Letting \(𝒥 = 𝟚\) be the ‘categorical interval’ we have that functors \(𝒞 × 𝒥 ⟶ 𝒟\) are, by the trivia-relevant result, the same as natural transformations. That is, natural transformations extend the notion of homotopies, or path-deformations.

On mathoverflow, the above is recast succinctly as: A natural transformation from \(F\) to \(G\) is a functor, targeting an arrow category, whose ‘source’ is \(F\) and whose ‘target’ is \(G\). \[ \hspace{-2em} F \overset{.}{⟶} G : 𝒞 ⟶ 𝒟 \quad≅\quad Σ η ∶ 𝒞 ⟶ \mathsf{Arr}\, 𝒟 •\; \mathsf{Src} ∘ η = F \;\;∧\;\; \mathsf{Tgt} ∘ η = G \] Where, the projection functors

\begin{align*} \mathsf{Src}& &:& \mathsf{Arr}\, 𝒟 ⟶ 𝒟 \\ \mathsf{Src}& (A₁ , A₂ , f) &=& A₁ \\ \mathsf{Src}& (f , g , h₁ , h₂ , proofs) &=& h₁ \end{align*}

with \(\mathsf{Tgt}\) returning the other indexed items.

7.2 Graphs as functors

We give an example of a functor by building on our existing graphs setup. After showing that graphs correspond to certain functors, we then mention that the notion of graph-map is nothing more than the associated natural transformations! 

 module graphs-as-functors where

Let us construct our formal graph category, which contains the ingredients for a graph and a category and nothing more than the equations needed of a category. The main ingredients of a two-sorted graph are two sort-symbols E, V, along with two function-symbols s, t from E to V —this is also called ‘the signature of graphs’. To make this into a category, we need function-symbols id and a composition for which it is a unit. 

  -- formal objects
  data 𝒢₀ : Set where E V : 𝒢₀

  -- formal arrows
  data 𝒢₁ : 𝒢₀ → 𝒢₀ → Set where
     s t : 𝒢₁ E V
     id  : ∀ {o} → 𝒢₁ o o

  -- (forward) composition
  fcmp : ∀ {a b c} → 𝒢₁ a b → 𝒢₁ b c → 𝒢₁ a c
  fcmp f id = f
  fcmp id f = f

Putting it all together, 

  instance
   𝒢 : Category
   𝒢 = record
        { Obj     = 𝒢₀
        ; _⟶_     = 𝒢₁
        ; _⨾_     = fcmp
        ; assoc   = λ {a b c d f g h} → fcmp-assoc f g h
        ; Id      = id
        ; leftId  = left-id
        ; rightId = right-id
        }
    where
       -- exercises: prove associativity, left and right unit laws

Now we can show that every graph G gives rise to a functor: A semantics of 𝒢 in 𝒮e𝓉. 

  toFunc : Graph → Functor 𝒢 𝒮e𝓉
  toFunc G = record
    { obj  = ⟦_⟧₀
    ; mor  = ⟦_⟧₁
    ; id   = ≡-refl
    ; comp = λ {x y z f g} → fcmp-⨾ {x} {y} {z} {f} {g}
    }
    where
      ⟦_⟧₀ : Obj 𝒢 → Obj 𝒮e𝓉
      ⟦ 𝒢₀.V ⟧₀ = Graph.V G
      ⟦ 𝒢₀.E ⟧₀ = Σ x ∶ Graph.V G • Σ y ∶ Graph.V G • Graph._⟶_ G x y

      ⟦_⟧₁ : ∀ {x y : Obj 𝒢} → x ⟶ y → (⟦ x ⟧₀ → ⟦ y ⟧₀)
      ⟦ s ⟧₁ (src , tgt , edg) = src
      ⟦ t ⟧₁ (src , tgt , edg) = tgt
      ⟦ id ⟧₁ x = x

      -- Exercise: fcmp is realised as functional composition
      fcmp-⨾ : ∀{x y z} {f : 𝒢₁ x y} {g : 𝒢₁ y z} → ⟦ fcmp f g ⟧₁ ≡ ⟦ f ⟧₁ ⨾ ⟦ g ⟧₁

Conversely, every such functor gives a graph whose vertices and edges are the sets associated with the sort-symbols V and E, respectively. 

  fromFunc : Functor 𝒢 𝒮e𝓉 → Graph
  fromFunc F = record {
      V      = obj F 𝒢₀.V
    ; _⟶_    = λ x y → Σ e ∶ obj F 𝒢₀.E • src e ≡ x × tgt e ≡ y
             -- the type of edges whose source is x and target is y
    }
    where tgt src : obj F 𝒢₀.E → obj F 𝒢₀.V
          src = mor F 𝒢₁.s
          tgt = mor F 𝒢₁.t

It is to be noted that we can define ‘‘graphs over 𝒞’’ to be the category Func 𝒢 𝒞. Some consequences are as follows: Notion of graph in any category, the notion of graph-map is the specialisation of natural transformation (!), and most importantly, all the power of functor categories is avaiable for the study of graphs.

In some circles, you may hear people saying an ‘algebra over the signature of graphs’ is an interpretation domain (𝒞) and an operation (Functor 𝒢 𝒞) interpreting the symbols. Nice!

8 A few categorical constructions

We briefly take a pause to look at the theory of category theory. In particular, we show a pair of constructions to get new categories from old ones, interpret these constructions from the view of previously mentioned categories, and discuss how to define the morphism type _⟶_ on morphisms themselves, thereby yielding a functor.

8.1 Opposite

The ‘dual’ or ‘opposite’ category 𝒞ᵒᵖ is the category constructed from 𝒞 by reversing arrows: \((A ⟶_{𝒞ᵒᵖ} B) \;≔\; (B ⟶_𝒞 A)\), then necessarily \((f ⨾_{𝒞ᵒᵖ} g) \;≔\; g ⨾_𝒞 f\). A ‘contravariant functor’, or ‘cofunctor’, is a functor F from an opposite category and so there is a reversal of compositions: \(F(f \,⨾\, g) \;=\; F g \,⨾\, F f\). 

 _ᵒᵖ : ∀ {i j} → Category {i} {j} → Category
 𝒞 ᵒᵖ = {! exercise !}

Notice that \((𝒞 ᵒᵖ) ᵒᵖ \;=\; 𝒞\) and \(𝒞 ᵒᵖ \;≅\; 𝒞\) –one may have an intuitive idea of what this isomorphsim means, but formally it is only meaningful in the context of an ambient category; keep reading ;)

We must admit that for categories, the notion of isomorphism is considered less useful than that of equivalence which weakens the condition of the to-from functors being inverses to just being naturally isomorphic to identities; C.f., ‘evil’ above.

Some interpretations:

  • 𝒮e𝓉ᵒᵖ is usual sets and functions but with ‘backwards composition’: 

     infix 10 _∘_
 _∘_ : ∀ {i j } ⦃ 𝒞 : Category {i} {j}⦄ {A B C : Obj 𝒞} → B ⟶ C →  A ⟶ B → A ⟶ C
 f ∘ g = g ⨾ f

    Indeed, we have g ⨾ f within 𝒞 = f ∘ g within 𝒞 ᵒᵖ; which is how these composition operators are usually related in informal mathematics (without mention of the ambient categories of course).

    On a more serious note, the opposite of 𝒮e𝓉 is clearly 𝓉ℯ𝒮 haha —technically for the purposes of this pun we identify the words ‘opposite’ and ‘reverse’.

  • For a discrete category, its opposite is itself.
  • For a monoid (viewed as a category), its opposite is itself if the monoid operation is commutative, otherwise it is the ‘dual monoid’.

  • For a poset (viewed as a category), its opposite is the ‘dual poset’: \((P, ⊑)ᵒᵖ \;=\; (P, ⊒)\).

    In particular, the ‘least upper bound’, or ‘supremum’ in \((P, ⊑)\) of two elements \(x,y\) is an element \(s\) with the ‘universal property’: \(∀ z •\; x ⊑ z ∧ y ⊑ z \;≡\; s ⊑ z\). However, switching ⊑ with ⊒ gives us the notion of ‘infimum’, ‘greatest upper bound’! So any theorems about supremums automatically hold for infimums since the infifum is nothing more than the supremum in the dual category of the poset.

    It is not difficult to see that this idea of “2 for the price of 1” for theorems holds for all categories.

  • Stone Duality: FinBoolAlg ≃ FinSets ᵒᵖ , witnessed by considering the collection of atoms of a Boolean Algebra in one direction and the power set in the other. Finiteness can be removed at the cost of completeness and atomicitiy, CompleteAtomicBoolAlg ≃ 𝒮ℯ𝓉 ᵒᵖ.
  • What about the category of functors and natural transformations?

Speaking of functors, we can change the type of a functor by ᵒᵖ-ing its source and target, while leaving it alone, 

 -- this only changes type
 opify : ∀ {i j i’ j’} {𝒞 : Category {i} {j}} {𝒟 : Category {i’} {j’}}
      → Functor 𝒞 𝒟 → Functor (𝒞 ᵒᵖ) (𝒟 ᵒᵖ)
 opify F = record { obj   =  obj F
                  ; mor   =  mor F
                  ; id    =  Functor.id F
                  ; comp  =  Functor.comp F
                  }

Category Theory is the ‘op’ium of the people!

— Karl Marx might say it had cats existed in his time

This two definitions seem to indicate that we have some form of opposite-functor … ;) —keep reading!

opify seems to show that Functor 𝒞 𝒟 ≡ Functor (𝒞 ᵒᵖ) (𝒟 ᵒᵖ), or alternatively a functor can have ‘two different types’ —this is akin to using the integers as reals without writing out the inclusion formally, leaving it implicit; however, in the Agda mechanization everything must be made explicit —the type system doesn’t let you get away with such things. Professor Maarten Fokkinga has informed me that the formalization allowing multiple-types is called a pre-category.

8.1.1 ah-yeah: ∂ and dagger categories

With 𝒞𝒶𝓉 in-hand, we can formalise the opposite, or ∂ual, functor: 

 ∂ : ∀ {i j} → Functor (𝒞𝒶𝓉 {i} {j}) 𝒞𝒶𝓉
 ∂ = record { obj = _ᵒᵖ ; mor = opify ; id = ≡-refl ; comp = ≡-refl }

Conjecture: Assuming categories are equipped with a contravariant involutionary functor that is identity on objects, we can show that the identity functor is naturally isomorphic to the opposite functor. 

 ah-yeah : ∀ {i j} (let Cat = Obj (𝒞𝒶𝓉 {i} {j}))
     -- identity on objects cofunctor, sometimes denoted _˘
     → (dual : ∀ (𝒞 : Cat) {x y : Obj 𝒞}  →  x ⟶ y ∶ 𝒞  →  y ⟶ x ∶ 𝒞)
     → (Id˘ : ∀ ⦃ 𝒞 : Cat ⦄ {x : Obj 𝒞} → dual 𝒞 Id  ≡  Id {A = x})
     → (⨾-˘ : ∀ ⦃ 𝒞 : Cat ⦄ {x y z : Obj 𝒞} {f : x ⟶ y} {g : y ⟶ z}
            → dual 𝒞 (f ⨾ g ∶ 𝒞)  ≡  (dual 𝒞 g) ⨾ (dual 𝒞 f) ∶ 𝒞)
     -- which is involutionary
     → (˘˘ : ∀ ⦃ 𝒞 : Cat ⦄ {x y : Obj 𝒞} {f : x ⟶ y} → dual 𝒞 (dual 𝒞 f) ≡ f)
     -- which is respected by other functors
     → (respect : ⦃ 𝒞 𝒟 : Cat ⦄ {F : 𝒞 ⟶ 𝒟} {x y : Obj 𝒞} {f : x ⟶ y}
                → mor F (dual 𝒞 f) ≡ dual 𝒟 (mor F f))
     -- then
     → ∂ ≅ Id within Func (𝒞𝒶𝓉 {i} {j}) 𝒞𝒶𝓉

 ah-yeah = {! exercise !}

Some things to note.

  • Categories whose morphisms are all isomorphisms are called ‘groupoids’ —groups are just one-object groupoids. Consequently, restricted to groupoids the opposite functor is naturally isomorphic to the identity functor!

    In fact, the group case was the motivator for me to conjecture the theorem, which took a while to prove since I hadn’t a clue what I needed to assume. Here we’d use a ˘ ≔ a ⁻¹.

  • Consider the category Rel whose objects are sets and whose morphisms are ‘typed-relations’ \((S, R, T)\), where \(R\) is a relation from set \(S\) to set \(T\), and composition is just relational composition —the notion of ‘untyped’, or multi-typed, morphisms is formalized as pre-categories; see Fokkinga. Then we can define an endofunctor by taking -˘ to be relational converse: \(x \,(R ˘)\, y \;≡\; y \,R\, x\). Consequently, restricted to the category Rel we have that the opposite functor is naturally isomorphic to the identity functor.

The above items are instance of a more general concept, of course.

A category with an involutionary contravariant endofunctor that is the identity on objects is known as a dagger category, an involutive/star category, or a category with converse —and the functor is denoted as a superscript suffix by †, *, ˘, respectively. The dagger notation probably comes from the Hilbert space setting while the converse notation comes from the relation algebra setting. As far as I know, the first two names are more widely known. A dagger category bridges the gap between arbitrary categories and groupoids.

Just as matrices with matrix multiplication do not form a monoid but rather a category, we have that not all matrices are invertible but they all admit transposition and so we have a dagger category. In the same vein, relations admit converse and so give rise to a category with converse.

Besides relations and groupoids, other examples include:

  • discrete categories with the dagger being the identity functor
  • every monoid with an anti-involution is trivially a dagger category; e.g., lists with involution being reverse.
  • commutative monoids are anti-involutive monoids with anti-involution being identity

Spoilers!! Just as the category of categories is carestian closed, so too is the category of dagger categories and dagger preserving functors –c.f.,the respect premise above.

8.2 Products

For any two categories 𝒞 and 𝒟 we can construct their ‘product’ category \(𝒞 ⊗ 𝒟\) whose objects and morphisms are pairs with components from 𝒞 and 𝒟: \(\Obj\, (𝒞 ⊗ 𝒟) \;\;=\;\; \Obj\, 𝒞 \,×\, \Obj\, 𝒟\) and \((A , X) ⟶_{𝒞 ⊗ 𝒟} (B , Y) \;\;=\;\; (A ⟶_𝒞 B) \,×\, (X ⟶_𝒟 Y)\). 

 -- we cannot overload symbols in Agda and so using ‘⊗’ in-place of more common ‘×’.
 _⊗_ : ∀ {i j i’ j’} → Category {i} {j} → Category {i’} {j’} → Category
 𝒞 ⊗ 𝒟 = {! exercise !}

Observe that in weaker languages, a category is specified by its objects, morphisms, and composition —the proof obligations are delegated to comments, if they are realized at all. In such settings, one would need to prove that this construction actually produces a full-fledged category. Even worse, this proof may be a distance away in some documentation. With dependent types, our proof obligation is nothing more than another component of the program, a piece of the category type.

In a similar fashion we can show that the sum of two categories is again a category and in general we have the same for quantified variants: Π 𝒞 ∶ Family • 𝒞, likewise for ‘Σ’. For the empty family, the empty sum yields the category 𝟘 with no objects and the empty product yields the category 𝟙 of one object. One can then show the usual ‘laws of arithmetic’ —i.e., ×,+ form a commutative monoid, up to isomorphism— hold in this setting: Letting ★ ∈ {+,×}, we have associtivity A ★ (B ★ C) ≅ (A ★ B) ★ C, symmetry A ★ B ≅ B ★ A, unit 𝟙 × A ≅ 𝟘 + A ≅ A, and zero 𝟘 × A ≅ 𝟘. These notions can be defined for any category though the objects may or may not exist — in 𝒮e𝓉 and 𝒢𝓇𝒶𝓅𝒽, for example, they do exist ;) —and these associated arithmetical laws also hold.

Question! What of the distributivity law, A × (B + C) ≅ (A × B) + (A × C), does it hold in the mentioned cases? Let 𝒫𝒮e𝓉 be the category of sets with a distinguished point, i.e., Σ S : Obj 𝒮e𝓉 • S, and functions that preserve the ‘point’, one can then show —if he or she so desires, and is not lazy— that this category has notions of product and sum but distributivity fails.

Some interpretations:

  • For discrete categories, this is the usual Cartesian product.
  • For monoid (or poset) categories, this says that the product of two monoids (or posets) is again a monoid (respectively poset. This follows since the product does not affect the number of objects and so the product is again a one-object category, i.e., a monoid (poset respectively).
  • Interestingly, the sum of two monoids is not formed by their disjoint union: Instead it is the set of all alternating lists of elements from the two given monoids. Exercise: Find the associated operation ;-)

As expected, we have projections, 

 Fst : ∀ {i j i’ j’} {𝒞 : Category {i} {j}} {𝒟 : Category {i’} {j’}}
     → Functor (𝒞 ⊗ 𝒟) 𝒞
 Fst = record { obj = proj₁ ; mor = proj₁ ; id = ≡-refl ; comp = ≡-refl }

 Snd : ∀ {i j i’ j’} {𝒞 : Category {i} {j}} {𝒟 : Category {i’} {j’}}
     → Functor (𝒞 ⊗ 𝒟) 𝒟
 Snd = record { obj = proj₂ ; mor = proj₂ ; id = ≡-refl ; comp = ≡-refl }

8.2.1 Currying

For types we have \[ (𝒳 × 𝒴 ⟶ 𝒵) \quad≅\quad (𝒳 ⟶ 𝒵 ^ 𝒴) \quad≅\quad (𝒴 ⟶ 𝒵 ^ 𝒳)\] Since categories are essentially types endowed with nifty structure, we expect it to hold in that context as well. 

  -- Everyone usually proves currying in the first argument,
  -- let’s rebel and do so for the second argument
 curry₂ : ∀ {ix jx iy jy iz jz}
          {𝒳 : Category {ix} {jx}} {𝒴 : Category {iy} {jy}} {𝒵 : Category {iz} {jz}}
        → Functor (𝒳 ⊗ 𝒴) 𝒵 → Functor 𝒴 (Func 𝒳 𝒵)
 curry₂ = {! exercise !}

8.3 Pointwise extensions and the hom functor

Just as addition can be extended to number-valued functions pointwise, \(f + g \;≔\; λ x → f x + g x\), we can do the same thing with functors. 

 -- For bifunctor ‘⊕’ and functors ‘F, G’, we have a functor ‘λ x → F x ⊕ G x’
 pointwise : ∀ {ic jc id jd ix jx iy jy}
   {𝒞 : Category {ic} {jc}} {𝒟 : Category {id} {jd}} {𝒳 : Category {ix} {jx}} {𝒴 : Category {iy} {jy}}
   → Functor (𝒳 ⊗ 𝒴) 𝒟 → Functor 𝒞 𝒳 → Functor 𝒞 𝒴
   → Functor 𝒞 𝒟
 pointwise = {! exercise !}

By ‘extensionality’ p ≡ (proj₁ p , proj₂ p), we have that the pointwise extension along the projections is the orginal operation. 

 exempli-gratia : ∀ {𝒞 𝒟 𝒳 𝒴 : Category {ℓ₀} {ℓ₀}} (⊕ : Functor (𝒳 ⊗ 𝒴) 𝒟)
                → let _⟨⊕⟩_ = pointwise ⊕
                   in
                      Fst ⟨⊕⟩ Snd ≡ ⊕
 exempli-gratia Bi = funcext (≡-cong (obj Bi) ≡-refl) (≡-cong (mor Bi) ≡-refl)

An example bifunctor is obtained by extending the ‘⟶’ to morphisms: Given f : A ⟶ B , g : C ⟶ D we define (f ⟶ g) : (B ⟶ C) → (A ⟶ C) by λ h → f ⨾ h ⨾ g as this is the only way to define it so as to meet the type requirements. 

 Hom : ∀ {i j} {𝒞 : Category {i} {j} } → Functor (𝒞 ᵒᵖ ⊗ 𝒞) (𝒮e𝓉 {j})
   -- hence contravariant in ‘first arg’ and covaraint in ‘second arg’
 Hom {𝒞 = 𝒞} =
   let
     module 𝒞 = Category 𝒞
     instance 𝒞′ : Category ; 𝒞′ = 𝒞
     ⨾-cong₂ : ∀ {A B C : Obj 𝒞} {f : A 𝒞.⟶ B} {g g’ : B 𝒞.⟶ C}
             → g ≡ g’ → f 𝒞.⨾ g ≡ f 𝒞.⨾ g’
     ⨾-cong₂  q  =  ≡-cong₂ 𝒞._⨾_ ≡-refl q
   in record {
     obj = λ{ (A , B) →  A ⟶ B }
   ; mor = λ{ (f , g) → λ h → f ⨾ h ⨾ g }
   ; id = extensionality (λ {h} → begin
        Id 𝒞.⨾ h 𝒞.⨾ Id
      ≡⟨ leftId ⟩
        h 𝒞.⨾ Id
      ≡⟨ rightId ⟩
        h
      ∎)
   ; comp =  λ {x y z fg fg’} →
       let (f , g) = fg ; (f’ , g’) = fg’ in extensionality (λ {h} → begin
            (f’ 𝒞.⨾ f) 𝒞.⨾ h 𝒞.⨾ (g 𝒞.⨾ g’)
          ≡⟨ assoc ⟩
            f’ 𝒞.⨾ (f 𝒞.⨾ (h 𝒞.⨾ (g 𝒞.⨾ g’)))
          ≡⟨ ⨾-cong₂ (≡-sym assoc) ⟩
            f’ 𝒞.⨾ ((f 𝒞.⨾ h) 𝒞.⨾ (g 𝒞.⨾ g’))
          ≡⟨ ⨾-cong₂ (≡-sym assoc) ⟩
            f’ 𝒞.⨾ ((f 𝒞.⨾ h) 𝒞.⨾ g) 𝒞.⨾ g’
          ≡⟨ ⨾-cong₂ (≡-cong₂ 𝒞._⨾_ assoc ≡-refl) ⟩
            f’ 𝒞.⨾ (f 𝒞.⨾ h 𝒞.⨾ g) 𝒞.⨾ g’
          ∎)
     }

The naming probably comes from the algebra/monoid case where the functors are monoid hom-omorphisms. Some prefer to use the name Mor, short for mor-phisms, and that’s cool too. While Haskell programmers might call this the Reader functor.

Usual notation for this functor is Hom, but I like Fokkinga’s much better. He uses (_⟶_) and writes (f ⟶ g) = λ h • f ⨾ h ⨾ g —the first argument of Hom is the first argument of the composition and the last argument to Hom is the last argument of the resulting composition :-)

9 𝒮implicity 𝒰nderlies 𝒞omplexity

One way is to make it so 𝒮imple that there are obviously no deficiencies, and the other way is to make it so 𝒞omplicated that there are no obvious deficiencies. The first method is far more difficult. It demands the same skill, devotion, insight, and even inspiration as the discovery of the simple physical laws which 𝒰nderlie the complex phenomena of nature.

─C.A.R. Hoare

( The 𝒞omplex philosophy behinds games such as Chess and Go arise from some 𝒮imple board game rules. )

In this section we discuss what it means to be a ‘forgetful functor’? –Also called an `𝒰nderlying functor'.

The modifier ‘forgetful’ is meaningful when there’s a notion of extra structure. Indeed any functor F : 𝒞 ⟶ 𝒮 can be thought of as forgetful by construing the objects of 𝒞 as objects of 𝒮 with extra structure. Mostly: You know it (to be forgetful) when you see it!

9.1 Being forgetful: from injections to faithful functors

A common example from set theory is the ‘inclusion’ of a subset \(A\) of \(B\), the injection \(ι : A ↪ B : a ↦ a\) —it is essentially a form of ‘type casting’: \(a ∈ A\) and \(ι a \;=\; a ∈ B\). Such injections ‘forget’ the property that the argument is actually a member of a specified subset. Indeed, construing sets as categories then functions becomes functors and inclusions are then forgetful functors!

Since a functor F consists of two maps (F₀, F₁) ≔ (obj F, mor F) and some properties, we can speak about properties of the functor and about properties of either of its maps. The common definitions are a functor \(F\) is:

faithful
If its operation on morphisms is injective, and it is
full
If morphisms starting and ending at F are a result of applying \(F\);
i.e., F₁ is surjective on the image of F₀:
\(∀ x,y ∶ Obj \;•\; ∀ g ∶ F₀ x ⟶ F₀ y \;•\; ∃ f ∶ x ⟶ y \;•\; F₁ f = g\).

Now we can generalize the previous example. Every faithful functor F : 𝒞 ⟶ 𝒟 can be construed as forgetful: The 𝒞-maps can be embedded into the 𝒟-maps, since F is faithful, and so can be thought of as a special sub-collection of the 𝒟-maps; then \(F\) ‘forgets’ the property of being in this special sub-collection.

Are faithful functors in abundance? Well any functor forgetting only axioms (and/or structure) is faithful:

  1. Suppose 𝒞 consists of 𝒟 objects satisfying some axioms and 𝒟 maps preserving this structure.
  2. That is, 𝒞 has pairs of 𝒟 objects/morphisms with a proof that it satisfies the axioms/preserves-structure.
  3. Then “\(F : 𝒞 ⟶ 𝒟\) forgets only axioms” means \(F\, (f, \mathsf{proof}) \;=\; f\).

  4. Now given, \(F (f , prf) = F (g , prf) \;⇔\; f = g \;⇔\; (f , prf) = (g , prf)\) – equality does not (extensionally) depend on proof components.

    Hence, faithful :-)

    (Likewise for forgetting extra structure).

Of course we’re not saying all forgetful functors are necessarily faithful. A simple counterexample is the absolute value function: Given a real number \(x\) it’s absolute value \(∣x∣\) is obtained by totally ignoring its sign —of course \(x\) and \(∣x∣\) are equidistant from 0, the relation equidistant-from-0 is an equivalence relation –Exercise!–, and so the the two are isomorphic in some sense.

Motivated by this, given a set \(S\) it’s size is denoted \(∣ S ∣\) which totally forgets about the elements of the set —of course it can be shown that two sets are isomorphic precisely if they are equinumerous.

I assume it is with these as motivators, some people write \(∣·∣\) for a forgetful functor.

( Exercise: A functor F : 𝒞 ≃ 𝒟 is (part of) an equivalence iff it is full, faithful, and ‘‘essentially surjective on objects’’: ∀ D : Obj 𝒟 • Σ C : Obj 𝒞 • F C ≅ D —note the iso. )

9.2 Of basis vectors

If you’ve ever studied abstract algebra —the math with vector spaces— then you may recall that a collection of vectors ℬ is called a ‘basis’ if every vector can be written as a linear combination of these vectors: For any vector \(v\), there are scalars \(c₁, …, cₙ\) and vectors \(b₁, …, bₙ\) in ℬ with \(v \;=\; c₁·b₁ + ⋯ + cₙ·bₙ\). That is, a basis is a collection of ‘building blocks’ for the vector space. Then any function \(f\) between basis sets immediately lifts to a linear transformation (think vector space morphism) \(F\) as follows: Given a vector \(v\), since we have a basis, we can express it as \(c₁·b₁ + ⋯ + cₙ·bₙ\), now define \(F v \;≔\; c₁·(f\, b₁) + ⋯ + cₙ·(f\, bₙ)\).

Sweet!

Thus, to define a complicated linear transformation of vector spaces, it more than suffices to define a plain old simple function of basis sets. Moreover, by definition, such \(F\) maps basis vectors to basis vectors: \(f \;=\; ι ⨾ F\) where \(ι : ℬ ↪ 𝒱\) is the inclusion that realises basis vectors as just usual vectors in the vector space 𝒱. Slogan: Vector space maps are determined by where they send their basis, and basis-vectors are preserved.

In the case of (List A, ++, []) we may consider A to be a ‘basis’ of the monoid —indeed, every list can be written as a linear combination of elements of A, given list [x₁, …, xₙ] : List A we have [x₁, …, xₙ] = x₁ + ⋯ + xₙ where x + y ≔ [x] ++ [y]. Reasoning similarly as above, or if you have familiarity with foldr , reduce, we have a slogan: Monoid homomorphisms from lists are determined by where they send their basis and basis-vectors are preserved.

Now the general case: \(F ⊣ U\) is a (free-forgetful) ‘adjunction’ means for functors ‘forget’ \(U : 𝒞 ⟶ 𝒮\) and ‘free’ \(F : 𝒮 → 𝒞\), we have that for a given 𝒮imple-object \(S\) there’s 𝒮imple-map \(ι : S ⟶_𝒮 U\,(F\, S)\) —a way to realise ‘basis vectors’— such that for any 𝒞omplicated-object \(C\) and 𝒮imple-maps \(φ : S ⟶_𝒮 U\, C\), there is a unique 𝒞omplicated-map \(Φ : F\, S ⟶_𝒞 C\) that preserves the basis vectors: \(φ = ι ⨾ U Φ\).

By analogy to the previous two cases, we may consider \(U\, X\) to be a ‘basis’, and make the slogan: 𝒞omplicated-maps from free objects are determined by where they send their basis and ‘basis vectors’ are preserved.

[ In more categorical lingo, one says \(ι\) is the ‘insertion of generators’.

Question: Does the way we took \(ι\) in the previous graph show that it is a natural transformation \(ι : \Id ⟶ F ⨾ U\)? —The naturality just says that a ‘homomorphism’ \(F f\) on the free object is completely determined by what \(f\) does to the generators ;-) ]

9.3 Of adjunctions

An adjunction \(L ⊣ U\), where the L-ower adjoint is from 𝒮 to 𝒞 and the U-pper adjoint is in the opposite direction, lends itself to an elemntary interpretation if we consider 𝒞 to be some universe of 𝒞omplicated items of study, while 𝒮 to be a universe of 𝒮imple items of study. Then adjointness implies that given a simple-object \(S\) and a complicated-object \(C\), a simple-map \(X ⟶ U\, C\) corresponds to a complicated-map \(L\, S ⟶ C\). To work with complicated-maps it is more than enough to work with simple-maps!

Formally this correspondence, saying \(F : 𝒞 ⟶ 𝒟\) is adjoint to \(G : 𝒟 ⟶ 𝒞\), written \(F ⊣ G\), holds precisely when \((F ∘ X ⟶ Y) \;≅\; (X ⟶ G ∘ Y)\) in a functor category: 

 _⊣₀_ : ∀ {i j} {𝒞 𝒟 : Category {i} {j}} → Functor 𝒞 𝒟 → Functor 𝒟 𝒞 → Set (i ⊍ j)
 _⊣₀_ {𝒞 = 𝒞} {𝒟} F G
    =
      (F ′ ∘ X  ⟶ₙₐₜ Y)  ≅  (X ⟶ₙₐₜ G ∘ Y)  within  Func (𝒞 ᵒᵖ ⊗ 𝒟) 𝒮e𝓉
   where
     X = Fst ; Y = Snd ; _′ = opify -- only changes types

     infix 5 _⟶ₙₐₜ_
     _⟶ₙₐₜ_ : ∀ {i j} {𝒜 : Category {i} {j}} →
            Functor (𝒞 ᵒᵖ ⊗ 𝒟) (𝒜 ᵒᵖ) → Functor (𝒞 ᵒᵖ ⊗ 𝒟) 𝒜 → Functor (𝒞 ᵒᵖ ⊗ 𝒟) 𝒮e𝓉
     _⟶ₙₐₜ_ {i} {j} {𝒜} = pointwise (Hom {i} {j} {𝒜})

Note that if we use Agda's built-in rewrite mechanism to add the rule, 

{𝒞 𝒟 : Category {ℓ₀} {ℓ₀}} → Functor (𝒞 ᵒᵖ) (𝒟 ᵒᵖ) ≡ Functor 𝒞 𝒟

then we might be able to get away without using opify.

Anyhow, this says for any objects \(X\) and \(Y\), the collection of morphisms \((F\, A ⟶ B)\) is isomorphic to the collection \((A ⟶ G\, B)\) and naturally so in \(A\) and \(B\).

Unfolding it, we have 

 record _⊣_ {i j i’ j’} {𝒞 : Category {i} {j}} {𝒟 : Category {i’} {j’}}
        (F : Functor 𝒞 𝒟) (G : Functor 𝒟 𝒞)
        : Set (j’ ⊍ i’ ⊍ j ⊍ i) where

   open Category 𝒟 renaming (_⨾_ to _⨾₂_)
   open Category 𝒞 renaming (_⨾_ to _⨾₁_)
   field
     -- ‘left-adjunct’  L ≈ ⌊  and  ‘right-adjunct’  r ≈ ⌈
     ⌊_⌋ : ∀ {X Y} →   obj F X ⟶ Y ∶ 𝒟   →   X ⟶ obj G Y ∶ 𝒞
     ⌈_⌉ : ∀ {X Y} →   X ⟶ obj G Y ∶ 𝒞   →   obj F X ⟶ Y ∶ 𝒟

     -- Adjuncts are inverse operations
     lid : ∀ {X Y} {d : obj F X ⟶ Y ∶ 𝒟} → ⌈ ⌊ d ⌋ ⌉ ≡ d
     rid : ∀ {X Y} {c : X ⟶ obj G Y ∶ 𝒞} → ⌊ ⌈ c ⌉ ⌋ ≡ c

     -- That for a fixed argument, are natural transformations between Hom functors
     lfusion : ∀ {A B C D} {f : A ⟶ B ∶ 𝒞} {ψ : obj F B ⟶ C ∶ 𝒟} {g : C ⟶ D ∶ 𝒟}
             →  ⌊ mor F f ⨾₂ ψ ⨾₂ g ⌋  ≡  f ⨾₁ ⌊ ψ ⌋ ⨾₁ mor G g
     rfusion : ∀ {A B C D} {f : A ⟶ B ∶ 𝒞} {ψ : B ⟶ obj G C ∶ 𝒞} {g : C ⟶ D ∶ 𝒟}
             →  ⌈ f ⨾₁ ψ ⨾₁ mor G g ⌉  ≡  mor F f ⨾₂ ⌈ ψ ⌉ ⨾₂ g

This is easier for verifying an adjunction, while the former is easier for remembering and understanding what an adjunction actually is.

As the slogan goes ‘adjunctions are everywhere’. They can be said to capture the notions of optimization and efficiency, but also that of simplicity.

For example, the supremum of a function is defined to be an upper bound of its image set and the least such bound. Formally, this definition carries a few quantifiers and so a bit lengthy. More elegantly, we can say the supremum operation is left-adjoint to the constant function: \[ \mathsf{sup} ⊣ 𝒦 \] which means \[ ∀ z •\qquad \mathsf{sup}\, f \,≤\, z \quad⇔\quad f \overset{.}{≤} 𝒦\, z\] Where \(𝒦\, x\, y \,=\, x\) and the \(\overset{.}{≤}\) on the right is the point-wise ordering on functions. This formulation of supremum is not only shorter to write but easier to use in calculational proofs.

For the efficiency bit, recall that it is efficient to specify a 𝒮imple-map, then use the adjuction, to obtain a 𝒞omplicated-map. Recall in the last paragraph how we define the super complicated notion of supremum of a function in terms of the most elementary constant function!

Adjunctions over poset categories are called ‘Galois connections’ and a good wealth of material on them can be found in nearly any writing by Backhouse et. al., while a very accessible introduction is by Aarts, and there is also an Agda mechanisation by Kahl & Al-hassy.

Regarding forgetful functors: Generally, but not always, forgetful functors are faithful and have left adjoints —because the notion of ‘forget’ ought to have a corresponding notion of ‘free’. An exception to this is the category of fields, which has a forgetful functor to the category of sets with no left adjoint.

9.4 Adjunctions and Representable Functors

Another awesome thing about adjunctions L ⊣ U is that they give us ‘representable functors’, a.k.a. ‘the best kind of functors’, when terminal objects exist.

  • An object 𝟙 is ‘terminal’ if for any object A there is a unique morphism ! {A} : A ⟶ 𝟙. In 𝒮ℯ𝓉 we have (A ⟶ 𝟙) ≅ 𝟙 and (𝟙 ⟶ A) ≅ A.
  • Specialising the adjunction, where U : 𝒞 ⟶ 𝒮e𝓉, to a given set A and 𝟙 we obtain (L 𝟙 ⟶ A) ≅ (𝟙 ⟶ U A) ≅ U A and so one says ‘ U is represented by L 𝟙 ’.
  • In particular, if 𝒞 is built on 𝒮ℯ𝓉 by adding some structure and we are interested in utilising the elements of an object A then it suffices to utilise the maps L 𝟙 ⟶ A.

In the case of a free-forgetful adjunction, this says that a forgetful functor is represented by the free object with generator 𝟙.

For example, for monoids the one-point monoid is the terminal object: 𝟙 ≔ ({*}, ⊕, *) with x ⊕ y ≔ ⋆. Then every monoid-homomorphism from 𝟙 just picks out an element of the carrier of a monoid and so (𝟙 ⟶ M) ≅ 𝒰 M where 𝒰 is the forgetful functor for monoids mentioned in the introduction.

9.5 Concluding remarks

A final note about ‘free objects’ —arising from an adjoint to a forgetful functor.

‘‘The free object is generic’’: The only truths provable for the free object are precisely those that hold for every complicated-object.

(Begin squinting eyes)
This follows from the definition of adjunction which says we can construct a unique morphism between complicated-objects from a simple-map and by naturality we may transport any proof for the free object to any complicated object.
(Feel ‘free’ to stop squinting your eyes)

For futher reading consider reading the adjoint article at the comic book library and for more on the adjective ‘forgetful’ see ncatlab or mathworld A nice list of common free objects can be found on wikipedia.

You might be asking, musa, when am I ever going to encounter this in daily life? In a popular setting? This concept is everywhere, even inclusions as mentioned earlier are an instance. For the second question, enjoy listening to this lovely musical group –they use the words ‘forgetful functors’ ;)

The remainder of this document can be seen as one fully-worked out example of constructing a free functor for the forgetful 𝒰 defined above from 𝒞𝒶𝓉 to 𝒢𝓇𝒶𝓅𝒽.

10 Designing Paths

The “right” definition is hard to obtain!

We can now define a ‘path’ of length n in a graph G to be a graph-map [ n ] ⟶ G. 

Path₀ : ℕ → Graph₀ → Set (ℓsuc ℓ₀)
Path₀ n G = [ n ]₀ 𝒢⟶₀ G

Unfolding the definition of graph-morphisms, this just says that a path of length n consists of a sequence [v₀, v₁, v₂, …, vₙ] of vertices of G and a sequence [e₀, e₁, …, eₙ₋₁] of edges of G with typing eᵢ : vᵢ ⟶ vᵢ₊₁.

The definition is pretty slick! However, as the name suggests, perhaps we can concatenate paths and it’s not at all clear how to do this for the vertex- and edge- morphisms of the graph-maps involved, whereas it’s immediately clear how to do this with sequences: We just concatenate the sequences and ensure the result is coherent.

Since the vertices can be obtained from the edges via src and tgt, we can dispense with them and use the definition as outlined above. 

open import Data.Vec using (Vec ; lookup)

record Path₁ (n : ℕ) (G : Graph₀) : Set (ℓsuc ℓ₀) where
  open Graph₀
  field
    edges     : Vec (E G) (suc n)
    coherency : {i : Fin n} → tgt G (lookup (` i) edges) ≡ src G (lookup (fsuc i) edges)

That is, edges [e₀, …, eₙ] with coherency tgt eᵢ ≡ src eᵢ₊₁.

Great, we’ve cut the definition of Path₀ in half but that fact that we get a raw list of edges and then need coherency to ensure that it is a well-formed path is still not terribly lovely. After all, we’re in Agda, we’re among kings, we should be able to form the list in such a way that the end result is a path. Let’s do that!

Enough of this repetition, let us fix a graph G, 

module Path-definition-2 (G : Graph₀) where
  open Graph₀ G

  mutual
    data Path₂ : Set where
      _!   : V → Path₂
      cons : (v : V) (e : E) (ps : Path₂) (s : v ≡ src e) (t : tgt e ≡ head₂ ps) → Path₂

    head₂ : Path₂ → V
    head₂ (v !) = v
    head₂ (cons v e p s t) = v

Defining paths for the parallel-pair approach to graphs leaves us with the need to carry proofs around, and this is a tad too clunky in this case. Let's try yet again. 

module Path-definition-3 (G : Graph) where

  open Graph G

  -- handy dandy syntax
  infixr 5 cons
  syntax cons v ps e = v ⟶[ e ]⟶ ps -- v goes, by e, onto path ps

  -- we want well-formed paths
  mutual
    data Path₃ : Set where
      _!   : (v : V) → Path₃
      cons : (v : V) (ps : Path₃) (e : v ⟶ head₃ ps) → Path₃

    head₃ : Path₃ → V
    head₃ (v !) = v
    head₃ (v ⟶[ e ]⟶ ps) = v

  -- motivation for the syntax declaration above
  example : (v₁ v₂ v₃ : V) (e₁ : v₁ ⟶ v₂) (e₂ : v₂ ⟶ v₃) → Path₃
  example v₁ v₂ v₃ e₁ e₂ = v₁ ⟶[ e₁ ]⟶ v₂ ⟶[ e₂ ]⟶ v₃ !

  end₃ : Path₃ → V
  end₃ (v !) = v
  end₃ (v ⟶[ e ]⟶ ps) = end₃ ps

  -- typed paths; squigarrowright
  record _⇝_ (x y : V) : Set where
    field
      path   : Path₃
      start  : head₃ path ≡ x
      finish : end₃ path  ≡ y

This seems great, but there’s always room for improvement:

  • Since the cons constructor's third argument depends on its first, we must use a syntax declaration to get the desired look. Such aesthetic is not only pleasing but reminiscent of diagrammatic paths; moreover, it’s guaranteed to be an actual path and not just an alternating lists of vertices and edges. Using the clunky Path₂, we’d write 

      v₁ ⟶[ v₁≈se₁ , e₁ , te₁≈v₂ ]⟶ v₂ ⟶[ v₂≈se₂ , e₂ , te₂≈v₃ ]⟶ v₃ !
  where
  syntax cons v e ps s t = v ⟶[ s , e , t ]⟶ ps

    yuck!

    Finally, the syntax-declaration does not make the emacs agda-mode auto-case using the syntax, and so I have to write it out by hand, each time I want to use the syntax.

  • Again since cons's third argument depends on the second argument, we need a mutual definition to extract the item of the dependence. Perhaps if we embed this item at the type level we may avoid the need of an auxiliary mutually-defined function.
  • By defining what the start and finish of a path are, we can assign types to it. However, this approach is reminiscent of the parallel-pair approach to graphs, as in Graph₀, which we argued is less preferable to the typed-approach to graphs. Perhaps defining paths with types by default, we can reap the benefits and simplicity of the typed-approach to graphs.
module TypedPaths (G : Graph) where

  open Graph G hiding(V)
  open Graph   using (V)

  data _⇝_ : V G → V G → Set where
    _!      : ∀ x → x ⇝ x
    _⟶[_]⟶_ : ∀ x {y ω} (e : x ⟶ y) (ps : y ⇝ ω) → x ⇝ ω

One might think that since we can write 

  src : {x y : V G} (e : x ⟶ y) → V G
  src {x} {y} e = x

we can again ignore vertices and it suffices to just keep a coherent list of edges. Then what is an empty path at a vertex? This’ enough to keep vertices around —moreover, the ensuing terms look like diagrammatic paths! Cool!

Finding this definitional form was a major hurdle in this endeavour.

10.1 Aside: An Adjunction between 𝒮ℯ𝓉 and 𝒞𝒶𝓉

With paths in hand, we can now consider a neat sequence of exercises :-)

  1. Show that graphmaps preserve paths: (f : G ⟶ H) → x ⇝ y → fᵥ x ⇝ fᵥ y; this is nothing more than type-preservation for f to be a functor 𝒫G ⟶ 𝒫H ;)

    Hint: This is lift from the next section.

  2. Define 

    a connected b  ≡  (a ⇝ b) ⊎ (b ⇝ a)  --  path “between” a and b; not ‘from a to b’.
  3. This is an equivalence relation whose equivalence classes are called the connected components of G; denote them by 𝒦G.
  4. For any category 𝒞, define 𝒦 𝒞 ≔ 𝒦 (𝒰₀ 𝒞) which is a subcategory of 𝒞.
  5. Phrase the connected components subcategory using a universal property, thereby avoiding the need for quotient types.
  6. Since graphmaps preserve paths, every graph map can be extended to connected components, 𝒦f : 𝒦G ⟶ 𝒦H : (connected component of x) ↦ (connected component of fᵥ x).
  7. Hence, we have a functor 𝒦 : Graph ⟶ Set.

  8. Then there is a natural transformation 𝒱 ⟶ 𝒦, where 𝒱 is the vertices functor.

    Hint: Such a transformation means we can realise vertices as connected components and this suggests taking assigning a vertex to the connected-component block that contains it.

    yeah!

Finally, if we let 𝒟 : 𝒮ℯ𝓉 → 𝒞𝒶𝓉 be the free category functor that associates each set with the discrete category over it, then we have 𝒦 is the associated forgetful functor.

10.2 Equality Combinators for Paths

Here's a handy-dandy combinator for forming certain equality proofs of paths. 

  -- Preprend preserves path equality
  ⟶-≡ : ∀{x y ω} {e : x ⟶ y} {ps qs : y ⇝ ω}
      → ps ≡ qs → (x ⟶[ e ]⟶ ps) ≡ (x ⟶[ e ]⟶ qs)
  ⟶-≡ {x} {y} {ω} {e} {ps} {qs} eq = ≡-cong (λ r → x ⟶[ e ]⟶ r) eq

Less usefully, we leave as exercises: 

  edges : ∀ {x ω} (p : x ⇝ ω) → List (Σ s ∶ V G • Σ t ∶ V G • s ⟶ t)
  edges = {! exercise !}

  path-eq : ∀ {x y} {p q : x ⇝ y} → edges p ≡ edges q → p ≡ q
  path-eq = {! exercise !}

Given time, path-eq could be rewritten so as to be more easily applicable. For now, two path equality proofs occur in the document and both are realised by quick-and-easy induction.

10.3 Category of paths over a graph

Now we turn back to the problem of catenating two paths. 

  infixr 5 _++_

  _++_ : ∀{x y z} → x ⇝ y → y ⇝ z → x ⇝ z
  x ! ++ q           = q                         -- left unit
  (x ⟶[ e ]⟶ p) ++ q = x ⟶[ e ]⟶ (p ++ q)     -- mutual-associativity

Notice that the the base case indicate that ! forms a left-unit for ++, while the inductive case says that path-formation associates with path catenation. Both observations also hold for the definition of list catenation ;-)

If we had not typed our paths, as in Path₂, we would need to carry around a proof that paths are compatible for concatenation: 

  catenate : (p q : Path) (coh : end p ≡ head q) → Path
  syntax catenate p q compatibility = p ++[ compatibility ] q

Even worse, to show p ++[ coh ] q ≡ p ++[ coh’ ] q we need to invoke proof-irrelevance of identity proofs to obtain coh ≡ coh’, each time we want such an equality! Moving the proof obligation to the type level removes this need.

As can be seen, being type-less is a terrible ordeal.

Just as the first clause of _++_ indicates _! is a left unit, 

  leftId : ∀ {x y} {p : x ⇝ y} → x ! ++ p ≡ p
  leftId = ≡-refl

Is it also a right identity? 

  rightId : ∀ {x y} {p : x ⇝ y} → p ++ y ! ≡ p
  rightId {x} {.x} {.x !} = ≡-refl
  rightId {x} {y } {.x ⟶[ e ]⟶ ps} = ≡-cong (λ q → x ⟶[ e ]⟶ q) rightId

Is this operation associative? 

  assoc : ∀{x y z ω} {p : x ⇝ y} {q : y ⇝ z} {r : z ⇝ ω}
        → (p ++ q) ++ r ≡ p ++ (q ++ r)
  assoc {x} {p = .x !} = ≡-refl
  assoc {x} {p = .x ⟶[ e ]⟶ ps} {q} {r} = ≡-cong (λ s → x ⟶[ e ]⟶ s) (assoc {p = ps})

Hence, we’ve shown that the paths over a graph G constitute a category! Let’s call it 𝒫 G.

10.4 The 𝒫ath to freedom

In the last section, we showed that the paths over a graph make a category, 

𝒫₀ : Graph → Category
𝒫₀ G = let open TypedPaths G in
    record
      { Obj     = Graph.V G
      ; _⟶_     = _⇝_
      ; _⨾_     = _++_
      ; assoc   = λ {x y z ω p q r} → assoc {p = p}
      ; Id      = λ {x} → x !
      ; leftId  = leftId
      ; rightId = rightId
      }

Can we make 𝒫 into a functor by defining it on morphisms? That is, to lift graph-maps to category-maps, i.e., functors. 

𝒫₁ : ∀ {G H} → GraphMap G H → Functor (𝒫₀ G) (𝒫₀ H)
𝒫₁ {G} {H} f = record
    { obj  = ver f
    ; mor  = amore
    ; id   = ≡-refl
    ; comp = λ {x} {y} {z} {p} → comp {p = p}
    }
    where
      open TypedPaths ⦃...⦄ public
      instance G' : Graph ; G' = G
               H' : Graph ; H' = H

      amore : {x y : Graph.V G} →  x ⇝ y → (ver f x) ⇝ (ver f y)
      amore (x !) = ver f x !
      amore (x ⟶[ e ]⟶ p) = ver f x ⟶[ edge f e ]⟶ amore p

      comp : {x y z : Graph.V G} {p : x ⇝ y} {q : y ⇝ z}
          →  amore (p ++ q)  ≡  amore p ++ amore q
      comp {x} {p = .x !} = ≡-refl    -- since ! is left unit of ++
      comp {x} {p = .x ⟶[ e ]⟶ ps} = ⟶-≡ (comp {p = ps})

Sweet!

With these two together, we have that 𝒫 is a functor. 

𝒫 : Functor 𝒢𝓇𝒶𝓅𝒽 𝒞𝒶𝓉
𝒫 = record { obj   = 𝒫₀
            ; mor  = 𝒫₁
            ; id   = λ {G} → funcext ≡-refl (id ⦃ G ⦄)
            ; comp = funcext ≡-refl comp
            }
    where
      open TypedPaths ⦃...⦄
      open Category   ⦃...⦄

      module 𝒞𝒶𝓉   = Category 𝒞𝒶𝓉
      module 𝒢𝓇𝒶𝓅𝒽 = Category 𝒢𝓇𝒶𝓅𝒽

      id : ∀ ⦃ G ⦄ {x y} {p : x ⇝ y}
        →   mor (𝒞𝒶𝓉.Id {𝒫₀ G}) p  ≡  mor (𝒫₁ (𝒢𝓇𝒶𝓅𝒽.Id)) p
      id {p = x !} = ≡-refl
      id {p = x ⟶[ e ]⟶ ps} = ⟶-≡ (id {p = ps})

      comp : {G H K : Graph} {f : GraphMap G H} {g : GraphMap H K}
           → {x y : Graph.V G} {p : TypedPaths._⇝_ G x y}
           →  mor (𝒫₁ f 𝒞𝒶𝓉.⨾ 𝒫₁ g) p  ≡  mor (𝒫₁ (f 𝒢𝓇𝒶𝓅𝒽.⨾ g)) p
      comp {p = x !} = ≡-refl
      comp {p = x ⟶[ e ]⟶ ps} = ⟶-≡ (comp {p = ps})

It seemed prudent in this case to explicitly delimit where the compositions lives —this is for clarity, since Agda can quickly resolve the appropriate category instances.

Exercise: Show that we have a natural transformation Id ⟶ 𝒰 ∘ 𝒫.

11 Free at last

Free at last, free at last, thank God almighty we are free at last.

– Martin Luther King Jr.

Recall why lists give the ‘free monoid’: We can embed a type \(A\) into \(\List A\) by the map \([\_{}]\), and we can lift any map \(f : A ⟶ B\) to a monoid map \[\foldr \; (λ a b → f\, a ⊕ b)\; e \;:\; (\List A ,\_{}++\_{} , []) \,⟶\, (B,\_{}⊕\_{} , e)\] I.e., \([a₁, …, aₖ] \;↦\; f\, a₁ ⊕ ⋯ ⊕ f\, aₖ\). Moreover this ‘preserves the basis’ \(A\) – i.e., \(∀ a •\; f\, a \,=\, \foldr \,f \,e \, [ a ]\) – and this lifted map is unique.

Likewise, let us show that \(𝒫G\) is the ‘free category’ over the graph \(G\). This amounts to saying that there is a way, a graph-map, say \(ι\), that embeds \(G\) into \(𝒫G\), and a way to lift any graph-map \(f \,:\, G \,𝒢⟶\, 𝒰₀ 𝒞\) to a functor \(\mathsf{lift}\, f : 𝒫G ⟶ 𝒞\) that ‘preserves the basis’ \(f \;=\; ι ⨾ 𝒰₁ (\mathsf{lift}\, f)\) and uniquely so.

Let’s begin! 

module freedom (G : Obj 𝒢𝓇𝒶𝓅𝒽) {𝒞 : Category {ℓ₀} {ℓ₀} } where

  open TypedPaths G using (_! ; _⟶[_]⟶_ ;  _⇝_ ; _++_)
  open Category ⦃...⦄

  module 𝒢𝓇𝒶𝓅𝒽 = Category 𝒢𝓇𝒶𝓅𝒽
  module 𝒮ℯ𝓉 = Category (𝒮e𝓉 {ℓ₀})
  module 𝒞 = Category 𝒞
  instance 𝒞′ : Category ; 𝒞′ = 𝒞

11.1 Defining the needed operations

The only obvious, and most natural, way to embed a graph into its ‘graph of paths’ is to send vertices to vertices and edges to paths of length 1. 

  ι : G ⟶ 𝒰₀ (𝒫₀ G)
  ι = record { ver = Id ; edge = λ {x} {y} e  →  x ⟶[ e ]⟶ (y !) }

Given a graph map \(f\), following the list-analagoue of \([a₁, …, aₖ] \;↦\; f\, a₁ ⊕ ⋯ ⊕ f\, aₖ\) we attempt to lift the map onto paths by taking the edges \(e₁, …, eₖ\) of a path to a morphism \(\edge\, f\, e₁ ⨾ ⋯ ⨾ \edge\, f\, eₖ\). That is, a path of the form \[x_0 \xrightarrow{e_1} x_1 \xrightarrow{e_2} x_2 \xrightarrow{e_3} ⋯ \xrightarrow{e_k} x_k \] Is lifted to the composition of morphisms \[\mathsf{ver}\, f\, x_0 \xrightarrow{\edge\, f\, e_1} \mathsf{ver}\, f\, x_1 \xrightarrow{\edge\, f\, e_2} \mathsf{ver}\, f\, x_2 \xrightarrow{\edge\, f\, e_3} ⋯ \xrightarrow{\edge\, f\, e_k} \mathsf{ver}\, f\, x_k \]

Of course, we then need to verify that this construction is indeed functorial. 

  lift : G ⟶ 𝒰₀ 𝒞  →  𝒫₀ G ⟶ 𝒞
  lift f = record
     { obj  = λ v → ver f v -- Only way to obtain an object of 𝒞; hope it works!
     ; mor  = fmap
     ; id   = ≡-refl
     ; comp = λ {x y z p q} → proof {x} {y} {z} {p} {q}
     }
     where
          fmap : ∀ {x y} → x ⇝ y → ver f x 𝒞.⟶ ver f y
          fmap (y !) = 𝒞.Id
          fmap (x ⟶[ e ]⟶ p) = edge f e 𝒞.⨾ fmap p

          -- homomorphism property
          proof : ∀{x y z} {p : x ⇝ y} {q : y ⇝ z} → fmap (p ++ q) ≡ fmap p 𝒞.⨾ fmap q
          proof {p = ._ !} = ≡-sym 𝒞.leftId
          proof {p = ._ ⟶[ e ]⟶ ps} =  ≡-cong (λ m → edge f e 𝒞.⨾ m) (proof {p = ps})
                                     ⟨≡≡⟩ ≡-sym assoc
                                     -- Exercise: Rewrite this calculationally!

Now we have the embedding and the lifting, it remains to show that the aforementioned ‘preserves basis’ property holds as does uniqueness.

11.2 Realising the proof-obligations

Let's begin with the ‘basis preservation’ property: 

  property : ∀{f : G ⟶ 𝒰₀ 𝒞}  →  f  ≡  (ι 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ (lift f))
  property {f} = graphmapext
    -- Proving: ∀ {v} → ver f v ≡ ver (ι 𝒞.⨾ 𝒰₁ (lift f)) v
    -- by starting at the complicated side and simplifying
    (λ {v} → ≡-sym (begin
              ver (ι 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ (lift f)) v
            ≡⟨" definition of ver on composition "⟩′
              (ver ι 𝒮ℯ𝓉.⨾ ver (𝒰₁ (lift f))) v
            ≡⟨" definition of 𝒰₁ says: ver (𝒰₁ F) = obj F "⟩′
              (ver ι 𝒮ℯ𝓉.⨾ obj (lift f)) v
            ≡⟨" definition of lift says: obj (lift f) = ver f "⟩′
              (ver ι 𝒮ℯ𝓉.⨾ ver f) v
            ≡⟨" definition of ι on vertices is identity "⟩′
              ver f v
            ∎))

    -- Proving: edge (ι ⨾g 𝒰₁ (lift f)) e ≡ edge f e
    (λ {x} {y} {e} → begin
               edge (ι 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ (lift f)) e
             ≡⟨" definition of edge on composition "⟩′
               (edge ι 𝒮ℯ𝓉.⨾ edge (𝒰₁ (lift f))) e
             ≡⟨" definition of 𝒰 says: edge (𝒰₁ F) = mor F "⟩′
               (edge ι 𝒮ℯ𝓉.⨾ mor (lift f)) e
             ≡⟨" definition chasing gives: mor (lift f) (edge ι e) = edge f e ⨾ Id "⟩′
               edge f e 𝒞.⨾ Id
             ≡⟨ 𝒞.rightId ⟩
               edge f e
             ∎)

Observe that we simply chased definitions and as such graphmapext ≡-refl rightId suffices as a proof, but it’s not terribly clear why, for human consumption, and so we choose to elaborate with the detail.

Finally, it remains to show that there is a unique way to preserve ‘basis’: 

  uniqueness : ∀{f : G ⟶ 𝒰₀ 𝒞} {F : 𝒫₀ G ⟶ 𝒞} → f ≡ (ι 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F) → lift f ≡ F
  uniqueness {.(ι 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F)} {F} ≡-refl = funcext ≡-refl (≡-sym pf)
    where
      pf : ∀{x y} {p : x ⇝ y} →  mor (lift (ι 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F)) p  ≡  mor F p
      pf {x} {.x} {p = .x !} = ≡-sym (Functor.id F)
      pf {x} {y} {p = .x ⟶[ e ]⟶ ps} = begin
         mor (lift (ι 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F)) (x ⟶[ e ]⟶ ps)
       ≡⟨" definition of mor on lift, the inductive clause "⟩′
         edge (ι 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F) e 𝒞.⨾ mor (lift (ι 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F)) ps
       ≡⟨ ≡-cong₂ 𝒞._⨾_ ≡-refl (pf {p = ps}) ⟩ -- inductive step
         edge (ι 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F) e 𝒞.⨾ mor F ps
       ≡⟨" definition of edge says it preserves composition "⟩′
         (edge ι 𝒮ℯ𝓉.⨾ edge (𝒰₁ F)) e 𝒞.⨾ mor F ps
       ≡⟨" definition of 𝒰 gives: edge (𝒰₁ F) = mor F "⟩′
         (edge ι 𝒮ℯ𝓉.⨾ mor F) e 𝒞.⨾ mor F ps
       ≡⟨" definition of functional composition 𝒮ℯ𝓉 "⟩′
          mor F (edge ι e) 𝒞.⨾ mor F ps
       ≡⟨ ≡-sym (Functor.comp F) {- i.e., functors preserve composition -} ⟩
          mor F (edge ι e ++ ps)
       ≡⟨" definition of embedding and concatenation "⟩′
         mor F (x ⟶[ e ]⟶ ps)
       ∎

Challenge: Define graph-map equality ‘≈g’ by extensionality –two graph maps are equal iff their vertex and edge maps are extensionally equal. This is far more relaxed than using propositional equality ‘≡’. Now show the stronger uniqueness claim: 

∀{f : G ⟶ 𝒰₀ 𝒞} {F : 𝒫₀ G ⟶ 𝒞}   →   f  ≈g  (ι ⨾ 𝒰₁ F)   →   lift f  ≡  F

11.3 Another freedom proof

However, saying each graph-map gives rise to exactly one unique functor is tantamount to saying the type GraphMap G (𝒰₀ 𝒞) is isomorphic to Functor (𝒫₀ G) 𝒞, that is (𝒫₀ G ⟶ 𝒞) ≅ (G ⟶ 𝒰₀ 𝒞) —observe that this says we can ‘move’ 𝒫₀ from the left to the right of an arrow at the cost of it (and the arrow) changing.

A few healthy exercises, 

  lift˘ : Functor 𝒫G 𝒞 → GraphMap G (𝒰₀ 𝒞)
  lift˘ F = ι ⨾g 𝒰₁ F  --  i.e., record {ver = obj F , edge = mor F ∘ edge ι}

  rid : ∀{f : GraphMap G (𝒰₀ 𝒞)} → ∀{x y} {e : x ⟶g y} → lift˘ (lift f) ≡ f
  rid = {! exercise !}

  lid : ∀{F : Functor 𝒫G 𝒞} → lift (lift˘ F) ≡ F
  lid = {! exercise !}

One can of course obtain these proofs from the other ones without recourse to definitions, however for comprehension one would do well to prove them from first principles. The worked out solutions are available in the literate source file of this document.

We can then provide an alternative, and more succinct, proof of uniqueness for ‘basis preservation’: 

  uniqueness’  :  ∀{f h}   →    f  ≡  (ι 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ h)   →   lift f  ≡  h
  uniqueness’ {f} {h} f≈ι⨾𝒰₁h = begin
      lift f
    ≡⟨ ≡-cong lift f≈ι⨾𝒰₁h ⟩
      lift (ι 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ h)
    ≡⟨" definition of lift˘ "⟩′
      lift (lift˘ h)
    ≡⟨ lid ⟩
      h
    ∎

The difference between this proof and the original one is akin to the difference between heaven and earth! That or it's much more elegant ;-)

11.4 𝒫 ⊣ 𝒰

Thus far, we have essentially shown \[(𝒫₀\, G \,⟶\, 𝒞) \quad≅\quad (G \,⟶\, 𝒰₀\, 𝒞)\] We did so by finding a pair of inverse maps: 

lift   :  (    G ⟶ 𝒰₀ 𝒞)  →  (𝒫₀ G ⟶     𝒞)
lift˘  :  (𝒫₀ G  ⟶    𝒞)  →  (   G ⟶  𝒰₀ 𝒞)

This is nearly 𝒫 ⊣ 𝒰 which implies 𝒫 is a ‘free-functor’ since it is left-adjoint to a forgetful-functor.

‘Nearly’ since we need to exhibit naturality: For every graph map g and functors F, k we have lift˘ (𝒫 g ⨾ k ⨾ F) ≈ g ⨾ lift˘ k ⨾ 𝒰 F in the category of graphs.

Fokkinga (Theorem A.4), among others, would call these laws ‘fusion’ instead since they inform us how to compose, or ‘fuse’, a morphism with a lift˘-ed morphism: Taking F to be the identity and remembering that functors preserve identities, we have that g ⨾ lift˘ K ≡ lift˘( 𝒫₁ g ⨾ K) –we can push a morphism into a lift˘ at the cost of introducing a 𝒫₁; dually for lift-ed morphisms.

First the setup, 

module _ {G H : Graph} {𝒞 𝒟 : Category {ℓ₀} {ℓ₀}}
          (g : GraphMap G H) (F : Functor 𝒞 𝒟) where

  private
    lift˘ = λ {A} {C} B → freedom.lift˘ A {C} B
    lift = λ {A} {C} B → freedom.lift A {C} B
  open Category ⦃...⦄

  module 𝒞     = Category 𝒞
  module 𝒟     = Category 𝒟
  module 𝒢𝓇𝒶𝓅𝒽 = Category 𝒢𝓇𝒶𝓅𝒽
  module 𝒞𝒶𝓉   = Category (𝒞𝒶𝓉 {ℓ₀} {ℓ₀})
  module 𝒮ℯ𝓉   = Category (𝒮e𝓉 {ℓ₀})

Just as we needed to prove two inverse laws for lift and lift˘, we need two naturality proofs. 

  naturality˘ : ∀ {K : Functor (𝒫₀ H) 𝒞}
              →  lift˘ (𝒫₁ g 𝒞𝒶𝓉.⨾ K 𝒞𝒶𝓉.⨾ F)  ≡  (g 𝒢𝓇𝒶𝓅𝒽.⨾ lift˘ K 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F)
  naturality˘ = graphmapext ≡-refl ≡-refl

That was easier than assumed! Hahaha: Hard to formalise but so easy to prove lolz! It says we can ‘shunt’ lift˘ into certain compositions at the cost of replacing functor instances.

Now for the other proof: 

  naturality : ∀ {k : GraphMap H (𝒰₀ 𝒞)} →     lift (g 𝒢𝓇𝒶𝓅𝒽.⨾ k 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F)
                                              ≡  (𝒫₁ g 𝒞𝒶𝓉.⨾ lift k 𝒞𝒶𝓉.⨾ F)
  naturality {k} = funcext ≡-refl (λ {x y p} → proof {x} {y} {p})
    where
      open TypedPaths ⦃...⦄
      instance G′ : Graph ; G′ = G
               H′ : Graph ; H′ = H
      proof : ∀ {x y : Graph.V G} {p : x ⇝ y}
            →    mor (𝒫₁ g 𝒞𝒶𝓉.⨾ lift {H} {𝒞} k 𝒞𝒶𝓉.⨾ F) p
               ≡  mor (lift {G} {𝒟} (g 𝒢𝓇𝒶𝓅𝒽.⨾ k 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F)) p
      proof {p = _ !} = functor (𝒫₁ g 𝒞𝒶𝓉.⨾ lift {H} {𝒞} k 𝒞𝒶𝓉.⨾ F) preserves-identities
      proof {p = x ⟶[ e ]⟶ ps} = begin
            mor (𝒫₁ g 𝒞𝒶𝓉.⨾ lift {H} {𝒞} k 𝒞𝒶𝓉.⨾ F) (x ⟶[ e ]⟶ ps)
         ≡⟨" By definition, “mor” distributes over composition "⟩′
            (mor (𝒫₁ g) 𝒮ℯ𝓉.⨾ mor (lift {H} {𝒞} k) 𝒮ℯ𝓉.⨾ mor F) (x ⟶[ e ]⟶ ps)
         ≡⟨" Definitions of function composition and “𝒫₁ ⨾ mor” "⟩′
            mor F (mor (lift {H} {𝒞} k) (mor (𝒫₁ g) (x ⟶[ e ]⟶ ps)))
                                                  -- This explicit path is in G
         ≡⟨" Lifting graph-map “g” onto a path "⟩′
            mor F (mor (lift {H} {𝒞} k) (ver g x ⟶[ edge g e ]⟶ mor (𝒫₁ g) ps))
                                                  -- This explicit path is in H
         ≡⟨" Definition of “lift ⨾ mor” on inductive case for paths "⟩′
            mor F (edge k (edge g e) 𝒞.⨾ mor (lift {H} {𝒞} k) (mor (𝒫₁ g) ps))
         ≡⟨ functor F preserves-composition ⟩
                mor F (edge k (edge g e))
           𝒟.⨾  mor F (mor (lift {H} {𝒞} k) (mor (𝒫₁ g) ps))
         ≡⟨" Definition of function composition, for top part "⟩′
               (edge g 𝒮ℯ𝓉.⨾ edge k 𝒮ℯ𝓉.⨾ mor F) e  -- ≈ mor F ∘ edge k ∘ edge g
           𝒟.⨾ (mor (𝒫₁ g) 𝒮ℯ𝓉.⨾ mor (lift {H} {𝒞} k) 𝒮ℯ𝓉.⨾ mor F) ps
         ≡⟨" “𝒰₁ ⨾ edge = mor” and “edge” and “mor” are functorial by definition "⟩′
                edge (g 𝒢𝓇𝒶𝓅𝒽.⨾ k 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F) e
           𝒟.⨾  mor (𝒫₁ g 𝒞𝒶𝓉.⨾ lift {H} {𝒞} k 𝒞𝒶𝓉.⨾ F) ps
         ≡⟨ {- Inductive Hypothesis: -} ≡-cong₂ 𝒟._⨾_ ≡-refl (proof {p = ps}) ⟩
                edge (g 𝒢𝓇𝒶𝓅𝒽.⨾ k 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F) e
           𝒟.⨾  mor (lift {G} {𝒟} (g 𝒢𝓇𝒶𝓅𝒽.⨾ k 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F)) ps
         ≡⟨" Definition of “lift ⨾ mor” on inductive case for paths "⟩′
            mor (lift {G} {𝒟} (g 𝒢𝓇𝒶𝓅𝒽.⨾ k 𝒢𝓇𝒶𝓅𝒽.⨾ 𝒰₁ F)) (x ⟶[ e ]⟶ ps)
         ∎

Formally, we now have an adjunction: 

𝒫⊣𝒰 : 𝒫 ⊣ 𝒰
𝒫⊣𝒰 = record{
    ⌊_⌋ = lift˘
  ; ⌈_⌉ = lift
  ; lid = lid
  ; rid = λ {G 𝒞 c} → rid {G} {𝒞} {c}
  ; lfusion = λ {G H 𝒞 𝒟 f F K} → naturality˘ {G} {H} {𝒞} {𝒟} f K {F}
  ; rfusion = λ {G H 𝒞 𝒟 f k F} → naturality {G} {H} {𝒞} {𝒟} f F {k} }
  where
    module _ {G : Graph} {𝒞 : Category} where open freedom G {𝒞} public

12 Folds Over Paths

Observe that for the freedom proof we recalled that ists determine a form of quantification, ‘folding’: given an operation ⊕, we may form the operation [x₁, …, xₖ] ↦ x₁ ⊕ ⋯ ⊕ xₖ. Then used that to define our operation lift, whose core was essentially, 

module folding (G : Graph) where
  open TypedPaths G
  open Graph G
                                              -- Given:
  fold : {X : Set} (v : V → X)               -- realise G's vertices as X elements
         (f : ∀ x {y} (e : x ⟶ y) → X → X) -- realise paths as X elements
       → (∀ {a b} → a ⇝ b → X)            -- Then: Any path is an X value
  fold v f (b !) = v b
  fold v f (x ⟶[ e ]⟶ ps) = f x e (fold v f ps)

For example, what is the length of a path? 

  length : ∀{x y} → x ⇝ y → ℕ
  length = fold (λ _ → 0)          -- single walks are length 0.
                (λ _ _ n → 1 + n)  -- edges are one more than the
                                    -- length of the remaining walk

Let’s verify that this is actually what we intend by the length of a path. 

  length-! : ∀{x} → length (x !) ≡ 0
  length-! = ≡-refl
  -- True by definition of “length”: The first argument to the “fold”

  length-ind : ∀ {x y ω} {e : x ⟶ y} {ps : y ⇝ ω}
            →  length (x ⟶[ e ]⟶ ps)  ≡  1 + length ps
  length-ind = ≡-refl
  -- True by definition of “length”: The second-argument to the “fold”

Generalising on length, suppose we have a ‘cost function’ c that assigns a cost of traversing an edge. Then we can ask what is the total cost of a path: 

  path-cost : (c : ∀{x y}(e : x ⟶ y) → ℕ) → ∀{x y}(ps : x ⇝ y) → ℕ
  path-cost c = fold (λ _ → 0)           -- No cost on an empty path.
                     (λ x e n → c e + n) -- Cost of current edge plus
                                          -- cost of remainder of path.

Now, we have length = path-cost (λ _ → 1): Length is just assigning a cost of 1 to each edge.

Under suitable conditions, list fold distributes over list catenation, can we find an analogue for paths? Yes. Yes, we can: 

  fold-++ :  ∀{X : Set} {v : V → X} {g : ∀ x {y} (e : x ⟶ y) → X}
          → (_⊕_ : X → X → X)
          → ∀{x y z : V} {p : x ⇝ y} {q : y ⇝ z}
          → (unitl : ∀{x y} → y ≡ v x ⊕ y)        -- Image of ‘v’ is left unit of ⊕
          → (assoc : ∀ {x y z} → x ⊕ (y ⊕ z) ≡ (x ⊕ y) ⊕ z )  -- ⊕ is associative
          → let f : ∀ x {y} (e : x ⟶ y) → X → X
                f = λ x e ps → g x e ⊕ ps
             in
               fold v f (p ++ q) ≡ fold v f p ⊕ fold v f q
  fold-++ {g = g} _⊕_ {x = x} {p = .x !} unitl assoc =  unitl
  fold-++ {g = g} _⊕_ {x = x} {p = .x ⟶[ e ]⟶ ps} unitl assoc =
    ≡-cong (λ exp → g x e ⊕ exp) (fold-++ _⊕_ {p = ps} unitl assoc) ⟨≡≡⟩ assoc

Compare this with the proof-obligation of lift.

12.1 Lists are special kinds of paths

We called our path catenation _++_, why the same symbol as that for list catenation?

How do we interpret a list over \(A\) as a graph? Well the vertices can be any element of \(A\) and an edge \(x ⟶ y\) merely indicates that ‘‘the item after \(x\) in the list is the element \(y\)’’, so we want it to be always true; or always inhabited without distinction of the inhabitant: So we might as well use a unit type. 

module lists (A : Set) where

  open import Data.Unit

  listGraph : Graph
  listGraph = record { V = A ; _⟶_ = λ a a’ → ⊤ }

I haven’t a clue if this works, you read my reasoning above.

The only thing we can do is test our hypothesis by looking at the typed paths over this graph. In particular, we attempt to show every non-empty list of \(A\)’s corresponds to a path. Since a typed path needs a priori the start and end vertes, let us construe List A ≅ Σ n ∶ ℕ • Fin n → A –later note that Path G ≅ Σ n ∶ ℕ • [n] 𝒢⟶ G. 

  open TypedPaths listGraph
  open folding listGraph

  -- Every non-empty list [x₀, …, xₖ] of A’s corresonds to a path x₀ ⇝ xₖ.
  toPath : ∀{n} (list : Fin (suc n) → A) →  list fzero ⇝ list (fromℕ n)
  toPath {zero} list = list fzero !
  toPath {suc n} list = list fzero ⟶[ tt ]⟶ toPath {n} (λ i → list(fsuc i))
    -- Note that in the inductive case, “list : Fin (suc (suc n)) → A”
    -- whereas “suc ⨾ list : Fin (suc n) → A”.
    --
    -- For example, if “list ≈ [x , y , z]” yields
    --          “fsuc ⨾ list ≈ [y , z ]” and
    --   “fsuc ⨾ fsuc ⨾ list ≈ [z]”.

Hm! Look at that, first guess and it worked! Sweet.

Now let’s realize the list fold as an instance of path fold, 

  -- List type former
  List = λ (X : Set) → Σ n ∶ ℕ • (Fin n → X)

  -- Usual list folding, but it's in terms of path folding.
  foldr : ∀{B : Set} (f : A → B → B) (e : B) → List A → B
  foldr f e (zero , l) = e
  foldr f e (suc n , l) = fold (λ a → f a e) (λ a _ rem → f a rem) (toPath l)

  -- example
  listLength : List A → ℕ -- result should clearly be “proj₁” of the list, anyhow:
  listLength = foldr
    (λ a rem → 1 + rem) -- Non-empty list has length 1 more than the remainder.
    0                    -- Empty list has length 0.

Let’s prepare for a more useful example 

  -- Empty list
  [] : ∀{X : Set} → List X
  [] = 0 , λ ()

  -- Cons for lists
  _∷_ : ∀{X : Set} → X → List X → List X
  _∷_ {X} x (n , l) = 1 + n , cons x l
    where
      -- “cons a l  ≈  λ i : Fin (1 + n) → if i ≈ 0 then a else l i”
      cons : ∀{n} → X → (Fin n → X) → (Fin (suc n) → X)
      cons x l fzero = x
      cons x l (fsuc i) = l i

  map : ∀ {B} (f : A → B) → List A → List B
  map f =  foldr (λ a rem → f a ∷ rem) []  -- looks like the usual map don’t it ;)

  -- list concatenation
  _++ℓ_ : List A → List A → List A
  l ++ℓ r = foldr _∷_ r l -- fold over ‘l’ by consing its elements infront of ‘r’

  -- Exercise: Write path catenation as a path-fold.

These few adventures would suggest that much of list theory can be brought over to the world of paths. It looks promising, let me know dear reader if you make progress on related explorations!

13 That was fun; Bye!

This note took longer to write than I had initally assumed; perhaps I should have taken into account

Hofstadter’s Law

It always takes longer than you expect, even when you take into account Hofstadter’s Law.

─Gödel, Escher, Bach: An Eternal Golden Braid

Lessons learned:

  • In Agda, Use implicits when possible in-favour of instance variables since the former can be inferred from the local context, whereas the latter must be resolved using the entire global context thereby incurring possibly more unification problems to solve thereby costing more time.
  • If you really want to learn something, teach it to someone: A proof assistant wont let you get away with skipping over anything!
  • Coming up with the right data representation for the tasks being tackled is a matter of discovery!

The astute reader may have noticed that the tone of writing sometimes changes drastically. This is because some of this article was written by me in March 2016 and I wished to preserve interesting writing style I then had –if anything to contrast with my now somewhat semi-formal style.

This article was motivated while I was reading Conceptual Mathematics for fun. One of the problems was to show that paths over a graph form a category and do so freely. It took me about 20 minutes on paper and pencil, but this resulting mechanisation took much more time –but it was also much more fun!

I had fun writing this up & I hope you enjoy it too :-)

Highly Recommended Read
The diligent reader may be interested to know that Maarten Fokkinga has written a very accessible and gentle introduction to category theory using the calculational approach.

( This article is not yet ‘done’, but good enough for now. )

Tags: category-theory agda types
Generated by Emacs and Org-mode (•̀ᴗ•́)و
 
]]> https://alhassy.github.io/PathCat.html https://alhassy.github.io/PathCat.html Mon, 24 Dec 2018 19:29:00 -0500 <![CDATA[Discovering Heyting Algebra]]>

  Ξ  

We attempt to motivate the structure of a Heyting Algebra by considering ‘inverse problems’.

For example,

  • You have a secret number \(x\) and your friend has a secret number \(y\), which you've communicated to each other in person.
  • You communicate a ‘message’ to each other by adding onto your secret number.
  • Hence, if I receive a number \(z\), then I can undo the addition operation to find the ‘message’ \(m = z - y\).

What if we decided, for security, to change our protocol from using addition to using minimum. That is, we encode our message \(m\) as \(z = x ↓ m\). Since minimum is not invertible, we decide to send our encoded messages with a ‘context’ \(c\) as a pair \((z, c)\). From this pair, a unique number \(m′\) can be extracted, which is not necessarily the original \(m\). Read on, and perhaps you'll figure out which messages can be communicated 😉

This exploration demonstrates that relative pseudo-complements

  • Are admitted by the usual naturals precisely when infinity is considered a number;
  • Are exactly implication for the Booleans;
  • Internalises implication for sets;
  • Yield the largest complementary subgraph when considering subgraphs.

In some sense, the pseudo-complement is the “best approximate inverse” to forming meets, minima, intersections.

Along the way we develop a number of the theorems describing the relationships between different structural components of Heyting Algebras; most notably the internalisation of much of its own structure.

The article aims to be self-contained, however it may be helpful to look at this lattice cheat sheet (•̀ᴗ•́)و

( Photo by Ludovic Fremondiere on Unsplash )

1 Meet Semi-Lattices

Recall that an order is nothing more than a type \(Carrier\) with a relation \(\_⊑\_\) such that the following list of axioms holds: For any \(x,y,z : Carrier\),

\[\eqn{⊑-reflexive}{x ⊑ x}\]

\[\eqn{⊑-transitive}{x ⊑ y \landS y ⊑ z \impliesS x ⊑ z}\]

\[\eqn{⊑-antisymmetric}{x ⊑ y \landS y ⊑ x \impliesS x = y}\]

This models notions of containment, inclusion, hierarchy, and approximation.

Recall that a meet is an additional operation \(\_⊓\_\) specified by \[\eqnColour{Meet Characterisation}{ z \;⊑\; x ⊓ y \equivS z ⊑ x \landS z ⊑ y}{green}\]

Meets model notions of greatest lower bounds, or infima.

Observe that meets allow us to encode a pair of inclusions as a single inclusion! That is, an external conjunction \(∧\) is equivalent to an internal meet \(⊓\).

In computing parlance, think of a top-level ‘method’ that takes and yields data. In many languages, the method itself can be thought of as data! It is this kind of external-internal duality we are alluding to –and is captured nicely by exponential objects in category theory, of which we are considering a special case.

1.1 Examples

  • (ℕ, ≤, ↓) —where ↓ denotes minimum.
  • (ℕ, ∣, gcd) –the naturals ordered by divisibility.
  • (Sets, ⊆, ∩)
  • (𝔹, ⇒, ∧)
  • Formulae of a logic ordered by the proves, or syntactic consequence, relationship \(\_⊢\_\) with syntactic conjunction as meet.
  • (Sets, →, ×): Sets with “A atmost B” meaning there is a function \(f : A → B\), then the Cartesian product can be used as meet.
    • This is not strictly a semi-lattice, as defined here, but it is when we consider ‘setoids’.
    • Moreover it provides excellent intuition!
  • Subgraphs of a given simple graph \(G = (V,E)\) –which is just a relation \(E\) on a set of vertices \(V\).
    • The ordering is obtained by subset inclusion, \[(V₁, E₁) ⊑ (V₂, E₂) \equivS V₁ ⊆ V₂ \lands E₁ ⊆ E₂\] and so the meet is obtained by intersection, \[(V₁, E₁) ⊓ (V₂, E₂) = (V₁ ∩ V₂, E₁ ∩ E₂)\]

    • However, we cannot define complement in the same fashion, since the resulting relation is not over the resulting vertex set!

      Indeed suppose we define \(∼ (V′, E′) \;:=\; (V - V′, E - E′)\), then the discrete graph \((V, ø)\) has complement \((ø, E)\) which is a ‘graph’ with many edges \(E\) but no vertices! —Provided \((V,E)\) has edges.

      However, the edges can be relativised to the vertices to produce the pseudo-complement.

1.2 The Principle of Indirect Equality

It is not clear how \(\ref{Meet Characterisation}\) can be used to prove properties about meet.

The laws \ref{⊑-antisymmetric} and \ref{⊑-reflexive} can be fused together into one law: \[\eqnColour{Indirect Equality}{ x = y \equivS \left(∀ z \;•\quad ⊑\; z ⊑ x \equivs z ⊑ y\right)}{green}\]

That is, for all practical purposes, \(x = y\) precisely when they have the same sub-parts!

Using this, we can prove that meet is idempotent \(x ⊓ x = x\), symmetric \(x ⊓ y = y ⊓ x\), associative \(x ⊓ (y ⊓ z) = (x ⊓ y) ⊓ z\), and monotonic: \(a ⊑ b \landS c ⊑ d \impliesS a ⊓ c \sqleqS b ⊓ c\).

Below we use this principle in a number of places, for example \ref{Distributivity of → over ⊓}.

2 Relative Pseudo-complements

The relative pseudo-complement of \(a\) wrt \(b\), \((a ⟶ b)\), is “the largest element \(x\) that ensures modus ponens”, i.e., “the largest element \(x\) whose meet with \(a\) is contained in \(b\)”:

\[\eqnColour{Relative Pseudo-Complement Characterisation}{\hspace{-5em} a ⊓ x \;⊑\; b \equivS x \;⊑\; (a → b)}{green}\]

This is also sometimes denoted \(a ➩ b\) or \(a \backslash b\).

In five of the above settings this becomes,

  • \(m ↓ x ≤ n \equivS x ≤ (m → n)\)

    Not at all clear what to do so looking for a counterexample shows that pseduocomplements cannot exist for the naturals otherwise selecting \(m ≔ n\) yields:

    \begin{calc} ∀ x \;•\quad n ↓ x \;≤\; n \equivS x \;≤\; (n → n) \step{ Weakening: The minimum is at least both its arguments } ∀ x \;•\quad \mathsf{true} \equivS x \;≤\; (n → n) \step{ Identity of ≡ } ∀ x \;•\quad x \;≤\; (n → n) \step{ Definition of Infinity } (n → n) \;=\; +∞ \end{calc}

    Thus the existence of psquedo-complements implies the existence of a top element “\((n ⟶ n) = +∞\)”!

    Okay, no problem: Let's consider 𝒩, the set of natural numbers along with a new maximum element “+∞”; then we can define a relative pseudo-complement. \[\eqn{Definition of → for 𝒩}{m → n \quad=\quad \mathsf{if}\; m > n \;\mathsf{then}\; n \;\mathsf{else}\; +∞ \;\mathsf{fi}}\] We now have a way to approximate an inverse to minima, which is in general not invertible.

    –This definition works for any linear order with a top element—

  • \(p ∧ x ⇒ q \equivS x ⇒ (p → q)\)

    Starting with the right side,

    \begin{calc} x \impliesS (p → q) \step{ Characterisation of pseudo-complement } p ∧ x \impliesS q \step{ Symmetry of ∧ } x ∧ p \impliesS q \step{ Shunting } x \impliesS (p ⇒ q) \end{calc}

    Hence, by indirect equality, \(p → q \;=\; p ⇒ q \;=\; ¬ p ∨ q\).

  • \((A ∩ X) \;⊆\; B \equivS X \;⊆\; (A → B)\)

    Where we can similarly verify \((A → B) \;\;=\;\; ∼ A ∪ B\).

    It is interesting to note that \(x ∈ (A → B) \equivS x ∈ A \impliess x ∈ B\).

  • \(G ⊓ X \;⊑\; G′ \equivS X \;⊑\; (G → G′)\)

    We disclosed earlier that subgraph difference did not yield valid subgraphs, but if we relativised the resulting edge relationship to only consider the resulting vertex set, then we do have a subgraph.

    That is, subgraphs admit relative pseduo-complements, by \((V₁, E₁) → (V₂, E₂) \equivS (V₁ - V₂, (E₁ - E₂) ∩ (V₃ × V₃))\) where \(V₃ = V₁ - V₂\).

    The result of \(G₁ → G₂\) is the largest subgraph of \(G₁\) that does not overlap with \(G₂\).

  • \((A × B → C) \equivS A → (B → C)\)

    In the setting of functions, this says that a function taking a pair of inputs can be considered as a function that takes one input, of type \(A\), then yields another function that takes the second input. That is, the two inputs no longer need to be provided at the same time. This is known as currying.

  • \(P, Q ⊢ R \equivS P ⊢ (Q → R)\)

    In the logical formulae setting, the characterisation is known as the deduction theorem and allows us to ‘suppose’ an antecedent in the process of a proof.

In the above we have witnessed that the usual naturals admit pseudo-complements precisely when infinity is considered a number, that it is exactly implication for the Booleans, that it internalises implication for sets, and for subgraphs it is encodes the largest complementary subgraph.

In some sense, the pseudo-complement is the “best approximate inverse” to forming minima.

We leave the remaining example as an exercise 😉

3 Theorems — Generalising Observations from the Examples

Recall the \ref{Relative Pseudo-Complement Characterisation} says \[a ⊓ x \;⊑\; b \equivS x \;⊑\; (a → b)\]

We readily obtain some results by making parts of the characterisation true. E.g., making the left/right part true by instantiating the variables.

For example, taking \(x ≔ (a → b)\) yields \[\eqn{Modus Ponens}{a ⊓ (a → b) \quad⊑\quad b}\] Exercise: Prove this directly!

  • In the Boolean setting, this reads “if \(a\) is true and \(a\) implies \(b\), then \(b\) is true”.
  • In the functional setting, this reads “if \(f : A → B\) and we have an element \(a : A\), then we have an element \(f(a) \, : \, B\)”. In this setting, this operation is known as ‘evaluation’, or function application.

Using the principle of indirect equality, we can strengthen this into an equality and also obtain a close variant. \[\eqn{Strong Modus Ponens}{a ⊓ (a → b) \quad=\quad a ⊓ b}\]

\[\eqn{Absorption}{b ⊓ (a → b) \quad=\quad b}\]

\ref{Modus Ponens} suggest an order preservation property:

\begin{calc} a → x \quad⊑\quad a → y \step{ \ref{Relative Pseudo-Complement Characterisation} } a ⊓ (a → x) \quad⊑\quad y \stepWith{\Leftarrow}{ \ref{⊑-transitive} } a ⊓ (a → x) \quad⊑\quad x \landS x \quad⊑\quad y \step{ \ref{Modus Ponens} and Identity of ∧ } x \quad⊑\quad y \end{calc}

Hence we have derived the following consequent weakening rule, \[\eqn{Monotonicity₂}{a → x \quad⊑\quad a → y \qquad\Leftarrow\qquad x \;⊑\; y}\]

An immediate sequel is, \[\eqn{Weakening₂}{a → (x ⊓ y) \quad⊑\quad a → y}\]

Here are a few more properties for you to get familiar with this, the first three are immediate instantiation of the characterisation, while the fourth one may require using monotonicity properties of meet, and the final one uses indirect equality.

\[\eqn{Top Element}{x \quad⊑\quad a → a}\]

\[\eqn{Strengthening}{b \quad⊑\quad a → b}\]

\[\eqn{UnCurrying}{x \quad⊑\quad a → a ⊓ x}\]

\[\eqn{Weakening}{x \quad⊑\quad (a ⊓ b) → b}\]

\[\eqn{Antitonicity₁}{a → x \quad⊑\quad b → x \qquad\Leftarrow\qquad b \;⊑\; a}\]

\[\eqn{Self-Sub-Distributive}{a → (b → c) \sqleqS (a → b) → (a → c)}\]

Observe that, in the functional case, \ref{UnCurrying} says we have a function \[X → (A → (A × X)) \;\;:\;\; x \mapsto (a \mapsto (a, x))\]

4 → Furnishes ⊓

Recall \ref{Top Element} said that we have a greatest element in the order. Suppose our universe, \(Carrier\), is non-empty and has some element \(c₀\). Then we may define \(⊤ = (c₀ → c₀)\). This element is in-fact invariant over \(c₀\):

\[\eqn{Top Element Invariance}{ ∀ x \;•\quad ⊤ \quad=\quad (x → x) }\] The proof is simply an appeal to \ref{⊑-antisymmetric} then \ref{Top Element} twice.

From this, we obtain two immediate properties about meets.

\[\eqn{Identity of ⊓}{ x ⊓ ⊤ \quad=\quad x }\]

\[\eqn{Shunting}{x \;⊑\; a → (b → c) \equivS x \;⊑\; (a ⊓ b) → c}\]

Along with two properties about top element.

\[\eqn{Right Zero of →}{ x → ⊤ \quad=\quad ⊤ }\]

\[\eqn{Left Identity of →}{ ⊤ → x \quad=\quad x }\]

Notice that \ref{Right Zero of →} internalises what it means to be a \ref{Top Element}; namely \(∀ x \;•\; x ≤ ⊤\).

A bit more interestingly, we can fuse a meet with a pseudo-complement:

\[\eqn{Sub-mutual Associtivity of ⊓ and →}{\hspace{-3em}x ⊓ (a → b) \sqleqS (x ⊓ a) → b}\]

The converse of this statement is not true in general. In particular, in the presence of bottoms, the converse, \((x ⊓ a) → b \;\;⊑\;\; x ⊓ (a → b)\), implies that there is only one possible value: ⊥!

Exercise: Show that the converse statement implies \(⊥ = ⊤\) then from this conclude that \(x = ⊥\), for all \(x\).

5 Internalising ⊑ and ⊓

We have seen how relative pseudo-complements allowed us to reflect external characterisations such as \ref{Top Element} that use logical connectives into internal forms such as \ref{Right Zero of →} which only uses the symbols of the language, namely →, ⊓, ⊤.

Even the order, which takes two elements and yields a Boolean, can be internalised: \[\eqn{Internalising}{a ⊑ b \equivS (a → b) = ⊤}\]

Notice the striking resemblance to the \ref{Definition of → for 𝒩}!

\ref{Meet Characterisation} can also be internalised:

\begin{calc} x \sqleqS (a → c) \;⊓\; (a → b) \step{ \ref{Meet Characterisation} } x ⊑ (a → c) \landS x ⊑ (a → b) \step{ \ref{Relative Pseudo-Complement Characterisation} } a ⊓ x ⊑ c \landS a ⊓ x ⊑ b \step{ \ref{Meet Characterisation} } a ⊓ x \sqleqS c ⊓ b \step{ \ref{Relative Pseudo-Complement Characterisation} } x \sqleqS a → (c ⊓ b) \end{calc}

Hence, by the principle of \ref{Indirect Equality}, we have \[\eqn{Distributivity of → over ⊓}{ a → (c ⊓ b) \quad=\quad (a → c) \;⊓\; (a → b) }\]

6 Flipping the Inclusions Around

Recall \ref{Meet Characterisation} says \[ z \;⊑\; x ⊓ y \equivS z ⊑ x \landS z ⊑ y \] If we now mirror ‘⊑’ with ‘⊒’ we obtain –after renaming ⊓ with ⊔– \[ z \;⊒\; x ⊔ y \equivS z ⊒ x \landS z ⊒ y \] That is, we obtain upper bounds! \[\eqnColour{Join Characterisation}{ x ⊔ y \;⊑\; z \equivS x ⊑ z \landS y ⊑ z}{green}\]

Moreover, using →, it can be shown that joins and meets distribute over each other.

\[\eqn{Distributivity₁}{a \;⊔\; (b ⊓ c) \quad=\quad (a ⊔ b) \;⊓\; (a ⊔ c)}\] \[\eqn{Distributivity₂}{a \;⊓\; (b ⊔ c) \quad=\quad (a ⊓ b) \;⊔\; (a ⊓ c)}\]

7 Almost True Complements

Can we obtain the usual De Morgan's law?

Suppose we have a least element \(⊥ : Carrier\), i.e., for any \(x\), \[\eqn{Bottom Element}{ ⊥ \sqleqs x}\]

For usual ℕ, 𝔹, sets, and graphs this amounts to 0, \(\mathsf{false}\), \(\emptyset\), and the empty graph with no nodes nor any edges, respectively.

Unsurprising this can also be internalised! \[\eqn{ex falso quod libet}{⊥ → a \quad=\quad ⊤}\]

Moreover we can now define an operation \(¬\_\) as follows, \[\eqn{Pseudo-Complement Definition}{ ¬ x \quad=\quad (x → ⊥) }\]

A complement of an element \(x\) is an element \(y\) that is disjoint from \(x\) and together their join is the top element.

A pseudo-complement generalises this idea by discarding the second half of that conjunction; i.e., instead requiring a greatest element \(y\) disjoint from \(x\).

Indeed this is the case here,

\begin{calc} x \;⊓\; ¬ x \quad=\quad ⊥ \step{ \ref{⊑-antisymmetric} } (x \;⊓\; ¬ x) \sqleqs ⊥ \landS ⊥ \sqleqs (x \;⊓\; ¬ x) \step{ \ref{Bottom Element} } x \;⊓\; ¬ x \sqleqS ⊥ \step{ \ref{Modus Ponens} } \mathsf{true} \end{calc}

We now have the linguistic prerequisites to actually express De Morgan's laws. \[\eqn{Constructive De Morgan}{¬(x \;⊔\; y) \quad=\quad ¬ x \;⊓\; ¬ y}\]

The other form \(¬(x ⊓ y) \;=\; ¬ x ⊔ ¬ y\) however is not true in general. Likewise neither are double negation, \(¬¬x \;=\; x\), nor the law of the the excluded middle \(x \;⊔\; ¬ x \;=\; ⊤\).

Indeed for 𝒩, the natural numbers extended with +∞, the law of the exluded middle is falsified as follows:

\begin{calc} 3 ↑ ¬ 3 \step{ \ref{Pseudo-Complement Definition} } 3 ↑ (3 → 0) \step{ \ref{Definition of → for 𝒩} } 3 ↑ 0 \step{ Maximum } 3 \end{calc}

Likewise double negation is falsified by \(¬ ¬ 3 \;=\; 0\).

Exercise: Find an example to falsify the other De Morgan's law.

Having ⊓, ⊔, ⊥, ⊤, → together constitutes a Heyting Algebra.

8 So long and thanks for the fish

It took a while, but we've more or less shimmied our way to the structure needed for Heyting Algebras.

Hope you had fun!

Tags: order-theory category-theory
Generated by Emacs and Org-mode (•̀ᴗ•́)و
 
]]> https://alhassy.github.io/HeytingAlgebra.html https://alhassy.github.io/HeytingAlgebra.html Wed, 14 Nov 2018 19:29:00 -0500