Skip to content

Commit aee4189

Browse files
JacquesCaretteJacquesCarette
authored
Merge pull request #406 from agda/bump-stdlib-2.0
Bump stdlib to 2.0
2 parents 4f2988e + 34711fc commit aee4189

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

65 files changed

+897
-905
lines changed

‎.github/workflows/ci-ubuntu.yml‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -45,8 +45,8 @@ on:
4545
########################################################################
4646

4747
env:
48-
AGDA_COMMIT: tags/v2.6.3
49-
STDLIB_VERSION: 1.7.2
48+
AGDA_COMMIT: tags/v2.6.4
49+
STDLIB_VERSION: "2.0"
5050

5151
GHC_VERSION: 8.10.7
5252
CABAL_VERSION: 3.6.2.0

‎agda-categories.agda-lib‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,3 @@
11
name: agda-categories
2-
depend: standard-library-1.7.2
2+
depend: standard-library-2.0
33
include: src/

‎src/Categories/Adjoint.agda‎

Lines changed: 15 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -7,16 +7,14 @@ open import Level
77

88
open import Data.Product using (_,_; _×_)
99
open import Function using (_$_) renaming (_∘_ to _∙_)
10-
open import Function.Equality using (Π; _⟶_)
11-
import Function.Inverse as FI
10+
open import Function.Bundles using (Inverse)
1211
open import Relation.Binary using (Rel; IsEquivalence; Setoid)
1312
open import Relation.Binary.PropositionalEquality as ≡ using (_≡_)
1413

1514
-- be explicit in imports to 'see' where the information comes from
1615
open import Categories.Category.Core using (Category)
1716
open import Categories.Category.Product using (Product; _⁂_)
18-
open import Categories.Category.Instance.Setoids
19-
open import Categories.Morphism
17+
open import Categories.Category.Instance.Setoids using (Setoids)
2018
open import Categories.Functor using (Functor; _∘F_) renaming (id to idF)
2119
open import Categories.Functor.Bifunctor using (Bifunctor)
2220
open import Categories.Functor.Hom using (Hom[_][-,-])
@@ -91,23 +89,19 @@ record Adjoint (L : Functor C D) (R : Functor D C) : Set (levelOfTerm L ⊔ leve
9189
module Hom[-,R-] = Functor Hom[-,R-]
9290

9391
-- Inverse is more 'categorical' than bijection defined via injection/surjection
94-
Hom-inverse : ∀ A B → FI.Inverse (Hom[L-,-].F₀ (A , B)) (Hom[-,R-].F₀ (A , B))
92+
Hom-inverse : ∀ A B → Inverse (Hom[L-,-].F₀ (A , B)) (Hom[-,R-].F₀ (A , B))
9593
Hom-inverse A B = record
96-
{ to = record
97-
{ _⟨$⟩_ = Ladjunct {A} {B}
98-
; cong = C.∘-resp-≈ˡ ∙ R.F-resp-≈
99-
}
100-
; from = record
101-
{ _⟨$⟩_ = Radjunct {A} {B}
102-
; cong = D.∘-resp-≈ʳ ∙ L.F-resp-≈
103-
}
104-
; inverse-of = record
105-
{ left-inverse-of = λ _ → RLadjunct≈id
106-
; right-inverse-of = λ _ → LRadjunct≈id
94+
{ to = Ladjunct {A} {B}
95+
; to-cong = C.∘-resp-≈ˡ ∙ R.F-resp-≈
96+
; from = Radjunct {A} {B}
97+
; from-cong = D.∘-resp-≈ʳ ∙ L.F-resp-≈
98+
; inverse = record
99+
{ fst = λ p → C.∘-resp-≈ˡ (R.F-resp-≈ p) C.HomReasoning.○ LRadjunct≈id
100+
; snd = λ p → D.∘-resp-≈ʳ (L.F-resp-≈ p) D.HomReasoning.○ RLadjunct≈id
107101
}
108102
}
109103

110-
module Hom-inverse {A} {B} = FI.Inverse (Hom-inverse A B)
104+
module Hom-inverse {A} {B} = Inverse (Hom-inverse A B)
111105

112106
op : Adjoint R.op L.op
113107
op = record
@@ -188,15 +182,15 @@ record Adjoint (L : Functor C D) (R : Functor D C) : Set (levelOfTerm L ⊔ leve
188182
Hom-NI = record
189183
{ F⇒G = ntHelper record
190184
{ η = λ _ → record
191-
{ _⟨$⟩_ = λ f → lift (Ladjunct (lower f))
192-
; cong = λ eq → lift (Ladjunct-resp-≈ (lower eq))
185+
{ to = λ f → lift (Ladjunct (lower f))
186+
; cong = λ eq → lift (Ladjunct-resp-≈ (lower eq))
193187
}
194188
; commute = λ _ eq → lift $ Ladjunct-comm (lower eq)
195189
}
196190
; F⇐G = ntHelper record
197191
{ η = λ _ → record
198-
{ _⟨$⟩_ = λ f → lift (Radjunct (lower f))
199-
; cong = λ eq → lift (Radjunct-resp-≈ (lower eq))
192+
{ to = λ f → lift (Radjunct (lower f))
193+
; cong = λ eq → lift (Radjunct-resp-≈ (lower eq))
200194
}
201195
; commute = λ _ eq → lift $ Radjunct-comm (lower eq)
202196
}

‎src/Categories/Adjoint/Compose.agda‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7,8 +7,6 @@ open import Level
77

88
open import Data.Product using (_,_; _×_)
99
open import Function using (_$_) renaming (_∘_ to _∙_)
10-
open import Function.Equality using (Π; _⟶_)
11-
import Function.Inverse as FI
1210
open import Relation.Binary using (Rel; IsEquivalence; Setoid)
1311

1412
-- be explicit in imports to 'see' where the information comes from

‎src/Categories/Adjoint/Equivalents.agda‎

Lines changed: 11 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -8,16 +8,15 @@ open import Level
88

99
open import Data.Product using (_,_; _×_)
1010
open import Function using (_$_) renaming (_∘_ to _∙_)
11-
open import Function.Equality using (Π; _⟶_)
12-
import Function.Inverse as FI
11+
open import Function.Bundles using (Equivalence; LeftInverse; Func; _⟨$⟩_)
1312
open import Relation.Binary using (Rel; IsEquivalence; Setoid)
1413

1514
-- be explicit in imports to 'see' where the information comes from
1615
open import Categories.Adjoint using (Adjoint; _⊣_)
1716
open import Categories.Category.Core using (Category)
1817
open import Categories.Category.Product using (Product; _⁂_)
19-
open import Categories.Category.Instance.Setoids
20-
open import Categories.Morphism
18+
open import Categories.Category.Instance.Setoids using (Setoids)
19+
open import Categories.Morphism using (Iso)
2120
open import Categories.Functor using (Functor; _∘F_) renaming (id to idF)
2221
open import Categories.Functor.Bifunctor using (Bifunctor)
2322
open import Categories.Functor.Hom using (Hom[_][-,-])
@@ -50,11 +49,11 @@ module _ {C : Category o ℓ e} {D : Category o′ ℓ e} {L : Functor C D} {R :
5049
Hom-NI′ : NaturalIsomorphism Hom[L-,-] Hom[-,R-]
5150
Hom-NI′ = record
5251
{ F⇒G = ntHelper record
53-
{ η = λ _ → Hom-inverse.to
52+
{ η = λ _ → record { to = Hom-inverse.to ; cong = Hom-inverse.to-cong }
5453
; commute = λ _ eq → Ladjunct-comm eq
5554
}
5655
; F⇐G = ntHelper record
57-
{ η = λ _ → Hom-inverse.from
56+
{ η = λ _ → record { to = Hom-inverse.from ; cong = Hom-inverse.from-cong }
5857
; commute = λ _ eq → Radjunct-comm eq
5958
}
6059
; iso = λ _ → record
@@ -78,10 +77,10 @@ module _ {C : Category o ℓ e} {D : Category o′ ℓ e} {L : Functor C D} {R :
7877
open NaturalIsomorphism Hni
7978
open NaturalTransformation
8079
open Functor
81-
open Π
80+
open Func
8281

8382
private
84-
unitη : ∀ X → F₀ Hom[L-,-] (X , L.F₀ X) ⟶ F₀ Hom[-,R-] (X , L.F₀ X)
83+
unitη : ∀ X → Func (F₀ Hom[L-,-] (X , L.F₀ X)) (F₀ Hom[-,R-] (X , L.F₀ X))
8584
unitη X = ⇒.η (X , L.F₀ X)
8685

8786
unit : NaturalTransformation idF (R ∘F L)
@@ -100,7 +99,7 @@ module _ {C : Category o ℓ e} {D : Category o′ ℓ e} {L : Functor C D} {R :
10099
open HomReasoning
101100
open MR C
102101

103-
counitη : ∀ X → F₀ Hom[-,R-] (R.F₀ X , X) ⟶ F₀ Hom[L-,-] (R.F₀ X , X)
102+
counitη : ∀ X → Func (F₀ Hom[-,R-] (R.F₀ X , X)) (F₀ Hom[L-,-] (R.F₀ X , X))
104103
counitη X = ⇐.η (R.F₀ X , X)
105104

106105
counit : NaturalTransformation (L ∘F R) idF
@@ -160,7 +159,7 @@ module _ {C : Category o ℓ e} {D : Category o′ ℓ′ e′} {L : Functor C D
160159
module L = Functor L
161160
module R = Functor R
162161
open Functor
163-
open Π
162+
open Func
164163

165164
Hom[L-,-] : Bifunctor C.op D (Setoids _ _)
166165
Hom[L-,-] = LiftSetoids ℓ e ∘F Hom[ D ][-,-] ∘F (L.op ⁂ idF)
@@ -171,7 +170,7 @@ module _ {C : Category o ℓ e} {D : Category o′ ℓ′ e′} {L : Functor C D
171170
module _ (Hni : Hom[L-,-] ≃ Hom[-,R-]) where
172171
open NaturalIsomorphism Hni using (module ⇒; module ⇐; iso)
173172
private
174-
unitη : ∀ X → F₀ Hom[L-,-] (X , L.F₀ X) ⟶ F₀ Hom[-,R-] (X , L.F₀ X)
173+
unitη : ∀ X → Func (F₀ Hom[L-,-] (X , L.F₀ X)) (F₀ Hom[-,R-] (X , L.F₀ X))
175174
unitη X = ⇒.η (X , L.F₀ X)
176175

177176
unit : NaturalTransformation idF (R ∘F L)
@@ -196,7 +195,7 @@ module _ {C : Category o ℓ e} {D : Category o′ ℓ′ e′} {L : Functor C D
196195
open HomReasoning
197196
open MR C
198197

199-
counitη : ∀ X → F₀ Hom[-,R-] (R.F₀ X , X) ⟶ F₀ Hom[L-,-] (R.F₀ X , X)
198+
counitη : ∀ X → Func (F₀ Hom[-,R-] (R.F₀ X , X)) (F₀ Hom[L-,-] (R.F₀ X , X))
200199
counitη X = ⇐.η (R.F₀ X , X)
201200

202201
counit : NaturalTransformation (L ∘F R) idF

‎src/Categories/Adjoint/Instance/0-Truncation.agda‎

Lines changed: 9 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -7,9 +7,10 @@ module Categories.Adjoint.Instance.0-Truncation where
77

88
open import Level using (Lift)
99
open import Data.Unit using (⊤)
10-
import Function
10+
open import Function.Base renaming (id to id→)
11+
open import Function.Bundles using (Func)
12+
import Function.Construct.Identity as Id
1113
open import Relation.Binary using (Setoid)
12-
open import Function.Equality using (Π) renaming (id to idΠ)
1314

1415
open import Categories.Adjoint using (_⊣_)
1516
open import Categories.Category.Construction.0-Groupoid using (0-Groupoid)
@@ -26,7 +27,7 @@ open import Categories.NaturalTransformation.NaturalIsomorphism using (refl)
2627
Inclusion : ∀ {c ℓ} e → Functor (Setoids c ℓ) (Groupoids c ℓ e)
2728
Inclusion {c} {ℓ} e = record
2829
{ F₀ = 0-Groupoid e
29-
; F₁ = λ f → record { F₀ = f ⟨$⟩_ ; F₁ = cong f }
30+
; F₁ = λ f → record { F₀ = to f; F₁ = cong f }
3031
; identity = refl
3132
; homomorphism = refl
3233
; F-resp-≈ = λ {S T f g} f≗g →
@@ -37,27 +38,27 @@ Inclusion {c} {ℓ} e = record
3738
; F⇐G = record { η = λ _ → T.sym (f≗g S.refl) }
3839
}
3940
}
40-
where open Π
41+
where open Func
4142

4243
-- Trunc is left-adjoint to the inclusion functor from Setoids to Groupoids
4344

4445
TruncAdj : ∀ {o ℓ e} → Trunc ⊣ Inclusion {o} {ℓ} e
4546
TruncAdj {o} {ℓ} {e} = record
4647
{ unit = unit
4748
; counit = counit
48-
; zig = Function.id
49+
; zig = id→
4950
; zag = refl
5051
}
5152
where
52-
open Π
53+
open Func
5354
open Groupoid using (category)
5455

5556
unit : NaturalTransformation idF (Inclusion e ∘F Trunc)
5657
unit = record
57-
{ η = λ _ → record { F₀ = Function.id ; F₁ = Function.id }
58+
{ η = λ _ → record { F₀ = id→ ; F₁ = id→ }
5859
; commute = λ _ → refl
5960
; sym-commute = λ _ → refl
6061
}
6162

6263
counit : NaturalTransformation (Trunc ∘F Inclusion e) idF
63-
counit = ntHelper record { η = λ S → idΠ ; commute = λ f → cong f }
64+
counit = ntHelper record { η = Id.function; commute = λ f → cong f }

‎src/Categories/Adjoint/Instance/PosetCore.agda‎

Lines changed: 9 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -7,16 +7,16 @@ module Categories.Adjoint.Instance.PosetCore where
77

88
open import Level using (_⊔_)
99
import Function
10-
open import Function.Equality using (Π; _⟶_)
10+
open import Function.Bundles using (Func)
1111
open import Relation.Binary using (Setoid; Poset)
1212
open import Relation.Binary.Morphism.Bundles using (PosetHomomorphism; mkPosetHomo)
1313
import Relation.Binary.Morphism.Construct.Composition as Comp
1414

1515
open import Categories.Adjoint using (_⊣_)
1616
import Categories.Adjoint.Instance.0-Truncation as Setd
1717
import Categories.Adjoint.Instance.01-Truncation as Pos
18-
open import Categories.Category using (Category)
19-
open import Categories.Category.Construction.Thin
18+
open import Categories.Category.Core using (Category)
19+
open import Categories.Category.Construction.Thin using (Thin; module EqIsIso)
2020
open import Categories.Category.Instance.Posets using (Posets)
2121
open import Categories.Category.Instance.Setoids using (Setoids)
2222
open import Categories.Functor.Instance.Core using () renaming (Core to CatCore)
@@ -28,15 +28,16 @@ open import Categories.NaturalTransformation using (ntHelper)
2828
open import Categories.NaturalTransformation.NaturalIsomorphism
2929
using (_≃_; niHelper)
3030

31-
open Π
3231
open PosetHomomorphism using (⟦_⟧; cong)
3332

3433
-- The "forgetful" functor from Setoids to Posets (forgetting symmetry).
3534

35+
open Func
36+
3637
Forgetful : ∀ {c ℓ} → Functor (Setoids c ℓ) (Posets c ℓ ℓ)
3738
Forgetful = record
3839
{ F₀ = Forgetful₀
39-
; F₁ = λ f → mkPosetHomo _ _ (f ⟨$⟩_) (cong f)
40+
; F₁ = λ f → mkPosetHomo _ _ (to f) (cong f)
4041
; identity = λ {S} → refl S
4142
; homomorphism = λ {_ _ S} → refl S
4243
; F-resp-≈ = λ {S _} f≗g → f≗g (refl S)
@@ -70,7 +71,7 @@ Forgetful = record
7071
Core : ∀ {c ℓ₁ ℓ₂} → Functor (Posets c ℓ₁ ℓ₂) (Setoids c ℓ₁)
7172
Core = record
7273
{ F₀ = λ A → record { isEquivalence = isEquivalence A }
73-
; F₁ = λ f → record { _⟨$⟩_ = ⟦ f ⟧ ; cong = cong f }
74+
; F₁ = λ f → record { to = ⟦ f ⟧ ; cong = cong f }
7475
; identity = Function.id
7576
; homomorphism = λ {_ _ _ f g} → cong (Comp.posetHomomorphism f g)
7677
; F-resp-≈ = λ {_ B} {f _} f≗g x≈y → Eq.trans B (cong f x≈y) f≗g
@@ -91,8 +92,8 @@ CoreAdj = record
9192
open Functor Core using () renaming (F₀ to Core₀; F₁ to Core₁)
9293
open Functor Forgetful using () renaming (F₀ to U₀ ; F₁ to U₁)
9394

94-
unit : ∀ S → S ⟶ Core₀ (U₀ S)
95-
unit S = record { _⟨$⟩_ = Function.id ; cong = Function.id }
95+
unit : ∀ S → Func S (Core₀ (U₀ S))
96+
unit S = record { to = Function.id ; cong = Function.id }
9697

9798
counit : ∀ A → PosetHomomorphism (U₀ (Core₀ A)) A
9899
counit A = mkPosetHomo (U₀ (Core₀ A)) A Function.id (reflexive A)

‎src/Categories/Adjoint/Mate.agda‎

Lines changed: 50 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,9 @@ module Categories.Adjoint.Mate where
66

77
open import Level
88
open import Data.Product using (Σ; _,_)
9-
open import Function.Equality using (Π; _⟶_; _⇨_) renaming (_∘_ to _∙_)
9+
open import Function.Bundles using (Func; _⟨$⟩_)
10+
open import Function.Construct.Composition using (function)
11+
open import Function.Construct.Setoid using () renaming (function to _⇨_)
1012
open import Relation.Binary using (Setoid; IsEquivalence)
1113

1214
open import Categories.Category
@@ -107,14 +109,32 @@ module _ {L L′ : Functor C D} {R R′ : Functor D C}
107109

108110
-- there are two squares to show
109111
module _ {X : C.Obj} {Y : D.Obj} where
110-
open Setoid (L′⊣R′.Hom[L-,-].F₀ (X , Y) ⇨ L⊣R.Hom[-,R-].F₀ (X , Y))
112+
private
113+
From : Setoid _ _
114+
From = L′⊣R′.Hom[L-,-].F₀ (X , Y)
115+
To : Setoid _ _
116+
To = L⊣R.Hom[-,R-].F₀ (X , Y)
117+
SS = From ⇨ To
118+
open Setoid SS using (_≈_)
111119
open C hiding (_≈_)
112120
open MR C
113121
open C.HomReasoning
114122
module DH = D.HomReasoning
115-
116-
mate-commute₁ : F₁ Hom[ C ][-,-] (C.id , β.η Y) ∙ L′⊣R′.Hom-inverse.to {X} {Y}
117-
≈ L⊣R.Hom-inverse.to {X} {Y} ∙ F₁ Hom[ D ][-,-] (α.η X , D.id)
123+
private
124+
-- annoyingly the new bundles don't export this
125+
D⟶C : Func (D.hom-setoid {F₀ L′ X} {Y}) (C.hom-setoid {X} {F₀ R′ Y})
126+
D⟶C = record
127+
{ to = L′⊣R′.Hom-inverse.to {X} {Y}
128+
; cong = L′⊣R′.Hom-inverse.to-cong
129+
}
130+
D⟶C′ : Func D.hom-setoid C.hom-setoid
131+
D⟶C′ = record
132+
{ to = L⊣R.Hom-inverse.to {X} {Y}
133+
; cong = L⊣R.Hom-inverse.to-cong
134+
}
135+
136+
mate-commute₁ : function D⟶C (F₁ Hom[ C ][-,-] (C.id , β.η Y))
137+
≈ function (F₁ Hom[ D ][-,-] (α.η X , D.id)) D⟶C′
118138
mate-commute₁ {f} {g} f≈g = begin
119139
β.η Y ∘ (F₁ R′ f ∘ L′⊣R′.unit.η X) ∘ C.id ≈⟨ refl⟩∘⟨ identityʳ ⟩
120140
β.η Y ∘ F₁ R′ f ∘ L′⊣R′.unit.η X ≈⟨ pullˡ (β.commute f) ⟩
@@ -124,14 +144,35 @@ module _ {L L′ : Functor C D} {R R′ : Functor D C}
124144
F₁ R (D.id D.∘ g D.∘ α.η X) ∘ L⊣R.unit.η X ∎
125145

126146
module _ {X : C.Obj} {Y : D.Obj} where
127-
open Setoid (L′⊣R′.Hom[-,R-].F₀ (X , Y) ⇨ L⊣R.Hom[L-,-].F₀ (X , Y))
128147
open D hiding (_≈_)
129148
open MR D
130149
open D.HomReasoning
131150
module CH = C.HomReasoning
132-
133-
mate-commute₂ : F₁ Hom[ D ][-,-] (α.η X , D.id) ∙ L′⊣R′.Hom-inverse.from {X} {Y}
134-
≈ L⊣R.Hom-inverse.from {X} {Y} ∙ F₁ Hom[ C ][-,-] (C.id , β.η Y)
151+
private
152+
From : Setoid _ _
153+
From = L′⊣R′.Hom[-,R-].F₀ (X , Y)
154+
To : Setoid _ _
155+
To = L⊣R.Hom[L-,-].F₀ (X , Y)
156+
module From = Setoid From
157+
module To = Setoid To
158+
SS : Setoid _ _
159+
SS = From ⇨ To
160+
open Setoid SS using (_≈_)
161+
private
162+
-- annoyingly the new bundles don't export this
163+
C⟶D : Func C.hom-setoid D.hom-setoid
164+
C⟶D = record
165+
{ to = L′⊣R′.Hom-inverse.from {X} {Y}
166+
; cong = L′⊣R′.Hom-inverse.from-cong
167+
}
168+
C⟶D′ : Func C.hom-setoid D.hom-setoid
169+
C⟶D′ = record
170+
{ to = L⊣R.Hom-inverse.from {X} {Y}
171+
; cong = L⊣R.Hom-inverse.from-cong
172+
}
173+
174+
mate-commute₂ : function C⟶D (F₁ Hom[ D ][-,-] (α.η X , D.id))
175+
≈ function (F₁ Hom[ C ][-,-] (C.id , β.η Y)) C⟶D′
135176
mate-commute₂ {f} {g} f≈g = begin
136177
D.id ∘ (L′⊣R′.counit.η Y ∘ F₁ L′ f) ∘ α.η X ≈⟨ identityˡ ⟩
137178
(L′⊣R′.counit.η Y ∘ F₁ L′ f) ∘ α.η X ≈˘⟨ pushʳ (α.commute f) ⟩

0 commit comments

Comments
 (0)