Programming with Universal Mapping Properties

2021 James B. Wilson

Colorado State University

Academic Programmer's Quandry

Where to start?

What to make first?

Any "real-world" problem?

How to reuse what exists?

Can I publish a paper?

Is it "real-world" experience?

Is it math?

Can I teach it to a student?

Will my advisor understand?

Where's a proof?

When will it be useful?

How to finish it?

Will a math system take it?

FACT (Grace Hopper).

Programming is Math.

Programming Idioms: logic written in simulate human language

\[\forall x.(1\leq x\leq 5\Rightarrow ...)\]

Public Domain, original copyright (c) James S. Davis

for x in [1..5] ...

Programming "Idioma" Language

Collection of idioms that can

model a symbolic logic.

Theorem (Curry-Howard).

Propositions=Data Types

Proofs=Algorithms*

Prop. (Division Algorithm).

For every \(n\in \mathbb{N}, m\in \mathbb{N}^+\) there exists \(q\in \mathbb{N},r\in \mathbb{N}_{<m}\) where \[n=qm+r.\]

Proof.

def div(n:Nat,m:PosNat): (Nat,Fin m) = 
  if n < m then
    (0,n)
  else
    (1,0) + div(n-m,m)

By Gleb.svechnikov - Own work, CC BY-SA 4.0, https://commons.wikimedia.org/w/index.php?curid=58344593

William Howard

(no photo)

Haskell Curry

*So long as you phrase contradictions in the negative.

\(div:\mathbb{N}\times\mathbb{N}_{>0}\to \mathbb{N}\times \mathbb{N}_{<m}\)

Can be more precise:

\[\begin{aligned} div&:\mathbb{N}\times\mathbb{N}_{>0}\to \\ & \bigcup_{q\in \mathbb{N}}\bigcup_{r\in \mathbb{N}_{<m}} n=qm+r\end{aligned}\]

where \(n=qm+r\) is the type of data that proves equality (e.g. same place in memory; equal arithmetic circuits, etc.).

Types 101

Types are annotations to data that imply the data be used strictly by fixed rules.

E.g. Annotations

\[5\in \mathbb{Z}\qquad 5:\mathbb{Z}\qquad 5^{\mathbb{N}}\]

int x
x:Int
x // x is an integer.

Types are just documentation!

Some Prog. Lang. read these docs to double-check "type-check"; others assume the best and wait for a problem.

'5':Char, 2:Int means '5'+2 is an error;

5:Int, 2:Int allows 5+2.

Universal Mapping Properties (UMP) Yield Data Types

--- Borrow from context
import K:Comm, I:Type from Gamma
--- Make a new type
data Vec K I where ...

Free Module : FORMATION

\[\frac{K:Comm\qquad I:Set}{K^I:Type}\quad(F_{vec})\]

// Borrow from context
import K:Comm, I:Type from Gamma
// Make a new type
class Vec[K,I] { ... }

Procedural

Functional

\(K^I\)

\(I\)

\(\Gamma\vdash K,I\)

import K:Comm, I:Type from Gamma
data Vec K I where 
  Unit : {K:Comm} -> {I:Type} -> (i:I) -> (Unit K I)
  
> Unit Float (Fin 3) 2
Unit 2 : Unit Float (Fin 3)

Free Module : INTRODUCTION

\[\frac{i:I}{e_i:K^I}\quad(I_{e-vec})\]

import K:Comm, I:Type from Gamma
class Vec[K,I] 
case class Unit[K,I](i:I) extends Vec[K,I]

// e_2 in R^3
> e2 = new Unit[Float,range(3)](2)

Procedural

Functional

\(K^I\)

\(I\)

\(e\)

\(\Gamma\vdash K,I\)

import K:Comm, I:Type from Gamma
data Vec K I where 
  Unit : {K:Comm} -> {I:Type} -> (i:I) -> (Vec K I)
   Sum : (u:Vec K I) -> (v:Vec K I) -> (Vec K I)
   Scl : (a:K) -> (u:Vec K I) -> (Vec K I)

Free Module : IMPLICIT INTRODUCTIONS

\[\frac{a:K\qquad u:K^I}{a*u:K^I}\quad(I_{*-vec})\]

import K:Comm, I:Type from Gamma
class Vec[K,I] 
case class Unit[K,I](i:I) extends Vec[K,I]
case class Sum[K,I](u:Vec[K,I],v:Vec[K,I]) extends Vec[K,I]
case class Scl[K,I](a:K, u:Vec[K,I]) extends Vec[K,I]

Procedural

Functional

\[\frac{u,v:K^I}{u+v:K^I}\quad(I_{+-vec})\]

Multiple intros called "Inductive Type"

import K:Comm, I:Type from Gamma
data Vec K I where 
  Unit : (i:I) -> (Vec K I)
   Sum : (u:Vec K I) -> (v:Vec K I) -> (Vec K I)
   Scl : (a:K) -> (u:Vec K I) -> (Vec K I)

--- The Universal Mapping Property
umap:{U:Mod}->(Vec K I)->(f:I->U)->U

Free Module : ELIMINATION

import K:Comm, I:Type from Gamma
class Vec[K,I] {
  // Universal Mapping Property
  abstract def umap[U<:Mod[K]](f:I->U):U
}
case class Unit(i:I) extends Vec[K,I]
case class Sum(u:Vec[K,I],v:Vec[K,I]) extends Vec[K,I]
case class Scl(a:K, u:Vec[K,I]) extends Vec[K,I]

Procedural

Functional

\[\frac{v:K^I\quad U:{_K Mod}\quad f:I\to U}{\hat{f}(v):U}\quad(E_{vec})\]

\(K^I\)

\(I\)

\(e\)

\(U\)

\(\exists!\hat{f}\)

\(f\)

\(\Gamma\vdash K,I\)

import K:Comm, I:Type from Gamma
data Vec K I where 
  Unit : (i:I) -> (Vec K I)
   Sum : (u:Vec K I) -> (v:Vec K I) -> (Vec K I)
   Scl : (a:K) -> (u:Vec K I) -> (Vec K I)

umap:(U:Mod)->(Vec K I)->(f:I->U)->U
---Implement the computation
umap U (Unit i) f  = f i

Free Module : COMPUTATION

import K:Comm, I:Type from Gamma
class Vec[K,I] {
  abstract def umap[U<:Mod[K]](f:I->U):U
}
case class Unit(i:I) extends Vec[K,I] {
  // Implement the computation
  override def umap(f:I->U):U = f(i)
}
case class Sum(u:Vec[K,I],v:Vec[K,I]) extends Vec[K,I]
case class Scl(a:K, u:Vec[K,I]) extends Vec[K,I]

Procedural

Functional

\[\frac{i:I\quad U:{_K Mod}\quad f:I\to U}{\hat{f}(e_i)=f(i)}\quad(C_{e-vec})\]

\(K^I\)

\(I\)

\(e\)

\(U\)

\(\exists!\hat{f}\)

\(f\)

\(\Gamma\vdash K,I\)

import K:Comm, I:Type from Gamma
data Vec K I where 
  Unit : (i:I) -> (Vec K I)
   Sum : (u:Vec K I) -> (v:Vec K I) -> (Vec K I)
   Scl : (a:K) -> (u:Vec K I) -> (Vec K I)

--- The Universal Mapping Property
umap:(U:Mod)->(Vec K I)->(f:I->U)->U
umap U (Unit i) f  = f i
umap U (Sum x y) f = (umap U x f)+(umap U y f)
umap U (Scl a x) f = a*(umap U x f)

Free Module : IMPLICIT COMPUTATION

import K:Comm, I:Type from Gamma
class Vec[K,I] {
  abstract def umap[U<:Mod[K]](f:I->U):U
}
case class Unit(i:I) extends Vec[K,I] {
  override def umap(f:I->U):U = f(i)
}
case class Sum(u:Vec[K,I],v:Vec[K,I]) extends Vec[K,I] {
  override def umap(f:I->U):U = u.umap(f)+v.umap(f)
}
case class Scl(a:K, u:Vec[K,I]) extends Vec[K,I]{
  override def umap(f:I->U):U = a*u.umap(f)
}

Procedural

Functional

\[\frac{u,v:K^I\quad U:{_K Mod}\quad f:I\to U}{\hat{f}(u+v)=f(u)+f(v)}\quad(C_{+-vec})\]

\[\frac{a:K\quad v:K^I\quad U:{_K Mod}\quad f:I\to U}{\hat{f}(a*v)=a*f(v)}\quad(C_{*-vec})\]

Summary

Each UMP natural writes its own program.
Even polar opposite Programming Conventions look the same when implementing UMPs
The code is quite skinny.

That's a lousy solution

Under the hood

// [ 3.14159, 2.71828]
v = Sum( Scl(3.14159, Unit(1)), Scl(2.71828, Unit(2))

Bulky syntax, but that can be fixed with a function; let that go.

HEAP

type:"Scl099F"
a0001: 0000 0003, 0000 374F
v0001: 7F66 A008

type:"Tree07A2"
l0001: 7F66 9800
r0001: 7F66 A000

type:"class"
name:"Vec001B"
K2B01:"Float64"
I0458:"FinAA03"
meth1:"eval"
+p1:"func"<X,Y>
+p2:K2B01
-r:<Y>

type:"Vec001B"
K2B01:"Float64"
I0458:"FinAA03"

type:"class"
name:"Unit70E0"
sup:"Vect001B"

type:"Vec001B"
K2B01:"Float64"
I0458:"FinAA03"

type:"class"
name:"FinAA03"
I0001:0000 0003

    ....

type:"Unit07A2"
i0001: 0000 0001

type:"Unit07A2"
i0001: 0000 0002

type:"Scl099F"
a0001: 0000 0002, 0001 1894
v0001: 7F66 A001

type:"foo9056"
...

type:"foo9056"
...

type:"foo9056"
...

type:"bazEE01"
...

type:"Tree07A2"
l0001: 7F66 9805
r0001: 7F66 A001

type:"Tree07A2"
l0001: 7F66 9801
r0001: 7F66 98A2

    ....

What you intend

// [ 3.14159, 2.71828]
v = Sum( Scl(3.14159, Unit(1)), Scl(2.71828, Unit(2))

HEAP

type:"Tree07A2"
l0001: 7F66 9800
r0001: 7F66 A000

type:"class"
name:"Vec001B"
K2B01:"Float64"
I0458:"FinAA03"
meth1:"eval"
+p1:"func"<X,Y>
+p2:K2B01
-r:<Y>

type:"Vec001B"
K2B01:"Float64"
I0458:"FinAA03"

type:"class"
name:"Unit70E0"
sup:"Vect001B"

type:"Vec001B"
K2B01:"Float64"
I0458:"FinAA03"

type:"class"
name:"FinAA03"
I0001:0000 0003

    ....

type:"vev009E"

a0001: 0000 0003, 0000 374F
a0001: 0000 0002, 0001 1894

type:"foo9056"
...

type:"foo9056"
...

type:"foo9056"
...

type:"bazEE01"
...

type:"Tree07A2"
l0001: 7F66 9805
r0001: 7F66 A001

    ....

Many designs

Blocks: keeping data together that is used together
Packing: fill in the 0000
Packeting: Size data to move through machine fast.
Flyweights: scrapping headers
...branch predictions, precomputing, reusing ...

Our design is terrible

So why are we so smug?

Scenario

We made a free-module type: Vec
Engineers will make MUCH better ones: FastVec
PROBLEM: convert between them.

Mathematical detour

Prop. Any two free modules on \(I\) are naturally isomorphic.

Proof. Let \(\langle F_k, e^{(k)}:I\to F_k\rangle\) be free.

Then \(e^{(2)}:I\to F_2\) induces a linear map \(\hat{e}_2:F_1\to F_2\) and vice-versa \(\hat{e}^{(1)}:F_2\to F_1\). Furthermore \(\hat{e}_1\circ \hat{e}_2\circ e^{(1)}=e^{(1)}\). But so does the identity, so by uniqueness of UMP, \[\hat{e}_1\circ \hat{e}_2=id_{F_1}.\] Likewise if we reverse the composition. So these functions are isomorphisms.

Return to Code

Prop. Any two free modules on \(I\) are naturally isomorphic.

Proof. Let \(\langle F_k, e^{(k)}:I\to F_k\rangle\) be free.

PROOFS CARRY ALGORITHMIC CONTENT

(Curry-Howard Isomorphism Theorem)

Solution (from proof)

> my_u:MyVec[K,I] = ...
> f:I->YourVec[K,I] = i -> YourUnit[K,I](i)
> your_u = my_u.ump(f)

Prop. Any two free modules on \(I\) are naturally isomorphic.

Proof. Let \(\langle F_k, e^{(k)}:I\to F_k\rangle\) be free.

~~Then~~ \(e^{(2)}:I\to F_2\) induces a linear map \(\hat{e}_2:F_1\to F_2\) and vice-versa \(\hat{e}^{(1)}:F_2\to F_1\). ~~Furthermore \(\hat{e}_1\circ \hat{e}_2\circ e^{(1)}=e^{(1)}\). But so does the identity, so by uniqueness of UMP,~~ \[\hat{e}_1\circ \hat{e}_2=id_{F_1}.\] ~~Likewise if we reverse the composition. So these functions are isomorphisms.~~

Summary

Start with UMP, even a basic implementation
Later upgrades achieved automatically by UMP theory of essential uniqueness
Other UMP properties:
- Preserved under functors \(\Rightarrow\) Less re-programming.
- Unified naming/conventions \(\Rightarrow\) Less fatal style wars; easier to read other's work, easy to pass on.

Programming with Universal Mapping Properties

By James Wilson

Programming with Universal Mapping Properties

Using universal mapping properties to prescribe data types and using resulting theory to build useful algorithms.

Programming with Universal Mapping Properties

Academic Programmer's Quandry

FACT (Grace Hopper).

Programming is Math.

Theorem (Curry-Howard).

Propositions=Data Types

Proofs=Algorithms*

Types 101

Universal Mapping Properties (UMP) Yield Data Types

Summary

That's a lousy solution

Under the hood

What you intend

Many designs

Our design is terrible

So why are we so smug?

Scenario

Mathematical detour

Return to Code

Solution (from proof)

Summary

Programming with Universal Mapping Properties

More from James Wilson