Canonical Structures & Hierarchies

Anton Trunov

2021.04.29

Motivation

  • Generic comparison operation
  • x == y
eq_op : (T : Type) -> (x y : T) -> bool

Notation "x == y" := (eq_op _ x y).
  • eq_op is not possible to implement in general

Solution: eqType structure

Structure eqType := Pack {
  sort : Type;
  eq_op : sort -> sort -> bool;
  spec : forall x y,
           reflect (x = y) (eq_op x y)
}.

Solution: eqType structure

Inductive eqType :=
 Pack : forall
         (sort : Type)
         (eq_op : sort -> sort -> bool)
         (spec : forall x y,
           reflect (x = y) (eq_op x y)),
         eqType.

Definition sort (e : eqType) : Type :=
 let (sort, _, _) := e in sort.

(* and `eq_op` and `spec` projections *)

Solution: eqType structure

Structure eqType := Pack {
 sort : Type;
 eq_op : sort -> sort -> bool;
 spec : forall x y, reflect (x = y) (eq_op x y)
}.

Solution: eqType structure

Structure eqType := Pack {
 sort : Type;
 eq_op : sort -> sort -> bool;
 spec : forall x y, reflect (x = y) (eq_op x y)
}.


Coercion sort : eqType >-> Sortclass.

Solution: eqType structure

Structure eqType := Pack {
 sort : Type;
 eq_op : sort -> sort -> bool;
 spec : forall x y, reflect (x = y) (eq_op x y)
}.


Coercion sort : eqType >-> Sortclass.


Lemma eq_sym (T : eqType) (x y : T) :
  x == y -> y == x.

Solution: eqType structure

Structure eqType := Pack {
 sort : Type;
 eq_op : sort -> sort -> bool;
 spec : forall x y, reflect (x = y) (eq_op x y)
}.


Coercion sort : eqType >-> Sortclass.


Lemma eq_sym (T : eqType) (x y : sort T) :
  x == y -> y == x.

Solution: eqType structure

Structure eqType := Pack {
 sort : Type;
 eq_op : sort -> sort -> bool;
 spec : forall x y, reflect (x = y) (eq_op x y)
}.

eq_op : forall {T : eqType},
        sort T -> sort T -> bool

Example: 1 == 2

initially we have 

1 == 2

Example: 1 == 2

unfold == notation 

@eq_op _ 1 2        (* 1 == 2 *)

Example: 1 == 2

unfold == notation 

eq_op _ 1 2

@eq_op : forall (T : eqType),
        sort T -> sort T -> bool

Example: 1 == 2

add types and names 

eq_op (?T : eqType) (1 : sort ?T) (2 : sort ?T)

Example: 1 == 2

add types and names 

eq_op (?T : eqType) (1 : sort ?T) (2 : sort ?T)
eq_op (?T : eqType) (1 : nat)     (2 : nat)

Example: 1 == 2

so we need to be able to solve equations like 

sort (?T : eqType) ≡ nat
  • inference is undecidable in this case
  • we need hints for that

Canonical Structures to the rescue

Canonical nat_eqType := Pack nat eqn proof.
Print Canonical Projections.
...
nat <- sort ( nat_eqType )
...

Canonical Structures to the rescue

  • Or you can print out just the instances for your projection
Print Canonical Projections sort.

nat <- sort ( nat_eqType )

Example: 1 == 2


eq_op (?T : eqType) (1 : sort ?T) (2 : sort ?T)
eq_op (?T : eqType) (1 : nat)     (2 : nat)

Example: 1 == 2

nat <- sort ( nat_eqType )

eq_op (?T : eqType) (1 : sort ?T) (2 : sort ?T)
                         |             |
                         v             v
eq_op (?T : eqType) (1 : nat)     (2 : nat)

Example: 1 == 2

nat <- sort ( nat_eqType )

eq_op (nat_eqType : eqType)
      (1 : sort nat_eqType)
      (2 : sort nat_eqType)

Equality for product type

Definition pair_eq (A B : eqType)
                   (u v : A * B)
:= (u.1 == v.1) && (u.2 == v.2).

Equality for product type

Definition pair_eq (A B : eqType)
                   (u v : A * B)
:= (u.1 == v.1) && (u.2 == v.2).

Canonical prod_eqType A B :=
  Pack (A * B) pair_eq proof.

Equality for product type

Definition pair_eq (A B : eqType)
                   (u v : sort A * sort B)
:= (u.1 == v.1) && (u.2 == v.2).

Canonical prod_eqType A B :=
  Pack (sort A * sort B) pair_eq proof.

Equality for product type

Definition pair_eq (A B : eqType)
                   (u v : sort A * sort B)
:= (u.1 == v.1) && (u.2 == v.2).

Canonical prod_eqType A B :=
  Pack (sort A * sort B) pair_eq proof.

Print Canonical Projections sort.
nat <- sort ( nat_eqType )
prod <- sort ( prod_eqType )

Equality for product type

Definition pair_eq (A B : eqType)
                   (u v:prod (sort A) (sort B))
:= (u.1 == v.1) && (u.2 == v.2).

Canonical prod_eqType A B :=
  Pack (prod (sort A) (sort B)) pair_eq proof.

Print Canonical Projections sort.
nat <- sort ( nat_eqType )
prod <- sort ( prod_eqType )

Example

Canonical bool_eqType := Pack bool eqb proof.

Compute (1, true) == (1, true).

Example

Compute (1, true) == (1, true).
true

How does it work?

(1, true) == (1, true)

How does it work?

desugars into 

eq_op _ (1, true) (1, true)

How does it work?

eq_op : (?T : eqType) -> (x y:sort ?T) -> bool
eq_op   _                (1, true)  ...

How does it work?

eq_op : (?T : eqType) -> (x y:sort ?T) -> bool
eq_op   _                (1, true)  ...
                            ..
                         nat * bool

How does it work?

eq_op : (?T : eqType) -> (x y:sort ?T) -> bool
eq_op   _                (1, true)  ...
                            ..
                         nat * bool
sort ?T ≡ nat * bool

How does it work?

eq_op : (?T : eqType) -> (x y:sort ?T) -> bool
eq_op   _                (1, true)  ...
                            ..
                       prod nat bool
sort ?T ≡ prod nat bool

How does it work?

eq_op : (?T : eqType) -> (x y:sort ?T) -> bool
eq_op   _                (1, true)  ...
                            ..
                       prod nat bool
sort ?T ≡ prod nat bool
prod <- sort ( prod_eqType )

How does it work?

eq_op : (?T : eqType) -> (x y:sort ?T) -> bool
eq_op   _                (1, true)  ...
                            ..
                       prod nat bool
sort ?T ≡ prod nat bool
prod <- sort ( prod_eqType ) 
sort (prod_eqType ?A ?B) ≡ prod nat bool

How does it work?

eq_op : (?T : eqType) -> (x y:sort ?T) -> bool
eq_op   _                (1, true)  ...
                            ..
                       prod nat bool
sort ?T ≡ prod nat bool
prod <- sort ( prod_eqType ) 
sort (prod_eqType ?A ?B) ≡ prod nat bool
(sort ?A) * (sort ?B) ≡ prod nat bool

How does it work?

eq_op : (?T : eqType) -> (x y:sort ?T) -> bool
eq_op   _                (1, true)  ...
                            ..
                       prod nat bool
sort ?T ≡ prod nat bool
prod <- sort ( prod_eqType ) 
sort (prod_eqType ?A ?B) ≡ prod nat bool
prod (sort ?A) (sort ?B) ≡ prod nat bool

How does it work?

eq_op : (?T : eqType) -> (x y:sort ?T) -> bool
eq_op   _                (1, true)  ...
                            ..
                       prod nat bool
sort ?T ≡ prod nat bool
prod <- sort ( prod_eqType ) 
sort (prod_eqType ?A ?B) ≡ prod nat bool
prod (sort ?A) (sort ?B) ≡ prod nat bool
(sort ?A) ≡ nat         (sort ?B) ≡ bool

How does it work?

eq_op : (?T : eqType) -> (x y:sort ?T) -> bool
eq_op   _                (1, true)  ...
                            ..
                       prod nat bool
sort ?T ≡ prod nat bool
prod <- sort ( prod_eqType ) 
sort (prod_eqType ?A ?B) ≡ prod nat bool
prod (sort ?A) (sort ?B) ≡ prod nat bool
(sort ?A) ≡ nat         (sort ?B) ≡ bool
?A ≡ nat_eqType         ?B ≡ bool_eqType

Canonical Structures vs Typeclasses

  • Canonical Structures (CS) are coherent: one instance per key
  • Typeclasses (TC) are not coherent: there may be several instances for a given type (with priorities)

Canonical Structures vs Typeclasses

  • CS work at the unification level (predictable)
  • TC mechanism uses eauto-like proof search and may even loop forever

Canonical Structures vs Typeclasses

  • TC are keyed on types
  • CS are not tied to types and can be keyed on terms!

Canonical Structures vs Typeclasses

  • Both CS and TC can be used to implement overloading, implicit program (and proof) construction
  • Performance issues: experimental rewriting of MathComp with type classes did not scale up to modules on a ring

Keying on terms: big operations

Mathcomp's bigop module defines monoids like so: 

Module Monoid.
...
Structure law (T : Type) (idm : T) : Type :=
 Law
  { operator : T -> T -> T;
    _ : associative operator;
    _ : left_id idm operator;
    _ : right_id idm operator }.
...
End Monoid.

Keying on terms: big operations

  • Monoids are usually not unique for a given type

Here are some instances on nat: 

Canonical addn_monoid := Law addnA add0n addn0.
Canonical muln_monoid := Law mulnA mul1n muln1.
Canonical maxn_monoid := Law maxnA max0n maxn0.
  • Haskell works around this using newtype
  • Coq does not have to: it uses terms as keys

Keying on terms: big operations

operator is the key for canonical instances search 

Print Canonical Projections operator.

cat <- operator ( cat_monoid )
div.lcmn <- operator ( lcmn_monoid )
div.gcdn <- operator ( gcdn_monoid )
maxn <- operator ( maxn_monoid )
muln <- operator ( muln_monoid )
addn <- operator ( addn_monoid )
addb <- operator ( addb_monoid )
orb <- operator ( orb_monoid )
andb <- operator ( andb_monoid )

Keying on terms: demo

From mathcomp Require Import ssreflect ssrnat bigop.
Import Monoid.

Lemma foo m n p q r :
  m + (n + p * (q * r)) = m + n + p * q * r.
Proof.
by rewrite !mulmA /=.
Qed.

Demo time

Packed classes

  • Hierarchies of structures are formalized by nesting dependent records but naive approaches do not scale
  • Packed classes is one battle-tested alternative to telescopes

Packed classes: architecture

Structure structure := Pack {
  sort : Type;
  _ : class_of sort }.

Record class_of T := Class {
  base : Parent.class_of T;
  mixin : mixin_of T
}.

Record mixin_of T := Mixin {
  ...
}.

Packed classes

  • Allow multiple inheritance (as opposed to telescopes)
  • Maximal sharing of notations and theories
  • Automated structure inference
  • Solve performance issues

Disclaimer

  • I lied a bit about ordType earlier: it's parent is choiceType, not eqType

Hierarchy Builder

  • Pretty hard to extend a hierarchy in the middle
  • Solution: use Hierarchy Builder
  • HB: High level commands to declare a hierarchy based on packed classes
  • Warning: HB may not be stable at the moment

Hierarchy Builder

Definition eq_axiom T (e : rel T) :=
  forall x y, reflect (x = y) (e x y).

HB.mixin Record HasDecEq T :=
  { eq_op : rel T; eqP : eq_axiom eq_op }.

HB.structure Definition Equality :=
  { T of HasDecEq T }.

Generally useful Mathcomp hierarchy

  • eqType and subType
  • choiceType (e.g. finite maps on types with choice operator)
  • ordType

Further reading

Further reading

  • Packaging Mathematical Structures - G. Gonthier et al. (2009)
  • Generic Proof Tools and Finite Group Theory - F. Garillot (2011)
  • How to Make Ad Hoc Proof Automation Less Ad Hoc - A. Nanevski et al. (2013)
  • https://github.com/coq-community/lemma-overloading

Further reading

  • Hierarchy Builder: Algebraic Hierarchies Made Easy in Coq with Elpi - C. Cohen, K. Sakaguchi, E. Tassi (2020)
  • Validating Mathematical Structures - K. Sakaguchi (2020)
  • Competing Inheritance Paths in Dependent Type Theory: A Case Study in Functional Analysis - R. Affeldt, C. Cohen, M. Kerjean, A. Mahboubi, D. Rouhling, K. Sakaguchi (2020)
  • https://github.com/math-comp/hierarchy-builder