open import 1Lab.Reflection.Induction
open import 1Lab.Prelude

open import Data.Dec

open is-iso

module Data.Set.Coequaliser where

private variable
β β' : Level
A B A' B' A'' B'' : Type β


# Set coequalisersπ

In their most general form, colimits can be pictured as taking disjoint unions and then βgluing togetherβ some parts. The βgluing togetherβ part of that definition is where coequalisers come in: If you have parallel maps then the coequaliser can be thought of as β with the images of and identifiedβ.

data Coeq (f g : A β B) : Type (level-of A β level-of B) where
inc    : B β Coeq f g
glue   : β x β inc (f x) β‘ inc (g x)
squash : is-set (Coeq f g)


The universal property of coequalisers, being a type of colimit, is a mapping-out property: Maps from are maps out of satisfying a certain property. Specifically, for a map if we have then the map factors (uniquely) through inc. The situation can be summarised with the diagram below.

We refer to this unique factoring as Coeq-rec.

Coeq-rec
: β {β} {C : Type β} {f g : A β B} β¦ _ : H-Level C 2 β¦
β (h : B β C)
β (β x β h (f x) β‘ h (g x)) β Coeq f g β C
Coeq-rec h h-coeqs (inc x) = h x
Coeq-rec h h-coeqs (glue x i) = h-coeqs x i
Coeq-rec β¦ cs β¦ h h-coeqs (squash x y p q i j) =
hlevel 2 (g x) (g y) (Ξ» i β g (p i)) (Ξ» i β g (q i)) i j
where g = Coeq-rec β¦ cs β¦ h h-coeqs


An alternative phrasing of the desired universal property is precomposition with inc induces an equivalence between the βspace of maps which coequalise and β and the maps In this sense, inc is the universal map which coequalises and

To construct the map above, we used Coeq-elim-prop, which has not yet been defined. It says that, to define a dependent function from Coeq to a family of propositions, it suffices to define how it acts on inc: The path constructions donβt matter.

Coeq-elim-prop
: β {β} {f g : A β B} {C : Coeq f g β Type β}
β (β x β is-prop (C x))
β (β x β C (inc x))
β β x β C x
Coeq-elim-prop cprop cinc (inc x) = cinc x


Since C was assumed to be a family of propositions, we automatically get the necessary coherences for glue and squash.

Coeq-elim-prop {f = f} {g = g} cprop cinc (glue x i) =
is-propβpathp (Ξ» i β cprop (glue x i)) (cinc (f x)) (cinc (g x)) i
Coeq-elim-prop cprop cinc (squash x y p q i j) =
is-propβsquarep (Ξ» i j β cprop (squash x y p q i j))
(Ξ» i β g x) (Ξ» i β g (p i)) (Ξ» i β g (q i)) (Ξ» i β g y) i j
where g = Coeq-elim-prop cprop cinc

instance
Inductive-Coeq
: β {β βm} {f g : A β B} {P : Coeq f g β Type β}
β β¦ _ : Inductive (β x β P (inc x)) βm β¦
β β¦ _ : β {x} β H-Level (P x) 1 β¦
β Inductive (β x β P x) βm
Inductive-Coeq β¦ i β¦ = record
{ methods = i .Inductive.methods
; from    = Ξ» f β Coeq-elim-prop (Ξ» x β hlevel 1) (i .Inductive.from f)
}

Extensional-coeq-map
: β {β β' β'' βr} {A : Type β} {B : Type β'} {C : Type β''} {f g : A β B}
β β¦ sf : Extensional (B β C) βr β¦ β¦ _ : H-Level C 2 β¦
β Extensional (Coeq f g β C) βr
Extensional-coeq-map β¦ sf β¦ .Pathα΅ f g = sf .Pathα΅ (f β inc) (g β inc)
Extensional-coeq-map β¦ sf β¦ .reflα΅ f = sf .reflα΅ (f β inc)
Extensional-coeq-map β¦ sf β¦ .idsα΅ .to-path h = funext \$
elim! (happly (sf .idsα΅ .to-path h))
Extensional-coeq-map β¦ sf β¦ .idsα΅ .to-path-over p =
is-propβpathp (Ξ» i β Pathα΅-is-hlevel 1 sf (hlevel 2)) _ _


Since βthe space of maps which coequalise and β is a bit of a mouthful, we introduce an abbreviation: Since a colimit is defined to be a certain universal (co)cone, we call these Coeq-cones.

private
coeq-cone : β {β} (f g : A β B) β Type β β Type _
coeq-cone {B = B} f g C = Ξ£[ h β (B β C) ] (h β f β‘ h β g)


The universal property of Coeq then says that Coeq-cone is equivalent to the maps and this equivalence is given by inc, the βuniversal Coequalising mapβ.

Coeq-univ : β {β} {C : Type β} {f g : A β B} β¦ _ : H-Level C 2 β¦
β is-equiv {A = Coeq f g β C} {B = coeq-cone f g C}
(Ξ» h β h β inc , Ξ» i z β h (glue z i))
Coeq-univ {C = C} {f = f} {g = g} =
is-isoβis-equiv (iso cr' (Ξ» x β refl) islinv) where
cr' : coeq-cone f g C β Coeq f g β C
cr' (f , f-coeqs) = Coeq-rec f (happly f-coeqs)

islinv : is-left-inverse cr' (Ξ» h β h β inc , Ξ» i z β h (glue z i))
islinv f = trivial!


# Eliminationπ

Above, we defined what it means to define a dependent function when is a family of propositions, and what it means to define a non-dependent function Now, we combine the two notions, and allow dependent elimination into families of sets:

Coeq-elim : β {β} {f g : A β B} {C : Coeq f g β Type β}
β (β x β is-set (C x))
β (ci : β x β C (inc x))
β (β x β PathP (Ξ» i β C (glue x i)) (ci (f x)) (ci (g x)))
β β x β C x
Coeq-elim cset ci cg (inc x) = ci x
Coeq-elim cset ci cg (glue x i) = cg x i
Coeq-elim cset ci cg (squash x y p q i j) =
is-setβsquarep (Ξ» i j β cset (squash x y p q i j))
(Ξ» i β g x) (Ξ» i β g (p i)) (Ξ» i β g (q i)) (Ξ» i β g y) i j
where g = Coeq-elim cset ci cg

Coeq-recβ : β {β} {f g : A β B} {f' g' : A' β B'} {C : Type β}
β is-set C
β (ci : B β B' β C)
β (β a x β ci (f x) a β‘ ci (g x) a)
β (β a x β ci a (f' x) β‘ ci a (g' x))
β Coeq f g β Coeq f' g' β C
Coeq-recβ cset ci r1 r2 (inc x) (inc y) = ci x y
Coeq-recβ cset ci r1 r2 (inc x) (glue y i) = r2 x y i
Coeq-recβ cset ci r1 r2 (inc x) (squash y z p q i j) = cset
(Coeq-recβ cset ci r1 r2 (inc x) y)
(Coeq-recβ cset ci r1 r2 (inc x) z)
(Ξ» j β Coeq-recβ cset ci r1 r2 (inc x) (p j))
(Ξ» j β Coeq-recβ cset ci r1 r2 (inc x) (q j))
i j

Coeq-recβ cset ci r1 r2 (glue x i) (inc xβ) = r1 xβ x i
Coeq-recβ {f = f} {g} {f'} {g'} cset ci r1 r2 (glue x i) (glue y j) =
is-setβsquarep (Ξ» i j β cset)
(Ξ» j β r1 (f' y) x j)
(Ξ» j β r2 (f x) y j)
(Ξ» j β r2 (g x) y j)
(Ξ» j β r1 (g' y) x j)
i j

Coeq-recβ {f = f} {g} {f'} {g'} cset ci r1 r2 (glue x i) (squash y z p q j k) =
is-hlevel-suc 2 cset
(go (glue x i) y) (go (glue x i) z)
(Ξ» j β go (glue x i) (p j))
(Ξ» j β go (glue x i) (q j))
(Ξ» i j β exp i j) (Ξ» i j β exp i j)
i j k
where
go = Coeq-recβ cset ci r1 r2
exp : I β I β _
exp l m = cset
(go (glue x i) y) (go (glue x i) z)
(Ξ» j β go (glue x i) (p j))
(Ξ» j β go (glue x i) (q j))
l m

Coeq-recβ cset ci r1 r2 (squash x y p q i j) z =
cset (go x z) (go y z) (Ξ» j β go (p j) z) (Ξ» j β go (q j) z) i j
where go = Coeq-recβ cset ci r1 r2

instance
H-Level-coeq : β {f g : A β B} {n} β H-Level (Coeq f g) (2 + n)
H-Level-coeq = basic-instance 2 squash


# Quotientsπ

With dependent sums, we can recover quotients as a special case of coequalisers. Observe that, by taking the total space of a relation we obtain two projection maps which have as image all of the possible related elements in By coequalising these projections, we obtain a space where any related objects are identified: the quotient

private
tot : β {β} β (A β A β Type β) β Type (level-of A β β)
tot {A = A} R = Ξ£[ x β A ] Ξ£[ y β A ] R x y

/-left : β {β} {R : A β A β Type β} β tot R β A
/-left (x , _ , _) = x

/-right : β {β} {R : A β A β Type β} β tot R β A
/-right (_ , x , _) = x

private variable
R S T : A β A β Type β


We form the quotient as the aforementioned coequaliser of the two projections from the total space of

_/_ : β {β β'} (A : Type β) (R : A β A β Type β') β Type (β β β')
A / R = Coeq (/-left {R = R}) /-right

infixl 25 _/_

quot : β {β β'} {A : Type β} {R : A β A β Type β'} {x y : A} β R x y
β Path (A / R) (inc x) (inc y)
quot r = glue (_ , _ , r)


Using Coeq-elim, we can recover the elimination principle for quotients:

Quot-elim : β {β} {B : A / R β Type β}
β (β x β is-set (B x))
β (f : β x β B (inc x))
β (β x y (r : R x y) β PathP (Ξ» i β B (quot r i)) (f x) (f y))
β β x β B x
Quot-elim bset f r = Coeq-elim bset f Ξ» { (x , y , w) β r x y w }


Conversely, we can describe coequalisers in terms of quotients. In order to form the coequaliser of we interpret the span formed by and as a binary relation on a witness that are related is an element of the fibre of at that is an such that and

spanβR
: β {β β'} {A : Type β} {B : Type β'} (f g : A β B)
β B β B β Type (β β β')
spanβR f g = curry (fibre β¨ f , g β©)


We then recover the coequaliser of and as the quotient of by this relation.

Coeqβquotient
: β {β β'} {A : Type β} {B : Type β'} (f g : A β B)
β Coeq f g β B / spanβR f g
Coeqβquotient {B = B} f g = IsoβEquiv is where
is : Iso (Coeq f g) (B / spanβR f g)
is .fst = Coeq-rec inc Ξ» a β quot (a , refl)
is .snd .inv = Coeq-rec inc Ξ» (_ , _ , a , p) β
sym (ap (inc β fst) p) Β·Β· glue a Β·Β· ap (inc β snd) p
is .snd .rinv = elim! Ξ» _ β refl
is .snd .linv = elim! Ξ» _ β refl

inc-is-surjective : {f g : A β B} β is-surjective {B = Coeq f g} inc
inc-is-surjective (inc x) = inc (x , refl)
inc-is-surjective {f = f} {g = g} (glue x i) = is-propβpathp
(Ξ» i β β₯_β₯.squash {A = fibre Coeq.inc (glue x i)})
(β₯_β₯.inc (f x , refl))
(β₯_β₯.inc (g x , refl)) i
inc-is-surjective (squash x y p q i j) = is-propβsquarep
(Ξ» i j β β₯_β₯.squash {A = fibre inc (squash x y p q i j)})
(Ξ» i β inc-is-surjective x)
(Ξ» j β inc-is-surjective (p j))
(Ξ» j β inc-is-surjective (q j))
(Ξ» i β inc-is-surjective y) i j


## Effectivityπ

The most well-behaved case of quotients is when takes values in propositions, is reflexive, transitive and symmetric (an equivalence relation). In this case, we have that the quotient is effective: The map quot is an equivalence.

record Congruence {β} (A : Type β) β' : Type (β β lsuc β') where
field
_βΌ_         : A β A β Type β'
has-is-prop : β x y β is-prop (x βΌ y)
reflαΆ : β {x} β x βΌ x
_βαΆ_  : β {x y z} β x βΌ y β y βΌ z β x βΌ z
symαΆ  : β {x y}   β x βΌ y β y βΌ x

infixr 30 _βαΆ_

relation = _βΌ_

quotient : Type _
quotient = A / _βΌ_


We will show this using an encode-decode method. For each we define a type family which represents an equality Importantly, the fibre over will be so that the existence of functions converting between and paths is enough to establish effectivity of the quotient.

  private
Code : A β quotient β Prop β'
Code x = Quot-elim
(Ξ» x β n-Type-is-hlevel 1)
(Ξ» y β el (x βΌ y) (has-is-prop x y) {- 1 -})
Ξ» y z r β
n-ua (prop-ext (has-is-prop _ _) (has-is-prop _ _)
(Ξ» z β z βαΆ r)
Ξ» z β z βαΆ (symαΆ r))


We do quotient induction into the type of propositions, which by univalence is a set. Since the fibre over must be thatβs what we give for the inc constructor ({- 1 -}, above). For this to respect the quotient, it suffices to show that, given we have which follows from the assumption that is an equivalence relation ({- 2 -}).

    encode : β x y (p : inc x β‘ y) β β£ Code x y β£
encode x y p = subst (Ξ» y β β£ Code x y β£) p reflαΆ

decode : β x y (p : β£ Code x y β£) β inc x β‘ y
decode = elim! Ξ» x y r β quot r


For encode, it suffices to transport the proof that is reflexive along the given proof, and for decoding, we eliminate from the quotient to a proposition. It boils down to establishing that which is what the constructor quot says. Putting this all together, we get a proof that equivalence relations are effective.

  is-effective : β {x y : A} β is-equiv (quot {R = relation})
is-effective {x = x} {y} =
prop-ext (has-is-prop x y) (squash _ _) (decode x (inc y)) (encode x (inc y)) .snd

  effective : β {x y : A} β Path quotient (inc x) (inc y) β x βΌ y
effective = equivβinverse is-effective

Quot-opβ : β {C : Type β} {T : C β C β Type β'}
β (β x β R x x) β (β y β S y y)
β (_β_ : A β B β C)
β ((a b : A) (x y : B) β R a b β S x y β T (a β x) (b β y))
β A / R β B / S β C / T
Quot-opβ Rr Sr op resp =
Coeq-recβ squash (Ξ» x y β inc (op x y))
(Ξ» { z (x , y , r) β quot (resp x y z z r (Sr z)) })
Ξ» { z (x , y , r) β quot (resp z z x y (Rr z) r) }

Discrete-quotient
: β {A : Type β} (R : Congruence A β')
β (β x y β Dec (Congruence.relation R x y))
β Discrete (Congruence.quotient R)
Discrete-quotient cong rdec {x} {y} =
elim! {P = Ξ» x β β y β Dec (x β‘ y)} go _ _ where
go : β x y β Dec (inc x β‘ inc y)
go x y with rdec x y
... | yes xRy = yes (quot xRy)
... | no Β¬xRy = no Ξ» p β Β¬xRy (Congruence.effective cong p)

open Congruence

Congruence-pullback
: β {βa βb β} {A : Type βa} {B : Type βb}
β (A β B) β Congruence B β β Congruence A β
Congruence-pullback {β = β} {A = A} f R = f*R where
module R = Congruence R
f*R : Congruence A β
f*R ._βΌ_ x y = f x R.βΌ f y
f*R .has-is-prop x y = R.has-is-prop _ _
f*R .reflαΆ = R.reflαΆ
f*R ._βαΆ_ f g = f R.βαΆ g
f*R .symαΆ f = R.symαΆ f


## Relation to surjectionsπ

As mentioned in the definition of surjection, we can view a cover as expressing a way of gluing together the type by adding paths between the elements of When and are sets, this sounds a lot like a quotient! And, indeed, we can prove that every surjection induces an equivalence between its codomain and a quotient of its domain.

First, we define the kernel pair of a function the congruence on defined to be identity under

Kernel-pair
: β {β β'} {A : Type β} {B : Type β'} β is-set B β (A β B)
β Congruence A β'
Kernel-pair b-set f ._βΌ_ a b = f a β‘ f b
Kernel-pair b-set f .has-is-prop x y = b-set (f x) (f y)
Kernel-pair b-set f .reflαΆ = refl
Kernel-pair b-set f ._βαΆ_  = _β_
Kernel-pair b-set f .symαΆ  = sym


We can then set about proving that, if is a surjection into a set, then is the quotient of under the kernel pair of

surjectionβis-quotient
: β {β β'} {A : Type β} {B : Type β'}
β (b-set : is-set B)
β (f : A β  B)
β B β Congruence.quotient (Kernel-pair b-set (f .fst))

surjectionβis-quotient {A = A} {B} b-set (f , surj) =
_ , injective-surjectiveβis-equiv! g'-inj g'-surj
where

private module c = Congruence (Kernel-pair b-set f)


The construction is pretty straightforward: each fibre defines an element If we have another fibre then because

so the function is constant, and factors through the propositional truncation

  gβ : β {x} β fibre f x β c.quotient
gβ (a , p) = inc a

abstract
gβ-const : β {x} (pβ pβ : fibre f x) β gβ pβ β‘ gβ pβ
gβ-const (_ , p) (_ , q) = quot (p β sym q)

gβ : β {x} β β₯ fibre f x β₯ β c.quotient
gβ f = β₯-β₯-rec-set (hlevel 2) gβ gβ-const f


Since each is inhabited, all of these functions glue together to give a function A simple calculation shows that this function is both injective and surjective; since its codomain is a set, that means itβs an equivalence.

  g' : B β c.quotient
g' x = gβ (surj x)

g'-inj : injective g'
g'-inj {x} {y} = β₯-β₯-elimβ {P = Ξ» a b β gβ a β‘ gβ b β x β‘ y}
(Ξ» _ _ β fun-is-hlevel 1 (b-set _ _))
(Ξ» (_ , p) (_ , q) r β sym p β c.effective r β q)
(surj x) (surj y)

g'-surj : is-surjective g'
g'-surj x = do
(y , p) β inc-is-surjective x
pure (f y , ap gβ (squash (surj (f y)) (inc (y , refl))) β p)

private module test where
variable C : Type β

_ : {f g : A / R β B} β¦ _ : H-Level B 2 β¦
β ((x : A) β f (inc x) β‘ g (inc x)) β f β‘ g
_ = ext

_ : {f g : (A Γ B) / R β C} β¦ _ : H-Level C 2 β¦
β ((x : A) (y : B) β f (inc (x , y)) β‘ g (inc (x , y)))
β f β‘ g
_ = ext


## Closuresπ

We define the reflexive, transitive and symmetric closure of a relation and prove that it induces the same quotient as

module _ {β β'} {A : Type β} (R : A β A β Type β') where
data Closure : A β A β Type (β β β') where
inc : β {x y} β R x y β Closure x y
Closure-refl : β {x} β Closure x x
Closure-trans : β {x y z} β Closure x y β Closure y z β Closure x z
Closure-sym : β {x y} β Closure y x β Closure x y
squash : β {x y} β is-prop (Closure x y)

Closure-congruence : Congruence A _
Closure-congruence .Congruence._βΌ_ = Closure
Closure-congruence .Congruence.has-is-prop _ _ = squash
Closure-congruence .Congruence.reflαΆ = Closure-refl
Closure-congruence .Congruence._βαΆ_ = Closure-trans
Closure-congruence .Congruence.symαΆ = Closure-sym

  unquoteDecl Closure-elim-prop = make-elim-n 1 Closure-elim-prop (quote Closure)

Closure-rec-congruence
: β {β''} (S : Congruence A β'') (let module S = Congruence S)
β (β {x y} β R x y β x S.βΌ y)
β β {x y} β Closure x y β x S.βΌ y
Closure-rec-congruence S h = Closure-elim-prop
{P = Ξ» {x} {y} _ β x S.βΌ y}
(Ξ» _ β S.has-is-prop _ _)
h S.reflαΆ (Ξ» _ q _ r β q S.βαΆ r) (Ξ» _ r β S.symαΆ r)
where module S = Congruence S

Closure-rec-β‘
: β {β'} {D : Type β'}
β β¦ H-Level D 2 β¦
β (f : A β D)
β (β {x y} β R x y β f x β‘ f y)
β β {x y} β Closure x y β f x β‘ f y
Closure-rec-β‘ f = Closure-rec-congruence (Kernel-pair (hlevel 2) f)

Closure-quotient
: β {β β'} {A : Type β} (R : A β A β Type β')
β A / R β A / Closure R
Closure-quotient {A = A} R = IsoβEquiv is where
is : Iso (A / R) (A / Closure R)
is .fst = Coeq-rec inc Ξ» (a , b , r) β quot (inc r)
is .snd .inv = Coeq-rec inc Ξ» (a , b , r) β Closure-rec-β‘ _ inc quot r
is .snd .rinv = elim! Ξ» _ β refl
is .snd .linv = elim! Ξ» _ β refl

instance
Closure-H-Level
: β {β β'} {A : Type β} {R : A β A β Type β'} {x y} {n}
β H-Level (Closure R x y) (suc n)
Closure-H-Level = prop-instance squash