How To Program Equivalence

Higher Inductive Type Approach

2022 James B. Wilson

Colorado State University

 --- 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})$

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.~~

How To Program Equivalence Higher Inductive Type Approach 2022 James B. Wilson Colorado State University

How To Program Equivalence

Higher Inductive Type Approach

Recall:

An Inductive Type Is "Polynomials"

Polynomial=Induction

Summary

Technicalities

Idea:

A Quotient Type Is "Polynomials with rewriting rules"

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

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

	// Borrow from context
	import K:Comm, I:Type from Gamma
	// Make a new type
	class Vec[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)

	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)

	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

	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]

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

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