Search is not available for this dataset
text
string | meta
dict |
|---|---|
{-# OPTIONS --safe #-}
module Cubical.Algebra.Group.Instances.DiffInt where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Int.MoreInts.DiffInt renaming ( _+_ to _+ℤ_ ; _-_ to _-ℤ_)
open import Cubical.Algebra.Group.Base
open import Cubical.Algebra.Semigroup.Base
open import Cubical.Algebra.Monoid.Base
open import Cubical.HITs.SetQuotients
open GroupStr
ℤ-isGroup : IsGroup {G = ℤ} ([ 0 , 0 ]) (_+ℤ_) (-ℤ_)
IsSemigroup.is-set (IsMonoid.isSemigroup (IsGroup.isMonoid ℤ-isGroup)) = ℤ-isSet
IsSemigroup.assoc (IsMonoid.isSemigroup (IsGroup.isMonoid ℤ-isGroup)) = +ℤ-assoc
IsMonoid.identity (IsGroup.isMonoid ℤ-isGroup) = λ x → (zero-identityʳ 0 x , zero-identityˡ 0 x)
IsGroup.inverse ℤ-isGroup = λ x → (-ℤ-invʳ x , -ℤ-invˡ x)
ℤGroup : Group₀
fst ℤGroup = ℤ
1g (snd ℤGroup) = [ 0 , 0 ]
_·_ (snd ℤGroup) = _+ℤ_
inv (snd ℤGroup) = -ℤ_
isGroup (snd ℤGroup) = ℤ-isGroup
|
{
"alphanum_fraction": 0.7264573991,
"avg_line_length": 30.7586206897,
"ext": "agda",
"hexsha": "e5276df7ae733ecd827bd75a80b78751045ede3e",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "ce3120d3f8d692847b2744162bcd7a01f0b687eb",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "guilhermehas/cubical",
"max_forks_repo_path": "Cubical/Algebra/Group/Instances/DiffInt.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "ce3120d3f8d692847b2744162bcd7a01f0b687eb",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "guilhermehas/cubical",
"max_issues_repo_path": "Cubical/Algebra/Group/Instances/DiffInt.agda",
"max_line_length": 97,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "ce3120d3f8d692847b2744162bcd7a01f0b687eb",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "guilhermehas/cubical",
"max_stars_repo_path": "Cubical/Algebra/Group/Instances/DiffInt.agda",
"max_stars_repo_stars_event_max_datetime": "2021-10-31T17:32:49.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-10-31T17:32:49.000Z",
"num_tokens": 330,
"size": 892
}
|
{-# OPTIONS --without-K --rewriting #-}
{- Remember to keep CodeBP.agda in sync. -}
open import HoTT
import homotopy.RelativelyConstantToSetExtendsViaSurjection as SurjExt
module homotopy.vankampen.CodeAP {i j k l}
(span : Span {i} {j} {k})
{D : Type l} (h : D → Span.C span) (h-is-surj : is-surj h) where
open Span span
data precodeAA (a₀ : A) : A → Type (lmax (lmax (lmax i j) k) l)
data precodeAB (a₀ : A) (b₁ : B) : Type (lmax (lmax (lmax i j) k) l)
data precodeAA a₀ where
pc-a : ∀ {a₁} (pA : a₀ =₀ a₁) → precodeAA a₀ a₁
pc-aba : ∀ d {a₁} (pc : precodeAB a₀ (g (h d))) (pA : f (h d) =₀ a₁) → precodeAA a₀ a₁
infix 66 pc-a
syntax pc-a p = ⟧a p
infixl 65 pc-aba
syntax pc-aba d pcAB pA = pcAB ab⟦ d ⟧a pA
data precodeAB a₀ b₁ where
pc-aab : ∀ d (pc : precodeAA a₀ (f (h d))) (pB : g (h d) =₀ b₁) → precodeAB a₀ b₁
infixl 65 pc-aab
syntax pc-aab d pcAA pB = pcAA aa⟦ d ⟧b pB
data precodeAA-rel {a₀ : A} : {a₁ : A}
→ precodeAA a₀ a₁ → precodeAA a₀ a₁ → Type (lmax (lmax (lmax i j) k) l)
data precodeAB-rel {a₀ : A} : {b₁ : B}
→ precodeAB a₀ b₁ → precodeAB a₀ b₁ → Type (lmax (lmax (lmax i j) k) l)
data precodeAA-rel {a₀} where
pcAAr-idp₀-idp₀ : ∀ {d} pcAA → precodeAA-rel (pcAA aa⟦ d ⟧b idp₀ ab⟦ d ⟧a idp₀) pcAA
pcAAr-cong : ∀ {d a₁ pcAB₁ pcAB₂} (r : precodeAB-rel pcAB₁ pcAB₂) (pA : f (h d) =₀ a₁)
→ precodeAA-rel (pcAB₁ ab⟦ d ⟧a pA) (pcAB₂ ab⟦ d ⟧a pA)
data precodeAB-rel {a₀} where
pcABr-idp₀-idp₀ : ∀ {d} pcAB → precodeAB-rel (pcAB ab⟦ d ⟧a idp₀ aa⟦ d ⟧b idp₀) pcAB
pcABr-switch : ∀ {d₀ d₁ : D} pcAB (pC : h d₀ =₀ h d₁)
→ precodeAB-rel (pcAB ab⟦ d₀ ⟧a ap₀ f pC aa⟦ d₁ ⟧b idp₀) (pcAB ab⟦ d₀ ⟧a idp₀ aa⟦ d₀ ⟧b ap₀ g pC)
pcABr-cong : ∀ {d b₁ pcAA₁ pcAA₂} (r : precodeAA-rel pcAA₁ pcAA₂) (pB : g (h d) =₀ b₁)
→ precodeAB-rel (pcAA₁ aa⟦ d ⟧b pB) (pcAA₂ aa⟦ d ⟧b pB)
codeAA : A → A → Type (lmax (lmax (lmax i j) k) l)
codeAA a₀ a₁ = SetQuot (precodeAA-rel {a₀} {a₁})
codeAB : A → B → Type (lmax (lmax (lmax i j) k) l)
codeAB a₀ b₁ = SetQuot (precodeAB-rel {a₀} {b₁})
c-aba : ∀ {a₀} d {a₁} (pc : codeAB a₀ (g (h d))) (pA : f (h d) =₀ a₁) → codeAA a₀ a₁
c-aba d {a₁} c pA = SetQuot-rec SetQuot-is-set
(λ pc → q[ pc-aba d pc pA ])
(λ r → quot-rel $ pcAAr-cong r pA) c
c-aab : ∀ {a₀} d {b₁} (pc : codeAA a₀ (f (h d))) (pB : g (h d) =₀ b₁) → codeAB a₀ b₁
c-aab d {a₁} c pB = SetQuot-rec SetQuot-is-set
(λ pc → q[ pc-aab d pc pB ])
(λ r → quot-rel $ pcABr-cong r pB) c
-- codeAP
abstract
pcAA-idp₀-idp₀-head : ∀ {d₀ a} (pA : f (h d₀) =₀ a)
→ q[ ⟧a idp₀ aa⟦ d₀ ⟧b idp₀ ab⟦ d₀ ⟧a pA ] == q[ ⟧a pA ] :> codeAA _ a
pcAA-idp₀-idp₀-head {d₀} = Trunc-elim (λ _ → =-preserves-set SetQuot-is-set) lemma where
lemma : ∀ {a} (pA : f (h d₀) == a)
→ q[ ⟧a idp₀ aa⟦ d₀ ⟧b idp₀ ab⟦ d₀ ⟧a [ pA ] ] == q[ ⟧a [ pA ] ] :> codeAA _ a
lemma idp = quot-rel $ pcAAr-idp₀-idp₀ (⟧a idp₀)
pcAA-prepend : ∀ {a₀} d₁ {a₂} → a₀ =₀ f (h d₁) → precodeAA (f (h d₁)) a₂ → precodeAA a₀ a₂
pcAB-prepend : ∀ {a₀} d₁ {b₂} → a₀ =₀ f (h d₁) → precodeAB (f (h d₁)) b₂ → precodeAB a₀ b₂
pcAA-prepend d₁ pA (pc-a pA₁) = pc-aba d₁ (pc-aab d₁ (pc-a pA) idp₀) pA₁
pcAA-prepend d₁ pA (pc-aba d pc pA₁) = pc-aba d (pcAB-prepend d₁ pA pc) pA₁
pcAB-prepend d₁ pA (pc-aab d pc pB) = pc-aab d (pcAA-prepend d₁ pA pc) pB
abstract
pcAA-prepend-idp₀ : ∀ {d₀ a₁} (pcAA : precodeAA (f (h d₀)) a₁)
→ q[ pcAA-prepend d₀ idp₀ pcAA ] == q[ pcAA ] :> codeAA (f (h d₀)) a₁
pcAB-prepend-idp₀ : ∀ {d₀ b₁} (pcAB : precodeAB (f (h d₀)) b₁)
→ q[ pcAB-prepend d₀ idp₀ pcAB ] == q[ pcAB ] :> codeAB (f (h d₀)) b₁
pcAA-prepend-idp₀ (pc-a pA) = pcAA-idp₀-idp₀-head pA
pcAA-prepend-idp₀ (pc-aba d pc pA) = pcAB-prepend-idp₀ pc |in-ctx λ c → c-aba d c pA
pcAB-prepend-idp₀ (pc-aab d pc pA) = pcAA-prepend-idp₀ pc |in-ctx λ c → c-aab d c pA
transp-cAA-l : ∀ d {a₀ a₁} (p : f (h d) == a₀) (pcAA : precodeAA (f (h d)) a₁)
→ transport (λ x → codeAA x a₁) p q[ pcAA ] == q[ pcAA-prepend d [ ! p ] pcAA ]
transp-cAA-l d idp pcAA = ! $ pcAA-prepend-idp₀ pcAA
transp-cAB-l : ∀ d {a₀ b₁} (p : f (h d) == a₀) (pcAB : precodeAB (f (h d)) b₁)
→ transport (λ x → codeAB x b₁) p q[ pcAB ] == q[ pcAB-prepend d [ ! p ] pcAB ]
transp-cAB-l d idp pcAB = ! $ pcAB-prepend-idp₀ pcAB
transp-cAA-r : ∀ d {a₀ a₁} (p : f (h d) == a₁) (pcAA : precodeAA a₀ (f (h d)))
→ transport (λ x → codeAA a₀ x) p q[ pcAA ] == q[ pcAA aa⟦ d ⟧b idp₀ ab⟦ d ⟧a [ p ] ]
transp-cAA-r d idp pcAA = ! $ quot-rel $ pcAAr-idp₀-idp₀ pcAA
transp-cAB-r : ∀ d {a₀ b₁} (p : g (h d) == b₁) (pcAB : precodeAB a₀ (g (h d)))
→ transport (λ x → codeAB a₀ x) p q[ pcAB ] == q[ pcAB ab⟦ d ⟧a idp₀ aa⟦ d ⟧b [ p ] ]
transp-cAB-r d idp pcAB = ! $ quot-rel $ pcABr-idp₀-idp₀ pcAB
module CodeAAEquivCodeAB (a₀ : A) where
eqv-on-image : (d : D) → codeAA a₀ (f (h d)) ≃ codeAB a₀ (g (h d))
eqv-on-image d = equiv to from to-from from-to where
to = λ c → c-aab d c idp₀
from = λ c → c-aba d c idp₀
abstract
from-to : ∀ cAA → from (to cAA) == cAA
from-to = SetQuot-elim
(λ _ → =-preserves-set SetQuot-is-set)
(λ pcAA → quot-rel (pcAAr-idp₀-idp₀ pcAA))
(λ _ → prop-has-all-paths-↓ (SetQuot-is-set _ _))
to-from : ∀ cAB → to (from cAB) == cAB
to-from = SetQuot-elim
(λ _ → =-preserves-set SetQuot-is-set)
(λ pcAB → quot-rel (pcABr-idp₀-idp₀ pcAB))
(λ _ → prop-has-all-paths-↓ (SetQuot-is-set _ _))
abstract
eqv-is-const : ∀ d₁ d₂ (p : h d₁ == h d₂)
→ eqv-on-image d₁ == eqv-on-image d₂
[ (λ c → codeAA a₀ (f c) ≃ codeAB a₀ (g c)) ↓ p ]
eqv-is-const d₁ d₂ p = ↓-Subtype-in (λ d → is-equiv-prop) $
↓-→-from-transp $ λ= $
SetQuot-elim (λ _ → =-preserves-set SetQuot-is-set)
(λ pcAA →
transport (λ c → codeAB a₀ (g c)) p q[ pcAA aa⟦ d₁ ⟧b idp₀ ]
=⟨ ap-∘ (codeAB a₀) g p |in-ctx (λ p → coe p q[ pcAA aa⟦ d₁ ⟧b idp₀ ]) ⟩
transport (codeAB a₀) (ap g p) q[ pcAA aa⟦ d₁ ⟧b idp₀ ]
=⟨ transp-cAB-r d₁ (ap g p) (pcAA aa⟦ d₁ ⟧b idp₀) ⟩
q[ pcAA aa⟦ d₁ ⟧b idp₀ ab⟦ d₁ ⟧a idp₀ aa⟦ d₁ ⟧b [ ap g p ] ]
=⟨ ! $ quot-rel $ pcABr-switch (pcAA aa⟦ d₁ ⟧b idp₀) [ p ] ⟩
q[ pcAA aa⟦ d₁ ⟧b idp₀ ab⟦ d₁ ⟧a [ ap f p ] aa⟦ d₂ ⟧b idp₀ ]
=⟨ ! $ transp-cAA-r d₁ (ap f p) pcAA |in-ctx (λ c → c-aab d₂ c idp₀) ⟩
c-aab d₂ (transport (codeAA a₀) (ap f p) q[ pcAA ]) idp₀
=⟨ ∘-ap (codeAA a₀) f p |in-ctx (λ p → coe p q[ pcAA ]) |in-ctx (λ c → c-aab d₂ c idp₀) ⟩
c-aab d₂ (transport (λ c → codeAA a₀ (f c)) p q[ pcAA ]) idp₀
=∎)
(λ _ → prop-has-all-paths-↓ (SetQuot-is-set _ _))
module SE = SurjExt
(λ c → ≃-is-set SetQuot-is-set SetQuot-is-set)
h h-is-surj
eqv-on-image
eqv-is-const
abstract
eqv : ∀ c → codeAA a₀ (f c) ≃ codeAB a₀ (g c)
eqv = SE.ext
eqv-β : ∀ d → eqv (h d) == eqv-on-image d
eqv-β = SE.β
module CodeAP (a₀ : A) = PushoutRec (codeAA a₀) (codeAB a₀)
(ua ∘ CodeAAEquivCodeAB.eqv a₀)
codeAP : A → Pushout span → Type (lmax (lmax (lmax i j) k) l)
codeAP = CodeAP.f
abstract
codeAP-level : ∀ {a₀ p₁} → is-set (codeAP a₀ p₁)
codeAP-level {a₀} {p₁} = Pushout-elim
{P = λ p₁ → is-set (codeAP a₀ p₁)}
(λ a₁ → SetQuot-is-set)
(λ b₁ → SetQuot-is-set)
(λ c₁ → prop-has-all-paths-↓ is-set-is-prop)
p₁
codeAP-is-set = codeAP-level
abstract
transp-cAP-glue : ∀ {a₀} d₁ (pcAA : precodeAA a₀ (f (h d₁)))
→ transport (codeAP a₀) (glue (h d₁)) q[ pcAA ] == q[ pcAA aa⟦ d₁ ⟧b idp₀ ]
transp-cAP-glue {a₀} d₁ pcAA =
transport (codeAP a₀) (glue (h d₁)) q[ pcAA ]
=⟨ ap (λ e → coe e q[ pcAA ]) (CodeAP.glue-β a₀ (h d₁) ∙ ap ua (CodeAAEquivCodeAB.eqv-β a₀ d₁)) ⟩
coe (ua (CodeAAEquivCodeAB.eqv-on-image a₀ d₁)) q[ pcAA ]
=⟨ coe-β (CodeAAEquivCodeAB.eqv-on-image a₀ d₁) q[ pcAA ] ⟩
q[ pcAA aa⟦ d₁ ⟧b idp₀ ]
=∎
transp-cAP-!glue : ∀ {a₀} d₁ (pcAB : precodeAB a₀ (g (h d₁)))
→ transport (codeAP a₀) (! (glue (h d₁))) q[ pcAB ] == q[ pcAB ab⟦ d₁ ⟧a idp₀ ]
transp-cAP-!glue {a₀} d₁ pcAB =
transport (codeAP a₀) (! (glue (h d₁))) q[ pcAB ]
=⟨ ap (λ e → coe e q[ pcAB ]) (ap-! (codeAP a₀) (glue (h d₁)))
∙ coe-! (ap (codeAP a₀) (glue (h d₁))) q[ pcAB ] ⟩
transport! (codeAP a₀) (glue (h d₁)) q[ pcAB ]
=⟨ ap (λ e → coe! e q[ pcAB ]) (CodeAP.glue-β a₀ (h d₁) ∙ ap ua (CodeAAEquivCodeAB.eqv-β a₀ d₁)) ⟩
coe! (ua (CodeAAEquivCodeAB.eqv-on-image a₀ d₁)) q[ pcAB ]
=⟨ coe!-β (CodeAAEquivCodeAB.eqv-on-image a₀ d₁) q[ pcAB ] ⟩
q[ pcAB ab⟦ d₁ ⟧a idp₀ ]
=∎
-- code to path
pcAA-to-path : ∀ {a₀ a₁} → precodeAA a₀ a₁ → left a₀ =₀ left a₁ :> Pushout span
pcAB-to-path : ∀ {a₀ b₁} → precodeAB a₀ b₁ → left a₀ =₀ right b₁ :> Pushout span
pcAA-to-path (pc-a pA) = ap₀ left pA
pcAA-to-path (pc-aba d pc pA) = pcAB-to-path pc ∙₀' !₀ [ glue (h d) ] ∙₀' ap₀ left pA
pcAB-to-path (pc-aab d pc pB) = pcAA-to-path pc ∙₀' [ glue (h d) ] ∙₀' ap₀ right pB
abstract
pcAA-to-path-rel : ∀ {a₀ a₁} {pcAA₀ pcAA₁ : precodeAA a₀ a₁}
→ precodeAA-rel pcAA₀ pcAA₁ → pcAA-to-path pcAA₀ == pcAA-to-path pcAA₁
pcAB-to-path-rel : ∀ {a₀ b₁} {pcAB₀ pcAB₁ : precodeAB a₀ b₁}
→ precodeAB-rel pcAB₀ pcAB₁ → pcAB-to-path pcAB₀ == pcAB-to-path pcAB₁
pcAA-to-path-rel (pcAAr-idp₀-idp₀ pcAA) =
∙₀'-assoc (pcAA-to-path pcAA) [ glue (h _) ] [ ! (glue (h _)) ]
∙ ap (λ p → pcAA-to-path pcAA ∙₀' [ p ]) (!-inv'-r (glue (h _)))
∙ ∙₀'-unit-r (pcAA-to-path pcAA)
pcAA-to-path-rel (pcAAr-cong pcAB pA) = pcAB-to-path-rel pcAB |in-ctx _∙₀' !₀ [ glue (h _) ] ∙₀' ap₀ left pA
pcAB-to-path-rel (pcABr-idp₀-idp₀ pcAB) =
∙₀'-assoc (pcAB-to-path pcAB) [ ! (glue (h _)) ] [ glue (h _) ]
∙ ap (λ p → pcAB-to-path pcAB ∙₀' [ p ]) (!-inv'-l (glue (h _)))
∙ ∙₀'-unit-r (pcAB-to-path pcAB)
pcAB-to-path-rel (pcABr-switch pcAB pC) =
ap (_∙₀' [ glue (h _) ]) (! (∙₀'-assoc (pcAB-to-path pcAB) [ ! (glue (h _)) ] (ap₀ left (ap₀ f pC))))
∙ ∙₀'-assoc (pcAB-to-path pcAB ∙₀' [ ! (glue (h _)) ]) (ap₀ left (ap₀ f pC)) [ glue (h _) ]
∙ ap ((pcAB-to-path pcAB ∙₀' [ ! (glue (h _)) ]) ∙₀'_) (natural₀ pC)
where
natural : ∀ {c₀ c₁} (p : c₀ == c₁)
→ (ap left (ap f p) ∙' glue c₁) == (glue c₀ ∙' ap right (ap g p))
:> (left (f c₀) == right (g c₁) :> Pushout span)
natural idp = ∙'-unit-l (glue _)
natural₀ : ∀ {c₀ c₁} (p : c₀ =₀ c₁)
→ (ap₀ left (ap₀ f p) ∙₀' [ glue c₁ ]) == ([ glue c₀ ] ∙₀' ap₀ right (ap₀ g p))
:> (left (f c₀) =₀ right (g c₁) :> Pushout span)
natural₀ = Trunc-elim (λ _ → =-preserves-set Trunc-level) (ap [_] ∘ natural)
pcAB-to-path-rel (pcABr-cong pcAA pB) = pcAA-to-path-rel pcAA |in-ctx _∙₀' [ glue (h _) ] ∙₀' ap₀ right pB
decodeAA : ∀ {a₀ a₁} → codeAA a₀ a₁ → left a₀ =₀ left a₁ :> Pushout span
decodeAB : ∀ {a₀ b₁} → codeAB a₀ b₁ → left a₀ =₀ right b₁ :> Pushout span
decodeAA = SetQuot-rec Trunc-level pcAA-to-path pcAA-to-path-rel
decodeAB = SetQuot-rec Trunc-level pcAB-to-path pcAB-to-path-rel
abstract
decodeAA-is-decodeAB : ∀ {a₀} c₁ →
decodeAA {a₀} {f c₁} == decodeAB {a₀} {g c₁}
[ (λ p₁ → codeAP a₀ p₁ → left a₀ =₀ p₁) ↓ glue c₁ ]
decodeAA-is-decodeAB {a₀ = a₀} = SurjExt.ext
(λ _ → ↓-preserves-level $ Π-is-set λ _ → Trunc-level) h h-is-surj
(λ d₁ → ↓-→-from-transp $ λ= $ SetQuot-elim
{P = λ cAA → transport (left a₀ =₀_) (glue (h d₁)) (decodeAA cAA)
== decodeAB (transport (codeAP a₀) (glue (h d₁)) cAA)}
(λ _ → =-preserves-set Trunc-level)
(λ pcAA →
transport (left a₀ =₀_) (glue (h d₁)) (pcAA-to-path pcAA)
=⟨ transp₀-cst=₀idf [ glue (h d₁) ] (pcAA-to-path pcAA) ⟩
pcAA-to-path pcAA ∙₀' [ glue (h d₁) ]
=⟨ ! $ ap (λ e → decodeAB (–> e q[ pcAA ])) (CodeAAEquivCodeAB.eqv-β a₀ d₁) ⟩
decodeAB (–> (CodeAAEquivCodeAB.eqv a₀ (h d₁)) q[ pcAA ])
=⟨ ! $ ap decodeAB (coe-β (CodeAAEquivCodeAB.eqv a₀ (h d₁)) q[ pcAA ]) ⟩
decodeAB (coe (ua (CodeAAEquivCodeAB.eqv a₀ (h d₁))) q[ pcAA ])
=⟨ ! $ ap (λ p → decodeAB (coe p q[ pcAA ])) (CodeAP.glue-β a₀ (h d₁)) ⟩
decodeAB (transport (codeAP a₀) (glue (h d₁)) q[ pcAA ])
=∎)
(λ _ → prop-has-all-paths-↓ $ Trunc-level {n = 0} _ _))
(λ _ _ _ → prop-has-all-paths-↓ $ ↓-level $ Π-is-set λ _ → Trunc-level)
decodeAP : ∀ {a₀ p₁} → codeAP a₀ p₁ → left a₀ =₀ p₁
decodeAP {p₁ = p₁} = Pushout-elim
(λ a₁ → decodeAA) (λ b₁ → decodeAB)
decodeAA-is-decodeAB
p₁
|
{
"alphanum_fraction": 0.5404271845,
"avg_line_length": 47.6851851852,
"ext": "agda",
"hexsha": "9131de1c9617bb44170c717ee9a533ef39130001",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2018-12-26T21:31:57.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-12-26T21:31:57.000Z",
"max_forks_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "mikeshulman/HoTT-Agda",
"max_forks_repo_path": "theorems/homotopy/vankampen/CodeAP.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "mikeshulman/HoTT-Agda",
"max_issues_repo_path": "theorems/homotopy/vankampen/CodeAP.agda",
"max_line_length": 112,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "mikeshulman/HoTT-Agda",
"max_stars_repo_path": "theorems/homotopy/vankampen/CodeAP.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 5715,
"size": 12875
}
|
{-# OPTIONS --without-K #-}
-- this is mostly reference for an unused intermediate step.
module Cauchy2 where
open import Data.Nat
open import Data.Vec renaming (map to mapV; _++_ to _++V_; concat to concatV)
open import Data.Fin using (Fin; inject+; raise; inject≤; fromℕ; toℕ)
open import Function using (id)
open import Relation.Binary.PropositionalEquality using (_≡_; subst)
open import VectorLemmas
open import LeqLemmas
open import Cauchy using (id+)
Cauchy : ℕ → ℕ → Set
Cauchy n₁ n₂ = Vec (Fin n₁) n₂
------------------------------------------------------------------------------
-- Elementary permutations in the Cauchy representation
emptycauchy : Cauchy 0 0
emptycauchy = []
idcauchy : (n : ℕ) → Cauchy n n
idcauchy = allFin
-- Sequential composition
scompcauchy : ∀ {n₀ n₁ n₂} → Cauchy n₁ n₀ → Cauchy n₂ n₁ → Cauchy n₂ n₀
scompcauchy {n} perm₁ perm₂ =
tabulate (λ i → lookup (lookup i perm₁) perm₂)
-- swap the first m elements with the last n elements
-- [ v₀ , v₁ , v₂ , ... , vm-1 , vm , vm₊₁ , ... , vm+n-1 ]
-- ==>
-- [ vm , vm₊₁ , ... , vm+n-1 , v₀ , v₁ , v₂ , ... , vm-1 ]
swap+cauchy : (m n : ℕ) → Cauchy (m + n) (n + m)
swap+cauchy m n = {!!} -- tabulate swapper
-- Parallel additive composition
-- append both permutations but adjust the indices in the second
-- permutation by the size of the first type so that it acts on the
-- second part of the vector
pcompcauchy : ∀ {m₁ n₁ m₂ n₂} → Cauchy m₁ m₂ → Cauchy n₁ n₂ → Cauchy (m₁ + n₁) (m₂ + n₂)
pcompcauchy {m} {n} α β = mapV (inject+ n) α ++V mapV (raise m) β
-- Tensor multiplicative composition
-- Transpositions in α correspond to swapping entire rows
-- Transpositions in β correspond to swapping entire columns
tcompcauchy : ∀ {m₁ n₁ m₂ n₂} → Cauchy m₁ m₂ → Cauchy n₁ n₂ → Cauchy (m₁ * n₁) (m₂ * n₂)
tcompcauchy {m} {n} α β =
concatV
(mapV
(λ b →
mapV (λ d → inject≤ (fromℕ (toℕ b * n + toℕ d)) (i*n+k≤m*n b d)) β)
α)
-- swap⋆
--
-- This is essentially the classical problem of in-place matrix transpose:
-- "http://en.wikipedia.org/wiki/In-place_matrix_transposition"
-- Given m and n, the desired permutation in Cauchy representation is:
-- P(i) = m*n-1 if i=m*n-1
-- = m*i mod m*n-1 otherwise
transposeIndex : (m n : ℕ) →
(b : Fin m) → (d : Fin n) → Fin (n * m)
transposeIndex m n b d =
inject≤ (fromℕ (toℕ d * m + toℕ b))
(i*n+k≤m*n d b)
{- inject≤
(fromℕ (toℕ d * m + toℕ b))
(trans≤ (i*n+k≤m*n d b) (refl′ (*-comm n m))) -}
swap⋆cauchy : (m₁ n₁ m₂ n₂ : ℕ) → (meq : m₂ ≡ m₁) → (neq : n₂ ≡ n₁) → Cauchy (n₁ * m₁) (n₂ * m₂)
swap⋆cauchy m₁ n₁ m₂ n₂ meq neq =
concatV (mapV
(λ d → mapV (λ b → transposeIndex m₁ n₁ (subst Fin meq b) (subst Fin neq d)) (allFin m₂))
(allFin n₂))
|
{
"alphanum_fraction": 0.6117945007,
"avg_line_length": 33.3012048193,
"ext": "agda",
"hexsha": "595a2bd1f4cf569782a017b6fc64f368110792bb",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2019-09-10T09:47:13.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-05-29T01:56:33.000Z",
"max_forks_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "JacquesCarette/pi-dual",
"max_forks_repo_path": "Univalence/Obsolete/Cauchy2.agda",
"max_issues_count": 4,
"max_issues_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1",
"max_issues_repo_issues_event_max_datetime": "2021-10-29T20:41:23.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-06-07T16:27:41.000Z",
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "JacquesCarette/pi-dual",
"max_issues_repo_path": "Univalence/Obsolete/Cauchy2.agda",
"max_line_length": 100,
"max_stars_count": 14,
"max_stars_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "JacquesCarette/pi-dual",
"max_stars_repo_path": "Univalence/Obsolete/Cauchy2.agda",
"max_stars_repo_stars_event_max_datetime": "2021-05-05T01:07:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-08-18T21:40:15.000Z",
"num_tokens": 1017,
"size": 2764
}
|
{-# OPTIONS --without-K --exact-split --rewriting #-}
open import lib.Basics
open import lib.types.Truncation
open import lib.types.Fin
open import lib.types.Nat
open import lib.types.Empty
open import lib.types.Unit
open import lib.types.Coproduct
open import lib.types.Sigma
open import lib.types.Paths
open import lib.NConnected
open import Util.Misc
open import Util.Finite
open import Util.Coproducts
open import Graphs.Definition
open import Graphs.Properties
open import Coequalizers.Definition
open import Coequalizers.PreserveEquivalence
open import Coequalizers.EdgeCoproduct
open import Coequalizers.Misc
open import Graphs.SubTrees
{- We show that graphs with finite vertex set have spanning trees. -}
module Graphs.SpanningTreeFinite {i : ULevel} where
module _ (E : Type i) (V : Type i) ⦃ gph : Graph E V ⦄ where
instance
noedges : {j : ULevel} {V : Type j} → Graph ⊥ V -- defines the trivial coequalizer V / ⊥
noedges = record { π₀ = ⊥-elim ; π₁ = ⊥-elim }
noedge-triv : {j : ULevel} {V : Type j} → V / ⊥ ≃ V
noedge-triv {V = V} = f , (record { g = c[_] ; f-g = f-g ; g-f = g-f ; adj = adj })
where
f : V / ⊥ → V
f = Coeq-rec (idf V) (λ _ → idp)
f-g : (v : V) → (f (c[ v ]) == v)
f-g v = idp
g-f : (z : V / ⊥) → (c[ (f z) ] == z)
g-f = Coeq-elim _ (λ _ → idp) ⊥-elim
adj : (z : V / ⊥) → ap f (g-f z) == idp
adj = Coeq-elim _ (λ _ → idp) ⊥-elim
{- A spanning tree is a subtree where the inclusion of vertex sets is an
equivalence and the inclusion of edge sets is complemented.
-}
record SpanningTree {j k l : ULevel} (E : Type i) (V : Type j) ⦃ gph : Graph E V ⦄
(E' : Type k) (V' : Type l) : Type (lmax (lmax i j) (lmax l k)) where
field
is-st : SubTree E V E' V'
open SubTree is-st public
field
all-vertices : is-equiv inU
is-complemented : E ≃ E' ⊔ Σ E (λ e → ¬ (hfiber inD e))
inD-comm : inD ∼ (<– is-complemented) ∘ inl
module ExtendSpanningTree {j k l : ULevel} (E : Type i) (V : Type j) ⦃ gph : Graph E V ⦄
(E' : Type k) (V' : Type l) (spantree : SpanningTree E V E' V') where
open SpanningTree spantree
¬E' = Σ E (λ e → ¬ (hfiber (SubTree.inD is-st) e))
instance
gph-coprod : Graph (E' ⊔ ¬E') V'
gph-coprod = record { π₀ = ⊔-rec π₀ λ e → is-equiv.g all-vertices (π₀ (<– is-complemented (inr e)))
; π₁ = ⊔-rec π₁ λ e → is-equiv.g all-vertices (π₁ (<– is-complemented (inr e))) }
inU-equiv : V' ≃ V
inU-equiv = (inU , all-vertices)
spantree-equiv : V / E ≃ V' / (E' ⊔ ¬E')
spantree-equiv = (Coeq-emap inU-equiv (is-complemented ⁻¹)
(λ { (inl e') → ! (comm₀ e') ∙ ap π₀ (inD-comm e') ; (inr x) → <–-inv-r inU-equiv _})
λ { (inl e') → ! (comm₁ e') ∙ ap π₁ (inD-comm e') ; (inr x) → <–-inv-r inU-equiv _}) ⁻¹
composepp : {j k l : ULevel} {E' : Type j} {E : Type k} {V : Type l} ( inc : E' → E ) ⦃ gph : Graph E V ⦄ → Graph E' V
composepp inc ⦃ gph = gph ⦄ = record { π₀ = P.π₀ ∘ inc ; π₁ = P.π₁ ∘ inc }
where
module P = Graph gph
Fin-equiv-Unit : Fin 1 ≃ ⊤
Fin-equiv-Unit =
Fin 1
≃⟨ Fin-equiv-Coprod ⟩
Fin 0 ⊔ ⊤
≃⟨ ⊔-emap Fin-equiv-Empty (ide ⊤) ⟩
⊥ ⊔ ⊤
≃⟨ ⊔₁-Empty ⊤ ⟩
⊤
≃∎
compose-equiv-subtree-l : {j k l m n : ULevel} {E : Type i} {V : Type j} ⦃ gph : Graph E V ⦄
(D : Type k) (U : Type l) (D' : Type m) (U' : Type n) → (D' ≃ D) → (U' ≃ U) →
SubTree E V D U → SubTree E V D' U'
compose-equiv-subtree-l D U D' U' equivD equivU (subtree inD inU D-inj U-inj U-dec comm₀ comm₁) =
subtree (inD ∘ –> equivD) (inU ∘ –> equivU) (∘-is-inj D-inj (–>-is-inj equivD)) (∘-is-inj U-inj (–>-is-inj equivU))
(λ v → ⊔-rec (λ {(u , p) → inl ((<– equivU u) , (ap inU (<–-inv-r equivU u) ∙ p))})
(λ f → inr (λ {(u , p) → f ((–> equivU u) , p) })) (U-dec v))
(λ d → comm₀ (–> equivD d) ∙ ap inU (! (<–-inv-r equivU _)))
(λ d → comm₁ (–> equivD d) ∙ ap inU (! (<–-inv-r equivU _)))
where
instance
gph' : Graph D' U'
gph' = record { π₀ = λ d → <– equivU (π₀ (–> equivD d)) ; π₁ = λ d → <– equivU (π₁ (–> equivD d)) }
c : is-contr (U' / D')
c = equiv-preserves-level ((Coeq-emap equivU equivD (λ d → <–-inv-r equivU _) λ d → <–-inv-r equivU _) ⁻¹)
{- Since the vertex set is finite, we can build the spanning tree up a step at a time. -}
build-spanning-tree : (E : Type i) (n : ℕ) ⦃ gph : Graph E (Fin (S n)) ⦄ ⦃ conn : gph-is-connected gph ⦄ →
(k : ℕ) → (k < S n) → ∥ SubTree E (Fin (S n)) (Fin k) (Fin (S k)) ∥
build-spanning-tree E n O l =
[ compose-equiv-subtree-l _ _ _ _ Fin-equiv-Empty Fin-equiv-Unit t ]
where
instance
ic : is-contr (⊤ / ⊥)
ic = equiv-preserves-level (noedge-triv ⁻¹)
t : SubTree E (Fin (S n)) ⊥ ⊤
t = subtree ⊥-elim (λ _ → 0 , l) ⊥-elim (λ {unit unit _ → idp}) (λ v → ⊔-fmap (λ p → unit , (! p)) (λ {f (unit , p) → f (! p)}) (Fin-has-dec-eq v (0 , l)))
⊥-elim ⊥-elim
build-spanning-tree E n (S k) l =
do
ih ← (build-spanning-tree E n k (<-trans ltS l))
let x = Fin-smaller-is-smaller l (SubTree.inU ih)
t ← (extend-subtree E (Fin (S n)) Fin-has-dec-eq ih (fst x) (snd x))
[ compose-equiv-subtree-l _ _ _ _ (⊔-sym ∘e Fin-equiv-Coprod) Fin-equiv-Coprod t ]
spanning-tree : (E : Type i) (Edec : has-dec-eq E) (n : ℕ) ⦃ gph : Graph E (Fin (S n)) ⦄ ⦃ conn : gph-is-connected gph ⦄ →
∥ SpanningTree E (Fin (S n)) (Fin n) (Fin (S n)) ∥
spanning-tree E Edec n = Trunc-fmap from-subtree (build-spanning-tree E _ _ ltS)
where
from-subtree : SubTree E (Fin (S n)) (Fin n) (Fin (S n)) → SpanningTree E (Fin (S n)) (Fin n) (Fin (S n))
from-subtree st@(subtree ⦃ gphDU ⦄ inD inU D-inj U-inj U-dec comm₀ comm₁) =
record
{ is-st = st
; all-vertices = Fin-inj-to-equiv inU U-inj
; is-complemented = dec-img-to-⊔ inD D-inj (Fin-hfiber-dec Edec inD) ⁻¹
; inD-comm = λ _ → idp
}
|
{
"alphanum_fraction": 0.5599797537,
"avg_line_length": 37.5126582278,
"ext": "agda",
"hexsha": "62df9649813bea30b54cd2118c835a6868b8e928",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "84be713b8a8e41ea6f01f8ccf7251ebbbd73ad5d",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "awswan/nielsenschreier-hott",
"max_forks_repo_path": "main/Graphs/SpanningTreeFinite.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "84be713b8a8e41ea6f01f8ccf7251ebbbd73ad5d",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "awswan/nielsenschreier-hott",
"max_issues_repo_path": "main/Graphs/SpanningTreeFinite.agda",
"max_line_length": 159,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "84be713b8a8e41ea6f01f8ccf7251ebbbd73ad5d",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "awswan/nielsenschreier-hott",
"max_stars_repo_path": "main/Graphs/SpanningTreeFinite.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2345,
"size": 5927
}
|
{-# OPTIONS --universe-polymorphism #-}
module SortDependingOnIndex where
open import Imports.Level
data Bad : (l : Level) → Set l where
|
{
"alphanum_fraction": 0.7338129496,
"avg_line_length": 19.8571428571,
"ext": "agda",
"hexsha": "6dfa7c6fdf28bdb96f8c3686dae0a15fa2f11614",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "20596e9dd9867166a64470dd24ea68925ff380ce",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "np/agda-git-experiment",
"max_forks_repo_path": "test/fail/SortDependingOnIndex.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "20596e9dd9867166a64470dd24ea68925ff380ce",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "np/agda-git-experiment",
"max_issues_repo_path": "test/fail/SortDependingOnIndex.agda",
"max_line_length": 39,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/agda-kanso",
"max_stars_repo_path": "test/fail/SortDependingOnIndex.agda",
"max_stars_repo_stars_event_max_datetime": "2019-11-27T04:41:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-11-27T04:41:05.000Z",
"num_tokens": 34,
"size": 139
}
|
{-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Orders.Total.Definition
open import Orders.Total.Lemmas
open import Maybe
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Vectors
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Order
module KeyValue.LinearStore.Implementation {a b c} (keySet : Set a) (valueSet : Set b) (keyOrder : TotalOrder {_} keySet {c}) where
record ReducedMap (min : keySet) : Set (a ⊔ b ⊔ c)
record ReducedMap min where
inductive
field
firstEntry : valueSet
next : Maybe (Sg keySet (λ nextKey → (ReducedMap nextKey) && (TotalOrder._<_ keyOrder min nextKey)))
addReducedMap : {min : keySet} → (k : keySet) → (v : valueSet) → (m : ReducedMap min) → ReducedMap (TotalOrder.min keyOrder min k)
addReducedMap {min} k v m with TotalOrder.totality keyOrder min k
addReducedMap {min} k v record { firstEntry = firstEntry ; next = no } | inl (inl min<k) = record { firstEntry = firstEntry ; next = yes (k , (record { firstEntry = v ; next = no} ,, min<k))}
addReducedMap {min} k v record { firstEntry = minVal ; next = yes (nextKey , (m ,, pr)) } | inl (inl min<k) = record { firstEntry = minVal ; next = yes ((TotalOrder.min keyOrder nextKey k) , (addReducedMap {_} k v m ,, minFromBoth keyOrder pr min<k))}
addReducedMap {min} k v record { firstEntry = firstEntry ; next = next } | inl (inr k<min) = record { firstEntry = v ; next = yes (min , (record { firstEntry = firstEntry ; next = next } ,, k<min)) }
addReducedMap {min} k v record { firstEntry = firstEntry ; next = next } | inr min=k rewrite min=k = record { firstEntry = v ; next = next }
lookupReduced : {min : keySet} → (m : ReducedMap min) → (target : keySet) → Maybe valueSet
lookupReduced {min} m k with TotalOrder.totality keyOrder min k
lookupReduced {min} record { firstEntry = firstEntry ; next = no } k | inl (inl min<k) = no
lookupReduced {min} record { firstEntry = firstEntry ; next = (yes (newMin , (m ,, _))) } k | inl (inl min<k) = lookupReduced {newMin} m k
lookupReduced {min} m k | inl (inr k<min) = no
lookupReduced {min} record { firstEntry = firstEntry ; next = next } k | inr min=k = yes firstEntry
countReduced : {min : keySet} → (m : ReducedMap min) → ℕ
countReduced record { firstEntry = firstEntry ; next = no } = 1
countReduced record { firstEntry = firstEntry ; next = (yes (key , (m ,, pr))) } = succ (countReduced m)
lookupReducedSucceedsAfterAdd : {min : keySet} → (k : keySet) → (v : valueSet) → (m : ReducedMap min) → (lookupReduced (addReducedMap k v m) k ≡ yes v)
lookupReducedSucceedsAfterAdd {min} k v m with TotalOrder.totality keyOrder min k
lookupReducedSucceedsAfterAdd {min} k v record { firstEntry = firstEntry ; next = no } | inl (inl min<k) with TotalOrder.totality keyOrder min k
lookupReducedSucceedsAfterAdd {min} k v record { firstEntry = firstEntry ; next = no } | inl (inl min<k) | inl (inl _) with TotalOrder.totality keyOrder k k
lookupReducedSucceedsAfterAdd {min} k v record { firstEntry = firstEntry ; next = no } | inl (inl min<k) | inl (inl _) | inl (inl k<k) = exFalso (TotalOrder.irreflexive keyOrder k<k)
lookupReducedSucceedsAfterAdd {min} k v record { firstEntry = firstEntry ; next = no } | inl (inl min<k) | inl (inl _) | inl (inr k<k) = exFalso (TotalOrder.irreflexive keyOrder k<k)
lookupReducedSucceedsAfterAdd {min} k v record { firstEntry = firstEntry ; next = no } | inl (inl min<k) | inl (inl _) | inr p = refl
lookupReducedSucceedsAfterAdd {min} k v record { firstEntry = firstEntry ; next = no } | inl (inl min<k) | inl (inr k<min) = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder min<k k<min))
lookupReducedSucceedsAfterAdd {min} k v record { firstEntry = firstEntry ; next = no } | inl (inl min<k) | inr min=k rewrite min=k = exFalso (TotalOrder.irreflexive keyOrder min<k)
lookupReducedSucceedsAfterAdd {min} k v record { firstEntry = firstEntry ; next = (yes (newMin , (m ,, pr))) } | inl (inl min<k) with TotalOrder.totality keyOrder min k
lookupReducedSucceedsAfterAdd {min} k v record { firstEntry = firstEntry ; next = (yes (newMin , (m ,, pr))) } | inl (inl min<k) | inl (inl _) = lookupReducedSucceedsAfterAdd k v m
lookupReducedSucceedsAfterAdd {min} k v record { firstEntry = firstEntry ; next = (yes (newMin , (m ,, pr))) } | inl (inl min<k) | inl (inr k<min) = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder min<k k<min))
lookupReducedSucceedsAfterAdd {min} k v record { firstEntry = firstEntry ; next = (yes (newMin , (m ,, pr))) } | inl (inl min<k) | inr min=k rewrite min=k = exFalso (TotalOrder.irreflexive keyOrder min<k)
lookupReducedSucceedsAfterAdd {min} k v m | inl (inr k<min) with TotalOrder.totality keyOrder k k
lookupReducedSucceedsAfterAdd {min} k v m | inl (inr k<min) | inl (inl k<k) = exFalso (TotalOrder.irreflexive keyOrder k<k)
lookupReducedSucceedsAfterAdd {min} k v m | inl (inr k<min) | inl (inr k<k) = exFalso (TotalOrder.irreflexive keyOrder k<k)
lookupReducedSucceedsAfterAdd {min} k v m | inl (inr k<min) | inr p = refl
lookupReducedSucceedsAfterAdd {min} k v m | inr min=k with TotalOrder.totality keyOrder k k
lookupReducedSucceedsAfterAdd {min} k v m | inr min=k | inl (inl k<k) = exFalso (TotalOrder.irreflexive keyOrder k<k)
lookupReducedSucceedsAfterAdd {min} k v m | inr min=k | inl (inr k<k) = exFalso (TotalOrder.irreflexive keyOrder k<k)
lookupReducedSucceedsAfterAdd {min} k v m | inr min=k | inr p with TotalOrder.totality keyOrder min k
lookupReducedSucceedsAfterAdd {min} k v m | inr min=k | inr p | inl (inl min<k) rewrite min=k = exFalso (TotalOrder.irreflexive keyOrder min<k)
lookupReducedSucceedsAfterAdd {min} k v m | inr min=k | inr p | inl (inr k<min) rewrite min=k = exFalso (TotalOrder.irreflexive keyOrder k<min)
lookupReducedSucceedsAfterAdd {.k} k v record { firstEntry = firstEntry ; next = next } | inr refl | inr p | inr s = refl
lookupReducedSucceedsAfterUnrelatedAdd : {min : keySet} → (unrelatedK : keySet) → (unrelatedV : valueSet) → (k : keySet) → (v : valueSet) → ((TotalOrder._<_ keyOrder unrelatedK k) || (TotalOrder._<_ keyOrder k unrelatedK)) → (m : ReducedMap min) → (lookupReduced m k ≡ yes v) → lookupReduced (addReducedMap unrelatedK unrelatedV m) k ≡ yes v
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v pr m lookupReducedSucceeds with TotalOrder.totality keyOrder min k'
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v pr m lookupReducedSucceeds | inl (inl min<k') with TotalOrder.totality keyOrder min k
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v pr record { firstEntry = firstEntry ; next = no } () | inl (inl min<k') | inl (inl min<k)
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v pr record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } lookupReducedSucceeds | inl (inl min<k') | inl (inl min<k) = lookupReducedSucceedsAfterUnrelatedAdd {a} k' v' k v pr fst lookupReducedSucceeds
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v (inl x) m lookupReducedSucceeds | inl (inl min<k') | inl (inr k<min) = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder k<min (TotalOrder.<Transitive keyOrder min<k' x)))
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v (inr k<k') m () | inl (inl min<k') | inl (inr k<min)
lookupReducedSucceedsAfterUnrelatedAdd {.min} k' v' min v (inl x) m lookupReducedSucceeds | inl (inl min<k') | inr refl = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder x min<k'))
lookupReducedSucceedsAfterUnrelatedAdd {.min} k' v' min v (inr x) record { firstEntry = v2 ; next = no } p | inl (inl min<k') | inr refl = applyEquality yes (yesInjective p)
lookupReducedSucceedsAfterUnrelatedAdd {.min} k' v' min v (inr x) record { firstEntry = .v ; next = (yes (a , b)) } refl | inl (inl min<k') | inr refl = applyEquality yes refl
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v pr m lookupReducedSucceeds | inl (inr k'<min) with TotalOrder.totality keyOrder k' k
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v pr m lookupReducedSucceeds | inl (inr k'<min) | inl (inl k'<k) with TotalOrder.totality keyOrder min k
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v pr m lookupReducedSucceeds | inl (inr k'<min) | inl (inl k'<k) | inl (inl min<k) = lookupReducedSucceeds
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v pr m () | inl (inr k'<min) | inl (inl k'<k) | inl (inr k<min)
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v pr m lookupReducedSucceeds | inl (inr k'<min) | inl (inl k'<k) | inr refl = lookupReducedSucceeds
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v (inl x) m lookupReducedSucceeds | inl (inr k'<min) | inl (inr k<k') = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder x k<k'))
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v (inr x) m lookupReducedSucceeds | inl (inr k'<min) | inl (inr k<k') with TotalOrder.totality keyOrder min k
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v (inr _) m lookupReducedSucceeds | inl (inr k'<min) | inl (inr k<k') | inl (inl x) = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder x (TotalOrder.<Transitive keyOrder k<k' k'<min)))
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v (inr _) m () | inl (inr k'<min) | inl (inr k<k') | inl (inr x)
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v (inr _) m lookupReducedSucceeds | inl (inr k'<min) | inl (inr k<k') | inr x rewrite x = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder k<k' k'<min))
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v (inl x) m lookupReducedSucceeds | inl (inr k'<min) | inr k'=k rewrite k'=k = exFalso (TotalOrder.irreflexive keyOrder x)
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v (inr x) m lookupReducedSucceeds | inl (inr k'<min) | inr k'=k rewrite k'=k = exFalso (TotalOrder.irreflexive keyOrder x)
lookupReducedSucceedsAfterUnrelatedAdd {min} k' v' k v pr m lookupReducedSucceeds | inr refl with TotalOrder.totality keyOrder min k
lookupReducedSucceedsAfterUnrelatedAdd {k'} k' v' k v (inl _) record { firstEntry = firstEntry ; next = no } () | inr refl | inl (inl min<k)
lookupReducedSucceedsAfterUnrelatedAdd {k'} k' v' k v (inl _) record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } lookupReducedSucceeds | inr refl | inl (inl min<k) = lookupReducedSucceeds
lookupReducedSucceedsAfterUnrelatedAdd {k'} k' v' k v (inr x) m lookupReducedSucceeds | inr refl | inl (inl min<k) = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder min<k x))
lookupReducedSucceedsAfterUnrelatedAdd {k'} k' v' k v (inl x) m () | inr refl | inl (inr k<min)
lookupReducedSucceedsAfterUnrelatedAdd {k'} k' v' k v (inr x) m () | inr refl | inl (inr k<min)
lookupReducedSucceedsAfterUnrelatedAdd {.min} .min v' min v (inl x) m lookupReducedSucceeds | inr refl | inr refl = exFalso (TotalOrder.irreflexive keyOrder x)
lookupReducedSucceedsAfterUnrelatedAdd {.min} .min v' min v (inr x) m lookupReducedSucceeds | inr refl | inr refl = exFalso (TotalOrder.irreflexive keyOrder x)
lookupReducedFailsAfterUnrelatedAdd : {min : keySet} → (unrelatedK : keySet) → (unrelatedV : valueSet) → (k : keySet) → ((TotalOrder._<_ keyOrder unrelatedK k) || (TotalOrder._<_ keyOrder k unrelatedK)) → (m : ReducedMap min) → (lookupReduced m k ≡ no) → lookupReduced (addReducedMap unrelatedK unrelatedV m) k ≡ no
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr m lookupReducedFails with TotalOrder.totality keyOrder min k'
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr m lookupReducedFails | inl (inl min<k') with TotalOrder.totality keyOrder min k
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr record { firstEntry = firstEntry ; next = no } lookupReducedFails | inl (inl min<k') | inl (inl min<k) with TotalOrder.totality keyOrder k' k
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr record { firstEntry = firstEntry ; next = no } lookupReducedFails | inl (inl min<k') | inl (inl min<k) | inl (inl x) = refl
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr record { firstEntry = firstEntry ; next = no } lookupReducedFails | inl (inl min<k') | inl (inl min<k) | inl (inr x) = refl
lookupReducedFailsAfterUnrelatedAdd {min} .k v' k (inl x) record { firstEntry = firstEntry ; next = no } lookupReducedFails | inl (inl min<k') | inl (inl min<k) | inr refl = exFalso (TotalOrder.irreflexive keyOrder x)
lookupReducedFailsAfterUnrelatedAdd {min} .k v' k (inr x) record { firstEntry = firstEntry ; next = no } lookupReducedFails | inl (inl min<k') | inl (inl min<k) | inr refl = exFalso (TotalOrder.irreflexive keyOrder x)
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } lookupReducedFails | inl (inl min<k') | inl (inl min<k) = lookupReducedFailsAfterUnrelatedAdd k' v' k pr fst lookupReducedFails
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr m lookupReducedFails | inl (inl min<k') | inl (inr k<min) = refl
lookupReducedFailsAfterUnrelatedAdd {.min} k' v' min pr m () | inl (inl min<k') | inr refl
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr m lookupReducedFails | inl (inr k'<min) with TotalOrder.totality keyOrder min k
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inr k'<min) | inl (inl min<k) with TotalOrder.totality keyOrder k' k
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inr k'<min) | inl (inl min<k) | inl (inl k'<k) with TotalOrder.totality keyOrder min k
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k (inl x₁) record { firstEntry = firstEntry ; next = no } lookupReducedFails | inl (inr k'<min) | inl (inl min<k) | inl (inl k'<k) | inl (inl _) = refl
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k (inl x₁) record { firstEntry = firstEntry ; next = (yes (a , b)) } lookupReducedFails | inl (inr k'<min) | inl (inl min<k) | inl (inl k'<k) | inl (inl _) = lookupReducedFails
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k (inr x₁) record { firstEntry = firstEntry ; next = no } lookupReducedFails | inl (inr k'<min) | inl (inl min<k) | inl (inl k'<k) | inl (inl _) = refl
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k (inr x₁) record { firstEntry = firstEntry ; next = (yes (a , b)) } lookupReducedFails | inl (inr k'<min) | inl (inl min<k) | inl (inl k'<k) | inl (inl _) = lookupReducedFails
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inr k'<min) | inl (inl min<k) | inl (inl k'<k) | inl (inr x) = refl
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inr k'<min) | inl (inl min<k) | inl (inl k'<k) | inr refl = exFalso (TotalOrder.irreflexive keyOrder min<k)
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inr k'<min) | inl (inl min<k) | inl (inr k<k') = refl
lookupReducedFailsAfterUnrelatedAdd {min} .k v' k (inl x) record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inr k'<min) | inl (inl min<k) | inr refl = exFalso (TotalOrder.irreflexive keyOrder x)
lookupReducedFailsAfterUnrelatedAdd {min} .k v' k (inr x) record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inr k'<min) | inl (inl min<k) | inr refl = exFalso (TotalOrder.irreflexive keyOrder x)
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr m lookupReducedFails | inl (inr k'<min) | inl (inr k<min) with TotalOrder.totality keyOrder k' k
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k (inl _) m lookupReducedFails | inl (inr k'<min) | inl (inr k<min) | inl (inl k'<k) with TotalOrder.totality keyOrder min k
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k (inl _) m lookupReducedFails | inl (inr k'<min) | inl (inr k<min) | inl (inl k'<k) | inl (inl min<k) = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder k<min min<k))
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k (inl _) m lookupReducedFails | inl (inr k'<min) | inl (inr k<min) | inl (inl k'<k) | inl (inr k<min') = refl
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k (inl _) m lookupReducedFails | inl (inr k'<min) | inl (inr k<min) | inl (inl k'<k) | inr refl = exFalso (TotalOrder.irreflexive keyOrder k<min)
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k (inr x) m lookupReducedFails | inl (inr k'<min) | inl (inr k<min) | inl (inl k'<k) = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder k'<k x))
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr m lookupReducedFails | inl (inr k'<min) | inl (inr k<min) | inl (inr k<k') = refl
lookupReducedFailsAfterUnrelatedAdd {min} .k v' k (inl x) m lookupReducedFails | inl (inr k'<min) | inl (inr k<min) | inr refl = exFalso (TotalOrder.irreflexive keyOrder x)
lookupReducedFailsAfterUnrelatedAdd {min} .k v' k (inr x) m lookupReducedFails | inl (inr k'<min) | inl (inr k<min) | inr refl = exFalso (TotalOrder.irreflexive keyOrder x)
lookupReducedFailsAfterUnrelatedAdd {min} k' v' k pr m () | inl (inr k'<min) | inr min=k
lookupReducedFailsAfterUnrelatedAdd {min} .min v' k pr m lookupReducedFails | inr refl with TotalOrder.totality keyOrder min k
lookupReducedFailsAfterUnrelatedAdd {min} .min v' k pr record { firstEntry = firstEntry ; next = no } lookupReducedFails | inr refl | inl (inl min<k) = refl
lookupReducedFailsAfterUnrelatedAdd {min} .min v' k pr record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } lookupReducedFails | inr refl | inl (inl min<k) = lookupReducedFails
lookupReducedFailsAfterUnrelatedAdd {min} .min v' k pr m lookupReducedFails | inr refl | inl (inr k<min) = refl
lookupReducedFailsAfterUnrelatedAdd {min} .min v' k pr m () | inr refl | inr min=k
countReducedBehavesWhenAddingNotPresent : {min : keySet} → (k : keySet) → (v : valueSet) → (m : ReducedMap min) → (lookupReduced m k ≡ no) → countReduced (addReducedMap k v m) ≡ succ (countReduced m)
countReducedBehavesWhenAddingNotPresent {min} k v m lookupReducedFails with TotalOrder.totality keyOrder k min
countReducedBehavesWhenAddingNotPresent {min} k v record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inl k<min) with TotalOrder.totality keyOrder min k
countReducedBehavesWhenAddingNotPresent {min} k v record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inl k<min) | inl (inl min<k) = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder min<k k<min))
countReducedBehavesWhenAddingNotPresent {min} k v record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inl k<min) | inl (inr _) = refl
countReducedBehavesWhenAddingNotPresent {min} k v record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inl k<min) | inr refl = exFalso (TotalOrder.irreflexive keyOrder k<min)
countReducedBehavesWhenAddingNotPresent {min} k v record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inr min<k) with TotalOrder.totality keyOrder min k
countReducedBehavesWhenAddingNotPresent {min} k v record { firstEntry = firstEntry ; next = no } lookupReducedFails | inl (inr min<k) | inl (inl _) = refl
countReducedBehavesWhenAddingNotPresent {min} k v record { firstEntry = firstEntry ; next = (yes (a , b)) } lookupReducedFails | inl (inr min<k) | inl (inl _) = applyEquality succ (countReducedBehavesWhenAddingNotPresent k v (_&&_.fst b) lookupReducedFails)
countReducedBehavesWhenAddingNotPresent {min} k v record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inr min<k) | inl (inr k<min) = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder min<k k<min))
countReducedBehavesWhenAddingNotPresent {min} k v record { firstEntry = firstEntry ; next = next } lookupReducedFails | inl (inr min<k) | inr refl = exFalso (TotalOrder.irreflexive keyOrder min<k)
countReducedBehavesWhenAddingNotPresent {min} k v m lookupReducedFails | inr refl with TotalOrder.totality keyOrder min min
countReducedBehavesWhenAddingNotPresent {k} k v m lookupReducedFails | inr refl | inl (inl min<min) = exFalso (TotalOrder.irreflexive keyOrder min<min)
countReducedBehavesWhenAddingNotPresent {k} k v m lookupReducedFails | inr refl | inl (inr min<min) = exFalso (TotalOrder.irreflexive keyOrder min<min)
countReducedBehavesWhenAddingNotPresent {k} k v record { firstEntry = firstEntry ; next = no } () | inr refl | inr p
countReducedBehavesWhenAddingNotPresent {k} k v record { firstEntry = firstEntry ; next = (yes x) } () | inr refl | inr p
countReducedBehavesWhenAddingPresent : {min : keySet} → (k : keySet) → (v v' : valueSet) → (m : ReducedMap min) → (lookupReduced m k ≡ yes v') → countReduced (addReducedMap k v m) ≡ countReduced m
countReducedBehavesWhenAddingPresent {min} k v v' m lookupReducedSucceeds with TotalOrder.totality keyOrder k min
countReducedBehavesWhenAddingPresent {min} k v v' m lookupReducedSucceeds | inl (inl k<min) with TotalOrder.totality keyOrder min k
countReducedBehavesWhenAddingPresent {min} k v v' m lookupReducedSucceeds | inl (inl k<min) | inl (inl min<k) = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder k<min min<k))
countReducedBehavesWhenAddingPresent {min} k v v' m () | inl (inl k<min) | inl (inr _)
countReducedBehavesWhenAddingPresent {min} k v v' m lookupReducedSucceeds | inl (inl k<min) | inr q = exFalso (TotalOrder.irreflexive keyOrder (identityOfIndiscernablesLeft (TotalOrder._<_ keyOrder) k<min (equalityCommutative q)))
countReducedBehavesWhenAddingPresent {min} k v v' m lookupReducedSucceeds | inl (inr min<k) with TotalOrder.totality keyOrder min k
countReducedBehavesWhenAddingPresent {min} k v v' record { firstEntry = firstEntry ; next = no } () | inl (inr min<k) | inl (inl _)
countReducedBehavesWhenAddingPresent {min} k v v' record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } lookupReducedSucceeds | inl (inr min<k) | inl (inl _) = applyEquality succ (countReducedBehavesWhenAddingPresent k v v' fst lookupReducedSucceeds)
countReducedBehavesWhenAddingPresent {min} k v v' m () | inl (inr min<k) | inl (inr k<min)
countReducedBehavesWhenAddingPresent {min} k v v' m lookupReducedSucceeds | inl (inr min<k) | inr q = exFalso (TotalOrder.irreflexive keyOrder (identityOfIndiscernablesLeft (λ a b → TotalOrder._<_ keyOrder a b) min<k q))
countReducedBehavesWhenAddingPresent {min} k v v' m lookupReducedSucceeds | inr q with TotalOrder.totality keyOrder min min
countReducedBehavesWhenAddingPresent {min} k v v' m lookupReducedSucceeds | inr q | inl (inl x) = exFalso (TotalOrder.irreflexive keyOrder x)
countReducedBehavesWhenAddingPresent {min} k v v' m lookupReducedSucceeds | inr q | inl (inr x) = exFalso (TotalOrder.irreflexive keyOrder x)
countReducedBehavesWhenAddingPresent {min} k v v' record { firstEntry = firstEntry ; next = no } lookupReducedSucceeds | inr _ | inr p with TotalOrder.totality keyOrder min k
countReducedBehavesWhenAddingPresent {min} k v v' record { firstEntry = firstEntry ; next = no } () | inr _ | inr p | inl (inl x)
countReducedBehavesWhenAddingPresent {min} k v v' record { firstEntry = firstEntry ; next = no } () | inr _ | inr p | inl (inr x`)
countReducedBehavesWhenAddingPresent {.k} k v v' record { firstEntry = firstEntry ; next = no } lookupReducedSucceeds | inr q | inr p | inr refl = refl
countReducedBehavesWhenAddingPresent {min} k v v' record { firstEntry = firstEntry ; next = (yes (a , b)) } lookupReducedSucceeds | inr q | inr p with TotalOrder.totality keyOrder k k
countReducedBehavesWhenAddingPresent {min} k v v' record { firstEntry = firstEntry ; next = (yes (a , b)) } lookupReducedSucceeds | inr q | inr p | inl (inl x) = exFalso (TotalOrder.irreflexive keyOrder x)
countReducedBehavesWhenAddingPresent {min} k v v' record { firstEntry = firstEntry ; next = (yes (a , b)) } lookupReducedSucceeds | inr q | inr p | inl (inr x) = exFalso (TotalOrder.irreflexive keyOrder x)
countReducedBehavesWhenAddingPresent {min} k v v' record { firstEntry = firstEntry ; next = (yes (a , (m ,, pr))) } q | inr q1 | inr p | inr x with TotalOrder.totality keyOrder min k
countReducedBehavesWhenAddingPresent {.k} k v v' record { firstEntry = firstEntry ; next = (yes (a , (m ,, pr))) } q | inr refl | inr p | inr x | inl (inl min<k) = exFalso (TotalOrder.irreflexive keyOrder min<k)
countReducedBehavesWhenAddingPresent {.k} k v v' record { firstEntry = firstEntry ; next = (yes (a , (m ,, pr))) } q | inr q1 | inr p | inr x | inr refl = refl
data Map : Set (a ⊔ b ⊔ c) where
empty : Map
nonempty : {min : keySet} → ReducedMap min → Map
addMap : (m : Map) → (k : keySet) → (v : valueSet) → Map
addMap empty k v = nonempty {min = k} record { firstEntry = v ; next = no }
addMap (nonempty x) k v = nonempty (addReducedMap k v x)
lookup : (m : Map) → (target : keySet) → Maybe valueSet
lookup empty t = no
lookup (nonempty x) t = lookupReduced x t
count : (m : Map) → ℕ
count empty = 0
count (nonempty x) = countReduced x
keysReduced : {min : keySet} → (m : ReducedMap min) → Vec keySet (countReduced m)
keysReduced {min = min} record { firstEntry = firstEntry ; next = no } = min ,- []
keysReduced {min = min} record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } = min ,- (keysReduced fst)
keys : (m : Map) → Vec keySet (count m)
keys empty = []
keys (nonempty m) = keysReduced m
lookupReducedWhenLess : {min : keySet} → (m : ReducedMap min) → (k : keySet) → (TotalOrder._<_ keyOrder k min) → (lookupReduced m k ≡ no)
lookupReducedWhenLess {min} m k k<min with TotalOrder.totality keyOrder min k
lookupReducedWhenLess {min} m k k<min | inl (inl min<k) = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder k<min min<k))
lookupReducedWhenLess {min} m k k<min | inl (inr _) = refl
lookupReducedWhenLess {min} m k k<min | inr min=k rewrite min=k = exFalso (TotalOrder.irreflexive keyOrder k<min)
lookupCertainReduced : {min : keySet} → (m : ReducedMap min) → (k : keySet) → (vecContains (keysReduced m) k) → Sg valueSet (λ v → lookupReduced m k ≡ yes v)
lookupCertainReduced {min} record { firstEntry = firstEntry ; next = no } k pr = firstEntry , q
where
t : min ≡ k
t = vecSolelyContains k pr
q : lookupReduced {min} (record { firstEntry = firstEntry ; next = no }) k ≡ yes firstEntry
q with TotalOrder.totality keyOrder k k
q | inl (inl k<k) = exFalso (TotalOrder.irreflexive keyOrder k<k)
q | inl (inr k<k) = exFalso (TotalOrder.irreflexive keyOrder k<k)
q | inr p with TotalOrder.totality keyOrder min k
q | inr p | inl (inl min<k) rewrite t = exFalso (TotalOrder.irreflexive keyOrder min<k)
q | inr p | inl (inr k<min) rewrite t = exFalso (TotalOrder.irreflexive keyOrder k<min)
q | inr p | inr x = refl
lookupCertainReduced {min} record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } k pr with TotalOrder.totality keyOrder min k
lookupCertainReduced {min} record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } k record { index = zero ; index<m = _ ; isHere = isHere } | inl (inl min<k) rewrite isHere = exFalso (TotalOrder.irreflexive keyOrder min<k)
lookupCertainReduced {min} record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } k record { index = (succ index) ; index<m = index<m ; isHere = isHere } | inl (inl min<k) = lookupCertainReduced fst k record { index = index ; index<m = canRemoveSuccFrom<N index<m ; isHere = isHere }
lookupCertainReduced {min} record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } k record { index = zero ; index<m = _ ; isHere = isHere } | inl (inr k<min) rewrite isHere = exFalso (TotalOrder.irreflexive keyOrder k<min)
lookupCertainReduced {min} record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } k record { index = (succ index) ; index<m = index<m ; isHere = isHere } | inl (inr k<min) with TotalOrder.totality keyOrder a k
lookupCertainReduced {min} record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } k record { index = (succ index) ; index<m = index<m ; isHere = isHere } | inl (inr k<min) | inl (inl a<k) = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder k<min (TotalOrder.<Transitive keyOrder snd a<k)))
lookupCertainReduced {min} record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } k record { index = (succ index) ; index<m = index<m ; isHere = isHere } | inl (inr k<min) | inl (inr k<a) = exFalso h
where
f : Sg valueSet (λ v → lookupReduced fst k ≡ yes v)
f = lookupCertainReduced fst k record { index = index ; index<m = canRemoveSuccFrom<N index<m ; isHere = isHere }
g : lookupReduced fst k ≡ no
g = lookupReducedWhenLess fst k k<a
noIsNotYes : {a : _} → {A : Set a} → {b : A} → (no ≡ yes b) → False
noIsNotYes {a} {A} {b} ()
h : False
h with f
h | a , b rewrite g = noIsNotYes b
lookupCertainReduced {min} record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } k record { index = (succ index) ; index<m = index<m ; isHere = isHere } | inl (inr k<min) | inr refl = exFalso (TotalOrder.irreflexive keyOrder (TotalOrder.<Transitive keyOrder snd k<min))
lookupCertainReduced {min} record { firstEntry = firstEntry ; next = (yes (a , (fst ,, snd))) } k pr | inr min=k = firstEntry , refl
lookupCertain : (m : Map) → (k : keySet) → (vecContains (keys m) k) → Sg valueSet (λ v → lookup m k ≡ yes v)
lookupCertain empty k record { index = index ; index<m = (le x ()) ; isHere = isHere }
lookupCertain (nonempty {min} m) k pr = lookupCertainReduced {min} m k pr
|
{
"alphanum_fraction": 0.7208856287,
"avg_line_length": 122.3004115226,
"ext": "agda",
"hexsha": "41c66894751d8b73f7078e995d22b4dd4fc529b4",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-29T13:23:07.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-29T13:23:07.000Z",
"max_forks_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Smaug123/agdaproofs",
"max_forks_repo_path": "KeyValue/LinearStore/Implementation.agda",
"max_issues_count": 14,
"max_issues_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_issues_repo_issues_event_max_datetime": "2020-04-11T11:03:39.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-06T21:11:59.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Smaug123/agdaproofs",
"max_issues_repo_path": "KeyValue/LinearStore/Implementation.agda",
"max_line_length": 341,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Smaug123/agdaproofs",
"max_stars_repo_path": "KeyValue/LinearStore/Implementation.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-28T06:04:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-08-08T12:44:19.000Z",
"num_tokens": 10176,
"size": 29719
}
|
{-# OPTIONS --without-K #-}
open import HoTT
open import homotopy.PtdAdjoint
module homotopy.SuspAdjointLoop where
module Σ⊣Ω {i} where
SuspFunctor : PtdFunctor i i
SuspFunctor = record {
obj = ⊙Susp;
arr = ⊙susp-fmap;
id = ⊙susp-fmap-idf;
comp = ⊙susp-fmap-∘}
LoopFunctor : PtdFunctor i i
LoopFunctor = record {
obj = ⊙Ω;
arr = ⊙ap;
id = λ _ → ⊙ap-idf;
comp = ⊙ap-∘}
module _ (X : Ptd i) where
η : fst X → Ω (⊙Susp X)
η x = merid _ x ∙ ! (merid _ (snd X))
module E = SuspensionRec (Ω X) (snd X) (snd X) (idf _)
ε : fst (⊙Susp (⊙Ω X)) → fst X
ε = E.f
⊙η : fst (X ⊙→ ⊙Ω (⊙Susp X))
⊙η = (η , !-inv-r (merid _ (snd X)))
⊙ε : fst (⊙Susp (⊙Ω X) ⊙→ X)
⊙ε = (ε , idp)
η-natural : {X Y : Ptd i} (f : fst (X ⊙→ Y))
→ ⊙η Y ⊙∘ f == ⊙ap (⊙susp-fmap f) ⊙∘ ⊙η X
η-natural {X = X} (f , idp) = ⊙λ=
(λ x → ! $
ap-∙ (susp-fmap f) (merid _ x) (! (merid _ (snd X)))
∙ SuspFmap.glue-β f x
∙2 (ap-! (susp-fmap f) (merid _ (snd X))
∙ ap ! (SuspFmap.glue-β f (snd X))))
(pt-lemma (susp-fmap f) (merid _ (snd X)) (SuspFmap.glue-β f (snd X)))
where
pt-lemma : ∀ {i j} {A : Type i} {B : Type j} (f : A → B)
{x y : A} (p : x == y) {q : f x == f y} (α : ap f p == q)
→ !-inv-r q == (! $ ap-∙ f p (! p) ∙ α ∙2 (ap-! f p ∙ ap ! α))
∙ ap (ap f) (!-inv-r p) ∙ idp
pt-lemma f idp idp = idp
ε-natural : {X Y : Ptd i} (f : fst (X ⊙→ Y))
→ ⊙ε Y ⊙∘ ⊙susp-fmap (⊙ap f) == f ⊙∘ ⊙ε X
ε-natural (f , idp) = ⊙λ=
(SuspensionElim.f _ idp idp
(λ p → ↓-='-from-square $ vert-degen-square $
ap-∘ (ε _) (susp-fmap (ap f)) (merid _ p)
∙ ap (ap (ε _)) (SuspFmap.glue-β (ap f) p)
∙ E.glue-β _ (ap f p)
∙ ap (ap f) (! (E.glue-β _ p))
∙ ∘-ap f (ε _) (merid _ p)))
idp
εΣ-Ση : (X : Ptd i) → ⊙ε (⊙Susp X) ⊙∘ ⊙susp-fmap (⊙η X) == ⊙idf _
εΣ-Ση X = ⊙λ=
(SuspensionElim.f _
idp
(merid _ (snd X))
(λ x → ↓-='-from-square $
(ap-∘ (ε (⊙Susp X)) (susp-fmap (η X)) (merid _ x)
∙ ap (ap (ε (⊙Susp X))) (SuspFmap.glue-β (η X) x)
∙ E.glue-β _ (merid _ x ∙ ! (merid _ (snd X))))
∙v⊡ square-lemma (merid _ x) (merid _ (snd X))
⊡v∙ ! (ap-idf (merid _ x))))
idp
where
square-lemma : ∀ {i} {A : Type i} {x y z : A}
(p : x == y) (q : z == y)
→ Square idp (p ∙ ! q) p q
square-lemma idp idp = ids
Ωε-ηΩ : (X : Ptd i) → ⊙ap (⊙ε X) ⊙∘ ⊙η (⊙Ω X) == ⊙idf _
Ωε-ηΩ X = ⊙λ=
(λ p → ap-∙ (ε X) (merid _ p) (! (merid _ idp))
∙ (E.glue-β X p ∙2 (ap-! (ε X) (merid _ idp) ∙ ap ! (E.glue-β X idp)))
∙ ∙-unit-r _)
(pt-lemma (ε X) (merid _ idp) (E.glue-β X idp))
where
pt-lemma : ∀ {i j} {A : Type i} {B : Type j} (f : A → B)
{x y : A} (p : x == y) {q : f x == f y} (α : ap f p == q)
→ ap (ap f) (!-inv-r p) ∙ idp
== (ap-∙ f p (! p) ∙ (α ∙2 (ap-! f p ∙ ap ! α)) ∙ !-inv-r q) ∙ idp
pt-lemma f idp idp = idp
adj : CounitUnitAdjoint SuspFunctor LoopFunctor
adj = record {
η = ⊙η;
ε = ⊙ε;
η-natural = η-natural;
ε-natural = ε-natural;
εF-Fη = εΣ-Ση;
Gε-ηG = Ωε-ηΩ}
|
{
"alphanum_fraction": 0.4459333126,
"avg_line_length": 29.1727272727,
"ext": "agda",
"hexsha": "45f75ab6d03fd666ba9f21f6ff314ca937ec5da7",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nicolaikraus/HoTT-Agda",
"max_forks_repo_path": "homotopy/SuspAdjointLoop.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nicolaikraus/HoTT-Agda",
"max_issues_repo_path": "homotopy/SuspAdjointLoop.agda",
"max_line_length": 79,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "f8fa68bf753d64d7f45556ca09d0da7976709afa",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "UlrikBuchholtz/HoTT-Agda",
"max_stars_repo_path": "homotopy/SuspAdjointLoop.agda",
"max_stars_repo_stars_event_max_datetime": "2021-06-30T00:17:55.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-06-30T00:17:55.000Z",
"num_tokens": 1551,
"size": 3209
}
|
module EvenOdd where
open import Data.Nat
data Even : ℕ → Set where
evenZero : Even 0
evenSuc : {n : ℕ} → Even n → Even (suc (suc n))
data Odd : ℕ → Set where
oddOne : Odd 1
oddSuc : {n : ℕ} → Odd n → Odd (suc (suc n))
_e+e_ : {n m : ℕ} → Even n → Even m → Even (n + m)
evenZero e+e b = b
evenSuc a e+e b = evenSuc (a e+e b)
_o+o_ : {n m : ℕ} → Odd n → Odd m → Even (n + m)
oddOne o+o oddOne = evenSuc evenZero
oddOne o+o oddSuc b = evenSuc (oddOne o+o b)
oddSuc a o+o b = evenSuc (a o+o b)
_o+e_ : {n m : ℕ} → Odd n → Even m → Odd (n + m)
oddOne o+e evenZero = oddOne
oddOne o+e evenSuc b = oddSuc (oddOne o+e b)
oddSuc a o+e b = oddSuc (a o+e b)
_e+o_ : {n m : ℕ} → Even n → Odd m → Odd (n + m)
evenZero e+o b = b
evenSuc a e+o b = oddSuc (a e+o b)
|
{
"alphanum_fraction": 0.5809399478,
"avg_line_length": 25.5333333333,
"ext": "agda",
"hexsha": "8ed5ff2ba3740aeb87f91ca55ff1dacd3b893d3f",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "37956e581dc51bf78008d7dd902bb18d2ee481f6",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Zalastax/adventofcode2017",
"max_forks_repo_path": "lib/EvenOdd.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "37956e581dc51bf78008d7dd902bb18d2ee481f6",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Zalastax/adventofcode2017",
"max_issues_repo_path": "lib/EvenOdd.agda",
"max_line_length": 50,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "37956e581dc51bf78008d7dd902bb18d2ee481f6",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Zalastax/adventofcode2017",
"max_stars_repo_path": "lib/EvenOdd.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 331,
"size": 766
}
|
-- {-# OPTIONS -v tc.meta:40 #-}
-- {-# OPTIONS --verbose tc.conv.term:40 #-}
-- {-# OPTIONS --verbose tc.conv.level:40 #-}
-- {-# OPTIONS --verbose tc.conv.atom:50 #-}
-- {-# OPTIONS --verbose tc.conv.elim:50 #-}
module Issue680-NeutralLevels where
open import Common.Level
postulate
N : Set
A : N → Set
level : N → Level
lac : ∀ {n} → A n → N
I : Level → Level → Set
refl : ∀ {l : Level} → I l l
data Test : Set where
mkTest : (n : N) → (tel : A n) → Test
test : Test → N
test (mkTest n tel) = n
where
test′ : I (lsuc (level (lac tel)))
(lsuc (level (lac tel)))
test′ = refl
|
{
"alphanum_fraction": 0.5377358491,
"avg_line_length": 21.9310344828,
"ext": "agda",
"hexsha": "e21d331ac4ca3e226a5a61229988f22b6efe6b02",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue680-NeutralLevels.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue680-NeutralLevels.agda",
"max_line_length": 45,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue680-NeutralLevels.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 210,
"size": 636
}
|
module sum where
open import level
open import bool
open import eq
open import maybe
open import product
open import functions
open import empty public
----------------------------------------------------------------------
-- datatypes
----------------------------------------------------------------------
data _⊎_ {ℓ ℓ'} (A : Set ℓ) (B : Set ℓ') : Set (ℓ ⊔ ℓ') where
inj₁ : (x : A) → A ⊎ B
inj₂ : (y : B) → A ⊎ B
_∨_ : ∀ {ℓ ℓ'} (A : Set ℓ) (B : Set ℓ') → Set (ℓ ⊔ ℓ')
_∨_ = _⊎_
----------------------------------------------------------------------
-- syntax
----------------------------------------------------------------------
infixr 1 _⊎_ _∨_
----------------------------------------------------------------------
-- operations
----------------------------------------------------------------------
_≫=⊎_ : ∀ {ℓ ℓ'}{A : Set ℓ}{B : Set ℓ'}{C : Set (ℓ ⊔ ℓ')} → A ⊎ B → (B → A ⊎ C) → A ⊎ C
inj₁ x ≫=⊎ f = inj₁ x
inj₂ x ≫=⊎ f = f x
return⊎ : ∀ {ℓ ℓ'}{A : Set ℓ}{B : Set ℓ'} → B → A ⊎ B
return⊎ b = inj₂ b
infix 5 error⊎_
error⊎_ : ∀ {ℓ ℓ'}{A : Set ℓ}{B : Set ℓ'} → A → A ⊎ B
error⊎_ a = inj₁ a
extract-inj₁≡ : ∀{ℓ}{ℓ'}{A : Set ℓ}{B : Set ℓ'}{a a' : A} → inj₁{B = B} a ≡ inj₁ a' → a ≡ a'
extract-inj₁≡ refl = refl
extract-inj₂≡ : ∀{ℓ}{ℓ'}{A : Set ℓ}{B : Set ℓ'}{b b' : B} → inj₂{A = A} b ≡ inj₂ b' → b ≡ b'
extract-inj₂≡ refl = refl
=⊎ : ∀{ℓ}{ℓ'}{A : Set ℓ}{B : Set ℓ'} → (A → A → 𝔹) → (B → B → 𝔹) → A ⊎ B → A ⊎ B → 𝔹
=⊎ eqa eqb (inj₁ a) (inj₁ a') = eqa a a'
=⊎ eqa eqb (inj₂ b) (inj₂ b') = eqb b b'
=⊎ _ _ _ _ = ff
=⊎-to-≡ : ∀{ℓ}{ℓ'}{A : Set ℓ}{B : Set ℓ'} → (_eqa_ : A → A → 𝔹) → (_eqb_ : B → B → 𝔹) → ((a a' : A) → (a eqa a' ≡ tt) → a ≡ a') → ((b b' : B) → (b eqb b' ≡ tt) → b ≡ b') → (x y : A ⊎ B) → =⊎ _eqa_ _eqb_ x y ≡ tt → x ≡ y
=⊎-to-≡ eqa eqb risea riseb (inj₁ a) (inj₁ a') p rewrite risea a a' p = refl
=⊎-to-≡ eqa eqb risea riseb (inj₂ b) (inj₂ b') p rewrite riseb b b' p = refl
=⊎-to-≡ eqa eqb risea riseb (inj₁ a) (inj₂ b) ()
=⊎-to-≡ eqa eqb risea riseb (inj₂ b) (inj₁ a) ()
≡⊎-to-= : ∀{ℓ}{ℓ'}{A : Set ℓ}{B : Set ℓ'} → (_eqa_ : A → A → 𝔹) → (_eqb_ : B → B → 𝔹) → ((a a' : A) → a ≡ a' → a eqa a' ≡ tt) → ((b b' : B) → b ≡ b' → b eqb b' ≡ tt) → (x y : A ⊎ B) → x ≡ y → =⊎ _eqa_ _eqb_ x y ≡ tt
≡⊎-to-= eqa eqb dropa dropb (inj₁ a) (inj₁ a') p = dropa a a' (extract-inj₁≡ p)
≡⊎-to-= eqa eqb dropa dropb (inj₂ b) (inj₂ b') p = dropb b b' (extract-inj₂≡ p)
≡⊎-to-= eqa eqb dropa dropb (inj₁ a) (inj₂ b) ()
≡⊎-to-= eqa eqb dropa dropb (inj₂ b) (inj₁ a) ()
⊎-assoc : ∀{ℓ}{U V W : Set ℓ} → U ⊎ V ⊎ W → (U ⊎ V) ⊎ W
⊎-assoc (inj₁ x) = inj₁ (inj₁ x)
⊎-assoc (inj₂ (inj₁ x)) = inj₁ (inj₂ x)
⊎-assoc (inj₂ (inj₂ y)) = inj₂ y
⊎-assoc-inv : ∀{ℓ}{U V W : Set ℓ} → (U ⊎ V) ⊎ W → U ⊎ V ⊎ W
⊎-assoc-inv (inj₁ (inj₁ x)) = inj₁ x
⊎-assoc-inv (inj₁ (inj₂ y)) = inj₂ (inj₁ y)
⊎-assoc-inv (inj₂ y) = inj₂ (inj₂ y)
⊎-ar : ∀{ℓ}{U V W : Set ℓ} → (U → W) → (V → W) → U ⊎ V → W
⊎-ar f g (inj₁ x) = f x
⊎-ar f g (inj₂ y) = g y
⊎-sym : ∀{ℓ}{X Y : Set ℓ} → X ⊎ Y → Y ⊎ X
⊎-sym (inj₁ x) = inj₂ x
⊎-sym (inj₂ y) = inj₁ y
⊎-left-ident : ∀{ℓ}{X : Set ℓ} → ⊥ {ℓ} ⊎ X → X
⊎-left-ident (inj₁ x) = ⊥-elim x
⊎-left-ident (inj₂ y) = y
⊎-left-ident-inv : ∀{ℓ}{X : Set ℓ} → X → ⊥ {ℓ} ⊎ X
⊎-left-ident-inv = inj₂
⊎-right-ident : ∀{ℓ}{X : Set ℓ} → X ⊎ ⊥ {ℓ} → X
⊎-right-ident (inj₁ x) = x
⊎-right-ident (inj₂ y) = ⊥-elim y
⊎-right-ident-inv : ∀{ℓ}{X : Set ℓ} → X → X ⊎ ⊥ {ℓ}
⊎-right-ident-inv = inj₁
⊎-map : {U W V R : Set} → (U → V) → (W → R) → U ⊎ W → V ⊎ R
⊎-map {U} {W} {V} {R} f g (inj₁ u) = inj₁ (f u)
⊎-map {U} {W} {V} {R} f g (inj₂ w) = inj₂ (g w)
⊎-×-distl : {U V W : Set} → U × (V ⊎ W) → U × V ⊎ U × W
⊎-×-distl {U} {V} {W} (u , inj₁ v) = inj₁ (u , v)
⊎-×-distl {U} {V} {W} (u , inj₂ w) = inj₂ (u , w)
⊎-×-distl-inv : {X Y Z : Set} → X × Y ⊎ X × Z → X × (Y ⊎ Z)
⊎-×-distl-inv {X} {Y} {Z} (inj₁ (x , y)) = x , inj₁ y
⊎-×-distl-inv {X} {Y} {Z} (inj₂ (x , z)) = x , inj₂ z
⊎-×-distl-iso₁ : ∀{U V W}{a : U × (V ⊎ W)} → (⊎-×-distl-inv ∘ ⊎-×-distl) a ≡ id a
⊎-×-distl-iso₁ {a = u , inj₁ v} = refl
⊎-×-distl-iso₁ {a = u , inj₂ w} = refl
⊎-×-distl-iso₂ : ∀{U V W}{a : U × V ⊎ U × W} → (⊎-×-distl ∘ ⊎-×-distl-inv) a ≡ id a
⊎-×-distl-iso₂ {a = inj₁ (u , v)} = refl
⊎-×-distl-iso₂ {a = inj₂ (u , w)} = refl
⊎-×-distr : {U V W : Set} → (U ⊎ V) × W → U × W ⊎ V × W
⊎-×-distr {U} {V} {W} (inj₁ u , w) = inj₁ (u , w)
⊎-×-distr {U} {V} {W} (inj₂ v , w) = inj₂ (v , w)
⊎-×-distr-inv : {X Z Y : Set} → X × Z ⊎ Y × Z → (X ⊎ Y) × Z
⊎-×-distr-inv {X} {Z} {Y} (inj₁ (x , z)) = inj₁ x , z
⊎-×-distr-inv {X} {Z} {Y} (inj₂ (y , z)) = inj₂ y , z
⊎-×-distr-iso₁ : ∀{U V W}{a : (U ⊎ V) × W} → (⊎-×-distr-inv ∘ ⊎-×-distr) a ≡ id a
⊎-×-distr-iso₁ {a = inj₁ u , w} = refl
⊎-×-distr-iso₁ {a = inj₂ v , w} = refl
⊎-×-distr-iso₂ : ∀{U V W}{a : (U × W) ⊎ (V × W)} → (⊎-×-distr ∘ ⊎-×-distr-inv) a ≡ id a
⊎-×-distr-iso₂ {a = inj₁ (u , w)} = refl
⊎-×-distr-iso₂ {a = inj₂ (v , w)} = refl
⊎-codiag : ∀{ℓ : level}{U : Set ℓ} → U ⊎ U → U
⊎-codiag (inj₁ x) = x
⊎-codiag (inj₂ y) = y
|
{
"alphanum_fraction": 0.4176731079,
"avg_line_length": 34.985915493,
"ext": "agda",
"hexsha": "d9202268faaea4bd5fbffacad61aadbbbe4f05dc",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b33c6a59d664aed46cac8ef77d34313e148fecc2",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "heades/AUGL",
"max_forks_repo_path": "sum.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b33c6a59d664aed46cac8ef77d34313e148fecc2",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "heades/AUGL",
"max_issues_repo_path": "sum.agda",
"max_line_length": 222,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "b33c6a59d664aed46cac8ef77d34313e148fecc2",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "heades/AUGL",
"max_stars_repo_path": "sum.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2751,
"size": 4968
}
|
module Text.Greek.Script.Unicode where
open import Text.Greek.Script
-- U+0390 - U+03CE
ΐ : Token -- U+0390 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
ΐ = with-accent-diaeresis ι′ lower (acute ι-vowel) ι-diaeresis
Α : Token -- U+0391 GREEK CAPITAL LETTER ALPHA
Α = unmarked α′ upper
Β : Token -- U+0392 GREEK CAPITAL LETTER BETA
Β = unmarked β′ upper
Γ : Token -- U+0393 GREEK CAPITAL LETTER GAMMA
Γ = unmarked γ′ upper
Δ : Token -- U+0394 GREEK CAPITAL LETTER DELTA
Δ = unmarked δ′ upper
Ε : Token -- U+0395 GREEK CAPITAL LETTER EPSILON
Ε = unmarked ε′ upper
Ζ : Token -- U+0396 GREEK CAPITAL LETTER ZETA
Ζ = unmarked ζ′ upper
Η : Token -- U+0397 GREEK CAPITAL LETTER ETA
Η = unmarked η′ upper
Θ : Token -- U+0398 GREEK CAPITAL LETTER THETA
Θ = unmarked θ′ upper
Ι : Token -- U+0399 GREEK CAPITAL LETTER IOTA
Ι = unmarked ι′ upper
Κ : Token -- U+039A GREEK CAPITAL LETTER KAPPA
Κ = unmarked κ′ upper
Λ : Token -- U+039B GREEK CAPITAL LETTER LAMDA
Λ = unmarked λ′ upper
Μ : Token -- U+039C GREEK CAPITAL LETTER MU
Μ = unmarked μ′ upper
Ν : Token -- U+039D GREEK CAPITAL LETTER NU
Ν = unmarked ν′ upper
Ξ : Token -- U+039E GREEK CAPITAL LETTER XI
Ξ = unmarked ξ′ upper
Ο : Token -- U+039F GREEK CAPITAL LETTER OMICRON
Ο = unmarked ο′ upper
Π : Token -- U+03A0 GREEK CAPITAL LETTER PI
Π = unmarked π′ upper
Ρ : Token -- U+03A1 GREEK CAPITAL LETTER RHO
Ρ = unmarked ρ′ upper
-- U+03A2 <reserved>
Σ : Token -- U+03A3 GREEK CAPITAL LETTER SIGMA
Σ = unmarked σ′ upper
Τ : Token -- U+03A4 GREEK CAPITAL LETTER TAU
Τ = unmarked τ′ upper
Υ : Token -- U+03A5 GREEK CAPITAL LETTER UPSILON
Υ = unmarked υ′ upper
Φ : Token -- U+03A6 GREEK CAPITAL LETTER PHI
Φ = unmarked φ′ upper
Χ : Token -- U+03A7 GREEK CAPITAL LETTER CHI
Χ = unmarked χ′ upper
Ψ : Token -- U+03A8 GREEK CAPITAL LETTER PSI
Ψ = unmarked ψ′ upper
Ω : Token -- U+03A9 GREEK CAPITAL LETTER OMEGA
Ω = unmarked ω′ upper
Ϊ : Token -- U+03AA GREEK CAPITAL LETTER IOTA WITH DIALYTIKA
Ϊ = with-diaeresis ι′ upper ι-diaeresis
Ϋ : Token -- U+03AB GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA
Ϋ = with-diaeresis υ′ upper υ-diaeresis
ά : Token -- U+03AC GREEK SMALL LETTER ALPHA WITH TONOS
ά = with-accent α′ lower (acute α-vowel)
έ : Token -- U+03AD GREEK SMALL LETTER EPSILON WITH TONOS
έ = with-accent ε′ lower (acute ε-vowel)
ή : Token -- U+03AE GREEK SMALL LETTER ETA WITH TONOS
ή = with-accent η′ lower (acute η-vowel)
ί : Token -- U+03AF GREEK SMALL LETTER IOTA WITH TONOS
ί = with-accent ι′ lower (acute ι-vowel)
ΰ : Token -- U+03B0 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
ΰ = with-accent-diaeresis υ′ lower (acute υ-vowel) υ-diaeresis
α : Token -- U+03B1 GREEK SMALL LETTER ALPHA
α = unmarked α′ lower
β : Token -- U+03B2 GREEK SMALL LETTER BETA
β = unmarked β′ lower
γ : Token -- U+03B3 GREEK SMALL LETTER GAMMA
γ = unmarked γ′ lower
δ : Token -- U+03B4 GREEK SMALL LETTER DELTA
δ = unmarked δ′ lower
ε : Token -- U+03B5 GREEK SMALL LETTER EPSILON
ε = unmarked ε′ lower
ζ : Token -- U+03B6 GREEK SMALL LETTER ZETA
ζ = unmarked ζ′ lower
η : Token -- U+03B7 GREEK SMALL LETTER ETA
η = unmarked η′ lower
θ : Token -- U+03B8 GREEK SMALL LETTER THETA
θ = unmarked θ′ lower
ι : Token -- U+03B9 GREEK SMALL LETTER IOTA
ι = unmarked ι′ lower
κ : Token -- U+03BA GREEK SMALL LETTER KAPPA
κ = unmarked κ′ lower
∙λ : Token -- U+03BB GREEK SMALL LETTER LAMDA
∙λ = unmarked λ′ lower
μ : Token -- U+03BC GREEK SMALL LETTER MU
μ = unmarked μ′ lower
ν : Token -- U+03BD GREEK SMALL LETTER NU
ν = unmarked ν′ lower
ξ : Token -- U+03BE GREEK SMALL LETTER XI
ξ = unmarked ξ′ lower
ο : Token -- U+03BF GREEK SMALL LETTER OMICRON
ο = unmarked ο′ lower
π : Token -- U+03C0 GREEK SMALL LETTER PI
π = unmarked π′ lower
ρ : Token -- U+03C1 GREEK SMALL LETTER RHO
ρ = unmarked ρ′ lower
ς : Token -- U+03C2 GREEK SMALL LETTER FINAL SIGMA
ς = final σ′ lower σ-final
σ : Token -- U+03C3 GREEK SMALL LETTER SIGMA
σ = unmarked σ′ lower
τ : Token -- U+03C4 GREEK SMALL LETTER TAU
τ = unmarked τ′ lower
υ : Token -- U+03C5 GREEK SMALL LETTER UPSILON
υ = unmarked υ′ lower
φ : Token -- U+03C6 GREEK SMALL LETTER PHI
φ = unmarked φ′ lower
χ : Token -- U+03C7 GREEK SMALL LETTER CHI
χ = unmarked χ′ lower
ψ : Token -- U+03C8 GREEK SMALL LETTER PSI
ψ = unmarked ψ′ lower
ω : Token -- U+03C9 GREEK SMALL LETTER OMEGA
ω = unmarked ω′ lower
ϊ : Token -- U+03CA GREEK SMALL LETTER IOTA WITH DIALYTIKA
ϊ = with-diaeresis ι′ lower ι-diaeresis
ϋ : Token -- U+03CB GREEK SMALL LETTER UPSILON WITH DIALYTIKA
ϋ = with-diaeresis υ′ lower υ-diaeresis
ό : Token -- U+03CC GREEK SMALL LETTER OMICRON WITH TONOS
ό = with-accent ο′ lower (acute ο-vowel)
ύ : Token -- U+03CD GREEK SMALL LETTER UPSILON WITH TONOS
ύ = with-accent υ′ lower (acute υ-vowel)
ώ : Token -- U+03CE GREEK SMALL LETTER OMEGA WITH TONOS
ώ = with-accent ω′ lower (acute ω-vowel)
-- U+1F00 - U+1FFF
ἀ : Token -- U+1F00 ἀ GREEK SMALL LETTER ALPHA WITH PSILI
ἀ = with-breathing α′ lower (smooth α-smooth)
ἁ : Token -- U+1F01 ἁ GREEK SMALL LETTER ALPHA WITH DASIA
ἁ = with-breathing α′ lower (rough α-rough)
ἂ : Token -- U+1F02 ἂ GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA
ἂ = with-accent-breathing α′ lower (grave α-vowel) (smooth α-smooth)
ἃ : Token -- U+1F03 ἃ GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA
ἃ = with-accent-breathing α′ lower (grave α-vowel) (rough α-rough)
ἄ : Token -- U+1F04 ἄ GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA
ἄ = with-accent-breathing α′ lower (acute α-vowel) (smooth α-smooth)
ἅ : Token -- U+1F05 ἅ GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA
ἅ = with-accent-breathing α′ lower (acute α-vowel) (rough α-rough)
ἆ : Token -- U+1F06 ἆ GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI
ἆ = with-accent-breathing α′ lower (circumflex α-long-vowel) (smooth α-smooth)
ἇ : Token -- U+1F07 ἇ GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI
ἇ = with-accent-breathing α′ lower (circumflex α-long-vowel) (rough α-rough)
Ἀ : Token -- U+1F08 Ἀ GREEK CAPITAL LETTER ALPHA WITH PSILI
Ἀ = with-breathing α′ upper (smooth Α-smooth)
Ἁ : Token -- U+1F09 Ἁ GREEK CAPITAL LETTER ALPHA WITH DASIA
Ἁ = with-breathing α′ upper (rough α-rough)
Ἂ : Token -- U+1F0A Ἂ GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA
Ἂ = with-accent-breathing α′ upper (grave α-vowel) (smooth Α-smooth)
Ἃ : Token -- U+1F0B Ἃ GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA
Ἃ = with-accent-breathing α′ upper (grave α-vowel) (rough α-rough)
Ἄ : Token -- U+1F0C Ἄ GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA
Ἄ = with-accent-breathing α′ upper (acute α-vowel) (smooth Α-smooth)
Ἅ : Token -- U+1F0D Ἅ GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA
Ἅ = with-accent-breathing α′ upper (acute α-vowel) (rough α-rough)
Ἆ : Token -- U+1F0E Ἆ GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI
Ἆ = with-accent-breathing α′ upper (circumflex α-long-vowel) (smooth Α-smooth)
Ἇ : Token -- U+1F0F Ἇ GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI
Ἇ = with-accent-breathing α′ upper (circumflex α-long-vowel) (rough α-rough)
ἐ : Token -- U+1F10 ἐ GREEK SMALL LETTER EPSILON WITH PSILI
ἐ = with-breathing ε′ lower (smooth ε-smooth)
ἑ : Token -- U+1F11 ἑ GREEK SMALL LETTER EPSILON WITH DASIA
ἑ = with-breathing ε′ lower (rough ε-rough)
ἒ : Token -- U+1F12 ἒ GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA
ἒ = with-accent-breathing ε′ lower (grave ε-vowel) (smooth ε-smooth)
ἓ : Token -- U+1F13 ἓ GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA
ἓ = with-accent-breathing ε′ lower (grave ε-vowel) (rough ε-rough)
ἔ : Token -- U+1F14 ἔ GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA
ἔ = with-accent-breathing ε′ lower (acute ε-vowel) (smooth ε-smooth)
ἕ : Token -- U+1F15 ἕ GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA
ἕ = with-accent-breathing ε′ lower (acute ε-vowel) (rough ε-rough)
-- U+1F16
-- U+1F17
Ἐ : Token -- U+1F18 Ἐ GREEK CAPITAL LETTER EPSILON WITH PSILI
Ἐ = with-breathing ε′ upper (smooth Ε-smooth)
Ἑ : Token -- U+1F19 Ἑ GREEK CAPITAL LETTER EPSILON WITH DASIA
Ἑ = with-breathing ε′ upper (rough ε-rough)
Ἒ : Token -- U+1F1A Ἒ GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA
Ἒ = with-accent-breathing ε′ upper (grave ε-vowel) (smooth Ε-smooth)
Ἓ : Token -- U+1F1B Ἓ GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA
Ἓ = with-accent-breathing ε′ upper (grave ε-vowel) (rough ε-rough)
Ἔ : Token -- U+1F1C Ἔ GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA
Ἔ = with-accent-breathing ε′ upper (acute ε-vowel) (smooth Ε-smooth)
Ἕ : Token -- U+1F1D Ἕ GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA
Ἕ = with-accent-breathing ε′ upper (acute ε-vowel) (rough ε-rough)
-- U+1F1E
-- U+1F1F
ἠ : Token -- U+1F20 ἠ GREEK SMALL LETTER ETA WITH PSILI
ἠ = with-breathing η′ lower (smooth η-smooth)
ἡ : Token -- U+1F21 ἡ GREEK SMALL LETTER ETA WITH DASIA
ἡ = with-breathing η′ lower (rough η-rough)
ἢ : Token -- U+1F22 ἢ GREEK SMALL LETTER ETA WITH PSILI AND VARIA
ἢ = with-accent-breathing η′ lower (grave η-vowel) (smooth η-smooth)
ἣ : Token -- U+1F23 ἣ GREEK SMALL LETTER ETA WITH DASIA AND VARIA
ἣ = with-accent-breathing η′ lower (grave η-vowel) (rough η-rough)
ἤ : Token -- U+1F24 ἤ GREEK SMALL LETTER ETA WITH PSILI AND OXIA
ἤ = with-accent-breathing η′ lower (acute η-vowel) (smooth η-smooth)
ἥ : Token -- U+1F25 ἥ GREEK SMALL LETTER ETA WITH DASIA AND OXIA
ἥ = with-accent-breathing η′ lower (acute η-vowel) (rough η-rough)
ἦ : Token -- U+1F26 ἦ GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI
ἦ = with-accent-breathing η′ lower (circumflex η-long-vowel) (smooth η-smooth)
ἧ : Token -- U+1F27 ἧ GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI
ἧ = with-accent-breathing η′ lower (circumflex η-long-vowel) (rough η-rough)
Ἠ : Token -- U+1F28 Ἠ GREEK CAPITAL LETTER ETA WITH PSILI
Ἠ = with-breathing η′ upper (smooth Η-smooth)
Ἡ : Token -- U+1F29 Ἡ GREEK CAPITAL LETTER ETA WITH DASIA
Ἡ = with-breathing η′ upper (rough η-rough)
Ἢ : Token -- U+1F2A Ἢ GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA
Ἢ = with-accent-breathing η′ upper (grave η-vowel) (smooth Η-smooth)
Ἣ : Token -- U+1F2B Ἣ GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA
Ἣ = with-accent-breathing η′ upper (grave η-vowel) (rough η-rough)
Ἤ : Token -- U+1F2C Ἤ GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA
Ἤ = with-accent-breathing η′ upper (acute η-vowel) (smooth Η-smooth)
Ἥ : Token -- U+1F2D Ἥ GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA
Ἥ = with-accent-breathing η′ upper (acute η-vowel) (rough η-rough)
Ἦ : Token -- U+1F2E Ἦ GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI
Ἦ = with-accent-breathing η′ upper (circumflex η-long-vowel) (smooth Η-smooth)
Ἧ : Token -- U+1F2F Ἧ GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI
Ἧ = with-accent-breathing η′ upper (circumflex η-long-vowel) (rough η-rough)
ἰ : Token -- U+1F30 ἰ GREEK SMALL LETTER IOTA WITH PSILI
ἰ = with-breathing ι′ lower (smooth ι-smooth)
ἱ : Token -- U+1F31 ἱ GREEK SMALL LETTER IOTA WITH DASIA
ἱ = with-breathing ι′ lower (rough ι-rough)
ἲ : Token -- U+1F32 ἲ GREEK SMALL LETTER IOTA WITH PSILI AND VARIA
ἲ = with-accent-breathing ι′ lower (grave ι-vowel) (smooth ι-smooth)
ἳ : Token -- U+1F33 ἳ GREEK SMALL LETTER IOTA WITH DASIA AND VARIA
ἳ = with-accent-breathing ι′ lower (grave ι-vowel) (rough ι-rough)
ἴ : Token -- U+1F34 ἴ GREEK SMALL LETTER IOTA WITH PSILI AND OXIA
ἴ = with-accent-breathing ι′ lower (acute ι-vowel) (smooth ι-smooth)
ἵ : Token -- U+1F35 ἵ GREEK SMALL LETTER IOTA WITH DASIA AND OXIA
ἵ = with-accent-breathing ι′ lower (acute ι-vowel) (rough ι-rough)
ἶ : Token -- U+1F36 ἶ GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI
ἶ = with-accent-breathing ι′ lower (circumflex ι-long-vowel) (smooth ι-smooth)
ἷ : Token -- U+1F37 ἷ GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI
ἷ = with-accent-breathing ι′ lower (circumflex ι-long-vowel) (rough ι-rough)
Ἰ : Token -- U+1F38 Ἰ GREEK CAPITAL LETTER IOTA WITH PSILI
Ἰ = with-breathing ι′ upper (smooth Ι-smooth)
Ἱ : Token -- U+1F39 Ἱ GREEK CAPITAL LETTER IOTA WITH DASIA
Ἱ = with-breathing ι′ upper (rough ι-rough)
Ἲ : Token -- U+1F3A Ἲ GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA
Ἲ = with-accent-breathing ι′ upper (grave ι-vowel) (smooth Ι-smooth)
Ἳ : Token -- U+1F3B Ἳ GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA
Ἳ = with-accent-breathing ι′ upper (grave ι-vowel) (rough ι-rough)
Ἴ : Token -- U+1F3C Ἴ GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA
Ἴ = with-accent-breathing ι′ upper (acute ι-vowel) (smooth Ι-smooth)
Ἵ : Token -- U+1F3D Ἵ GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA
Ἵ = with-accent-breathing ι′ upper (acute ι-vowel) (rough ι-rough)
Ἶ : Token -- U+1F3E Ἶ GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI
Ἶ = with-accent-breathing ι′ upper (circumflex ι-long-vowel) (smooth Ι-smooth)
Ἷ : Token -- U+1F3F Ἷ GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI
Ἷ = with-accent-breathing ι′ upper (circumflex ι-long-vowel) (rough ι-rough)
ὀ : Token -- U+1F40 ὀ GREEK SMALL LETTER OMICRON WITH PSILI
ὀ = with-breathing ο′ lower (smooth ο-smooth)
ὁ : Token -- U+1F41 ὁ GREEK SMALL LETTER OMICRON WITH DASIA
ὁ = with-breathing ο′ lower (rough ο-rough)
ὂ : Token -- U+1F42 ὂ GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA
ὂ = with-accent-breathing ο′ lower (grave ο-vowel) (smooth ο-smooth)
ὃ : Token -- U+1F43 ὃ GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA
ὃ = with-accent-breathing ο′ lower (grave ο-vowel) (rough ο-rough)
ὄ : Token -- U+1F44 ὄ GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA
ὄ = with-accent-breathing ο′ lower (acute ο-vowel) (smooth ο-smooth)
ὅ : Token -- U+1F45 ὅ GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA
ὅ = with-accent-breathing ο′ lower (acute ο-vowel) (rough ο-rough)
-- U+1F46
-- U+1F47
Ὀ : Token -- U+1F48 Ὀ GREEK CAPITAL LETTER OMICRON WITH PSILI
Ὀ = with-breathing ο′ upper (smooth Ο-smooth)
Ὁ : Token -- U+1F49 Ὁ GREEK CAPITAL LETTER OMICRON WITH DASIA
Ὁ = with-breathing ο′ upper (rough ο-rough)
Ὂ : Token -- U+1F4A Ὂ GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA
Ὂ = with-accent-breathing ο′ upper (grave ο-vowel) (smooth Ο-smooth)
Ὃ : Token -- U+1F4B Ὃ GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA
Ὃ = with-accent-breathing ο′ upper (grave ο-vowel) (rough ο-rough)
Ὄ : Token -- U+1F4C Ὄ GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA
Ὄ = with-accent-breathing ο′ upper (acute ο-vowel) (smooth Ο-smooth)
Ὅ : Token -- U+1F4D Ὅ GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA
Ὅ = with-accent-breathing ο′ upper (acute ο-vowel) (rough ο-rough)
-- U+1F4E
-- U+1F4F
ὐ : Token -- U+1F50 ὐ GREEK SMALL LETTER UPSILON WITH PSILI
ὐ = with-breathing υ′ lower (smooth υ-smooth)
ὑ : Token -- U+1F51 ὑ GREEK SMALL LETTER UPSILON WITH DASIA
ὑ = with-breathing υ′ lower (rough υ-rough)
ὒ : Token -- U+1F52 ὒ GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA
ὒ = with-accent-breathing υ′ lower (grave υ-vowel) (smooth υ-smooth)
ὓ : Token -- U+1F53 ὓ GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA
ὓ = with-accent-breathing υ′ lower (grave υ-vowel) (rough υ-rough)
ὔ : Token -- U+1F54 ὔ GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA
ὔ = with-accent-breathing υ′ lower (acute υ-vowel) (smooth υ-smooth)
ὕ : Token -- U+1F55 ὕ GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA
ὕ = with-accent-breathing υ′ lower (acute υ-vowel) (rough υ-rough)
ὖ : Token -- U+1F56 ὖ GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI
ὖ = with-accent-breathing υ′ lower (circumflex υ-long-vowel) (smooth υ-smooth)
ὗ : Token -- U+1F57 ὗ GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI
ὗ = with-accent-breathing υ′ lower (circumflex υ-long-vowel) (rough υ-rough)
-- U+1F58
Ὑ : Token -- U+1F59 Ὑ GREEK CAPITAL LETTER UPSILON WITH DASIA
Ὑ = with-breathing υ′ upper (rough υ-rough)
-- U+1F5A
Ὓ : Token -- U+1F5B Ὓ GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA
Ὓ = with-accent-breathing υ′ upper (grave υ-vowel) (rough υ-rough)
-- U+1F5C
Ὕ : Token -- U+1F5D Ὕ GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA
Ὕ = with-accent-breathing υ′ upper (acute υ-vowel) (rough υ-rough)
-- U+1F5E
Ὗ : Token -- U+1F5F Ὗ GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI
Ὗ = with-accent-breathing υ′ upper (circumflex υ-long-vowel) (rough υ-rough)
ὠ : Token -- U+1F60 ὠ GREEK SMALL LETTER OMEGA WITH PSILI
ὠ = with-breathing ω′ lower (smooth ω-smooth)
ὡ : Token -- U+1F61 ὡ GREEK SMALL LETTER OMEGA WITH DASIA
ὡ = with-breathing ω′ lower (rough ω-rough)
ὢ : Token -- U+1F62 ὢ GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA
ὢ = with-accent-breathing ω′ lower (grave ω-vowel) (smooth ω-smooth)
ὣ : Token -- U+1F63 ὣ GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA
ὣ = with-accent-breathing ω′ lower (grave ω-vowel) (rough ω-rough)
ὤ : Token -- U+1F64 ὤ GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA
ὤ = with-accent-breathing ω′ lower (acute ω-vowel) (smooth ω-smooth)
ὥ : Token -- U+1F65 ὥ GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA
ὥ = with-accent-breathing ω′ lower (acute ω-vowel) (rough ω-rough)
ὦ : Token -- U+1F66 ὦ GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI
ὦ = with-accent-breathing ω′ lower (circumflex ω-long-vowel) (smooth ω-smooth)
ὧ : Token -- U+1F67 ὧ GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI
ὧ = with-accent-breathing ω′ lower (circumflex ω-long-vowel) (rough ω-rough)
Ὠ : Token -- U+1F68 Ὠ GREEK CAPITAL LETTER OMEGA WITH PSILI
Ὠ = with-breathing ω′ upper (smooth Ω-smooth)
Ὡ : Token -- U+1F69 Ὡ GREEK CAPITAL LETTER OMEGA WITH DASIA
Ὡ = with-breathing ω′ upper (rough ω-rough)
Ὢ : Token -- U+1F6A Ὢ GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA
Ὢ = with-accent-breathing ω′ upper (grave ω-vowel) (smooth Ω-smooth)
Ὣ : Token -- U+1F6B Ὣ GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA
Ὣ = with-accent-breathing ω′ upper (grave ω-vowel) (rough ω-rough)
Ὤ : Token -- U+1F6C Ὤ GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA
Ὤ = with-accent-breathing ω′ upper (acute ω-vowel) (smooth Ω-smooth)
Ὥ : Token -- U+1F6D Ὥ GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA
Ὥ = with-accent-breathing ω′ upper (acute ω-vowel) (rough ω-rough)
Ὦ : Token -- U+1F6E Ὦ GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI
Ὦ = with-accent-breathing ω′ upper (circumflex ω-long-vowel) (smooth Ω-smooth)
Ὧ : Token -- U+1F6F Ὧ GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI
Ὧ = with-accent-breathing ω′ upper (circumflex ω-long-vowel) (rough ω-rough)
ὰ : Token -- U+1F70 ὰ GREEK SMALL LETTER ALPHA WITH VARIA
ὰ = with-accent α′ lower (grave α-vowel)
ά : Token -- U+1F71 ά GREEK SMALL LETTER ALPHA WITH OXIA
ά = with-accent α′ lower (acute α-vowel)
ὲ : Token -- U+1F72 ὲ GREEK SMALL LETTER EPSILON WITH VARIA
ὲ = with-accent ε′ lower (grave ε-vowel)
έ : Token -- U+1F73 έ GREEK SMALL LETTER EPSILON WITH OXIA
έ = with-accent ε′ lower (acute ε-vowel)
ὴ : Token -- U+1F74 ὴ GREEK SMALL LETTER ETA WITH VARIA
ὴ = with-accent η′ lower (grave η-vowel)
ή : Token -- U+1F75 ή GREEK SMALL LETTER ETA WITH OXIA
ή = with-accent η′ lower (acute η-vowel)
ὶ : Token -- U+1F76 ὶ GREEK SMALL LETTER IOTA WITH VARIA
ὶ = with-accent ι′ lower (grave ι-vowel)
ί : Token -- U+1F77 ί GREEK SMALL LETTER IOTA WITH OXIA
ί = with-accent ι′ lower (acute ι-vowel)
ὸ : Token -- U+1F78 ὸ GREEK SMALL LETTER OMICRON WITH VARIA
ὸ = with-accent ο′ lower (grave ο-vowel)
ό : Token -- U+1F79 ό GREEK SMALL LETTER OMICRON WITH OXIA
ό = with-accent ο′ lower (acute ο-vowel)
ὺ : Token -- U+1F7A ὺ GREEK SMALL LETTER UPSILON WITH VARIA
ὺ = with-accent υ′ lower (grave υ-vowel)
ύ : Token -- U+1F7B ύ GREEK SMALL LETTER UPSILON WITH OXIA
ύ = with-accent υ′ lower (acute υ-vowel)
ὼ : Token -- U+1F7C ὼ GREEK SMALL LETTER OMEGA WITH VARIA
ὼ = with-accent ω′ lower (grave ω-vowel)
ώ : Token -- U+1F7D ώ GREEK SMALL LETTER OMEGA WITH OXIA
ώ = with-accent ω′ lower (acute ω-vowel)
-- U+1F7E
-- U+1F7F
ᾀ : Token -- U+1F80 ᾀ GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI
ᾀ = with-breathing-iota α′ lower (smooth α-smooth) α-iota-subscript
ᾁ : Token -- U+1F81 ᾁ GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI
ᾁ = with-breathing-iota α′ lower (rough α-rough) α-iota-subscript
ᾂ : Token -- U+1F82 ᾂ GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI
ᾂ = with-accent-breathing-iota α′ lower (grave α-vowel) (smooth α-smooth) α-iota-subscript
ᾃ : Token -- U+1F83 ᾃ GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI
ᾃ = with-accent-breathing-iota α′ lower (grave α-vowel) (rough α-rough) α-iota-subscript
ᾄ : Token -- U+1F84 ᾄ GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI
ᾄ = with-accent-breathing-iota α′ lower (acute α-vowel) (smooth α-smooth) α-iota-subscript
ᾅ : Token -- U+1F85 ᾅ GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI
ᾅ = with-accent-breathing-iota α′ lower (acute α-vowel) (rough α-rough) α-iota-subscript
ᾆ : Token -- U+1F86 ᾆ GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
ᾆ = with-accent-breathing-iota α′ lower (circumflex α-long-vowel) (smooth α-smooth) α-iota-subscript
ᾇ : Token -- U+1F87 ᾇ GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
ᾇ = with-accent-breathing-iota α′ lower (circumflex α-long-vowel) (rough α-rough) α-iota-subscript
ᾈ : Token -- U+1F88 ᾈ GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI
ᾈ = with-breathing-iota α′ upper (smooth Α-smooth) α-iota-subscript
ᾉ : Token -- U+1F89 ᾉ GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI
ᾉ = with-breathing-iota α′ upper (rough α-rough) α-iota-subscript
ᾊ : Token -- U+1F8A ᾊ GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI
ᾊ = with-accent-breathing-iota α′ upper (grave α-vowel) (smooth Α-smooth) α-iota-subscript
ᾋ : Token -- U+1F8B ᾋ GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI
ᾋ = with-accent-breathing-iota α′ upper (grave α-vowel) (rough α-rough) α-iota-subscript
ᾌ : Token -- U+1F8C ᾌ GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI
ᾌ = with-accent-breathing-iota α′ upper (acute α-vowel) (smooth Α-smooth) α-iota-subscript
ᾍ : Token -- U+1F8D ᾍ GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI
ᾍ = with-accent-breathing-iota α′ upper (acute α-vowel) (rough α-rough) α-iota-subscript
ᾎ : Token -- U+1F8E ᾎ GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
ᾎ = with-accent-breathing-iota α′ upper (circumflex α-long-vowel) (smooth Α-smooth) α-iota-subscript
ᾏ : Token -- U+1F8F ᾏ GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
ᾏ = with-accent-breathing-iota α′ upper (circumflex α-long-vowel) (rough α-rough) α-iota-subscript
ᾐ : Token -- U+1F90 ᾐ GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI
ᾐ = with-breathing-iota η′ lower (smooth η-smooth) η-iota-subscript
ᾑ : Token -- U+1F91 ᾑ GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI
ᾑ = with-breathing-iota η′ lower (rough η-rough) η-iota-subscript
ᾒ : Token -- U+1F92 ᾒ GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI
ᾒ = with-accent-breathing-iota η′ lower (grave η-vowel) (smooth η-smooth) η-iota-subscript
ᾓ : Token -- U+1F93 ᾓ GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI
ᾓ = with-accent-breathing-iota η′ lower (grave η-vowel) (rough η-rough) η-iota-subscript
ᾔ : Token -- U+1F94 ᾔ GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI
ᾔ = with-accent-breathing-iota η′ lower (acute η-vowel) (smooth η-smooth) η-iota-subscript
ᾕ : Token -- U+1F95 ᾕ GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI
ᾕ = with-accent-breathing-iota η′ lower (acute η-vowel) (rough η-rough) η-iota-subscript
ᾖ : Token -- U+1F96 ᾖ GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
ᾖ = with-accent-breathing-iota η′ lower (circumflex η-long-vowel) (smooth η-smooth) η-iota-subscript
ᾗ : Token -- U+1F97 ᾗ GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
ᾗ = with-accent-breathing-iota η′ lower (circumflex η-long-vowel) (rough η-rough) η-iota-subscript
ᾘ : Token -- U+1F98 ᾘ GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI
ᾘ = with-breathing-iota η′ upper (smooth Η-smooth) η-iota-subscript
ᾙ : Token -- U+1F99 ᾙ GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI
ᾙ = with-breathing-iota η′ upper (rough η-rough) η-iota-subscript
ᾚ : Token -- U+1F9A ᾚ GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI
ᾚ = with-accent-breathing-iota η′ upper (grave η-vowel) (smooth Η-smooth) η-iota-subscript
ᾛ : Token -- U+1F9B ᾛ GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI
ᾛ = with-accent-breathing-iota η′ upper (grave η-vowel) (rough η-rough) η-iota-subscript
ᾜ : Token -- U+1F9C ᾜ GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI
ᾜ = with-accent-breathing-iota η′ upper (acute η-vowel) (smooth Η-smooth) η-iota-subscript
ᾝ : Token -- U+1F9D ᾝ GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI
ᾝ = with-accent-breathing-iota η′ upper (acute η-vowel) (rough η-rough) η-iota-subscript
ᾞ : Token -- U+1F9E ᾞ GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
ᾞ = with-accent-breathing-iota η′ upper (circumflex η-long-vowel) (smooth Η-smooth) η-iota-subscript
ᾟ : Token -- U+1F9F ᾟ GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
ᾟ = with-accent-breathing-iota η′ upper (circumflex η-long-vowel) (rough η-rough) η-iota-subscript
ᾠ : Token -- U+1FA0 ᾠ GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI
ᾠ = with-breathing-iota ω′ lower (smooth ω-smooth) ω-iota-subscript
ᾡ : Token -- U+1FA1 ᾡ GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI
ᾡ = with-breathing-iota ω′ lower (rough ω-rough) ω-iota-subscript
ᾢ : Token -- U+1FA2 ᾢ GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI
ᾢ = with-accent-breathing-iota ω′ lower (grave ω-vowel) (smooth ω-smooth) ω-iota-subscript
ᾣ : Token -- U+1FA3 ᾣ GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI
ᾣ = with-accent-breathing-iota ω′ lower (grave ω-vowel) (rough ω-rough) ω-iota-subscript
ᾤ : Token -- U+1FA4 ᾤ GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI
ᾤ = with-accent-breathing-iota ω′ lower (acute ω-vowel) (smooth ω-smooth) ω-iota-subscript
ᾥ : Token -- U+1FA5 ᾥ GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI
ᾥ = with-accent-breathing-iota ω′ lower (acute ω-vowel) (rough ω-rough) ω-iota-subscript
ᾦ : Token -- U+1FA6 ᾦ GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
ᾦ = with-accent-breathing-iota ω′ lower (circumflex ω-long-vowel) (smooth ω-smooth) ω-iota-subscript
ᾧ : Token -- U+1FA7 ᾧ GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
ᾧ = with-accent-breathing-iota ω′ lower (circumflex ω-long-vowel) (rough ω-rough) ω-iota-subscript
ᾨ : Token -- U+1FA8 ᾨ GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI
ᾨ = with-breathing-iota ω′ upper (smooth Ω-smooth) ω-iota-subscript
ᾩ : Token -- U+1FA9 ᾩ GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI
ᾩ = with-breathing-iota ω′ upper (rough ω-rough) ω-iota-subscript
ᾪ : Token -- U+1FAA ᾪ GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI
ᾪ = with-accent-breathing-iota ω′ upper (grave ω-vowel) (smooth Ω-smooth) ω-iota-subscript
ᾫ : Token -- U+1FAB ᾫ GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI
ᾫ = with-accent-breathing-iota ω′ upper (grave ω-vowel) (rough ω-rough) ω-iota-subscript
ᾬ : Token -- U+1FAC ᾬ GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI
ᾬ = with-accent-breathing-iota ω′ upper (acute ω-vowel) (smooth Ω-smooth) ω-iota-subscript
ᾭ : Token -- U+1FAD ᾭ GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI
ᾭ = with-accent-breathing-iota ω′ upper (acute ω-vowel) (rough ω-rough) ω-iota-subscript
ᾮ : Token -- U+1FAE ᾮ GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
ᾮ = with-accent-breathing-iota ω′ upper (circumflex ω-long-vowel) (smooth Ω-smooth) ω-iota-subscript
ᾯ : Token -- U+1FAF ᾯ GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
ᾯ = with-accent-breathing-iota ω′ upper (circumflex ω-long-vowel) (rough ω-rough) ω-iota-subscript
-- U+1FB0 ᾰ GREEK SMALL LETTER ALPHA WITH VRACHY
-- U+1FB1 ᾱ GREEK SMALL LETTER ALPHA WITH MACRON
ᾲ : Token -- U+1FB2 ᾲ GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI
ᾲ = with-accent-iota α′ lower (grave α-vowel) α-iota-subscript
ᾳ : Token -- U+1FB3 ᾳ GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI
ᾳ = with-iota α′ lower α-iota-subscript
ᾴ : Token -- U+1FB4 ᾴ GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI
ᾴ = with-accent-iota α′ lower (acute α-vowel) α-iota-subscript
-- U+1FB5
ᾶ : Token -- U+1FB6 ᾶ GREEK SMALL LETTER ALPHA WITH PERISPOMENI
ᾶ = with-accent α′ lower (circumflex α-long-vowel)
ᾷ : Token -- U+1FB7 ᾷ GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI
ᾷ = with-accent-iota α′ lower (circumflex α-long-vowel) α-iota-subscript
-- U+1FB8 Ᾰ GREEK CAPITAL LETTER ALPHA WITH VRACHY
-- U+1FB9 Ᾱ GREEK CAPITAL LETTER ALPHA WITH MACRON
Ὰ : Token -- U+1FBA Ὰ GREEK CAPITAL LETTER ALPHA WITH VARIA
Ὰ = with-accent α′ upper (grave α-vowel)
Ά : Token -- U+1FBB Ά GREEK CAPITAL LETTER ALPHA WITH OXIA
Ά = with-accent α′ upper (acute α-vowel)
ᾼ : Token -- U+1FBC ᾼ GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI
ᾼ = with-iota α′ upper α-iota-subscript
-- U+1FBD ᾽ GREEK KORONIS
-- U+1FBE ι GREEK PROSGEGRAMMENI
-- U+1FBF ᾿ GREEK PSILI
-- U+1FC0 ῀ GREEK PERISPOMENI
-- U+1FC1 ῁ GREEK DIALYTIKA AND PERISPOMENI
ῂ : Token -- U+1FC2 ῂ GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI accent (circumflex α-long-vowel)
ῂ = with-accent-iota η′ lower (grave η-vowel) η-iota-subscript
ῃ : Token -- U+1FC3 ῃ GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI
ῃ = with-iota η′ lower η-iota-subscript
ῄ : Token -- U+1FC4 ῄ GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI
ῄ = with-accent-iota η′ lower (acute η-vowel) η-iota-subscript
-- U+1FC5
ῆ : Token -- U+1FC6 ῆ GREEK SMALL LETTER ETA WITH PERISPOMENI
ῆ = with-accent η′ lower (circumflex η-long-vowel)
ῇ : Token -- U+1FC7 ῇ GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI
ῇ = with-accent-iota η′ lower (circumflex η-long-vowel) η-iota-subscript
Ὲ : Token -- U+1FC8 Ὲ GREEK CAPITAL LETTER EPSILON WITH VARIA
Ὲ = with-accent ε′ upper (grave ε-vowel)
Έ : Token -- U+1FC9 Έ GREEK CAPITAL LETTER EPSILON WITH OXIA
Έ = with-accent ε′ upper (acute ε-vowel)
Ὴ : Token -- U+1FCA Ὴ GREEK CAPITAL LETTER ETA WITH VARIA
Ὴ = with-accent η′ upper (grave η-vowel)
Ή : Token -- U+1FCB Ή GREEK CAPITAL LETTER ETA WITH OXIA
Ή = with-accent η′ upper (acute η-vowel)
ῌ : Token -- U+1FCC ῌ GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI
ῌ = with-iota η′ upper η-iota-subscript
-- U+1FCD ῍ GREEK PSILI AND VARIA
-- U+1FCE ῎ GREEK PSILI AND OXIA
-- U+1FCF ῏ GREEK PSILI AND PERISPOMENI
-- U+1FD0 ῐ GREEK SMALL LETTER IOTA WITH VRACHY
-- U+1FD1 ῑ GREEK SMALL LETTER IOTA WITH MACRON
ῒ : Token -- U+1FD2 ῒ GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA
ῒ = with-accent-diaeresis ι′ lower (grave ι-vowel) ι-diaeresis
ΐ : Token -- U+1FD3 ΐ GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA
ΐ = with-accent-diaeresis ι′ lower (acute ι-vowel) ι-diaeresis
-- U+1FD4
-- U+1FD5
ῖ : Token -- U+1FD6 ῖ GREEK SMALL LETTER IOTA WITH PERISPOMENI
ῖ = with-accent ι′ lower (circumflex ι-long-vowel)
ῗ : Token -- U+1FD7 ῗ GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI
ῗ = with-accent-diaeresis ι′ lower (circumflex ι-long-vowel) ι-diaeresis
-- U+1FD8 Ῐ GREEK CAPITAL LETTER IOTA WITH VRACHY
-- U+1FD9 Ῑ GREEK CAPITAL LETTER IOTA WITH MACRON
Ὶ : Token -- U+1FDA Ὶ GREEK CAPITAL LETTER IOTA WITH VARIA
Ὶ = with-accent ι′ upper (grave ι-vowel)
Ί : Token -- U+1FDB Ί GREEK CAPITAL LETTER IOTA WITH OXIA
Ί = with-accent ι′ upper (acute ι-vowel)
-- U+1FDC
-- U+1FDD ῝ GREEK DASIA AND VARIA
-- U+1FDE ῞ GREEK DASIA AND OXIA
-- U+1FDF ῟ GREEK DASIA AND PERISPOMENI
-- U+1FE0 ῠ GREEK SMALL LETTER UPSILON WITH VRACHY
-- U+1FE1 ῡ GREEK SMALL LETTER UPSILON WITH MACRON
ῢ : Token -- U+1FE2 ῢ GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA
ῢ = with-accent-diaeresis υ′ lower (grave υ-vowel) υ-diaeresis
ΰ : Token -- U+1FE3 ΰ GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA
ΰ = with-accent-diaeresis υ′ lower (acute υ-vowel) υ-diaeresis
ῤ : Token -- U+1FE4 ῤ GREEK SMALL LETTER RHO WITH PSILI
ῤ = with-breathing ρ′ lower (smooth ρ-smooth)
ῥ : Token -- U+1FE5 ῥ GREEK SMALL LETTER RHO WITH DASIA
ῥ = with-breathing ρ′ lower (rough ρ-rough)
ῦ : Token -- U+1FE6 ῦ GREEK SMALL LETTER UPSILON WITH PERISPOMENI
ῦ = with-accent υ′ lower (circumflex υ-long-vowel)
ῧ : Token -- U+1FE7 ῧ GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI
ῧ = with-accent-diaeresis υ′ lower (circumflex υ-long-vowel) υ-diaeresis
-- U+1FE8 Ῠ GREEK CAPITAL LETTER UPSILON WITH VRACHY
-- U+1FE9 Ῡ GREEK CAPITAL LETTER UPSILON WITH MACRON
Ὺ : Token -- U+1FEA Ὺ GREEK CAPITAL LETTER UPSILON WITH VARIA
Ὺ = with-accent υ′ upper (grave υ-vowel)
Ύ : Token -- U+1FEB Ύ GREEK CAPITAL LETTER UPSILON WITH OXIA
Ύ = with-accent υ′ upper (acute υ-vowel)
Ῥ : Token -- U+1FEC Ῥ GREEK CAPITAL LETTER RHO WITH DASIA
Ῥ = with-breathing ρ′ upper (rough ρ-rough)
-- U+1FED ῭ GREEK DIALYTIKA AND VARIA
-- U+1FEE ΅ GREEK DIALYTIKA AND OXIA
-- U+1FEF ` GREEK VARIA
-- U+1FF0
-- U+1FF1
ῲ : Token -- U+1FF2 ῲ GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI
ῲ = with-accent-iota ω′ lower (grave ω-vowel) ω-iota-subscript
ῳ : Token -- U+1FF3 ῳ GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI
ῳ = with-iota ω′ lower ω-iota-subscript
ῴ : Token -- U+1FF4 ῴ GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI
ῴ = with-accent-iota ω′ lower (acute ω-vowel) ω-iota-subscript
-- U+1FF5
ῶ : Token -- U+1FF6 ῶ GREEK SMALL LETTER OMEGA WITH PERISPOMENI
ῶ = with-accent ω′ lower (circumflex ω-long-vowel)
ῷ : Token -- U+1FF7 ῷ GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI
ῷ = with-accent-iota ω′ lower (circumflex ω-long-vowel) ω-iota-subscript
Ὸ : Token -- U+1FF8 Ὸ GREEK CAPITAL LETTER OMICRON WITH VARIA
Ὸ = with-accent ο′ upper (grave ο-vowel)
Ό : Token -- U+1FF9 Ό GREEK CAPITAL LETTER OMICRON WITH OXIA
Ό = with-accent ο′ upper (acute ο-vowel)
Ὼ : Token -- U+1FFA Ὼ GREEK CAPITAL LETTER OMEGA WITH VARIA
Ὼ = with-accent ω′ upper (grave ω-vowel)
Ώ : Token -- U+1FFB Ώ GREEK CAPITAL LETTER OMEGA WITH OXIA
Ώ = with-accent ω′ upper (acute ω-vowel)
ῼ : Token -- U+1FFC ῼ GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI
ῼ = with-iota ω′ upper ω-iota-subscript
-- U+1FFD ´ GREEK OXIA
-- U+1FFE ῾ GREEK DASIA
-- U+1FFF
|
{
"alphanum_fraction": 0.7291100791,
"avg_line_length": 57.6414141414,
"ext": "agda",
"hexsha": "6a8f76af66530f1c516c5401b51fed2c3a7b3c81",
"lang": "Agda",
"max_forks_count": 5,
"max_forks_repo_forks_event_max_datetime": "2017-06-11T11:25:09.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-02-27T22:34:13.000Z",
"max_forks_repo_head_hexsha": "915c46c27c7f8aad5907474d8484f2685a4cd6a7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "scott-fleischman/GreekGrammar",
"max_forks_repo_path": "agda/Text/Greek/Script/Unicode.agda",
"max_issues_count": 13,
"max_issues_repo_head_hexsha": "915c46c27c7f8aad5907474d8484f2685a4cd6a7",
"max_issues_repo_issues_event_max_datetime": "2020-09-07T11:58:38.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-05-28T20:04:08.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "scott-fleischman/GreekGrammar",
"max_issues_repo_path": "agda/Text/Greek/Script/Unicode.agda",
"max_line_length": 107,
"max_stars_count": 44,
"max_stars_repo_head_hexsha": "915c46c27c7f8aad5907474d8484f2685a4cd6a7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "scott-fleischman/GreekGrammar",
"max_stars_repo_path": "agda/Text/Greek/Script/Unicode.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-06T15:41:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-05-29T14:48:51.000Z",
"num_tokens": 14275,
"size": 34239
}
|
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Semiring -- for length
open import Lists.Lists
open import Functions.Definition
--open import Groups.Actions
module Groups.FinitePermutations where
allInsertions : {a : _} {A : Set a} (x : A) (l : List A) → List (List A)
allInsertions x [] = [ x ] :: []
allInsertions x (y :: l) = (x :: (y :: l)) :: (map (λ i → y :: i) (allInsertions x l))
permutations : {a : _} {A : Set a} (l : List A) → List (List A)
permutations [] = [ [] ]
permutations (x :: l) = flatten (map (allInsertions x) (permutations l))
factorial : ℕ → ℕ
factorial zero = 1
factorial (succ n) = (succ n) *N factorial n
factCheck : factorial 5 ≡ 120
factCheck = refl
allInsertionsLength : {a : _} {A : Set a} (x : A) (l : List A) → length (allInsertions x l) ≡ succ (length l)
allInsertionsLength x [] = refl
allInsertionsLength x (y :: l) = applyEquality succ (transitivity (equalityCommutative (lengthMap (allInsertions x l) {f = y ::_})) (allInsertionsLength x l))
allInsertionsLength' : {a : _} {A : Set a} (x : A) (l : List A) → allTrue (λ i → length i ≡ succ (length l)) (allInsertions x l)
allInsertionsLength' x [] = refl ,, record {}
allInsertionsLength' x (y :: l) with allInsertionsLength' x l
... | bl = refl ,, allTrueMap (λ i → length i ≡ succ (succ (length l))) (y ::_) (allInsertions x l) (allTrueExtension (λ z → length z ≡ succ (length l)) ((λ i → length i ≡ succ (succ (length l))) ∘ (y ::_)) (allInsertions x l) (λ {x} → λ p → applyEquality succ p) bl)
permutationsCheck : permutations (3 :: 4 :: []) ≡ (3 :: 4 :: []) :: (4 :: 3 :: []) :: []
permutationsCheck = refl
permsAllSameLength : {a : _} {A : Set a} (l : List A) → allTrue (λ i → length i ≡ length l) (permutations l)
permsAllSameLength [] = refl ,, record {}
permsAllSameLength (x :: l) with permsAllSameLength l
... | bl = allTrueFlatten (λ i → length i ≡ succ (length l)) (map (allInsertions x) (permutations l)) (allTrueMap (allTrue (λ i → length i ≡ succ (length l))) (allInsertions x) (permutations l) (allTrueExtension (λ z → length z ≡ length l) (allTrue (λ i → length i ≡ succ (length l)) ∘ allInsertions x) (permutations l) lemma bl))
where
lemma : {m : List _} → (lenM=lenL : length m ≡ length l) → allTrue (λ i → length i ≡ succ (length l)) (allInsertions x m)
lemma {m} lm=ll rewrite equalityCommutative lm=ll = allInsertionsLength' x m
allTrueEqual : {a b : _} {A : Set a} {B : Set b} (f : A → B) (equalTo : B) (l : List A) → allTrue (λ i → f i ≡ equalTo) l → map f l ≡ replicate (length l) equalTo
allTrueEqual f equalTo [] pr = refl
allTrueEqual f equalTo (x :: l) (fst ,, snd) rewrite fst | allTrueEqual f equalTo l snd = refl
totalReplicate : (l len : ℕ) → fold _+N_ 0 (replicate len l) ≡ l *N len
totalReplicate l zero rewrite multiplicationNIsCommutative l 0 = refl
totalReplicate l (succ len) rewrite totalReplicate l len | multiplicationNIsCommutative l (succ len) = applyEquality (l +N_) (multiplicationNIsCommutative l len)
permsLen : {a : _} {A : Set a} (l : List A) → length (permutations l) ≡ factorial (length l)
permsLen [] = refl
permsLen (x :: l) = transitivity (lengthFlatten (map (allInsertions x) (permutations l))) (transitivity (applyEquality (fold _+N_ 0) (mapMap (permutations l))) (transitivity (applyEquality (fold _+N_ 0) (mapExtension (permutations l) (length ∘ allInsertions x) (succ ∘ length) λ {y} → allInsertionsLength x y)) (transitivity (applyEquality (fold _+N_ 0) lemma) (transitivity (totalReplicate (succ (length l)) (length (permutations l))) ans))))
where
lemma : map (λ a → succ (length a)) (permutations l) ≡ replicate (length (permutations l)) (succ (length l))
lemma = allTrueEqual (λ a → succ (length a)) (succ (length l)) (permutations l) (allTrueExtension (λ z → length z ≡ length l) (λ i → succ (length i) ≡ succ (length l)) (permutations l) (λ pr → applyEquality succ pr) (permsAllSameLength l))
ans : length (permutations l) +N length l *N length (permutations l) ≡ factorial (length l) +N length l *N factorial (length l)
ans rewrite permsLen l = refl
--act : GroupAction (symmetricGroup (symmetricSetoid (reflSetoid (FinSet n))))
--act = ?
{- TODO: show that symmetricGroup acts in the obvious way on permutations FinSet
listElements : {a : _} {A : Set a} (l : List A) → Set
listElements [] = False
listElements (x :: l) = True || listElements l
listElement : {a : _} {A : Set a} {l : List A} (elt : listElements l) → A
listElement {l = []} ()
listElement {l = x :: l} (inl record {}) = x
listElement {l = x :: l} (inr elt) = listElement {l = l} elt
backwardRange : ℕ → List ℕ
backwardRange zero = []
backwardRange (succ n) = n :: backwardRange n
backwardRangeLength : {n : ℕ} → length (backwardRange n) ≡ n
backwardRangeLength {zero} = refl
backwardRangeLength {succ n} rewrite backwardRangeLength {n} = refl
applyPermutation : {n : ℕ} → (f : FinSet n → FinSet n) → listElements (permutations (backwardRange n)) → listElements (permutations (backwardRange n))
applyPermutation {zero} f (inl record {}) = inl (record {})
applyPermutation {zero} f (inr ())
applyPermutation {succ n} f elt = {!!}
finitePermutations : (n : ℕ) → SetoidToSet (symmetricSetoid (reflSetoid (FinSet n))) (listElements (permutations (backwardRange n)))
SetoidToSet.project (finitePermutations n) (sym {f} fBij) = {!!}
SetoidToSet.wellDefined (finitePermutations n) = {!!}
SetoidToSet.surj (finitePermutations n) = {!!}
SetoidToSet.inj (finitePermutations n) = {!!}
-}
|
{
"alphanum_fraction": 0.6696315121,
"avg_line_length": 57.3854166667,
"ext": "agda",
"hexsha": "3698e70ec144bae45ba794d74b4cbc40d4e73d05",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-29T13:23:07.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-29T13:23:07.000Z",
"max_forks_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Smaug123/agdaproofs",
"max_forks_repo_path": "Groups/FinitePermutations.agda",
"max_issues_count": 14,
"max_issues_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_issues_repo_issues_event_max_datetime": "2020-04-11T11:03:39.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-06T21:11:59.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Smaug123/agdaproofs",
"max_issues_repo_path": "Groups/FinitePermutations.agda",
"max_line_length": 443,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Smaug123/agdaproofs",
"max_stars_repo_path": "Groups/FinitePermutations.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-28T06:04:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-08-08T12:44:19.000Z",
"num_tokens": 1781,
"size": 5509
}
|
{-# OPTIONS --safe #-}
module RevRev where
open import Relation.Binary.PropositionalEquality
open import Data.List
open import Data.List.Properties
rev : ∀ {ℓ} {A : Set ℓ} → List A → List A
rev [] = []
rev (x ∷ xs) = rev xs ++ x ∷ []
lemma : ∀ {ℓ} {A : Set ℓ} (a b : List A) → rev (a ++ b) ≡ rev b ++ rev a
lemma [] b rewrite ++-identityʳ (rev b) = refl
lemma (x ∷ a) b rewrite lemma a b | ++-assoc (rev b) (rev a) (x ∷ []) = refl
revrevid : ∀ {ℓ} {A : Set ℓ} (a : List A) → rev (rev a) ≡ a
revrevid [] = refl
revrevid (x ∷ a) rewrite lemma (rev a) (x ∷ []) | revrevid a = refl
|
{
"alphanum_fraction": 0.5738831615,
"avg_line_length": 30.6315789474,
"ext": "agda",
"hexsha": "18af3d0e94e08557428b7293ad64c1b83bb314cc",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-12-13T04:50:46.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-12-13T04:50:46.000Z",
"max_forks_repo_head_hexsha": "eb2cef0556efb9a4ce11783f8516789ea48cc344",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Brethland/LEARNING-STUFF",
"max_forks_repo_path": "Agda/RevRev.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "eb2cef0556efb9a4ce11783f8516789ea48cc344",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Brethland/LEARNING-STUFF",
"max_issues_repo_path": "Agda/RevRev.agda",
"max_line_length": 76,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "eb2cef0556efb9a4ce11783f8516789ea48cc344",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Brethland/LEARNING-STUFF",
"max_stars_repo_path": "Agda/RevRev.agda",
"max_stars_repo_stars_event_max_datetime": "2020-03-11T10:35:42.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-02-03T05:05:52.000Z",
"num_tokens": 221,
"size": 582
}
|
------------------------------------------------------------------------
-- Some properties about subsets
------------------------------------------------------------------------
module Data.Fin.Subset.Props where
open import Data.Nat
open import Data.Vec hiding (_∈_)
open import Data.Empty
open import Data.Function
open import Data.Fin
open import Data.Fin.Subset
open import Data.Product
open import Relation.Binary.PropositionalEquality
------------------------------------------------------------------------
-- Constructor mangling
drop-there : ∀ {s n x} {p : Subset n} → suc x ∈ s ∷ p → x ∈ p
drop-there (there x∈p) = x∈p
drop-∷-⊆ : ∀ {n s₁ s₂} {p₁ p₂ : Subset n} → s₁ ∷ p₁ ⊆ s₂ ∷ p₂ → p₁ ⊆ p₂
drop-∷-⊆ p₁s₁⊆p₂s₂ x∈p₁ = drop-there $ p₁s₁⊆p₂s₂ (there x∈p₁)
drop-∷-Empty : ∀ {n s} {p : Subset n} → Empty (s ∷ p) → Empty p
drop-∷-Empty ¬¬∅ (x , x∈p) = ¬¬∅ (suc x , there x∈p)
------------------------------------------------------------------------
-- More interesting properties
allInside : ∀ {n} (x : Fin n) → x ∈ all inside
allInside zero = here
allInside (suc x) = there (allInside x)
allOutside : ∀ {n} (x : Fin n) → x ∉ all outside
allOutside zero ()
allOutside (suc x) (there x∈) = allOutside x x∈
⊆⊇⟶≡ : ∀ {n} {p₁ p₂ : Subset n} →
p₁ ⊆ p₂ → p₂ ⊆ p₁ → p₁ ≡ p₂
⊆⊇⟶≡ = helper _ _
where
helper : ∀ {n} (p₁ p₂ : Subset n) →
p₁ ⊆ p₂ → p₂ ⊆ p₁ → p₁ ≡ p₂
helper [] [] _ _ = refl
helper (s₁ ∷ p₁) (s₂ ∷ p₂) ₁⊆₂ ₂⊆₁ with ⊆⊇⟶≡ (drop-∷-⊆ ₁⊆₂)
(drop-∷-⊆ ₂⊆₁)
helper (outside ∷ p) (outside ∷ .p) ₁⊆₂ ₂⊆₁ | refl = refl
helper (inside ∷ p) (inside ∷ .p) ₁⊆₂ ₂⊆₁ | refl = refl
helper (outside ∷ p) (inside ∷ .p) ₁⊆₂ ₂⊆₁ | refl with ₂⊆₁ here
... | ()
helper (inside ∷ p) (outside ∷ .p) ₁⊆₂ ₂⊆₁ | refl with ₁⊆₂ here
... | ()
∅⟶allOutside : ∀ {n} {p : Subset n} →
Empty p → p ≡ all outside
∅⟶allOutside {p = []} ¬¬∅ = refl
∅⟶allOutside {p = s ∷ ps} ¬¬∅ with ∅⟶allOutside (drop-∷-Empty ¬¬∅)
∅⟶allOutside {p = outside ∷ .(all outside)} ¬¬∅ | refl = refl
∅⟶allOutside {p = inside ∷ .(all outside)} ¬¬∅ | refl =
⊥-elim (¬¬∅ (zero , here))
|
{
"alphanum_fraction": 0.4479302832,
"avg_line_length": 37.0161290323,
"ext": "agda",
"hexsha": "cbac082a07b0ea51feba646378d293b3ccd40d59",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:54:10.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-07-21T16:37:58.000Z",
"max_forks_repo_head_hexsha": "8ef786b40e4a9ab274c6103dc697dcb658cf3db3",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "isabella232/Lemmachine",
"max_forks_repo_path": "vendor/stdlib/src/Data/Fin/Subset/Props.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "8ef786b40e4a9ab274c6103dc697dcb658cf3db3",
"max_issues_repo_issues_event_max_datetime": "2022-03-12T12:17:51.000Z",
"max_issues_repo_issues_event_min_datetime": "2022-03-12T12:17:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "larrytheliquid/Lemmachine",
"max_issues_repo_path": "vendor/stdlib/src/Data/Fin/Subset/Props.agda",
"max_line_length": 72,
"max_stars_count": 56,
"max_stars_repo_head_hexsha": "8ef786b40e4a9ab274c6103dc697dcb658cf3db3",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "isabella232/Lemmachine",
"max_stars_repo_path": "vendor/stdlib/src/Data/Fin/Subset/Props.agda",
"max_stars_repo_stars_event_max_datetime": "2021-12-21T17:02:19.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-20T02:11:42.000Z",
"num_tokens": 878,
"size": 2295
}
|
postulate
A B : Set
f : @0 {{A}} → B
g : @0 {{A}} → B
g = f
|
{
"alphanum_fraction": 0.3636363636,
"avg_line_length": 8.25,
"ext": "agda",
"hexsha": "8024e6d2bd3cc3b0eecea5d7b0971dc54b48675d",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b5b3b1657556f720a7310cb7744edb1fac71eaf4",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "Seanpm2001-Agda-lang/agda",
"max_forks_repo_path": "test/Succeed/Issue5787.agda",
"max_issues_count": 6,
"max_issues_repo_head_hexsha": "b5b3b1657556f720a7310cb7744edb1fac71eaf4",
"max_issues_repo_issues_event_max_datetime": "2021-11-24T08:31:10.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-10-18T08:12:24.000Z",
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "Seanpm2001-Agda-lang/agda",
"max_issues_repo_path": "test/Succeed/Issue5787.agda",
"max_line_length": 18,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "KDr2/agda",
"max_stars_repo_path": "test/Succeed/Issue5787.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-05T00:25:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2022-03-05T00:25:14.000Z",
"num_tokens": 35,
"size": 66
}
|
{-# OPTIONS --without-K #-}
module sets.nat.struct where
open import sum
open import equality
open import function
open import container.core
open import container.w
open import sets.empty
open import sets.unit
open import sets.nat.core
open import sets.fin
open import sets.vec.dependent
open import hott.level
ℕ-c : Container _ _ _
ℕ-c = record
{ I = ⊤
; A = λ _ → Fin 2
; B = ⊥ ∷∷ ⊤ ∷∷ ⟦⟧
; r = λ _ → tt }
open Container ℕ-c
ℕ-algebra-iso : (⊤ ⊎ ℕ) ≅ ℕ
ℕ-algebra-iso = record
{ to = λ { (inj₁ _) → zero ; (inj₂ n) → suc n }
; from = λ { zero → inj₁ tt ; (suc n) → inj₂ n }
; iso₁ = λ { (inj₁ _) → refl ; (inj₂ n) → refl }
; iso₂ = λ { zero → refl ; (suc n) → refl } }
private
inℕ : F (λ _ → ℕ) tt → ℕ
inℕ (zero , u) = 0
inℕ (suc zero , u) = suc (u tt)
inℕ (suc (suc ()) , u)
ℕ-struct-iso : ℕ ≅ W ℕ-c tt
ℕ-struct-iso = iso f g α β
where
f : ℕ → W ℕ-c tt
f 0 = sup (zero) (λ ())
f (suc n) = sup (suc zero) (λ _ → f n)
g : W ℕ-c tt → ℕ
g = fold ℕ-c (λ i → inℕ) tt
α : (n : ℕ) → g (f n) ≡ n
α zero = refl
α (suc n) = ap suc (α n)
β : (n : W ℕ-c tt) → f (g n) ≡ n
β (sup zero u) = ap (sup zero) (funext λ ())
β (sup (suc zero) u) = ap (sup (suc zero)) (funext (λ x → β (u tt)))
β (sup (suc (suc ())) u)
private
F-struct-iso : ∀ {i}(X : ⊤ → Set i) → F X tt ≅ (⊤ ⊎ X tt)
F-struct-iso X = begin
( Σ (A tt) λ a → B a → X tt )
≅⟨ sym≅ (⊎-Σ-iso (λ a → B a → X tt)) ⟩
( (⊥ → X tt) ⊎ (⊤ → X tt) )
≅⟨ ⊎-ap-iso (contr-⊤-iso ⊥-initial) Π-left-unit ⟩
( ⊤ ⊎ X tt )
∎
where open ≅-Reasoning
ℕ-initial : ∀ {i} (X : ℕ → Set i)
→ (x₀ : X 0)(f : ∀ n → X n → X (suc n))
→ contr ( Σ ((n : ℕ) → X n) λ x
→ (x₀ ≡ x 0)
× (∀ n → f n (x n) ≡ x (suc n)) )
ℕ-initial X x₀ f = iso-level ℕ-alg-iso (W-section-contr ℕ-c 𝓧)
where
ψ : ∀ x → ((b : B (proj₁ x)) → X (proj₂ x b)) → X (inℕ x)
ψ (zero , u) v = x₀
ψ (suc zero , u) v = f (u tt) (v tt)
ψ (suc (suc ()) , u) v
P : ∀ i (n : W ℕ-c i) → Set _
P i n = X (invert ℕ-struct-iso n)
θ : ∀ i x → ((b : B (proj₁ x)) → P tt (proj₂ x b)) → P i (inW ℕ-c i x)
θ i (a , u) v = ψ (a , invert ℕ-struct-iso ∘' u) v
𝓧 : AlgFib ℕ-c _
𝓧 = P , θ
ℕ-alg-iso : AlgSection ℕ-c 𝓧 ≅
( Σ ((n : ℕ) → X n) λ x
→ (x₀ ≡ x 0)
× (∀ n → f n (x n) ≡ x (suc n)) )
ℕ-alg-iso = begin
AlgSection ℕ-c 𝓧
≅⟨ ( Σ-ap-iso Π-left-unit λ g → iso≡ Π-left-unit) ⟩
( Σ ((w : W ℕ-c tt) → P tt w) λ g
→ ( _≡_ {A = (x : F (W ℕ-c) tt) → P tt (inW ℕ-c tt x)}
(λ x → θ tt x (λ b → g (proj₂ x b)))
(λ x → g (inW ℕ-c tt x)) ) )
≅⟨ sym≅ ( Σ-ap-iso (Π-ap-iso ℕ-struct-iso λ _ → refl≅) λ g
→ iso≡ (Π-ap-iso (sym≅ (F-ap-iso (λ i → sym≅ ℕ-struct-iso) tt)) λ x
→ refl≅ ) ) ⟩
( Σ ((n : ℕ) → X n) λ g
→ ( _≡_ {A = (x : F (λ _ → ℕ) tt) → X (inℕ x)}
(λ x → ψ x (λ b → g (proj₂ x b)))
(λ x → g (inℕ x)) ) )
≅⟨ ( Σ-ap-iso refl≅ λ g
→ iso≡ (Π-ap-iso (F-struct-iso (λ _ → ℕ)) λ _ → refl≅) ) ⟩
( let φ = invert (F-struct-iso (λ _ → ℕ))
in Σ ((n : ℕ) → X n) λ g
→ ( _≡_ {A = (x : ⊤ ⊎ ℕ) → X (inℕ (φ x))}
(λ x → ψ (φ x) (λ b → g (proj₂ (φ x) b)))
(λ x → g (inℕ (φ x))) ) )
≅⟨ ( Σ-ap-iso refl≅ λ x → iso≡ ⊎-universal ) ⟩
( Σ ((n : ℕ) → X n) λ x
→ ( _≡_ {A = (⊤ → X 0) × ((n : ℕ) → X (suc n))}
((λ _ → x₀) , (λ n → f n (x n)))
((λ _ → x 0) , (λ n → x (suc n))) ) )
≅⟨ ( Σ-ap-iso refl≅ λ x → sym≅ ×-split-iso ) ⟩
( Σ ((n : ℕ) → X n) λ x
→ (_≡_ {A = ⊤ → X 0} (λ _ → x₀) (λ _ → x 0))
× (_≡_ {A = (n : ℕ) → X (suc n)} (λ n → f n (x n)) (λ n → x (suc n))) )
≅⟨ ( Σ-ap-iso refl≅ λ x → ×-ap-iso (iso≡ Π-left-unit) (sym≅ strong-funext-iso) ) ⟩
( Σ ((n : ℕ) → X n) λ x
→ (x₀ ≡ x 0)
× (∀ n → f n (x n) ≡ x (suc n)) )
∎
where
open ≅-Reasoning
ℕ-initial-simple : ∀ {i} {X : Set i} (x₀ : X)
→ contr ( Σ (ℕ → X) λ x
→ (x₀ ≡ x 0)
× (∀ n → x n ≡ x (suc n)) )
ℕ-initial-simple {X = X} x₀
= ((λ _ → x₀) , refl , λ _ → refl)
, (λ u → contr⇒prop (ℕ-initial (λ _ → X) x₀ (λ _ x → x)) _ u)
ℕ-elim-shift : ∀ {i}{X : ℕ → Set i}
→ ((n : ℕ) → X n)
≅ ( (X 0) × ((n : ℕ) → X (suc n)) )
ℕ-elim-shift {i}{X} = begin
((n : ℕ) → X n)
≅⟨ (Π-ap-iso (sym≅ ℕ-algebra-iso) λ _ → refl≅) ⟩
((n : ⊤ ⊎ ℕ) → X (apply ℕ-algebra-iso n))
≅⟨ ⊎-universal ⟩
((⊤ → X 0) × ((n : ℕ) → X (suc n)))
≅⟨ ×-ap-iso Π-left-unit refl≅ ⟩
(X 0 × ((n : ℕ) → X (suc n)))
∎
where
open ≅-Reasoning
|
{
"alphanum_fraction": 0.4024186822,
"avg_line_length": 31.3464052288,
"ext": "agda",
"hexsha": "6a134aae6a46537190d8a070dade0821782dfe04",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2019-02-26T06:17:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-04-11T17:19:12.000Z",
"max_forks_repo_head_hexsha": "beebe176981953ab48f37de5eb74557cfc5402f4",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "HoTT/M-types",
"max_forks_repo_path": "sets/nat/struct.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "beebe176981953ab48f37de5eb74557cfc5402f4",
"max_issues_repo_issues_event_max_datetime": "2015-02-11T15:20:34.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-02-11T11:14:59.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "HoTT/M-types",
"max_issues_repo_path": "sets/nat/struct.agda",
"max_line_length": 88,
"max_stars_count": 27,
"max_stars_repo_head_hexsha": "beebe176981953ab48f37de5eb74557cfc5402f4",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "HoTT/M-types",
"max_stars_repo_path": "sets/nat/struct.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-09T07:26:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-04-14T15:47:03.000Z",
"num_tokens": 2225,
"size": 4796
}
|
module Category.Functor.Lawful where
open import Agda.Primitive using (lsuc; _⊔_)
open import Category.Functor
open import Category.Applicative
open import Function using (id; _∘_)
open import Relation.Binary.PropositionalEquality using (_≡_; module ≡-Reasoning; sym; cong)
record LawfulFunctorImp {l₁ l₂} {F : Set l₁ → Set l₂} (FFunc : RawFunctor F) : Set (lsuc l₁ ⊔ l₂) where
open RawFunctor FFunc
field
<$>-identity : ∀ {a} {x : F a} → (id <$> x) ≡ x
<$>-compose : ∀ {a b c} {f : a → b} {g : b → c} {x : F a} → ((g ∘ f) <$> x) ≡ (g <$> (f <$> x))
module LawfulFunctor {l₁ l₂} {F : Set l₁ → Set l₂} {FFunc : RawFunctor F} (FLawful : LawfulFunctorImp FFunc) where
open RawFunctor FFunc public
open LawfulFunctorImp FLawful public
record LawfulApplicativeImp {l} {F : Set l → Set l} (FAppl : RawApplicative F) : Set (lsuc l) where
open RawApplicative FAppl
field
⊛-identity : ∀ {A} {u : F A} → (pure id ⊛ u) ≡ u
⊛-homomorphism : ∀ {A B} {u : A → B } {v : A} → (pure u ⊛ pure v) ≡ pure (u v)
⊛-interchange : ∀ {A B} {u : F (A → B)} {v : A} → (u ⊛ pure v) ≡ (pure (λ uᵢ → uᵢ v) ⊛ u)
⊛-composition : ∀ {A B C} {u : F (B → C)} {v : F (A → B)} {w : F A} → (pure (λ f g a → f (g a)) ⊛ u ⊛ v ⊛ w) ≡ (u ⊛ (v ⊛ w))
open ≡-Reasoning
private
composelemma : ∀ {a b c} {f : a → b} {g : b → c} {x : F a} → ((g ∘ f) <$> x) ≡ (g <$> (f <$> x))
composelemma {_} {_} {_} {f} {g} {x} =
pure (λ x₁ → g (f x₁)) ⊛ x ≡⟨ cong (_⊛ x) (sym ⊛-homomorphism) ⟩
pure (λ f x → g (f x)) ⊛ pure f ⊛ x ≡⟨ cong ((_⊛ x) ∘ (_⊛ pure f)) (sym ⊛-homomorphism) ⟩
pure (λ g f x → g (f x)) ⊛ pure g ⊛ pure f ⊛ x ≡⟨ ⊛-composition ⟩
pure g ⊛ (pure f ⊛ x) ∎
isLawfulFunctor : LawfulFunctorImp rawFunctor
isLawfulFunctor = record
{ <$>-identity = ⊛-identity
; <$>-compose = composelemma
}
module LawfulApplicative {l} {F : Set l → Set l} (FAppl : RawApplicative F) (FLawful : LawfulApplicativeImp FAppl) where
open RawApplicative FAppl public
open LawfulApplicativeImp FLawful public
open LawfulFunctorImp isLawfulFunctor public
|
{
"alphanum_fraction": 0.5574526996,
"avg_line_length": 50.3953488372,
"ext": "agda",
"hexsha": "5b34c43eb121d8a498fce1fa6c42f314042e2b4e",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "308afeeaa905870dbf1a995fa82e8825dfaf2d74",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "crisoagf/agda-optics",
"max_forks_repo_path": "src/Category/Functor/Lawful.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "308afeeaa905870dbf1a995fa82e8825dfaf2d74",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "crisoagf/agda-optics",
"max_issues_repo_path": "src/Category/Functor/Lawful.agda",
"max_line_length": 129,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "308afeeaa905870dbf1a995fa82e8825dfaf2d74",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "crisoagf/agda-optics",
"max_stars_repo_path": "src/Category/Functor/Lawful.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 877,
"size": 2167
}
|
module Common.Equality where
open import Common.Level
infix 4 _≡_
data _≡_ {a} {A : Set a} (x : A) : A → Set a where
refl : x ≡ x
{-# BUILTIN EQUALITY _≡_ #-}
{-# BUILTIN REFL refl #-}
subst : ∀ {a p}{A : Set a}(P : A → Set p){x y : A} → x ≡ y → P x → P y
subst P refl t = t
|
{
"alphanum_fraction": 0.541958042,
"avg_line_length": 20.4285714286,
"ext": "agda",
"hexsha": "b9a84df0fda80d5570299dade21768b9458e5fa2",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/agda-kanso",
"max_forks_repo_path": "test/Common/Equality.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/agda-kanso",
"max_issues_repo_path": "test/Common/Equality.agda",
"max_line_length": 70,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/agda-kanso",
"max_stars_repo_path": "test/Common/Equality.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 114,
"size": 286
}
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Unary relations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Relation.Unary where
open import Data.Empty
open import Data.Unit.Base using (⊤)
open import Data.Product
open import Data.Sum using (_⊎_; [_,_])
open import Function
open import Level
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality.Core using (_≡_)
------------------------------------------------------------------------
-- Unary relations
Pred : ∀ {a} → Set a → (ℓ : Level) → Set (a ⊔ suc ℓ)
Pred A ℓ = A → Set ℓ
------------------------------------------------------------------------
-- Unary relations can be seen as sets
-- i.e. they can be seen as subsets of the universe of discourse.
module _ {a} {A : Set a} where
----------------------------------------------------------------------
-- Special sets
-- The empty set
∅ : Pred A zero
∅ = λ _ → ⊥
-- The singleton set
｛_｝ : A → Pred A a
｛ x ｝ = x ≡_
-- The universe
U : Pred A zero
U = λ _ → ⊤
----------------------------------------------------------------------
-- Membership
infix 4 _∈_ _∉_
_∈_ : ∀ {ℓ} → A → Pred A ℓ → Set _
x ∈ P = P x
_∉_ : ∀ {ℓ} → A → Pred A ℓ → Set _
x ∉ P = ¬ x ∈ P
----------------------------------------------------------------------
-- Subsets
infix 4 _⊆_ _⊇_ _⊈_ _⊉_ _⊂_ _⊃_ _⊄_ _⊅_
_⊆_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊆ Q = ∀ {x} → x ∈ P → x ∈ Q
_⊇_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊇ Q = Q ⊆ P
_⊈_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊈ Q = ¬ (P ⊆ Q)
_⊉_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊉ Q = ¬ (P ⊇ Q)
_⊂_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊂ Q = P ⊆ Q × Q ⊈ P
_⊃_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊃ Q = Q ⊂ P
_⊄_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊄ Q = ¬ (P ⊂ Q)
_⊅_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊅ Q = ¬ (P ⊃ Q)
-- Dashed variants of _⊆_ for when 'x' can't be inferred from 'x ∈ P'.
infix 4 _⊆′_ _⊇′_ _⊈′_ _⊉′_ _⊂′_ _⊃′_ _⊄′_ _⊅′_
_⊆′_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊆′ Q = ∀ x → x ∈ P → x ∈ Q
_⊇′_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
Q ⊇′ P = P ⊆′ Q
_⊈′_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊈′ Q = ¬ (P ⊆′ Q)
_⊉′_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊉′ Q = ¬ (P ⊇′ Q)
_⊂′_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊂′ Q = P ⊆′ Q × Q ⊈′ P
_⊃′_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊃′ Q = Q ⊂′ P
_⊄′_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊄′ Q = ¬ (P ⊂′ Q)
_⊅′_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ⊅′ Q = ¬ (P ⊃′ Q)
----------------------------------------------------------------------
-- Properties of sets
-- Emptiness
Empty : ∀ {ℓ} → Pred A ℓ → Set _
Empty P = ∀ x → x ∉ P
-- Satisfiable
Satisfiable : ∀ {ℓ} → Pred A ℓ → Set _
Satisfiable P = ∃ λ x → x ∈ P
-- Universality
infix 10 Universal IUniversal
Universal : ∀ {ℓ} → Pred A ℓ → Set _
Universal P = ∀ x → x ∈ P
IUniversal : ∀ {ℓ} → Pred A ℓ → Set _
IUniversal P = ∀ {x} → x ∈ P
syntax Universal P = Π[ P ]
syntax IUniversal P = ∀[ P ]
-- Decidability
Decidable : ∀ {ℓ} → Pred A ℓ → Set _
Decidable P = ∀ x → Dec (P x)
-- Irrelevance
Irrelevant : ∀ {ℓ} → Pred A ℓ → Set _
Irrelevant P = ∀ {x} (a : P x) (b : P x) → a ≡ b
----------------------------------------------------------------------
-- Operations on sets
-- Set complement.
∁ : ∀ {ℓ} → Pred A ℓ → Pred A ℓ
∁ P = λ x → x ∉ P
-- Positive version of non-disjointness, dual to inclusion.
infix 4 _≬_
_≬_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Set _
P ≬ Q = ∃ λ x → x ∈ P × x ∈ Q
-- Set union.
infixr 6 _∪_
_∪_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Pred A _
P ∪ Q = λ x → x ∈ P ⊎ x ∈ Q
-- Set intersection.
infixr 7 _∩_
_∩_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Pred A _
P ∩ Q = λ x → x ∈ P × x ∈ Q
-- Implication.
infixr 8 _⇒_
_⇒_ : ∀ {ℓ₁ ℓ₂} → Pred A ℓ₁ → Pred A ℓ₂ → Pred A _
P ⇒ Q = λ x → x ∈ P → x ∈ Q
-- Infinitary union and intersection.
infix 10 ⋃ ⋂
⋃ : ∀ {ℓ i} (I : Set i) → (I → Pred A ℓ) → Pred A _
⋃ I P = λ x → Σ[ i ∈ I ] P i x
syntax ⋃ I (λ i → P) = ⋃[ i ∶ I ] P
⋂ : ∀ {ℓ i} (I : Set i) → (I → Pred A ℓ) → Pred A _
⋂ I P = λ x → (i : I) → P i x
syntax ⋂ I (λ i → P) = ⋂[ i ∶ I ] P
-- Update.
infixr 9 _⊢_
_⊢_ : ∀ {a b} {A : Set a} {B : Set b} {ℓ} → (A → B) → Pred B ℓ → Pred A ℓ
f ⊢ P = λ x → P (f x)
------------------------------------------------------------------------
-- Unary relation combinators
infixr 2 _⟨×⟩_
infixr 2 _⟨⊙⟩_
infixr 1 _⟨⊎⟩_
infixr 0 _⟨→⟩_
infixl 9 _⟨·⟩_
infix 10 _~
infixr 9 _⟨∘⟩_
infixr 2 _//_ _\\_
_⟨×⟩_ : ∀ {a b ℓ₁ ℓ₂} {A : Set a} {B : Set b} →
Pred A ℓ₁ → Pred B ℓ₂ → Pred (A × B) _
(P ⟨×⟩ Q) (x , y) = x ∈ P × y ∈ Q
_⟨⊙⟩_ : ∀ {a b ℓ₁ ℓ₂} {A : Set a} {B : Set b} →
Pred A ℓ₁ → Pred B ℓ₂ → Pred (A × B) _
(P ⟨⊙⟩ Q) (x , y) = x ∈ P ⊎ y ∈ Q
_⟨⊎⟩_ : ∀ {a b ℓ} {A : Set a} {B : Set b} →
Pred A ℓ → Pred B ℓ → Pred (A ⊎ B) _
P ⟨⊎⟩ Q = [ P , Q ]
_⟨→⟩_ : ∀ {a b ℓ₁ ℓ₂} {A : Set a} {B : Set b} →
Pred A ℓ₁ → Pred B ℓ₂ → Pred (A → B) _
(P ⟨→⟩ Q) f = P ⊆ Q ∘ f
_⟨·⟩_ : ∀ {a b ℓ₁ ℓ₂} {A : Set a} {B : Set b}
(P : Pred A ℓ₁) (Q : Pred B ℓ₂) →
(P ⟨×⟩ (P ⟨→⟩ Q)) ⊆ Q ∘ uncurry (flip _$_)
(P ⟨·⟩ Q) (p , f) = f p
-- Converse.
_~ : ∀ {a b ℓ} {A : Set a} {B : Set b} →
Pred (A × B) ℓ → Pred (B × A) ℓ
P ~ = P ∘ swap
-- Composition.
_⟨∘⟩_ : ∀ {a b c ℓ₁ ℓ₂} {A : Set a} {B : Set b} {C : Set c} →
Pred (A × B) ℓ₁ → Pred (B × C) ℓ₂ → Pred (A × C) _
(P ⟨∘⟩ Q) (x , z) = ∃ λ y → (x , y) ∈ P × (y , z) ∈ Q
-- Post and pre-division.
_//_ : ∀ {a b c ℓ₁ ℓ₂} {A : Set a} {B : Set b} {C : Set c} →
Pred (A × C) ℓ₁ → Pred (B × C) ℓ₂ → Pred (A × B) _
(P // Q) (x , y) = Q ∘ _,_ y ⊆ P ∘ _,_ x
_\\_ : ∀ {a b c ℓ₁ ℓ₂} {A : Set a} {B : Set b} {C : Set c} →
Pred (A × C) ℓ₁ → Pred (A × B) ℓ₂ → Pred (B × C) _
P \\ Q = (P ~ // Q ~) ~
|
{
"alphanum_fraction": 0.4055366683,
"avg_line_length": 23.3977272727,
"ext": "agda",
"hexsha": "5c72d2245eccbf866f8184dff95997ba09a1e620",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "omega12345/agda-mode",
"max_forks_repo_path": "test/asset/agda-stdlib-1.0/Relation/Unary.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "omega12345/agda-mode",
"max_issues_repo_path": "test/asset/agda-stdlib-1.0/Relation/Unary.agda",
"max_line_length": 73,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "omega12345/agda-mode",
"max_stars_repo_path": "test/asset/agda-stdlib-1.0/Relation/Unary.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2817,
"size": 6177
}
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Sn.Base where
open import Cubical.HITs.Susp
open import Cubical.Foundations.Pointed
open import Cubical.Data.Nat
open import Cubical.Data.NatMinusOne
open import Cubical.Data.Empty
open import Cubical.Foundations.Prelude
open import Cubical.Data.Bool
open import Cubical.HITs.S1
S : ℕ₋₁ → Type₀
S neg1 = ⊥
S (ℕ→ℕ₋₁ n) = Susp (S (-1+ n))
S₊ : ℕ → Type₀
S₊ 0 = Bool
S₊ 1 = S¹
S₊ (suc (suc n)) = Susp (S₊ (suc n))
ptSn : (n : ℕ) → S₊ n
ptSn zero = true
ptSn (suc zero) = base
ptSn (suc (suc n)) = north
-- Pointed version
S₊∙ : (n : ℕ) → Pointed₀
S₊∙ n = (S₊ n) , ptSn n
|
{
"alphanum_fraction": 0.6645962733,
"avg_line_length": 21.4666666667,
"ext": "agda",
"hexsha": "a8c656e722f9edfb8578f88ccfbe4f0790463b66",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "dan-iel-lee/cubical",
"max_forks_repo_path": "Cubical/HITs/Sn/Base.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_issues_repo_issues_event_max_datetime": "2022-01-27T02:07:48.000Z",
"max_issues_repo_issues_event_min_datetime": "2022-01-27T02:07:48.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "dan-iel-lee/cubical",
"max_issues_repo_path": "Cubical/HITs/Sn/Base.agda",
"max_line_length": 50,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "dan-iel-lee/cubical",
"max_stars_repo_path": "Cubical/HITs/Sn/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 264,
"size": 644
}
|
{-# OPTIONS --cubical --safe #-}
module Data.List.Syntax where
open import Data.List
open import Prelude
open import Data.Vec.Sigma using () renaming (toList to [_]) public
open import Data.Vec.Sigma
[_][_] : ∀ n → Vec A n → List A
[ n ][ xs ] = toList {n = n} xs
-- record ListSyntax {a b} (A : Type a) (B : Type b) : Type (a ℓ⊔ b) where
-- field [_] : B → List A
-- open ListSyntax ⦃ ... ⦄ public
-- instance
-- cons : ⦃ _ : ListSyntax A B ⦄ → ListSyntax A (A × B)
-- [_] ⦃ cons ⦄ (x , xs) = x ∷ [ xs ]
-- instance
-- sing : ListSyntax A A
-- [_] ⦃ sing ⦄ = _∷ []
|
{
"alphanum_fraction": 0.5614334471,
"avg_line_length": 21.7037037037,
"ext": "agda",
"hexsha": "e07dc5e0a096f38e209f7c9f0ff1ad7dac3fc352",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "oisdk/agda-playground",
"max_forks_repo_path": "Data/List/Syntax.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "oisdk/agda-playground",
"max_issues_repo_path": "Data/List/Syntax.agda",
"max_line_length": 74,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "oisdk/agda-playground",
"max_stars_repo_path": "Data/List/Syntax.agda",
"max_stars_repo_stars_event_max_datetime": "2021-11-16T08:11:34.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-09-11T17:45:41.000Z",
"num_tokens": 215,
"size": 586
}
|
module Data.Nat.DivMod.Properties where
open import Data.Nat
open ≤-Reasoning
open import Data.Nat.DivMod
open import Data.Nat.Etc
open import Data.Nat.Properties using (≰⇒>; m≤m+n)
open import Data.Nat.Properties.Simple using (+-right-identity; +-suc; +-assoc; +-comm; distribʳ-*-+)
open import Data.Fin using (Fin; toℕ; fromℕ; fromℕ≤; inject≤; inject₁)
renaming (_+_ to _F+_; zero to Fzero; suc to Fsuc)
open import Data.Fin.Properties using (bounded)
open import Function
-- import Level
open import Relation.Nullary.Negation using (contradiction; contraposition)
open import Relation.Nullary.Decidable using (True; False; toWitness)
open import Relation.Binary
open import Relation.Binary.PropositionalEquality as PropEq
using (_≡_; _≢_; refl; cong; cong₂; sym; trans; inspect)
open PropEq.≡-Reasoning
renaming (begin_ to beginEq_; _≡⟨_⟩_ to _≡Eq⟨_⟩_; _∎ to _∎Eq)
ℕ-isDecTotalOrder = DecTotalOrder.isDecTotalOrder decTotalOrder
ℕ-isTotalOrder = IsDecTotalOrder.isTotalOrder ℕ-isDecTotalOrder
ℕ-isPartialOrder = IsTotalOrder.isPartialOrder ℕ-isTotalOrder
ℕ-isPreorder = IsPartialOrder.isPreorder ℕ-isPartialOrder
≤-refl = IsPreorder.reflexive ℕ-isPreorder
≤-antisym = IsPartialOrder.antisym ℕ-isPartialOrder
≤-total = IsTotalOrder.total ℕ-isTotalOrder
lem-+-exchange : ∀ a b c d → (a + b) + (c + d) ≡ (a + c) + (b + d)
lem-+-exchange a b c d = beginEq
(a + b) + (c + d)
≡Eq⟨ sym (+-assoc (a + b) c d) ⟩
a + b + c + d
≡Eq⟨ cong (λ x → x + d) (+-assoc a b c) ⟩
a + (b + c) + d
≡Eq⟨ cong (λ x → a + x + d) (+-comm b c) ⟩
a + (c + b) + d
≡Eq⟨ cong (λ x → x + d) (sym (+-assoc a c b)) ⟩
a + c + b + d
≡Eq⟨ +-assoc (a + c) b d ⟩
(a + c) + (b + d)
∎Eq
{-
beginEq
{! !}
≡Eq⟨ {! !} ⟩
{! !}
≡Eq⟨ {! !} ⟩
{! !}
≡Eq⟨ {! !} ⟩
{! !}
≡Eq⟨ {! !} ⟩
{! !}
∎Eq
-}
record DM (dividend divisor : ℕ) : Set where
constructor dm
field
q : ℕ
r : Fin divisor
{-
_DM+_ : ∀ {b m n} → DM m b → DM n b → DM (m + n) b
_DM+_ {zero} (dm q₀ ()) (dm q₁ ())
_DM+_ {suc b} (dm zero Fzero) (dm q₁ r₁) = dm q₁ Fzero
_DM+_ {suc n₁} (dm zero (Fsuc r₀)) (dm q₁ r₁) = {! !}
_DM+_ {suc b} (dm (suc q₀) Fzero) (dm q₁ r₁) = {! !}
_DM+_ {suc b} (dm (suc q₀) (Fsuc r₀)) (dm q₁ r₁) = {! !}
-}
{-
_DivMod+_ : ∀ {b m n} → DivMod m b → DivMod n b → DivMod (m + n) b
_DivMod+_ {zero} (result q₀ () prop₀) (result q₁ () prop₁)
_DivMod+_ {suc b} {m} {n} (result zero Fzero prop₀) (result q₁ r₁ prop₁) = result q₁ r₁ {! prop₁ !} -- (cong₂ _+_ prop₀ prop₁)
_DivMod+_ {suc b} {m} {n} (result zero (Fsuc r₀) prop₀) (result q₁ r₁ prop₁) with ((toℕ (Fsuc r₀) + toℕ r₁) divMod (suc b))
_DivMod+_ {suc b} {m} {n} (result zero (Fsuc r₀) prop₀) (result q₁ r₁ prop₁) | result zero rᵣ propᵣ =
let q = q₁
r = rᵣ
in result q r $
beginEq
m + n
≡Eq⟨ cong₂ _+_ prop₀ prop₁ ⟩
suc (toℕ r₀ + zero + (toℕ r₁ + q₁ * suc b))
≡Eq⟨ lem-+-exchange (suc (toℕ r₀)) zero (toℕ r₁) (q₁ * suc b) ⟩
suc (toℕ r₀ + toℕ r₁) + (q₁ * suc b)
≡Eq⟨ cong (λ x → x + q₁ * suc b) propᵣ ⟩
toℕ rᵣ + zero + q₁ * suc b
≡Eq⟨ cong (λ x → x + q₁ * suc b) (+-right-identity (toℕ rᵣ)) ⟩
toℕ rᵣ + q₁ * suc b
∎Eq
_DivMod+_ {suc b} {m} {n} (result zero (Fsuc r₀) prop₀) (result q₁ r₁ prop₁) | result (suc qᵣ) rᵣ propᵣ =
let q = suc qᵣ + q₁
r = rᵣ
in result q r $
beginEq
m + n
≡Eq⟨ cong₂ _+_ prop₀ prop₁ ⟩
suc (toℕ r₀) + zero + (toℕ r₁ + q₁ * suc b)
≡Eq⟨ lem-+-exchange (suc (toℕ r₀)) zero (toℕ r₁) (q₁ * suc b) ⟩
suc (toℕ r₀) + toℕ r₁ + q₁ * suc b
≡Eq⟨ cong (λ x → x + q₁ * suc b) propᵣ ⟩
toℕ rᵣ + suc qᵣ * suc b + q₁ * suc b
≡Eq⟨ +-assoc (toℕ rᵣ) (suc qᵣ * suc b) (q₁ * suc b) ⟩
toℕ rᵣ + (suc qᵣ * suc b + q₁ * suc b)
≡Eq⟨ cong (λ x → toℕ rᵣ + x) (sym (distribʳ-*-+ (suc b) (suc qᵣ) q₁)) ⟩
toℕ rᵣ + (suc qᵣ + q₁) * suc b
∎Eq
_DivMod+_ {suc b} {m} {n} (result (suc q₀) Fzero prop₀) (result q₁ r₁ prop₁) = result (suc q₀ + q₁) r₁ $
beginEq
m + n
≡Eq⟨ cong₂ _+_ prop₀ prop₁ ⟩
suc q₀ * suc b + (toℕ r₁ + q₁ * suc b)
≡Eq⟨ sym (+-assoc (suc (b + q₀ * suc b)) (toℕ r₁) (q₁ * suc b)) ⟩
suc q₀ * suc b + toℕ r₁ + q₁ * suc b
≡Eq⟨ cong (λ x → x + q₁ * suc b) (+-comm (suc q₀ * suc b) (toℕ r₁)) ⟩
toℕ r₁ + suc q₀ * suc b + q₁ * suc b
≡Eq⟨ +-assoc (toℕ r₁) (suc q₀ * suc b) (q₁ * suc b) ⟩
toℕ r₁ + (suc q₀ * suc b + q₁ * suc b)
≡Eq⟨ cong (λ x → toℕ r₁ + x) (sym (distribʳ-*-+ (suc b) (suc q₀) q₁)) ⟩
toℕ r₁ + (suc q₀ + q₁) * suc b
∎Eq
_DivMod+_ {suc b} {m} {n} (result (suc q₀) (Fsuc r₀) prop₀) (result q₁ r₁ prop₁) with ((toℕ (Fsuc r₀) + toℕ r₁) divMod (suc b))
_DivMod+_ {suc b} {m} {n} (result (suc q₀) (Fsuc r₀) prop₀) (result q₁ r₁ prop₁) | result zero rᵣ propᵣ =
let q = suc q₀ + q₁
r = rᵣ
in result q r $
beginEq
m + n
≡Eq⟨ cong₂ _+_ prop₀ prop₁ ⟩
(suc (toℕ r₀) + suc q₀ * suc b) + (toℕ r₁ + q₁ * suc b)
≡Eq⟨ lem-+-exchange (suc (toℕ r₀)) (suc (b + q₀ * suc b)) (toℕ r₁) (q₁ * suc b) ⟩
(suc (toℕ r₀) + toℕ r₁) + (suc q₀ * suc b + q₁ * suc b)
≡Eq⟨ cong (λ x → (suc (toℕ r₀) + toℕ r₁) + x) (sym (distribʳ-*-+ (suc b) (suc q₀) q₁)) ⟩
(suc (toℕ r₀) + toℕ r₁) + (suc q₀ + q₁) * suc b
≡Eq⟨ cong (λ x → x + suc (q₀ + q₁) * suc b) propᵣ ⟩
toℕ rᵣ + zero + suc (b + (q₀ + q₁) * suc b)
≡Eq⟨ cong (λ x → x + suc (q₀ + q₁) * suc b) (+-right-identity (toℕ rᵣ)) ⟩
toℕ rᵣ + suc (q₀ + q₁) * suc b
∎Eq
_DivMod+_ {suc b} {m} {n} (result (suc q₀) (Fsuc r₀) prop₀) (result q₁ r₁ prop₁) | result (suc qᵣ) rᵣ propᵣ =
let q = suc qᵣ + (suc q₀ + q₁)
r = rᵣ
in result q r $
beginEq
m + n
≡Eq⟨ cong₂ _+_ prop₀ prop₁ ⟩
suc (toℕ r₀ + suc q₀ * suc b) + (toℕ r₁ + q₁ * suc b)
≡Eq⟨ lem-+-exchange (suc (toℕ r₀)) (suc (b + q₀ * suc b)) (toℕ r₁) (q₁ * suc b) ⟩
suc (toℕ r₀) + toℕ r₁ + ((suc q₀) * suc b + q₁ * suc b)
≡Eq⟨ cong (λ x → suc (toℕ r₀) + toℕ r₁ + x) (sym (distribʳ-*-+ (suc b) (suc q₀) q₁)) ⟩
suc (toℕ r₀) + toℕ r₁ + (suc q₀ + q₁) * suc b
≡Eq⟨ cong (λ x → x + (suc q₀ + q₁) * suc b) propᵣ ⟩
toℕ rᵣ + suc qᵣ * suc b + (suc q₀ + q₁) * suc b
≡Eq⟨ +-assoc (toℕ rᵣ) (suc qᵣ * suc b) ((suc q₀ + q₁) * suc b) ⟩
toℕ rᵣ + (suc qᵣ * suc b + (suc q₀ + q₁) * suc b)
≡Eq⟨ cong (λ x → toℕ rᵣ + x) (sym (distribʳ-*-+ (suc b) (suc qᵣ) (suc (q₀ + q₁)))) ⟩
toℕ rᵣ + (suc qᵣ + (suc q₀ + q₁)) * suc b
∎Eq
-}
-- DivMod+-left-identity : ∀ {b n} → (x : DivMod n (suc b)) → _DivMod+_ {suc b} {0} {n} (result 0 Fzero refl) x ≡ x
-- DivMod+-left-identity {b} {n} (result q r prop) = {! !}
{-
beginEq
_DivMod+_ {suc b} {m} {n} (result 0 Fzero p) (result q r prop)
≡Eq⟨ refl ⟩
{! !}
≡Eq⟨ {! !} ⟩
{! !}
≡Eq⟨ {! !} ⟩
{! !}
≡Eq⟨ {! !} ⟩
result q r prop
∎Eq -- cong (result q r) {! !} -- cong (result q r) refl
-}
{-
DivMod+-left-identity : ∀ {b m} → (x : DivMod m (suc b)) → (result 0 Fzero refl) DivMod+ x ≡ x
DivMod+-left-identity {b} {m} (result q r prop) with (toℕ Fzero + toℕ r) divMod (suc b)
DivMod+-left-identity {b} {m} (result q r prop) | result zero rᵣ propᵣ =
-- propᵣ : toℕ r ≡ toℕ rᵣ + 0
-- prop : m ≡ toℕ r + q * suc b
-- prop : m ≡ toℕ rᵣ + q * suc b
-- trans (cong₂ _+_ refl prop) (trans (trans (cong (λ z → z + q * suc b) (sym (+-right-identity (toℕ r)))) (trans (+-assoc (toℕ r) zero (q * suc b)) refl)) (trans (cong₂ _+_ propᵣ refl) (trans (cong (λ z → z + q * suc b) (+-right-identity (toℕ rᵣ))) refl))))
let prop' = beginEq
m
≡Eq⟨ cong₂ _+_ refl prop ⟩
toℕ r + q * suc b
≡Eq⟨ cong₂ _+_ propᵣ refl ⟩
toℕ rᵣ + 0 + q * suc b
≡Eq⟨ cong₂ _+_ (+-right-identity (toℕ rᵣ)) refl ⟩
toℕ rᵣ + q * suc b
∎Eq
in beginEq
result q rᵣ prop'
≡Eq⟨ cong (λ x → result q x {! prop' !}) (sym {! +-right-identity !}) ⟩
{! !}
≡Eq⟨ {! !} ⟩
{! !}
≡Eq⟨ {! !} ⟩
{! !}
≡Eq⟨ {! !} ⟩
result q r prop
∎Eq
DivMod+-left-identity (result q r prop) | result (suc qᵣ) rᵣ propᵣ = {! !}
-}
{-
DivMod+-left-identity : ∀ {b m} → (x : DivMod m (suc b)) → (result 0 Fzero refl) DivMod+ x ≡ x
DivMod+-left-identity {b} {m} (result q r prop) with (toℕ r) divMod (suc b)
DivMod+-left-identity {b} {m} (result q r prop) | result zero rᵣ propᵣ =
beginEq
result q rᵣ (beginEq
m
≡Eq⟨ cong (λ z → z) prop ⟩
toℕ r + q * suc b
≡Eq⟨ cong (λ z → z + q * suc b) (sym (+-right-identity (toℕ r))) ⟩
(toℕ r + zero) + q * suc b
≡Eq⟨ cong (λ z → z + zero + q * suc b) propᵣ ⟩
toℕ rᵣ + zero + zero + q * suc b
≡Eq⟨ cong (λ z → z + zero + q * suc b) (+-right-identity (toℕ rᵣ)) ⟩
(toℕ rᵣ + zero) + q * suc b
≡Eq⟨ +-assoc (toℕ rᵣ) zero (q * suc b) ⟩
toℕ rᵣ + q * suc b
∎Eq)
≡Eq⟨ {! !} ⟩
result q r prop
∎Eq
DivMod+-left-identity (result q r prop) | result (suc qᵣ) rᵣ propᵣ =
beginEq
(result 0 Fzero refl) DivMod+ {! !}
≡Eq⟨ {! !} ⟩
{! !}
≡Eq⟨ {! !} ⟩
{! !}
≡Eq⟨ {! !} ⟩
result q r prop
∎Eq
DivMod+-left-identity : (b n : ℕ) → (≢0 : False (b ≟ 0)) → ((0 divMod b) {≢0}) DivMod+ ((n divMod b) {≢0}) ≡ ((n divMod b) {≢0})
DivMod+-left-identity zero n ()
DivMod+-left-identity (suc b) zero ≢0 = refl
DivMod+-left-identity (suc b) (suc n) ≢0 = {! !}
divMod-hom : (b m n : ℕ) → (≢0 : False (b ≟ 0)) → ((m + n) divMod b) {≢0} ≡ ((m divMod b) {≢0}) DivMod+ ((n divMod b) {≢0})
divMod-hom zero m n ()
divMod-hom (suc b) zero n ≢0 = {! !}
divMod-hom (suc b) (suc m) n ≢0 = {! !}
div-suc-mono : (n base : ℕ) → (≢0 : False (base ≟ 0))
→ let _/base = λ x → (x div base) {≢0}
in suc n /base ≥ n /base
div-suc-mono n zero ()
div-suc-mono zero (suc b) ≢0 = z≤n
div-suc-mono (suc n) (suc b) ≢0 = {! !}
-}
-- TODO: proof div monotone
postulate
div-mono : (base : ℕ) → (≢0 : False (base ≟ 0))
→ let _/base = λ x → (x div base) {≢0}
in _/base Preserves _≤_ ⟶ _≤_
{-
n/n≡1 : ∀ n → (≢0 : False (n ≟ 0)) → (n div n) {≢0} ≡ 1
n/n≡1 zero ()
n/n≡1 (suc n) ≢0 with ((suc n) divMod (suc n)) {≢0} | inspect (λ w → ((suc n) divMod (suc n)) {w}) ≢0
n/n≡1 (suc n) ≢0 | result zero r prop | PropEq.[ eq ] =
let prop' : suc n ≡ toℕ r
prop' = trans prop (+-right-identity (toℕ r))
in contradiction (≤-refl prop') (>⇒≰ (bounded r))
n/n≡1 (suc n) ≢0 | result (suc zero) r prop | PropEq.[ eq ] = {! !}
n/n≡1 (suc n) ≢0 | result (suc (suc q)) r prop | PropEq.[ eq ] =
let prop' : suc n ≡ suc n + toℕ r + suc q * suc n
prop' = beginEq
suc n
≡Eq⟨ prop ⟩
toℕ r + (suc n + suc (n + q * suc n))
≡Eq⟨ sym (+-assoc (toℕ r) (suc n) (suc (n + q * suc n))) ⟩
toℕ r + suc n + suc (n + q * suc n)
≡Eq⟨ cong₂ _+_ (+-comm (toℕ r) (suc n)) refl ⟩
suc (n + toℕ r + suc (n + q * suc n))
∎Eq
in contradiction (≤-refl prop') (>⇒≰ {! !})
lem : ∀ m n → n ≤ m → (≢0 : False (n ≟ 0)) → (n div n) {≢0} ≤ (m div n) {≢0}
lem m zero n≤m ()
lem m (suc n) n≤m ≢0 = div-mono (suc n) {! !} n≤m
-}
{-
div-mono : (base : ℕ) → (≢0 : False (base ≟ 0))
→ let _/base = λ x → (x div base) {≢0}
in _/base Preserves _≤_ ⟶ _≤_
div-mono zero () rel
div-mono (suc b) ≢0 z≤n = z≤n
div-mono (suc b) ≢0 (s≤s {x} {y} rel) with compare x y
div-mono (suc b) ≢0 (s≤s rel) | less m k with ((suc m) divMod (suc b)) {≢0}
| inspect (λ w → ((suc m) divMod (suc b)) {w}) ≢0
| ((suc (suc m + k)) divMod (suc b)) {≢0}
| inspect (λ w → ((suc (suc m + k)) divMod (suc b)) {w}) ≢0
| ((suc k) divMod (suc b)) {≢0}
| inspect (λ w → ((suc k) divMod (suc b)) {w}) ≢0
div-mono (suc b) ≢0 (s≤s rel) | less m k | result q₀ r₀ prop₀ | PropEq.[ eq₀ ] | result q₁ r₁ prop₁ | PropEq.[ eq₁ ] | result q₂ r₂ prop₂ | PropEq.[ eq₂ ] =
-- prop₀: suc m ≡ toℕ r₀ + qₒ * suc b
-- prop₁: suc (suc m + k) ≡ toℕ r₁ + q₁ * suc b
-- prop₂: suc k ≡ toℕ r₂ + q₂ * suc b
begin
q₀
≤⟨ {! !} ⟩
{! !}
≤⟨ {! !} ⟩
{! !}
≤⟨ {! !} ⟩
{! !}
≤⟨ {! !} ⟩
{! !}
≤⟨ {! !} ⟩
{! !}
≤⟨ {! !} ⟩
q₁
∎
div-mono (suc b) ≢0 (s≤s rel) | equal m = ≤-refl refl
div-mono (suc b) ≢0 (s≤s rel) | greater m k = contradiction rel (>⇒≰ (s≤s (m≤m+n m k)))
div-mono (suc b) ≢0 (s≤s {x} {y} rel) with (x divMod (suc b)) {≢0}
| inspect (λ w → (x divMod (suc b)) {w}) ≢0
| (y divMod (suc b)) {≢0}
| inspect (λ w → (y divMod (suc b)) {w}) ≢0
div-mono (suc b) ≢0 (s≤s {x} {y} rel) | result qx rx propx | PropEq.[ eqx ] | result qy ry propy | PropEq.[ eqy ] with = {! !}
begin
{! !}
<⟨ {! !} ⟩
{! !}
<⟨ {! !} ⟩
{! !}
∎
begin
{! !}
≤⟨ {! !} ⟩
{! !}
≤⟨ {! !} ⟩
{! !}
≤⟨ {! !} ⟩
{! !}
≤⟨ {! !} ⟩
{! !}
∎
beginEq
{! !}
≡Eq⟨ {! !} ⟩
{! !}
≡Eq⟨ {! !} ⟩
{! !}
≡Eq⟨ {! !} ⟩
{! !}
≡Eq⟨ {! !} ⟩
{! !}
∎Eq
-}
|
{
"alphanum_fraction": 0.4437824732,
"avg_line_length": 39.6565934066,
"ext": "agda",
"hexsha": "e4ccf5eb7e17aea9cd3465edfd027429a2504e1b",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2015-05-30T05:50:50.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-05-30T05:50:50.000Z",
"max_forks_repo_head_hexsha": "aae093cc9bf21f11064e7f7b12049448cd6449f1",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "banacorn/numeral",
"max_forks_repo_path": "legacy/Data/Nat/DivMod/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "aae093cc9bf21f11064e7f7b12049448cd6449f1",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "banacorn/numeral",
"max_issues_repo_path": "legacy/Data/Nat/DivMod/Properties.agda",
"max_line_length": 262,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "aae093cc9bf21f11064e7f7b12049448cd6449f1",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "banacorn/numeral",
"max_stars_repo_path": "legacy/Data/Nat/DivMod/Properties.agda",
"max_stars_repo_stars_event_max_datetime": "2015-04-23T15:58:28.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-04-23T15:58:28.000Z",
"num_tokens": 6328,
"size": 14435
}
|
open import Relation.Binary.Core
module Heapsort.Impl2.Correctness.Permutation {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_)
(trans≤ : Transitive _≤_) where
open import BBHeap _≤_ hiding (forget) renaming (flatten to flatten')
open import BBHeap.Compound _≤_
open import BBHeap.Drop _≤_ tot≤ trans≤
open import BBHeap.Drop.Properties _≤_ tot≤ trans≤
open import BBHeap.Heapify _≤_ tot≤ trans≤
open import BBHeap.Insert _≤_ tot≤ trans≤
open import BBHeap.Insert.Properties _≤_ tot≤ trans≤
open import BBHeap.Order _≤_
open import BBHeap.Order.Properties _≤_
open import Bound.Lower A
open import Bound.Lower.Order _≤_
open import Data.List
open import Heapsort.Impl2 _≤_ tot≤ trans≤
open import List.Permutation.Base A
open import List.Permutation.Base.Equivalence A
open import OList _≤_
open import Order.Total _≤_ tot≤
lemma-flatten-flatten' : {b : Bound}(h : BBHeap b)(accₕ : Acc h) → forget (flatten h accₕ) ∼ flatten' h
lemma-flatten-flatten' leaf _ = ∼[]
lemma-flatten-flatten' (left {l = l} {r = r} b≤x l⋘r) (acc rs) = ∼x /head /head (trans∼ (lemma-flatten-flatten' (drop⋘ b≤x l⋘r) (rs (drop⋘ b≤x l⋘r) (lemma-drop≤′ (cl b≤x l⋘r)))) (lemma-drop⋘∼ b≤x l⋘r))
lemma-flatten-flatten' (right {l = l} {r = r} b≤x l⋙r) (acc rs) = ∼x /head /head (trans∼ (lemma-flatten-flatten' (drop⋙ b≤x l⋙r) (rs (drop⋙ b≤x l⋙r) (lemma-drop≤′ (cr b≤x l⋙r)))) (lemma-drop⋙∼ b≤x l⋙r))
lemma-flatten'-flatten : {b : Bound}(h : BBHeap b)(accₕ : Acc h) → (flatten' h) ∼ (forget (flatten h accₕ))
lemma-flatten'-flatten h tₕ = sym∼ (lemma-flatten-flatten' h tₕ)
theorem-heapsort∼ : (xs : List A) → xs ∼ forget (heapsort xs)
theorem-heapsort∼ [] = ∼[]
theorem-heapsort∼ (x ∷ xs) =
let h = heapify xs ;
accₕ = ≺-wf h ;
hᵢ = insert lebx h ;
accₕᵢ = ≺-wf hᵢ ;
xs∼fh = theorem-heapsort∼ xs ;
fh∼f'h = lemma-flatten-flatten' h accₕ ;
xs∼f'h = trans∼ xs∼fh fh∼f'h ;
xxs∼xf'h = ∼x /head /head xs∼f'h ;
xf'h∼f'hᵢ = lemma-insert∼ lebx h ;
xxs∼f'hᵢ = trans∼ xxs∼xf'h xf'h∼f'hᵢ ;
f'hᵢ∼fhᵢ = lemma-flatten'-flatten hᵢ accₕᵢ
in trans∼ xxs∼f'hᵢ f'hᵢ∼fhᵢ
|
{
"alphanum_fraction": 0.5742449664,
"avg_line_length": 48.6530612245,
"ext": "agda",
"hexsha": "520565ae25c850ee1bd6d726711cf8ff97480c64",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "bgbianchi/sorting",
"max_forks_repo_path": "agda/Heapsort/Impl2/Correctness/Permutation.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "bgbianchi/sorting",
"max_issues_repo_path": "agda/Heapsort/Impl2/Correctness/Permutation.agda",
"max_line_length": 202,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "bgbianchi/sorting",
"max_stars_repo_path": "agda/Heapsort/Impl2/Correctness/Permutation.agda",
"max_stars_repo_stars_event_max_datetime": "2021-08-24T22:11:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-05-21T12:50:35.000Z",
"num_tokens": 905,
"size": 2384
}
|
module Rec2 where
open import Data.Nat
open import Rec1
x : ℕ
x = 42
z : ℕ
z = y
|
{
"alphanum_fraction": 0.5729166667,
"avg_line_length": 8.7272727273,
"ext": "agda",
"hexsha": "a355d47f47a5c8330c1df1deedcf8fa082b2e594",
"lang": "Agda",
"max_forks_count": 304,
"max_forks_repo_forks_event_max_datetime": "2022-03-28T11:35:02.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-07-16T18:24:59.000Z",
"max_forks_repo_head_hexsha": "5468837f55cbea38d5c5a163e1ea5d48edb92bcc",
"max_forks_repo_licenses": [
"CC-BY-4.0"
],
"max_forks_repo_name": "andorp/plfa.github.io",
"max_forks_repo_path": "extra/extra/Rec2.agda",
"max_issues_count": 323,
"max_issues_repo_head_hexsha": "5468837f55cbea38d5c5a163e1ea5d48edb92bcc",
"max_issues_repo_issues_event_max_datetime": "2022-03-30T07:42:57.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-07-05T22:34:34.000Z",
"max_issues_repo_licenses": [
"CC-BY-4.0"
],
"max_issues_repo_name": "andorp/plfa.github.io",
"max_issues_repo_path": "extra/extra/Rec2.agda",
"max_line_length": 22,
"max_stars_count": 1003,
"max_stars_repo_head_hexsha": "5468837f55cbea38d5c5a163e1ea5d48edb92bcc",
"max_stars_repo_licenses": [
"CC-BY-4.0"
],
"max_stars_repo_name": "andorp/plfa.github.io",
"max_stars_repo_path": "extra/extra/Rec2.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-27T07:03:28.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-07-05T18:15:14.000Z",
"num_tokens": 39,
"size": 96
}
|
-- Following A CUBICAL TYPE THEORY FOR HIGHER INDUCTIVE TYPES
-- by Simon Huber at https://simhu.github.io/misc/hcomp.pdf
-- as closely as possible.
open import Cubical.Core.Primitives
open import Cubical.Core.Glue
import Agda.Builtin.Cubical.HCompU as HCompU
open HCompU using (primFaceForall)
open HCompU.Helpers using (refl)
private
variable
ℓ ℓ₁ : Level
ℓ′ ℓ₁′ : I → Level
-- Section 2 : New Primitives
-- This is just a special case of transp where φ = i0. I include it as it
-- has a far simpler type.
transport : (A : ∀ i → Type (ℓ′ i)) → A i0 → A i1
transport A u₀ = transp A i0 u₀
transp' :
(φ : I)
{ℓ' : I → Level [ φ ↦ (λ _ → ℓ) ]}
{a : PartialP φ (λ _ → Type ℓ)}
(A : (i : I) → Type (outS (ℓ' i)) [ φ ↦ (λ { (φ = i1) → a 1=1 }) ])
(u₀ : outS (A i0))
→ outS (A i1) [ φ ↦ (λ { (φ = i1) → u₀ }) ]
transp' φ A u₀ = inS (transp (λ i → outS (A i)) φ u₀)
transportFill :
(A : ∀ i → Type (ℓ′ i))
(u₀ : A i0)
(i : I)
→ A i
transportFill A u₀ i = transp (λ j → A (i ∧ j)) (~ i) u₀
-- Note that I fix the universe of A to make the type simpler. From now on we
-- are going to do that for all code involving transp where φ is not just i0.
transpFill :
(φ : I)
{a : Partial φ (Type ℓ)}
(A : I → Type ℓ [ φ ↦ a ])
(u₀ : outS (A i0))
(i : I)
→ outS (A i)
transpFill φ A u₀ i = transp (λ j → outS (A (i ∧ j))) (φ ∨ ~ i) u₀
forward :
(A : ∀ i → Type (ℓ′ i))
(r : I)
(u : A r)
→ A i1
forward A r u = transp (λ i → A (i ∨ r)) r u
hcomp' :
{A : Type ℓ}
{φ : I}
(u : ∀ i → Partial φ A)
(u₀ : A [ φ ↦ u i0 ])
→ A [ φ ↦ u i1 ]
hcomp' u u₀ = inS (hcomp u (outS u₀))
module Comp
(A : ∀ i → Type (ℓ′ i))
{φ : I}
(u : ∀ i → Partial φ (A i))
(u₀ : A i0 [ φ ↦ u i0 ])
where
comp' : A i1 [ φ ↦ u i1 ]
comp' =
inS
(hcomp
(λ i o → forward A i (u i o))
(forward A i0 (outS u₀)))
compId : comp A {φ = φ} u (outS u₀) ≡ outS comp'
compId = refl
-- Section 3 : Recursive definition of transport
data ℕ : Type where
zero : ℕ
suc : ℕ → ℕ
transpZeroId : (φ : I) → transp (λ _ → ℕ) φ zero ≡ zero
transpZeroId φ = refl
transpSucId : (φ : I) (u₀ : ℕ)
→ transp (λ _ → ℕ) φ (suc u₀) ≡ suc (transp (λ _ → ℕ) φ u₀)
transpSucId φ u₀ = refl
transpℕId : (φ : I) (u₀ : ℕ) → transp (λ _ → ℕ) φ u₀ ≡ u₀
transpℕId φ u₀ = refl
transportPathPId :
(A : (i j : I) → Type (ℓ′ i))
(v : (i : I) → A i i0)
(w : (i : I) → A i i1)
(u₀ : PathP (A i0) (v i0) (w i0))
→ transport (λ i → PathP (A i) (v i) (w i)) u₀
≡ λ j → comp
(λ i → A i j)
(λ i → λ
{ (j = i0) → v i
; (j = i1) → w i })
(u₀ j)
transportPathPId A v w u₀ = refl
transpPathPId :
(φ : I)
{a : I → Partial φ (Type ℓ)}
(A : (i j : I) → Type ℓ [ φ ↦ a j ])
{vφ : PartialP φ (a i0)}
(v : (i : I) → outS (A i i0) [ φ ↦ (λ { (φ = i1) → vφ 1=1 }) ])
{wφ : PartialP φ (a i1)}
(w : (i : I) → outS (A i i1) [ φ ↦ (λ { (φ = i1) → wφ 1=1 }) ])
(u₀ : PathP (λ j → outS (A i0 j)) (outS (v i0)) (outS (w i0)))
→ transp (λ i → PathP (λ j → outS (A i j)) (outS (v i)) (outS (w i))) φ u₀
≡ λ j → comp
(λ i → outS (A i j))
(λ i → λ
{ (φ = i1) → u₀ j
; (j = i0) → outS (v i)
; (j = i1) → outS (w i) })
(u₀ j)
transpPathPId φ A v w u₀ = refl
transportΣId :
(A : ∀ i → Type (ℓ′ i))
(B : ∀ i → A i → Type (ℓ₁′ i))
(u₀ : Σ (A i0) (B i0))
→ transport (λ i → Σ (A i) (B i)) u₀
≡ (transport A (u₀ .fst) ,
let v = transportFill A (u₀ .fst)
in transport (λ i → B i (v i)) (u₀ .snd))
transportΣId A B u₀ = refl
transpΣId :
(φ : I)
{a : Partial φ (Type ℓ)}
(A : I → Type ℓ [ φ ↦ a ])
{b : Partial φ (Type ℓ₁)}
(B : (i : I) → outS (A i) → Type ℓ₁ [ φ ↦ b ])
(u₀ : Σ (outS (A i0)) (λ x → outS (B i0 x)))
→ transp (λ i → Σ (outS (A i)) (λ x → outS (B i x))) φ u₀
≡ (transp (λ i → outS (A i)) φ (u₀ .fst) ,
let v = transpFill φ A (u₀ .fst)
in transp (λ i → outS (B i (v i))) φ (u₀ .snd))
transpΣId φ A B u₀ = refl
transportΠId :
(A : ∀ i → Type (ℓ′ i))
(B : ∀ i → A i → Type (ℓ₁′ i))
(u₀ : (x : A i0) → B i0 x)
→ transport (λ i → (x : A i) → B i x) u₀
≡ λ v →
let
w : (i : I) → A i
w i = transportFill (λ j → A (~ j)) v (~ i)
in
transport (λ i → B i (w i)) (u₀ (w i0))
transportΠId A B u₀ = refl
transpΠId :
(φ : I)
{a : Partial φ (Type ℓ)}
(A : I → Type ℓ [ φ ↦ a ])
{b : Partial φ (Type ℓ₁)}
(B : (i : I) → outS (A i) → Type ℓ₁ [ φ ↦ b ])
(u₀ : ((x : outS (A i0)) → outS (B i0 x)))
→ transp (λ i → (x : outS (A i)) → outS (B i x)) φ u₀
≡ λ v →
let
w : (i : I) → outS (A i)
w i = transpFill φ (λ j → (A (~ j))) v (~ i)
in
transp (λ i → outS (B i (w i))) φ (u₀ (w i0))
transpΠId φ A B u₀ = refl
transpUniverseId : (φ : I) (A : Type ℓ) → transp (λ _ → Type ℓ) φ A ≡ A
transpUniverseId φ A = refl
module TransportGlue
(A : ∀ i → Type (ℓ′ i))
(φ : I → I)
(T : (i : I) → Partial (φ i) (Type (ℓ₁′ i)))
(w : (i : I) → PartialP (φ i) (λ o → T i o ≃ A i))
(u₀ : primGlue (A i0) (T i0) (w i0))
where
B : (i : I) → Type (ℓ₁′ i)
B i = primGlue (A i) (T i) (w i)
∀φ : I
∀φ = primFaceForall φ
t : (i : I) → PartialP ∀φ (λ { (∀φ = i1) → T i 1=1 })
t i (∀φ = i1) = {!!}
transportGlue : B i1
transportGlue = {!!}
transportGlueId : transport B u₀ ≡ transportGlue
transportGlueId = {!!}
-- Section 4 : Recursive Definition of Homogeneous Composition
hcompZeroId : {φ : I} → hcomp (λ i → λ { (φ = i1) → zero }) zero ≡ zero
hcompZeroId = refl
hcompSucId :
{φ : I}
(u : I → Partial φ ℕ)
(u₀ : ℕ [ φ ↦ u i0 ])
→ hcomp (λ i o → suc (u i o)) (suc (outS u₀)) ≡ suc (hcomp u (outS u₀))
hcompSucId u u₀ = refl
hcompPathPId :
(A : I → Type ℓ)
(v : A i0)
(w : A i1)
{φ : I}
(u : I → Partial φ (PathP A v w))
(u₀ : PathP A v w [ φ ↦ u i0 ])
→ hcomp u (outS u₀)
≡ λ j →
hcomp
(λ i → λ { (φ = i1) → u i 1=1 j ; (j = i0) → v ; (j = i1) → w })
(outS u₀ j)
hcompPathPId A v w u u₀ = refl
hcompΣId :
(A : Type ℓ)
(B : (x : A) → Type ℓ₁)
{φ : I}
(u : I → Partial φ (Σ A B))
(u₀ : Σ A B [ φ ↦ u i0 ])
→ hcomp u (outS u₀)
≡ let
v : (i : I) → A
-- should use hfill instead
v = fill (λ _ → A) (λ i o → u i o .fst) (inS (outS u₀ .fst))
in
(v i1 ,
comp (λ i → B (v i)) (λ i → λ { (φ = i1) → u i 1=1 .snd }) (outS u₀ .snd))
hcompΣId A B u u₀ = refl
hcompΠId :
(A : Type ℓ)
(B : (x : A) → Type ℓ₁)
{φ : I}
(u : I → Partial φ ((x : A) → B x))
(u₀ : ((x : A) → B x) [ φ ↦ u i0 ])
→ hcomp u (outS u₀)
≡ λ v → hcomp (λ i o → u i o v) (outS u₀ v)
hcompΠId A B u u₀ = refl
-- Unfortunately hcomp E (outS A) is not judgmentally equal to
-- outS (hcompUniverse E A) which I don't know why.
hcompUniverse :
{φ : I}
(E : I → Partial φ (Type ℓ))
(A : Type ℓ [ φ ↦ E i0 ])
→ Type ℓ [ φ ↦ E i1 ]
hcompUniverse {φ = φ} E A =
inS
(primGlue
(outS A)
(E i1)
(λ { (φ = i1) → lineToEquiv (λ i → E (~ i) 1=1) }))
module HcompGlue
(A : Type ℓ)
{φ : I}
(T : Partial φ (Type ℓ₁))
(w : PartialP φ (λ o → T o ≃ A))
{ψ : I}
(u : I → Partial ψ (primGlue A T w))
(u₀ : primGlue A T w [ ψ ↦ u i0 ])
where
t : (i : I) → PartialP φ T
t i (φ = i1) = hfill u u₀ i
a₁ : A
a₁ = hcomp (λ i → λ
{ (ψ = i1) → unglue φ (u i 1=1)
; (φ = i1) → w 1=1 .fst (t i 1=1) })
(unglue φ (outS u₀))
hcompGlue : primGlue A T w [ ψ ↦ u i1 ]
hcompGlue = inS (glue (t i1) a₁)
hcompGlueId : hcomp u (outS u₀) ≡ outS hcompGlue
hcompGlueId = refl
|
{
"alphanum_fraction": 0.4822891885,
"avg_line_length": 24.4854368932,
"ext": "agda",
"hexsha": "4c6ee76d259ef31211a648971b59707b17e8e3a7",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "3aa0425c12e2edeb284ab8588a2b25ea46ae4394",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "howsiyu/hott-notes",
"max_forks_repo_path": "hcomp_paper.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "3aa0425c12e2edeb284ab8588a2b25ea46ae4394",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "howsiyu/hott-notes",
"max_issues_repo_path": "hcomp_paper.agda",
"max_line_length": 78,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "3aa0425c12e2edeb284ab8588a2b25ea46ae4394",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "howsiyu/hott-notes",
"max_stars_repo_path": "hcomp_paper.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 3499,
"size": 7566
}
|
{-# OPTIONS --without-K #-}
open import HoTT.Base
module HoTT.Identity where
open variables
private variable x y z w : A
-- Lemma 2.1.4
-- (i)
unitᵣ : {p : x == y} → p == p ∙ refl
unitᵣ {p = refl} = refl
unitₗ : {p : x == y} → p == refl ∙ p
unitₗ {p = refl} = refl
-- (ii)
invₗ : {p : x == y} → p ⁻¹ ∙ p == refl
invₗ {p = refl} = refl
invᵣ : {p : x == y} → p ∙ p ⁻¹ == refl
invᵣ {p = refl} = refl
-- (iv)
assoc : {p : x == y} {q : y == z} {r : z == w} →
p ∙ (q ∙ r) == (p ∙ q) ∙ r
assoc {p = refl} {refl} {refl} = refl
invinv : {p : x == y} → p ⁻¹ ⁻¹ == p
invinv {p = refl} = refl
-- Whiskering
_∙ᵣ_ : {p q : x == y} (α : p == q) (r : y == z) → p ∙ r == q ∙ r
refl ∙ᵣ refl = refl
infixl 25 _∙ᵣ_
_∙ₗ_ : {r s : y == z} (q : x == y) (β : r == s) → q ∙ r == q ∙ s
refl ∙ₗ refl = refl
infixl 25 _∙ₗ_
-- Horizontal composition
_⋆_ : {p q : x == y} {r s : y == z} → (p == q) → (r == s) → p ∙ r == q ∙ s
refl ⋆ refl = refl
cancelᵣ : {p q : x == y} {r : y == z} (α : p ∙ r == q ∙ r) → p == q
cancelᵣ {r = refl} α = unitᵣ ∙ α ∙ unitᵣ ⁻¹
cancelₗ : {r s : y == z} {q : x == y} (β : q ∙ r == q ∙ s) → r == s
cancelₗ {q = refl} β = unitₗ ∙ β ∙ unitₗ ⁻¹
pivotᵣ : {p : x == y} {q : y == z} {r : x == z} → p ∙ q == r → p == r ∙ q ⁻¹
pivotᵣ {p = refl} {q = refl} α = α ∙ unitᵣ
pivotₗ : {p : x == y} {q : y == z} {r : x == z} → p ∙ q == r → q == p ⁻¹ ∙ r
pivotₗ {p = refl} {q = refl} α = α ∙ unitₗ
-- Lemma 2.2.2
-- (i)
ap-∙ : (f : A → B) (p : x == y) (q : y == z) → ap f (p ∙ q) == ap f p ∙ ap f q
ap-∙ _ refl refl = refl
-- (ii)
ap-inv : (f : A → B) (p : x == y) → ap f (p ⁻¹) == ap f p ⁻¹
ap-inv _ refl = refl
-- (iii)
ap-∘ : {C : 𝒰 i} (f : B → C) (g : A → B) (p : x == y) → ap (f ∘ g) p == ap f (ap g p)
ap-∘ _ _ refl = refl
-- (iv)
ap-id : (p : x == y) → ap id p == p
ap-id refl = refl
ap-const : (p : x == y) → ap (const B) p == refl
ap-const refl = refl
-- Lemma 2.3.5
transportconst : (p : x == y) → transport (const B) p ~ id
transportconst refl _ = refl
-- Lemma 2.3.9
transport-∙ : (P : A → 𝒰 i) (p : x == y) (q : y == z) →
transport P (p ∙ q) ~ transport P q ∘ transport P p
transport-∙ P refl refl _ = refl
-- Lemma 2.3.10
transport-ap : (P : B → 𝒰 i) (f : A → B) {x y : A} (p : x == y) →
transport P (ap f p) ~ transport (P ∘ f) p
transport-ap _ _ refl _ = refl
-- Lemma 2.3.11
transport-∘ : (f : {x : A} → P x → Q x) (p : x == y) →
transport Q p ∘ f ~ f ∘ transport P p
transport-∘ _ refl _ = refl
module =-Reasoning {i} {A : 𝒰 i}
where
_=⟨_⟩_ : (x : A) {y z : A} → x == y → y == z → x == z
x =⟨ p ⟩ q = p ∙ q
infixr 2 _=⟨_⟩_
_=⟨⟩_ : (x : A) {y : A} → x == y → x == y
_ =⟨⟩ p = p
infixr 2 _=⟨⟩_
_∎ : (x : A) → x == x
_ ∎ = refl
infix 3 _∎
|
{
"alphanum_fraction": 0.4350364964,
"avg_line_length": 25.1376146789,
"ext": "agda",
"hexsha": "170d26688b8672ebc147ab3aa0aa6d7998e4dd3e",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508",
"max_forks_repo_licenses": [
"0BSD"
],
"max_forks_repo_name": "michaelforney/hott",
"max_forks_repo_path": "HoTT/Identity.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"0BSD"
],
"max_issues_repo_name": "michaelforney/hott",
"max_issues_repo_path": "HoTT/Identity.agda",
"max_line_length": 85,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508",
"max_stars_repo_licenses": [
"0BSD"
],
"max_stars_repo_name": "michaelforney/hott",
"max_stars_repo_path": "HoTT/Identity.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1363,
"size": 2740
}
|
open import Coinduction using ( ♭ ; ♯_ )
open import Data.Empty using ( ⊥-elim )
open import Data.Sum using ( _⊎_ ; inj₁ ; inj₂ )
open import Relation.Binary.PropositionalEquality
using ( _≡_ ; _≢_ ; refl ; sym ; cong ; cong₂ )
open import Relation.Nullary using ( ¬_ ; Dec ; yes ; no )
open import System.IO.Transducers.Lazy
using ( _⇒_ ; inp ; out ; done ; _⟫_ ;
equiv ; assoc ; assoc⁻¹ ; unit₁ ; unit₁⁻¹ ; unit₂ ; unit₂⁻¹ ;
_[&]_ ; ⟦_⟧ ; _≃_ )
open import System.IO.Transducers.Reflective using ( Reflective )
open import System.IO.Transducers.Strict using ( Strict )
open import System.IO.Transducers.Session
using ( I ; Σ ; IsΣ ; _∼_ ; ∼-refl ; ∼-trans ; ∼-sym ; _&_ )
renaming ( unit₁ to ∼-unit₁ ; unit₂ to ∼-unit₂ ; assoc to ∼-assoc )
open import System.IO.Transducers.Trace using ( Trace ; _✓ ; [] ; _∷_ )
open import System.IO.Transducers.Properties.Category
using ( ⟦done⟧ ; done-semantics ; _⟦⟫⟧_ ; ⟫-semantics ; ⟫-≃-⟦⟫⟧ ; ⟫-resp-≃ ; done-isEquiv ; ⟫-isEquiv ; equiv-is-iso )
open import System.IO.Transducers.Properties.Lemmas
using ( ≃-refl ; ≃-sym ; ✓-tl ; ✓? ; ⟦⟧-resp-✓ ; ⟦⟧-refl-✓ ; ⟦⟧-resp-[] ;
IsEquiv ; isEquiv ; ≃-equiv ; I-η)
module System.IO.Transducers.Properties.Monoidal where
open Relation.Binary.PropositionalEquality.≡-Reasoning
infixr 8 _++_ _⟦[&]⟧_
-- Concatenation of traces
_++_ : ∀ {S T} → (Trace S) → (Trace T) → (Trace (S & T))
_++_ {I} [] bs = bs
_++_ {Σ V F} [] bs = []
_++_ {Σ V F} (a ∷ as) bs = a ∷ (as ++ bs)
_++_ {I} (() ∷ as) bs
-- Projection of traces
front : ∀ {S T} → (Trace (S & T)) → (Trace S)
front {I} as = []
front {Σ V F} [] = []
front {Σ V F} (a ∷ as) = a ∷ front as
back : ∀ {S T} → (Trace (S & T)) → (Trace T)
back {I} as = as
back {Σ V F} [] = []
back {Σ V F} (a ∷ as) = back {♭ F a} as
-- Semantics of tensor
_⟦[&]⟧_ : ∀ {S T U V} →
(f : Trace S → Trace T) → (g : Trace U → Trace V) →
(Trace (S & U)) → (Trace (T & V))
_⟦[&]⟧_ {S} f g as = f (front as) ++ g (back {S} as)
[&]-semantics : ∀ {S T U V} (P : S ⇒ T) (Q : U ⇒ V) →
⟦ P [&] Q ⟧ ≃ ⟦ P ⟧ ⟦[&]⟧ ⟦ Q ⟧
[&]-semantics (inp {I} P) (inp Q) [] = refl
[&]-semantics (inp {I} P) (inp Q) (a ∷ as) = [&]-semantics (♭ P a) (inp Q) as
[&]-semantics (inp {I} P) done [] = refl
[&]-semantics (inp {I} P) done (a ∷ as) = [&]-semantics (♭ P a) done as
[&]-semantics (inp {Σ V F} P) Q [] = refl
[&]-semantics (inp {Σ V F} P) Q (a ∷ as) = [&]-semantics (♭ P a) Q as
[&]-semantics (out b P) Q as = cong (_∷_ b) ([&]-semantics P Q as)
[&]-semantics (done {I}) Q as = refl
[&]-semantics (done {Σ V F}) Q [] = refl
[&]-semantics (done {Σ V F}) Q (a ∷ as) = cong (_∷_ a) ([&]-semantics (done {♭ F a}) Q as)
[&]-semantics (inp {I} P) (out c Q) as =
begin
c ∷ ⟦ inp P [&] Q ⟧ as
≡⟨ cong (_∷_ c) ([&]-semantics (inp P) Q as) ⟩
c ∷ (⟦ inp P ⟧ ⟦[&]⟧ ⟦ Q ⟧) as
≡⟨ cong (_∷_ c) (cong₂ _++_ (I-η (⟦ inp P ⟧ (front as))) refl) ⟩
c ∷ ⟦ Q ⟧ _
≡⟨ cong₂ _++_ (sym (I-η (⟦ inp P ⟧ (front as)))) refl ⟩
(⟦ inp P ⟧ ⟦[&]⟧ ⟦ out c Q ⟧) as
∎
[&]-≃-⟦[&]⟧ : ∀ {S T U V}
{P : S ⇒ T} {f : Trace S → Trace T} {Q : U ⇒ V} {g : Trace U → Trace V} →
(⟦ P ⟧ ≃ f) → (⟦ Q ⟧ ≃ g) → (⟦ P [&] Q ⟧ ≃ f ⟦[&]⟧ g)
[&]-≃-⟦[&]⟧ {S} {T} {U} {V} {P} {f} {Q} {g} P≃f Q≃g as =
begin
⟦ P [&] Q ⟧ as
≡⟨ [&]-semantics P Q as ⟩
(⟦ P ⟧ ⟦[&]⟧ ⟦ Q ⟧) as
≡⟨ cong₂ _++_ (P≃f (front as)) (Q≃g (back {S} as)) ⟩
(f ⟦[&]⟧ g) as
∎
-- Semantics of units
⟦unit₁⟧ : ∀ {S} → (Trace (I & S)) → (Trace S)
⟦unit₁⟧ as = as
unit₁-semantics : ∀ {S} → ⟦ unit₁ {S} ⟧ ≃ ⟦unit₁⟧ {S}
unit₁-semantics {I} as = refl
unit₁-semantics {Σ V F} [] = refl
unit₁-semantics {Σ V F} (a ∷ as) = cong (_∷_ a) (unit₁-semantics as)
⟦unit₁⁻¹⟧ : ∀ {S} → (Trace (I & S)) → (Trace S)
⟦unit₁⁻¹⟧ as = as
unit₁⁻¹-semantics : ∀ {S} → ⟦ unit₁⁻¹ {S} ⟧ ≃ ⟦unit₁⁻¹⟧ {S}
unit₁⁻¹-semantics {I} as = refl
unit₁⁻¹-semantics {Σ V F} [] = refl
unit₁⁻¹-semantics {Σ V F} (a ∷ as) = cong (_∷_ a) (unit₁⁻¹-semantics as)
⟦unit₂⟧ : ∀ {S} → (Trace (S & I)) → (Trace S)
⟦unit₂⟧ = front
unit₂-semantics : ∀ {S} → ⟦ unit₂ {S} ⟧ ≃ ⟦unit₂⟧ {S}
unit₂-semantics {I} [] = refl
unit₂-semantics {Σ V F} [] = refl
unit₂-semantics {Σ V F} (a ∷ as) = cong (_∷_ a) (unit₂-semantics as)
unit₂-semantics {I} (() ∷ as)
⟦unit₂⁻¹⟧ : ∀ {S} → (Trace S) → (Trace (S & I))
⟦unit₂⁻¹⟧ as = as ++ []
unit₂⁻¹-semantics : ∀ {S} → ⟦ unit₂⁻¹ {S} ⟧ ≃ ⟦unit₂⁻¹⟧
unit₂⁻¹-semantics {I} [] = refl
unit₂⁻¹-semantics {Σ W F} [] = refl
unit₂⁻¹-semantics {Σ W F} (a ∷ as) = cong (_∷_ a) (unit₂⁻¹-semantics as)
unit₂⁻¹-semantics {I} (() ∷ as)
-- Semantics of associativity
⟦assoc⟧ : ∀ {S T U} → (Trace (S & (T & U))) → (Trace ((S & T) & U))
⟦assoc⟧ {S} {T} {U} as =
(front {S} as ++ front {T} (back {S} as)) ++ back {T} (back {S} as)
assoc-semantics : ∀ {S T U} → ⟦ assoc {S} {T} {U} ⟧ ≃ ⟦assoc⟧ {S} {T} {U}
assoc-semantics {I} {I} {I} [] = refl
assoc-semantics {I} {I} {Σ X H} [] = refl
assoc-semantics {I} {Σ W G} [] = refl
assoc-semantics {I} {I} {Σ X H} (a ∷ as) = cong (_∷_ a) (assoc-semantics {I} {I} as)
assoc-semantics {I} {Σ W G} (a ∷ as) = cong (_∷_ a) (assoc-semantics {I} {♭ G a} as)
assoc-semantics {Σ V F} [] = refl
assoc-semantics {Σ V F} (a ∷ as) = cong (_∷_ a) (assoc-semantics {♭ F a} as)
assoc-semantics {I} {I} {I} (() ∷ as)
⟦assoc⁻¹⟧ : ∀ {S T U} → (Trace ((S & T) & U)) → (Trace (S & (T & U)))
⟦assoc⁻¹⟧ {S} {T} {U} as =
front {S} (front {S & T} as) ++ back {S} (front {S & T} as) ++ back {S & T} as
assoc⁻¹-semantics : ∀ {S T U} → ⟦ assoc⁻¹ {S} {T} {U} ⟧ ≃ ⟦assoc⁻¹⟧ {S} {T} {U}
assoc⁻¹-semantics {I} {I} {I} [] = refl
assoc⁻¹-semantics {I} {I} {Σ X H} [] = refl
assoc⁻¹-semantics {I} {Σ W G} [] = refl
assoc⁻¹-semantics {I} {I} {Σ X H} (a ∷ as) = cong (_∷_ a) (assoc⁻¹-semantics {I} {I} as)
assoc⁻¹-semantics {I} {Σ W G} (a ∷ as) = cong (_∷_ a) (assoc⁻¹-semantics {I} {♭ G a} as)
assoc⁻¹-semantics {Σ V F} [] = refl
assoc⁻¹-semantics {Σ V F} (a ∷ as) = cong (_∷_ a) (assoc⁻¹-semantics {♭ F a} as)
assoc⁻¹-semantics {I} {I} {I} (() ∷ as)
-- Congruence for concatenation, where the rhs can assume the lhs has terminated
++-cong : ∀ {S T} {as₁ as₂ : Trace S} {bs₁ bs₂ : Trace T} →
(as₁ ≡ as₂) → (as₁ ✓ → bs₁ ≡ bs₂) → (as₁ ++ bs₁) ≡ (as₂ ++ bs₂)
++-cong {I} {T} {[]} refl bs₁≡bs₂ = bs₁≡bs₂ []
++-cong {Σ V F} {T} {[]} refl bs₁≡bs₂ = refl
++-cong {Σ V F} {T} {a ∷ as} refl bs₁≡bs₂ = cong (_∷_ a) (++-cong refl (λ ✓as → bs₁≡bs₂ (a ∷ ✓as)))
++-cong {I} {T} {() ∷ as} refl bs₁≡bs₂
-- Concatenation respects and reflects termination
++-resp-✓ : ∀ {S T} {as : Trace S} {bs : Trace T} → (as ✓) → (bs ✓) → (as ++ bs ✓)
++-resp-✓ [] ✓bs = ✓bs
++-resp-✓ {Σ V F} (a ∷ ✓as) ✓bs = a ∷ ++-resp-✓ ✓as ✓bs
++-resp-✓ {I} (() ∷ ✓as) ✓bs
++-refl-✓₁ : ∀ {S T} {as : Trace S} {bs : Trace T} → (as ++ bs ✓) → (as ✓)
++-refl-✓₁ {I} {T} {[]} ✓cs = []
++-refl-✓₁ {Σ V F} {T} {a ∷ as} (.a ∷ ✓cs) = a ∷ ++-refl-✓₁ ✓cs
++-refl-✓₁ {I} {T} {() ∷ as} ✓cs
++-refl-✓₁ {Σ V F} {T} {[]} ()
++-refl-✓₂ : ∀ {S T} {as : Trace S} {bs : Trace T} → (as ++ bs ✓) → (bs ✓)
++-refl-✓₂ {I} {T} {[]} ✓cs = ✓cs
++-refl-✓₂ {Σ W F} {T} {a ∷ as} (.a ∷ ✓cs) = ++-refl-✓₂ {♭ F a} {T} {as} ✓cs
++-refl-✓₂ {I} {T} {() ∷ as} cs
++-refl-✓₂ {Σ V F} {T} {[]} ()
-- Concatenaton respects emptiness
++-resp-[] : ∀ {S T} {as : Trace S} {bs : Trace T} →
(as ≡ []) → (bs ≡ []) → (as ++ bs ≡ [])
++-resp-[] {I} refl refl = refl
++-resp-[] {Σ V F} refl refl = refl
-- Beta and eta equivalence for concatenation.
-- Note that β₂ only holds when as is complete.
++-β₁ : ∀ {S T} (as : Trace S) → (bs : Trace T) → (front (as ++ bs) ≡ as)
++-β₁ {I} [] bs = refl
++-β₁ {I} (() ∷ as) bs
++-β₁ {Σ V F} [] bs = refl
++-β₁ {Σ V F} (a ∷ as) bs = cong (_∷_ a) (++-β₁ as bs)
++-β₂ : ∀ {S T} {as : Trace S} → (as ✓) → (bs : Trace T) → (back {S} (as ++ bs) ≡ bs)
++-β₂ {I} [] bs = refl
++-β₂ {Σ V F} (a ∷ as) bs = ++-β₂ as bs
++-β₂ {I} (() ∷ as) bs
++-η : ∀ {S T} (as : Trace (S & T)) → (front {S} as ++ back {S} as ≡ as)
++-η {I} [] = refl
++-η {I} (a ∷ as) = refl
++-η {Σ V F} [] = refl
++-η {Σ V F} (a ∷ as) = cong (_∷_ a) (++-η {♭ F a} as)
-- Beta for concatenation with an incomplete trace
++-β₂-[] : ∀ {S T} {as : Trace S} → (¬ (as ✓)) → (bs : Trace T) → (back {S} (as ++ bs) ≡ [])
++-β₂-[] {I} {T} {[]} ¬✓[] bs = ⊥-elim (¬✓[] [])
++-β₂-[] {Σ V F} {T} {[]} ¬✓[] bs = refl
++-β₂-[] {Σ V F} {T} {a ∷ as} ¬✓a∷as bs = ++-β₂-[] (λ ✓as → ¬✓a∷as (a ∷ ✓as)) bs
++-β₂-[] {I} {T} {() ∷ as} ¬✓a∷as bs
-- If the front of a trace is incomplete then its back is empty
back≡[] : ∀ {S T as} → (¬ (front {S} {T} as ✓)) → (back {S} {T} as ≡ [])
back≡[] {I} {T} {as} ¬✓as₁ = ⊥-elim (¬✓as₁ [])
back≡[] {Σ V F} {T} {[]} ¬✓as₁ = refl
back≡[] {Σ V F} {T} {a ∷ as} ¬✓a∷as₁ = back≡[] (λ ✓as₁ → ¬✓a∷as₁ (a ∷ ✓as₁))
-- Front respects completion, but only reflects it when T = I.
front-resp-✓ : ∀ {S T} {as : Trace (S & T)} → (as ✓) → (front {S} as ✓)
front-resp-✓ {I} ✓as = []
front-resp-✓ {Σ V F} (a ∷ ✓as) = a ∷ front-resp-✓ ✓as
front-refl-✓ : ∀ {S} (as : Trace (S & I)) → (front {S} as ✓) → (as ✓)
front-refl-✓ {I} [] ✓as₁ = []
front-refl-✓ {Σ V F} (a ∷ as) (.a ∷ ✓as₁) = a ∷ front-refl-✓ as ✓as₁
front-refl-✓ {I} (() ∷ as) ✓as₁
front-refl-✓ {Σ V F} [] ()
-- Back respects emptiness
back-resp-[] : ∀ {S T as} → (as ≡ []) → (back {S} {T} as ≡ [])
back-resp-[] {I} refl = refl
back-resp-[] {Σ V F} refl = refl
-- Back reflects completion for non-trivial T
back-refl-✓ : ∀ {S T} {isΣ : IsΣ T} (as : Trace (S & T)) → (back {S} as ✓) → (as ✓)
back-refl-✓ {I} as ✓as₂ = ✓as₂
back-refl-✓ {Σ V F} {Σ W G} (a ∷ as) ✓as₂ = a ∷ back-refl-✓ {♭ F a} as ✓as₂
back-refl-✓ {Σ V F} {I} {} as ✓as₂
back-refl-✓ {Σ V F} {Σ W G} [] ()
-- Back respects completion
back-resp-✓ : ∀ {S} {T} {as : Trace (S & T)} → (as ✓) → (back {S} as ✓)
back-resp-✓ {I} ✓as = ✓as
back-resp-✓ {Σ W F} (a ∷ ✓as) = back-resp-✓ {♭ F a} ✓as
-- Tensor plays nicely with concatenation when f reflects completion
⟦[&]⟧-++ : ∀ {S T U V} (f : Trace S → Trace T) (g : Trace U → Trace V) →
(∀ cs → (f cs ✓) → (cs ✓)) → ∀ as bs →
(f ⟦[&]⟧ g) (as ++ bs) ≡ (f as ++ g bs)
⟦[&]⟧-++ {S} {T} {U} {V} f g f-refl-✓ as bs =
begin
f (front {S} (as ++ bs)) ++ g (back {S} (as ++ bs))
≡⟨ cong₂ _++_ (cong f (++-β₁ as bs)) refl ⟩
f as ++ g (back {S} (as ++ bs))
≡⟨ ++-cong refl (λ ✓fas → cong g (++-β₂ (f-refl-✓ as ✓fas) bs)) ⟩
f as ++ g bs
∎
-- Tensor respects ≃
[&]-resp-≃ : ∀ {S T U V} {P₁ P₂ : S ⇒ T} {Q₁ Q₂ : U ⇒ V} →
(⟦ P₁ ⟧ ≃ ⟦ P₂ ⟧) → (⟦ Q₁ ⟧ ≃ ⟦ Q₂ ⟧) →
(⟦ P₁ [&] Q₁ ⟧ ≃ ⟦ P₂ [&] Q₂ ⟧)
[&]-resp-≃ {S} {T} {U} {V} {P₁} {P₂} {Q₁} {Q₂} P₁≃P₂ Q₁≃Q₂ as =
begin
⟦ P₁ [&] Q₁ ⟧ as
≡⟨ [&]-≃-⟦[&]⟧ P₁≃P₂ Q₁≃Q₂ as ⟩
(⟦ P₂ ⟧ ⟦[&]⟧ ⟦ Q₂ ⟧) as
≡⟨ sym ([&]-semantics P₂ Q₂ as) ⟩
⟦ P₂ [&] Q₂ ⟧ as
∎
-- Tensor respects identity
[&]-resp-done : ∀ S T → ⟦ done {S} [&] done {T} ⟧ ≃ ⟦ done {S & T} ⟧
[&]-resp-done S T as =
begin
⟦ done {S} [&] done {T} ⟧ as
≡⟨ [&]-semantics (done {S}) (done {T}) as ⟩
front {S} as ++ back {S} as
≡⟨ ++-η {S} as ⟩
as
∎
-- Tensor respects composition when g₁ reflects completion
⟦[&]⟧-resp-⟦⟫⟧ : ∀ {S₁ S₂ T₁ T₂ U₁ U₂} →
(f₁ : Trace S₁ → Trace T₁) → (g₁ : Trace T₁ → Trace U₁) →
(f₂ : Trace S₂ → Trace T₂) → (g₂ : Trace T₂ → Trace U₂) →
(∀ as → (g₁ as ✓) → (as ✓)) →
(((f₁ ⟦⟫⟧ g₁) ⟦[&]⟧ (f₂ ⟦⟫⟧ g₂)) ≃ (f₁ ⟦[&]⟧ f₂) ⟦⟫⟧ (g₁ ⟦[&]⟧ g₂))
⟦[&]⟧-resp-⟦⟫⟧ {S₁} f₁ g₁ f₂ g₂ g₁-refl-✓ as =
sym (⟦[&]⟧-++ g₁ g₂ g₁-refl-✓ (f₁ (front {S₁} as)) (f₂ (back {S₁} as)))
-- Tensor respects composition when f₁ respects completion and f₂ is strict
⟦[&]⟧-resp-⟦⟫⟧' : ∀ {S₁ S₂ T₁ T₂ U₁ U₂} →
(f₁ : Trace S₁ → Trace T₁) → (g₁ : Trace T₁ → Trace U₁) →
(f₂ : Trace S₂ → Trace T₂) → (g₂ : Trace T₂ → Trace U₂) →
(∀ as → as ✓ → f₁ as ✓) → (f₂ [] ≡ []) →
(((f₁ ⟦⟫⟧ g₁) ⟦[&]⟧ (f₂ ⟦⟫⟧ g₂)) ≃ (f₁ ⟦[&]⟧ f₂) ⟦⟫⟧ (g₁ ⟦[&]⟧ g₂))
⟦[&]⟧-resp-⟦⟫⟧' {S₁} {S₂} {T₁} {T₂} f₁ g₁ f₂ g₂ f₁-resp-✓ f₂[]≡[] as with ✓? (f₁ (front as))
⟦[&]⟧-resp-⟦⟫⟧' {S₁} {S₂} {T₁} {T₂} f₁ g₁ f₂ g₂ f₁-resp-✓ f₂[]≡[] as | yes ✓bs₁ =
cong₂ _++_ (cong g₁ (sym (++-β₁ _ _))) (cong g₂ (sym (++-β₂ ✓bs₁ _)))
⟦[&]⟧-resp-⟦⟫⟧' {S₁} {S₂} {T₁} {T₂} f₁ g₁ f₂ g₂ f₁-resp-✓ f₂[]≡[] as | no ¬✓bs₁ =
begin
g₁ (f₁ as₁) ++ g₂ (f₂ as₂)
≡⟨ cong (_++_ (g₁ (f₁ as₁))) (cong g₂ (cong f₂ (back≡[] ¬✓as₁))) ⟩
g₁ (f₁ as₁) ++ g₂ (f₂ [])
≡⟨ cong (_++_ (g₁ (f₁ as₁))) (cong g₂ f₂[]≡[]) ⟩
g₁ (f₁ as₁) ++ g₂ []
≡⟨ cong₂ _++_ (cong g₁ (sym (++-β₁ _ _))) (cong g₂ (sym (++-β₂-[] ¬✓bs₁ _))) ⟩
g₁ (front (f₁ as₁ ++ f₂ as₂)) ++ g₂ (back {T₁} (f₁ as₁ ++ f₂ as₂))
∎ where
as₁ = front {S₁} as
as₂ = back {S₁} as
¬✓as₁ : ¬ as₁ ✓
¬✓as₁ = λ as₁✓ → ¬✓bs₁ (f₁-resp-✓ as₁ as₁✓)
-- Tensor respects composition when Q₁ is reflective
[&]-resp-⟫ : ∀ {S₁ S₂ T₁ T₂ U₁ U₂}
(P₁ : S₁ ⇒ T₁) {Q₁ : T₁ ⇒ U₁} (⟳Q₁ : Reflective Q₁)
(P₂ : S₂ ⇒ T₂) (Q₂ : T₂ ⇒ U₂) →
⟦ (P₁ ⟫ Q₁) [&] (P₂ ⟫ Q₂) ⟧ ≃ ⟦ (P₁ [&] P₂) ⟫ (Q₁ [&] Q₂) ⟧
[&]-resp-⟫ P₁ {Q₁} ⟳Q₁ P₂ Q₂ as =
begin
⟦ (P₁ ⟫ Q₁) [&] (P₂ ⟫ Q₂) ⟧ as
≡⟨ [&]-≃-⟦[&]⟧ (⟫-semantics P₁ Q₁) (⟫-semantics P₂ Q₂) as ⟩
((⟦ P₁ ⟧ ⟦⟫⟧ ⟦ Q₁ ⟧) ⟦[&]⟧ (⟦ P₂ ⟧ ⟦⟫⟧ ⟦ Q₂ ⟧)) as
≡⟨ ⟦[&]⟧-resp-⟦⟫⟧ ⟦ P₁ ⟧ ⟦ Q₁ ⟧ ⟦ P₂ ⟧ ⟦ Q₂ ⟧ (⟦⟧-refl-✓ ⟳Q₁) as ⟩
((⟦ P₁ ⟧ ⟦[&]⟧ ⟦ P₂ ⟧) ⟦⟫⟧ (⟦ Q₁ ⟧ ⟦[&]⟧ ⟦ Q₂ ⟧)) as
≡⟨ sym (⟫-≃-⟦⟫⟧ ([&]-semantics P₁ P₂) ([&]-semantics Q₁ Q₂) as) ⟩
⟦ P₁ [&] P₂ ⟫ Q₁ [&] Q₂ ⟧ as
∎
-- Tensor respects composition when P₂ is strict
[&]-resp-⟫' : ∀ {S₁ S₂ T₁ T₂ U₁ U₂}
(P₁ : S₁ ⇒ T₁) (Q₁ : T₁ ⇒ U₁)
{P₂ : S₂ ⇒ T₂} (#P₂ : Strict P₂) (Q₂ : T₂ ⇒ U₂) →
⟦ (P₁ ⟫ Q₁) [&] (P₂ ⟫ Q₂) ⟧ ≃ ⟦ (P₁ [&] P₂) ⟫ (Q₁ [&] Q₂) ⟧
[&]-resp-⟫' P₁ Q₁ {P₂} #P₂ Q₂ as =
begin
⟦ (P₁ ⟫ Q₁) [&] (P₂ ⟫ Q₂) ⟧ as
≡⟨ [&]-≃-⟦[&]⟧ (⟫-semantics P₁ Q₁) (⟫-semantics P₂ Q₂) as ⟩
((⟦ P₁ ⟧ ⟦⟫⟧ ⟦ Q₁ ⟧) ⟦[&]⟧ (⟦ P₂ ⟧ ⟦⟫⟧ ⟦ Q₂ ⟧)) as
≡⟨ ⟦[&]⟧-resp-⟦⟫⟧' ⟦ P₁ ⟧ ⟦ Q₁ ⟧ ⟦ P₂ ⟧ ⟦ Q₂ ⟧ (⟦⟧-resp-✓ P₁) (⟦⟧-resp-[] #P₂) as ⟩
((⟦ P₁ ⟧ ⟦[&]⟧ ⟦ P₂ ⟧) ⟦⟫⟧ (⟦ Q₁ ⟧ ⟦[&]⟧ ⟦ Q₂ ⟧)) as
≡⟨ sym (⟫-≃-⟦⟫⟧ ([&]-semantics P₁ P₂) ([&]-semantics Q₁ Q₂) as) ⟩
⟦ P₁ [&] P₂ ⟫ Q₁ [&] Q₂ ⟧ as
∎
-- Units and associator are equivalences
unit₁-isEquiv : ∀ {S} → IsEquiv (unit₁ {S})
unit₁-isEquiv = isEquiv ∼-unit₁ ≃-refl
unit₂-isEquiv : ∀ {S} → IsEquiv (unit₂ {S})
unit₂-isEquiv {S} = isEquiv (∼-unit₂ {S}) ≃-refl
assoc-isEquiv : ∀ {S T U} → IsEquiv (assoc {S} {T} {U})
assoc-isEquiv {S} {T} = isEquiv (∼-assoc {S} {T}) ≃-refl
unit₁⁻¹-isEquiv : ∀ {S} → IsEquiv (unit₁⁻¹ {S})
unit₁⁻¹-isEquiv = isEquiv (∼-sym ∼-unit₁) ≃-refl
unit₂⁻¹-isEquiv : ∀ {S} → IsEquiv (unit₂⁻¹ {S})
unit₂⁻¹-isEquiv = isEquiv (∼-sym ∼-unit₂) ≃-refl
assoc⁻¹-isEquiv : ∀ {S T U} → IsEquiv (assoc⁻¹ {S} {T} {U})
assoc⁻¹-isEquiv {S} = isEquiv (∼-sym (∼-assoc {S})) ≃-refl
-- Equivalence respects &
&-resp-∼ : ∀ {S T U V} → (S ∼ T) → (U ∼ V) → ((S & U) ∼ (T & V))
&-resp-∼ I U∼V = U∼V
&-resp-∼ (Σ V F) U∼V = Σ V (♯ λ a → &-resp-∼ (♭ F a) U∼V)
equiv-resp-⟦[&]⟧ : ∀ {S T U V} (S∼T : S ∼ T) (U∼V : U ∼ V) →
⟦ equiv S∼T ⟧ ⟦[&]⟧ ⟦ equiv U∼V ⟧ ≃ ⟦ equiv (&-resp-∼ S∼T U∼V) ⟧
equiv-resp-⟦[&]⟧ I U∼V as = refl
equiv-resp-⟦[&]⟧ (Σ V F) U∼V [] = refl
equiv-resp-⟦[&]⟧ (Σ V F) U∼V (a ∷ as) = cong (_∷_ a) (equiv-resp-⟦[&]⟧ (♭ F a) U∼V as)
equiv-resp-[&] : ∀ {S T U V} (S∼T : S ∼ T) (U∼V : U ∼ V) →
⟦ equiv S∼T [&] equiv U∼V ⟧ ≃ ⟦ equiv (&-resp-∼ S∼T U∼V) ⟧
equiv-resp-[&] S∼T U∼V as =
begin
⟦ equiv S∼T [&] equiv U∼V ⟧ as
≡⟨ [&]-semantics (equiv S∼T) (equiv U∼V) as ⟩
(⟦ equiv S∼T ⟧ ⟦[&]⟧ ⟦ equiv U∼V ⟧) as
≡⟨ equiv-resp-⟦[&]⟧ S∼T U∼V as ⟩
⟦ equiv (&-resp-∼ S∼T U∼V) ⟧ as
∎
[&]-isEquiv : ∀ {S T U V} {P : S ⇒ T} {Q : U ⇒ V} →
(IsEquiv P) → (IsEquiv Q) → (IsEquiv (P [&] Q))
[&]-isEquiv {S} {T} {U} {V} {P} {Q} (isEquiv S∼T P≃S∼T) (isEquiv U∼V Q≃U∼V) =
isEquiv (&-resp-∼ S∼T U∼V) λ as →
begin
⟦ P [&] Q ⟧ as
≡⟨ [&]-resp-≃ P≃S∼T Q≃U∼V as ⟩
⟦ equiv S∼T [&] equiv U∼V ⟧ as
≡⟨ equiv-resp-[&] S∼T U∼V as ⟩
⟦ equiv (&-resp-∼ S∼T U∼V) ⟧ as
∎
-- Isomorphisms
unit₁-iso : ∀ {S} → ⟦ unit₁ {S} ⟫ unit₁⁻¹ {S} ⟧ ≃ ⟦ done ⟧
unit₁-iso = equiv-is-iso unit₁-isEquiv unit₁⁻¹-isEquiv
unit₁⁻¹-iso : ∀ {S} → ⟦ unit₁⁻¹ {S} ⟫ unit₁ {S} ⟧ ≃ ⟦ done ⟧
unit₁⁻¹-iso = equiv-is-iso unit₁⁻¹-isEquiv unit₁-isEquiv
unit₂-iso : ∀ {S} → ⟦ unit₂ {S} ⟫ unit₂⁻¹ {S} ⟧ ≃ ⟦ done ⟧
unit₂-iso {S} = equiv-is-iso (unit₂-isEquiv {S}) unit₂⁻¹-isEquiv
unit₂⁻¹-iso : ∀ {S} → ⟦ unit₂⁻¹ {S} ⟫ unit₂ {S} ⟧ ≃ ⟦ done ⟧
unit₂⁻¹-iso {S} = equiv-is-iso unit₂⁻¹-isEquiv (unit₂-isEquiv {S})
assoc-iso : ∀ {S T U} → ⟦ assoc {S} {T} {U} ⟫ assoc⁻¹ {S} {T} {U} ⟧ ≃ ⟦ done ⟧
assoc-iso {S} {T} = equiv-is-iso (assoc-isEquiv {S} {T}) (assoc⁻¹-isEquiv {S} {T})
assoc⁻¹-iso : ∀ {S T U} → ⟦ assoc⁻¹ {S} {T} {U} ⟫ assoc {S} {T} {U} ⟧ ≃ ⟦ done ⟧
assoc⁻¹-iso {S} {T} = equiv-is-iso (assoc⁻¹-isEquiv {S} {T}) (assoc-isEquiv {S} {T})
-- Coherence conditions
assoc-unit : ∀ {S T} →
⟦ done {S} [&] unit₁ {T} ⟧ ≃ ⟦ assoc {S} {I} {T} ⟫ unit₂ {S} [&] done {T} ⟧
assoc-unit {S} {T} =
≃-equiv ([&]-isEquiv (done-isEquiv {S}) (unit₁-isEquiv {T}))
(⟫-isEquiv (assoc-isEquiv {S} {I} {T}) ([&]-isEquiv (unit₂-isEquiv {S}) (done-isEquiv {T})))
assoc-assoc : ∀ {S T U V} →
⟦ done {S} [&] assoc {T} {U} {V} ⟫
assoc {S} {T & U} {V} ⟫
assoc {S} {T} {U} [&] done {V} ⟧ ≃
⟦ assoc {S} {T} {U & V} ⟫ assoc {S & T} {U} {V} ⟧
assoc-assoc {S} {T} {U} {V} =
≃-equiv
(⟫-isEquiv ([&]-isEquiv (done-isEquiv {S}) (assoc-isEquiv {T} {U} {V}))
(⟫-isEquiv (assoc-isEquiv {S} {T & U} {V})
([&]-isEquiv (assoc-isEquiv {S} {T} {U}) done-isEquiv)))
(⟫-isEquiv (assoc-isEquiv {S} {T} {U & V}) (assoc-isEquiv {S & T} {U} {V}))
-- Concatenation plays nicely with associativity
⟦assoc⟧-++ : ∀ {S T U} → (as : Trace S) (bs : Trace T) (cs : Trace U) →
⟦assoc⟧ {S} (as ++ (bs ++ cs)) ≡ ((as ++ bs) ++ cs)
⟦assoc⟧-++ {I} {I} [] bs cs = refl
⟦assoc⟧-++ {I} {Σ W G} [] [] cs = refl
⟦assoc⟧-++ {I} {Σ W G} [] (b ∷ bs) cs = cong (_∷_ b) (⟦assoc⟧-++ {I} [] bs cs)
⟦assoc⟧-++ {Σ W F} [] bs cs = refl
⟦assoc⟧-++ {Σ W F} (a ∷ as) bs cs = cong (_∷_ a) (⟦assoc⟧-++ as bs cs)
⟦assoc⟧-++ {I} (() ∷ as) bs cs
⟦assoc⁻¹⟧-++ : ∀ {S T U} → (as : Trace S) (bs : Trace T) (cs : Trace U) →
⟦assoc⁻¹⟧ {S} ((as ++ bs) ++ cs) ≡ (as ++ (bs ++ cs))
⟦assoc⁻¹⟧-++ {I} {I} [] bs cs = refl
⟦assoc⁻¹⟧-++ {I} {Σ W G} [] [] cs = refl
⟦assoc⁻¹⟧-++ {I} {Σ W G} [] (b ∷ bs) cs = cong (_∷_ b) (⟦assoc⁻¹⟧-++ {I} [] bs cs)
⟦assoc⁻¹⟧-++ {Σ W F} [] bs cs = refl
⟦assoc⁻¹⟧-++ {Σ W F} (a ∷ as) bs cs = cong (_∷_ a) (⟦assoc⁻¹⟧-++ as bs cs)
⟦assoc⁻¹⟧-++ {I} (() ∷ as) bs cs
-- Front and back play well with associativity
front-⟦assoc⟧ : ∀ {S T U} (as : Trace (S & (T & U))) →
(front {S} as ≡ front {S} (front {S & T} (⟦assoc⟧ {S} as)))
front-⟦assoc⟧ {I} as = refl
front-⟦assoc⟧ {Σ V F} [] = refl
front-⟦assoc⟧ {Σ V F} (a ∷ as) = cong (_∷_ a) (front-⟦assoc⟧ as)
mid-⟦assoc⟧ : ∀ {S T U} (as : Trace (S & (T & U))) →
(front {T} (back {S} as) ≡ back {S} (front {S & T} (⟦assoc⟧ {S} as)))
mid-⟦assoc⟧ {I} {T} as = cong (front {T}) (sym (++-η {T} as))
mid-⟦assoc⟧ {Σ V F} {I} [] = refl
mid-⟦assoc⟧ {Σ V F} {Σ W G} [] = refl
mid-⟦assoc⟧ {Σ V F} (a ∷ as) = mid-⟦assoc⟧ {♭ F a} as
back-⟦assoc⟧ : ∀ {S T U} (as : Trace (S & (T & U))) →
(back {T} (back {S} as) ≡ back {S & T} (⟦assoc⟧ {S} as))
back-⟦assoc⟧ {I} {T} as = cong (back {T}) (sym (++-η {T} as))
back-⟦assoc⟧ {Σ V F} {I} [] = refl
back-⟦assoc⟧ {Σ V F} {Σ W G} [] = refl
back-⟦assoc⟧ {Σ V F} (a ∷ as) = back-⟦assoc⟧ {♭ F a} as
-- Units are natural
⟦unit₁⟧-natural : ∀ {S T} (f : Trace S → Trace T) →
(⟦done⟧ {I} ⟦[&]⟧ f) ⟦⟫⟧ ⟦unit₁⟧ ≃ ⟦unit₁⟧ ⟦⟫⟧ f
⟦unit₁⟧-natural f [] = refl
⟦unit₁⟧-natural f (a ∷ as) = refl
unit₁-natural : ∀ {S T} (P : S ⇒ T) →
⟦ done {I} [&] P ⟫ unit₁ ⟧ ≃ ⟦ unit₁ ⟫ P ⟧
unit₁-natural P as =
begin
⟦ done {I} [&] P ⟫ unit₁ ⟧ as
≡⟨ ⟫-≃-⟦⟫⟧ ([&]-semantics (done {I}) P) unit₁-semantics as ⟩
(⟦done⟧ {I} ⟦[&]⟧ ⟦ P ⟧ ⟦⟫⟧ ⟦unit₁⟧) as
≡⟨ ⟦unit₁⟧-natural ⟦ P ⟧ as ⟩
(⟦unit₁⟧ ⟦⟫⟧ ⟦ P ⟧) as
≡⟨ sym (⟫-≃-⟦⟫⟧ unit₁-semantics ≃-refl as) ⟩
⟦ unit₁ ⟫ P ⟧ as
∎
⟦unit₂⟧-natural : ∀ {S T} (f : Trace S → Trace T) →
(f ⟦[&]⟧ ⟦done⟧ {I}) ⟦⟫⟧ ⟦unit₂⟧ ≃ ⟦unit₂⟧ ⟦⟫⟧ f
⟦unit₂⟧-natural {S} {T} f as =
++-β₁ (f (front {S} as)) (back {S} as)
unit₂-natural : ∀ {S T} (P : S ⇒ T) →
⟦ P [&] done {I} ⟫ unit₂ ⟧ ≃ ⟦ unit₂ ⟫ P ⟧
unit₂-natural {S} {T} P as =
begin
⟦ P [&] done {I} ⟫ unit₂ ⟧ as
≡⟨ ⟫-≃-⟦⟫⟧ ([&]-semantics P (done {I})) (unit₂-semantics {T}) as ⟩
(⟦ P ⟧ ⟦[&]⟧ ⟦done⟧ {I} ⟦⟫⟧ ⟦unit₂⟧) as
≡⟨ ⟦unit₂⟧-natural ⟦ P ⟧ as ⟩
(⟦unit₂⟧ ⟦⟫⟧ ⟦ P ⟧) as
≡⟨ sym (⟫-≃-⟦⟫⟧ (unit₂-semantics {S}) ≃-refl as) ⟩
⟦ unit₂ ⟫ P ⟧ as
∎
-- Associativity is natural
⟦assoc⟧-natural : ∀ {S S' T T' U U'}
(f : Trace S → Trace S') (g : Trace T → Trace T') (h : Trace U → Trace U') →
((f ⟦[&]⟧ (g ⟦[&]⟧ h)) ⟦⟫⟧ ⟦assoc⟧ {S'} {T'} {U'}) ≃
(⟦assoc⟧ {S} {T} {U} ⟦⟫⟧ ((f ⟦[&]⟧ g) ⟦[&]⟧ h))
⟦assoc⟧-natural {S} {S'} {T} {T'} {U} {U'} f g h as =
begin
⟦assoc⟧ {S'} (f as₁ ++ g as₂ ++ h as₃)
≡⟨ ⟦assoc⟧-++ (f as₁) (g as₂) (h as₃) ⟩
(f as₁ ++ g as₂) ++ h as₃
≡⟨ cong₂ _++_ (cong₂ _++_ (cong f (front-⟦assoc⟧ as))
(cong g (mid-⟦assoc⟧ {S} as))) (cong h (back-⟦assoc⟧ {S} as)) ⟩
((f ⟦[&]⟧ g) ⟦[&]⟧ h) ((as₁ ++ as₂) ++ as₃)
∎ where
as₁ = front {S} as
as₂ = front {T} (back {S} as)
as₃ = back {T} (back {S} as)
assoc-natural : ∀ {S S' T T' U U'} (P : S ⇒ S') (Q : T ⇒ T') (R : U ⇒ U') →
⟦ P [&] (Q [&] R) ⟫ assoc {S'} {T'} {U'} ⟧ ≃
⟦ assoc {S} {T} {U} ⟫ (P [&] Q) [&] R ⟧
assoc-natural {S} {S'} {T} {T'} {U} {U'} P Q R as =
begin
⟦ P [&] (Q [&] R) ⟫ assoc {S'} {T'} {U'} ⟧ as
≡⟨ ⟫-≃-⟦⟫⟧ ([&]-≃-⟦[&]⟧ {P = P} ≃-refl ([&]-semantics Q R)) (assoc-semantics {S'} {T'} {U'}) as ⟩
((⟦ P ⟧ ⟦[&]⟧ (⟦ Q ⟧ ⟦[&]⟧ ⟦ R ⟧)) ⟦⟫⟧ ⟦assoc⟧ {S'} {T'} {U'}) as
≡⟨ ⟦assoc⟧-natural ⟦ P ⟧ ⟦ Q ⟧ ⟦ R ⟧ as ⟩
(⟦assoc⟧ {S} {T} {U} ⟦⟫⟧ ((⟦ P ⟧ ⟦[&]⟧ ⟦ Q ⟧) ⟦[&]⟧ ⟦ R ⟧)) as
≡⟨ sym (⟫-≃-⟦⟫⟧ (assoc-semantics {S} {T} {U}) ([&]-≃-⟦[&]⟧ ([&]-semantics P Q) ≃-refl) as) ⟩
⟦ assoc {S} {T} {U} ⟫ (P [&] Q) [&] R ⟧ as
∎
|
{
"alphanum_fraction": 0.4445519729,
"avg_line_length": 39.5356521739,
"ext": "agda",
"hexsha": "eb831d291e99571663a86fd5d3376878ecedfbd4",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:40:23.000Z",
"max_forks_repo_forks_event_min_datetime": "2017-08-10T06:12:54.000Z",
"max_forks_repo_head_hexsha": "d06c219c7b7afc85aae3b1d4d66951b889aa7371",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "ilya-fiveisky/agda-system-io",
"max_forks_repo_path": "src/System/IO/Transducers/Properties/Monoidal.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "d06c219c7b7afc85aae3b1d4d66951b889aa7371",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "ilya-fiveisky/agda-system-io",
"max_issues_repo_path": "src/System/IO/Transducers/Properties/Monoidal.agda",
"max_line_length": 120,
"max_stars_count": 10,
"max_stars_repo_head_hexsha": "d06c219c7b7afc85aae3b1d4d66951b889aa7371",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "ilya-fiveisky/agda-system-io",
"max_stars_repo_path": "src/System/IO/Transducers/Properties/Monoidal.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-15T04:35:41.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-04T13:45:16.000Z",
"num_tokens": 12011,
"size": 22733
}
|
open import Proc
module Silence (param : Param) where
open import Basics
import Interp
import Hear
open Process param
open Interp param
open Hear param
NoSpeak : {a : U} -> Proc a -> Set
NoSpeak {a} p = (w : LT a)(q : Proc a) -> ¬ (p -! w !-> q)
silent-nospeak : {a : U}{p : Proc a} -> Silent p -> NoSpeak p
silent-nospeak silent-o w q ()
silent-nospeak silent-> w q ()
silent-nospeak (silent-|| s1 s2) w ._ (tx-!| h _) = silent-nospeak s1 _ _ h
silent-nospeak (silent-|| s1 s2) w ._ (tx-|! _ h) = silent-nospeak s2 _ _ h
silent-nospeak (silent-def s) w q (tx-def h) = silent-nospeak s _ _ h
silent-nospeak (silent-/| s) ._ ._ (tx-/| h) = silent-nospeak s _ _ h
nospeak-silent : {a : U}{p : Proc a} -> Guard p -> NoSpeak p -> Silent p
nospeak-silent og s = silent-o
nospeak-silent (>g f) s = silent->
nospeak-silent (w !g p) s = kill (s _ _ tx-!)
nospeak-silent (w ! p +g f) s = kill (s _ _ tx-+)
nospeak-silent (g1 ||g g2) s =
silent-|| (nospeak-silent g1 (inv1 g2 s))
(nospeak-silent g2 (inv2 g1 s))
where
module Inv {a : U}{p1 p2 : Proc a} where
inv1 : Guard p2 -> NoSpeak (p1 || p2) -> NoSpeak p1
inv1 g2 h w p t = h _ _ (tx-!| t (sound g2))
inv2 : Guard p1 -> NoSpeak (p1 || p2) -> NoSpeak p2
inv2 g1 h w p t = h _ _ (tx-|! (sound g1) t)
open Inv
nospeak-silent (φ /|g g) s = silent-/| (nospeak-silent g (inv s))
where
inv : forall {p} -> NoSpeak (φ /| p) -> NoSpeak p
inv h w p t = h _ _ (tx-/| t)
nospeak-silent (defg x g) s = silent-def (nospeak-silent g (inv s))
where
inv : NoSpeak (def x) -> NoSpeak (env _ x)
inv h w p t = h _ _ (tx-def t)
|
{
"alphanum_fraction": 0.5667060213,
"avg_line_length": 34.5714285714,
"ext": "agda",
"hexsha": "ee8a8559debc022d8945185622168e70025fab30",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "examples/outdated-and-incorrect/cbs/Silence.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "examples/outdated-and-incorrect/cbs/Silence.agda",
"max_line_length": 76,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "examples/outdated-and-incorrect/cbs/Silence.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 646,
"size": 1694
}
|
{-# OPTIONS --without-K #-}
open import HoTT.Base
open import HoTT.Equivalence
module HoTT.Equivalence.Transport where
open variables
transport-equiv : {x y : A} → x == y → P x ≃ P y
transport-equiv {A = A} {P = P} p = f , qinv→isequiv (g , η p , ε p)
where
f = transport P p
g = transport P (p ⁻¹)
variable x y : A
η : (p : x == y) → transport P (p ⁻¹) ∘ transport P p ~ id
η refl _ = refl
ε : (p : x == y) → transport P p ∘ transport P (p ⁻¹) ~ id
ε refl _ = refl
|
{
"alphanum_fraction": 0.5855670103,
"avg_line_length": 25.5263157895,
"ext": "agda",
"hexsha": "7c3d5322f30dbf8cd7bf09a3dfb973cec3c1765a",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508",
"max_forks_repo_licenses": [
"0BSD"
],
"max_forks_repo_name": "michaelforney/hott",
"max_forks_repo_path": "HoTT/Equivalence/Transport.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"0BSD"
],
"max_issues_repo_name": "michaelforney/hott",
"max_issues_repo_path": "HoTT/Equivalence/Transport.agda",
"max_line_length": 68,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508",
"max_stars_repo_licenses": [
"0BSD"
],
"max_stars_repo_name": "michaelforney/hott",
"max_stars_repo_path": "HoTT/Equivalence/Transport.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 182,
"size": 485
}
|
module Data where
import Lvl
open import Type
-- An empty type which cannot be constructed.
-- By default, this should be used to represent _the_ empty type.
data Empty {ℓ} : Type{ℓ} where
{-# FOREIGN GHC data Empty ℓ #-}
{-# COMPILE GHC Empty = data Empty () #-}
-- Empty functions.
-- The empty type eliminator.
-- Any type can be constructed from the empty type.
empty : ∀{ℓ₁ ℓ₂}{T : Type{ℓ₁}} → Empty{ℓ₂} → T
empty ()
{-# COMPILE GHC empty = \_ _ _ e -> case e of{} #-}
-- An unit type which can only be constructed in one way.
-- By default, this should be used to represent _the_ unit type.
record Unit {ℓ} : Type{ℓ} where
instance constructor <>
open Unit public
{-# BUILTIN UNIT Unit #-}
{-# FOREIGN GHC type Unit ℓ = () #-}
{-# COMPILE GHC Unit = data Unit (()) #-}
|
{
"alphanum_fraction": 0.6594663278,
"avg_line_length": 28.1071428571,
"ext": "agda",
"hexsha": "214383e4dc3e8ebaab0603f364448129eda726ae",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Lolirofle/stuff-in-agda",
"max_forks_repo_path": "Data.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "Data.agda",
"max_line_length": 65,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Lolirofle/stuff-in-agda",
"max_stars_repo_path": "Data.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-05T06:53:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:58:13.000Z",
"num_tokens": 218,
"size": 787
}
|
{-# OPTIONS --cubical --safe #-}
module Data.Maybe.Base where
open import Level
data Maybe (A : Type a) : Type a where
nothing : Maybe A
just : A → Maybe A
maybe : {B : Maybe A → Type b} → B nothing → ((x : A) → B (just x)) → (x : Maybe A) → B x
maybe b f nothing = b
maybe b f (just x) = f x
|
{
"alphanum_fraction": 0.5880398671,
"avg_line_length": 21.5,
"ext": "agda",
"hexsha": "6fc33d91c2220c3b4fdb3968c7a258f5f5b429a7",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "3c176d4690566d81611080e9378f5a178b39b851",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "oisdk/combinatorics-paper",
"max_forks_repo_path": "agda/Data/Maybe/Base.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "3c176d4690566d81611080e9378f5a178b39b851",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "oisdk/combinatorics-paper",
"max_issues_repo_path": "agda/Data/Maybe/Base.agda",
"max_line_length": 89,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "3c176d4690566d81611080e9378f5a178b39b851",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "oisdk/combinatorics-paper",
"max_stars_repo_path": "agda/Data/Maybe/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 101,
"size": 301
}
|
{-# OPTIONS --without-K --exact-split --safe #-}
open import Fragment.Algebra.Signature
module Fragment.Algebra.Homomorphism.Definitions (Σ : Signature) where
open import Fragment.Algebra.Algebra Σ
open import Level using (Level; _⊔_)
open import Relation.Binary using (Setoid)
open import Data.Vec using (Vec; map)
open import Function using (Congruent) public
private
variable
a b ℓ₁ ℓ₂ : Level
Homomorphic : (S : Algebra {a} {ℓ₁}) (T : Algebra {b} {ℓ₂})
→ (∥ S ∥ → ∥ T ∥) → Set (a ⊔ ℓ₂)
Homomorphic S T h = ∀ {arity} → (f : ops Σ arity)
→ (xs : Vec ∥ S ∥ arity)
→ T ⟦ f ⟧ (map h xs) =[ T ] h (S ⟦ f ⟧ xs)
|
{
"alphanum_fraction": 0.5985185185,
"avg_line_length": 28.125,
"ext": "agda",
"hexsha": "997d7cfac7c8f6d48d17b92c199264e01357e9c6",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2021-06-16T08:04:31.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-06-15T15:34:50.000Z",
"max_forks_repo_head_hexsha": "f2a6b1cf4bc95214bd075a155012f84c593b9496",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "yallop/agda-fragment",
"max_forks_repo_path": "src/Fragment/Algebra/Homomorphism/Definitions.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "f2a6b1cf4bc95214bd075a155012f84c593b9496",
"max_issues_repo_issues_event_max_datetime": "2021-06-16T10:24:15.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-06-16T09:44:31.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "yallop/agda-fragment",
"max_issues_repo_path": "src/Fragment/Algebra/Homomorphism/Definitions.agda",
"max_line_length": 70,
"max_stars_count": 18,
"max_stars_repo_head_hexsha": "f2a6b1cf4bc95214bd075a155012f84c593b9496",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "yallop/agda-fragment",
"max_stars_repo_path": "src/Fragment/Algebra/Homomorphism/Definitions.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-17T17:26:09.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-06-15T15:45:39.000Z",
"num_tokens": 217,
"size": 675
}
|
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Helper where
open import Level
open import Relation.Binary using (Rel; IsEquivalence)
open import Categories.Category.Core using (Category)
-- Since we add extra proofs in the definition of `Category` (i.e. `sym-assoc` and
-- `identity²`), we might still want to construct a `Category` in its originally
-- easier manner. Thus, this redundant definition is here to ease the construction.
record CategoryHelper (o ℓ e : Level) : Set (suc (o ⊔ ℓ ⊔ e)) where
infix 4 _≈_ _⇒_
infixr 9 _∘_
field
Obj : Set o
_⇒_ : Rel Obj ℓ
_≈_ : ∀ {A B} → Rel (A ⇒ B) e
id : ∀ {A} → (A ⇒ A)
_∘_ : ∀ {A B C} → (B ⇒ C) → (A ⇒ B) → (A ⇒ C)
field
assoc : ∀ {A B C D} {f : A ⇒ B} {g : B ⇒ C} {h : C ⇒ D} → (h ∘ g) ∘ f ≈ h ∘ (g ∘ f)
identityˡ : ∀ {A B} {f : A ⇒ B} → id ∘ f ≈ f
identityʳ : ∀ {A B} {f : A ⇒ B} → f ∘ id ≈ f
equiv : ∀ {A B} → IsEquivalence (_≈_ {A} {B})
∘-resp-≈ : ∀ {A B C} {f h : B ⇒ C} {g i : A ⇒ B} → f ≈ h → g ≈ i → f ∘ g ≈ h ∘ i
categoryHelper : ∀ {o ℓ e} → CategoryHelper o ℓ e → Category o ℓ e
categoryHelper C = record
{ Obj = Obj
; _⇒_ = _⇒_
; _≈_ = _≈_
; id = id
; _∘_ = _∘_
; assoc = assoc
; sym-assoc = sym assoc
; identityˡ = identityˡ
; identityʳ = identityʳ
; identity² = identityˡ
; equiv = equiv
; ∘-resp-≈ = ∘-resp-≈
}
where open CategoryHelper C
module _ {A B} where
open IsEquivalence (equiv {A} {B}) public
|
{
"alphanum_fraction": 0.5342913129,
"avg_line_length": 31.2448979592,
"ext": "agda",
"hexsha": "4cef9e39f6ce2c5af0f90b394ee96b3a14c3478d",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "5a49c6ac87cbb7e20511c28f28205163fe69f48f",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "laMudri/agda-categories",
"max_forks_repo_path": "src/Categories/Category/Helper.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "5a49c6ac87cbb7e20511c28f28205163fe69f48f",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "laMudri/agda-categories",
"max_issues_repo_path": "src/Categories/Category/Helper.agda",
"max_line_length": 91,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "5a49c6ac87cbb7e20511c28f28205163fe69f48f",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "laMudri/agda-categories",
"max_stars_repo_path": "src/Categories/Category/Helper.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 606,
"size": 1531
}
|
{-# OPTIONS --warning=error #-}
module Issue329 where
mutual
infixl 0 D Undeclared
data D : Set where
|
{
"alphanum_fraction": 0.7009345794,
"avg_line_length": 15.2857142857,
"ext": "agda",
"hexsha": "48948c488f609473fc936dccf0b90db95a75f7fb",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Fail/Issue329.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Fail/Issue329.agda",
"max_line_length": 31,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Fail/Issue329.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 32,
"size": 107
}
|
module PLRTree {A : Set} where
open import BTree {A} hiding (flatten)
open import Data.List
data Tag : Set where
perfect : Tag
left : Tag
right : Tag
data PLRTree : Set where
leaf : PLRTree
node : Tag → A → PLRTree → PLRTree → PLRTree
forget : PLRTree → BTree
forget leaf = leaf
forget (node _ x l r) = node x (forget l) (forget r)
flatten : PLRTree → List A
flatten leaf = []
flatten (node _ x l r) = x ∷ flatten l ++ flatten r
|
{
"alphanum_fraction": 0.6629213483,
"avg_line_length": 20.2272727273,
"ext": "agda",
"hexsha": "118b59ab75a76a9603de5488e9d76cf8663093a9",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "bgbianchi/sorting",
"max_forks_repo_path": "agda/PLRTree.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "bgbianchi/sorting",
"max_issues_repo_path": "agda/PLRTree.agda",
"max_line_length": 52,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "bgbianchi/sorting",
"max_stars_repo_path": "agda/PLRTree.agda",
"max_stars_repo_stars_event_max_datetime": "2021-08-24T22:11:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-05-21T12:50:35.000Z",
"num_tokens": 146,
"size": 445
}
|
open import Data.Product using ( _×_ )
open import Web.Semantic.DL.Signature using ( Signature ; CN ; RN )
module Web.Semantic.DL.FOL where
-- A fragment of first order logic with no existentials or disjunctions.
infixr 4 _∧_
data Formula (Σ : Signature) (Δ : Set) : Set where
true : Formula Σ Δ
false : Formula Σ Δ
_∧_ : Formula Σ Δ → Formula Σ Δ → Formula Σ Δ
_∈₁_ : Δ → CN Σ → Formula Σ Δ
_∈₁_⇒_ : Δ → CN Σ → Formula Σ Δ → Formula Σ Δ
_∈₂_ : (Δ × Δ) → RN Σ → Formula Σ Δ
_∈₂_⇒_ : (Δ × Δ) → RN Σ → Formula Σ Δ → Formula Σ Δ
_∼_ : Δ → Δ → Formula Σ Δ
_∼_⇒_ : Δ → Δ → Formula Σ Δ → Formula Σ Δ
∀₁ : (Δ → Formula Σ Δ) → Formula Σ Δ
|
{
"alphanum_fraction": 0.6152671756,
"avg_line_length": 31.1904761905,
"ext": "agda",
"hexsha": "6cda59c91985174c6ee0bcb736196ae33bb1e915",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:40:03.000Z",
"max_forks_repo_forks_event_min_datetime": "2017-12-03T14:52:09.000Z",
"max_forks_repo_head_hexsha": "8ddbe83965a616bff6fc7a237191fa261fa78bab",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "agda/agda-web-semantic",
"max_forks_repo_path": "src/Web/Semantic/DL/FOL.agda",
"max_issues_count": 4,
"max_issues_repo_head_hexsha": "8ddbe83965a616bff6fc7a237191fa261fa78bab",
"max_issues_repo_issues_event_max_datetime": "2021-01-04T20:57:19.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-11-14T02:32:28.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "agda/agda-web-semantic",
"max_issues_repo_path": "src/Web/Semantic/DL/FOL.agda",
"max_line_length": 72,
"max_stars_count": 9,
"max_stars_repo_head_hexsha": "8ddbe83965a616bff6fc7a237191fa261fa78bab",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "agda/agda-web-semantic",
"max_stars_repo_path": "src/Web/Semantic/DL/FOL.agda",
"max_stars_repo_stars_event_max_datetime": "2020-03-14T14:21:08.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-13T17:46:41.000Z",
"num_tokens": 277,
"size": 655
}
|
-- Andreas, 2015-07-16
-- For printing lambda-bound names, name _ should behave as no name.
-- {-# OPTIONS -v tc.term.lambda:60 #-}
module _ where
Test = (A : Set) {A : Set} → A → A
works : Test
works = λ C x → {!!}
-- the goal should be displayed as ?0 : .A
g : Test
g = λ C {_} x → {!!}
-- the goal should be displayed as ?1 : .A
-- not ?1 : _ or ?1 : A
h : Test
h = λ C {_} → λ x → {!!}
-- the goal should be displayed as ?1 : .A
-- not ?1 : _ or ?1 : A
|
{
"alphanum_fraction": 0.5472103004,
"avg_line_length": 17.9230769231,
"ext": "agda",
"hexsha": "2617883f9a8cc5f499c19a23660624ab1ce82629",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/interaction/Issue630a.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/interaction/Issue630a.agda",
"max_line_length": 68,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/interaction/Issue630a.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 164,
"size": 466
}
|
-- Andreas, 2018-09-12, issue #3167-2: --(no-)prop option
--
-- A local --prop option should override a global --no-prop flag.
-- Issue3167prop.flags has --no-prop.
{-# OPTIONS --prop #-}
-- The following depends on Prop enabled
data _≡_ {a} {A : Prop a} (x : A) : A → Prop a where
refl : x ≡ x
data P : Prop where
a b : P
test : (x y : P) → x ≡ y
test x y = refl
|
{
"alphanum_fraction": 0.5951742627,
"avg_line_length": 20.7222222222,
"ext": "agda",
"hexsha": "5936c9983e2e992a50da077df72aef4d04d1ff1b",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Succeed/Issue3167prop.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Succeed/Issue3167prop.agda",
"max_line_length": 65,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Succeed/Issue3167prop.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 131,
"size": 373
}
|
module BTA10 where
----------------------------------------
--equivalence between two typing systems
----------------------------------------
------------
--system one
------------
-- module annotated-type-one where
-- open import Data.Bool
-- open import Data.List
-- open import Data.Nat
-- infix 4 _∈_
-- data _∈_ {A : Set} : A → List A → Set where
-- hd : ∀ {x xs} → x ∈ (x ∷ xs)
-- tl : ∀ {x y xs} → x ∈ xs → x ∈ (y ∷ xs)
-- data BT : Set where
-- S : BT
-- D : BT
-- data _⊑_ : BT → BT → Set where
-- bt-refl : ∀ {bt} → bt ⊑ bt
-- bt-≤-dyn : ∀ {bt} → bt ⊑ D
-- data atype : BT → Set where
-- AInt : (bt : BT) → atype bt
-- AFun : (bt : BT) → ∀ {bt₁ bt₂} → atype bt₁ → atype bt₂ → bt ⊑ bt₁ → bt ⊑ bt₂ → atype bt
-- ⊎ : (bt : BT) → ∀ {bt₁ bt₂} → atype bt₁ → atype bt₂ → bt ⊑ bt₁ → bt ⊑ bt₂ → atype bt
-- • : (bt : BT) → ∀ {bt₁ bt₂} → atype bt₁ → atype bt₂ → bt ⊑ bt₁ → bt ⊑ bt₂ → atype bt
-- -- btof : ∀ {bt : BT} → atype bt → BT
-- -- btof (AInt bt) = bt
-- -- btof (AFun bt ty ty₁ x x₁) = bt
-- -- btof (⊎ bt ty ty₁ x x₁) = bt
-- -- btof (• bt ty ty₁ x x₁) = bt
-- ----------------
-- --typing context
-- ----------------
-- ----------------------
-- --auxiliary definition
-- ----------------------
-- record Sg (S : Set) (T : S → Set) : Set where
-- constructor _,_
-- field
-- ffst : S
-- ssnd : T ffst
-- open Sg public
-- _of_ : (BT : Set) → (BT → Set) → Set
-- BT of atype = Sg BT \ x → atype x
-- AType : Set
-- AType = BT of atype
-- ---------
-- --context
-- ---------
-- ACtx = List AType
-- ---------
-- --example
-- ---------
-- context1 : ACtx
-- context1 = (D , AInt D) ∷ (S , AInt S) ∷ (S , AFun S (AInt D) (AInt D) bt-≤-dyn bt-≤-dyn) ∷ []
-- ------------------
-- --typed expression
-- ------------------
-- data AExp (Δ : ACtx) : AType → Set where
-- Var : ∀ {α} → α ∈ Δ → AExp Δ α
-- Int : (bt : BT) → ℕ → AExp Δ (bt , AInt bt)
-- Add : ∀ {bt₁ bt₂} → (bt : BT) → AExp Δ (bt₁ , AInt bt₁) → AExp Δ (bt₂ , AInt bt₂)
-- → bt ⊑ bt₁ → bt ⊑ bt₂ → AExp Δ (bt , AInt bt)
-- ALam : ∀ {b b' : BT} {α₁ : atype b} {α₂ : atype b'} → (bt : BT) → AExp ((b , α₁) ∷ Δ) (b' , α₂)
-- → (e₁ : bt ⊑ b) → (e₂ : bt ⊑ b') → AExp Δ (bt , AFun bt α₁ α₂ e₁ e₂)
-- AApp : ∀ {b b' bt : BT} {α₁ : atype b} {α₂ : atype b'} {e₁ : bt ⊑ b} {e₂ : bt ⊑ b'} → AExp Δ (bt , AFun bt α₁ α₂ e₁ e₂)
-- → AExp Δ (b , α₁) → AExp Δ (b' , α₂)
-- -- Static pairs and sums
-- _,_ : ∀ {b b' bt : BT} {α₁ : atype b} {α₂ : atype b'} → AExp Δ (b , α₁) → AExp Δ (b' , α₂)
-- → (e₁ : bt ⊑ b) → (e₂ : bt ⊑ b') → AExp Δ (bt , • bt α₁ α₂ e₁ e₂)
-- Tl : ∀ {b b' bt : BT} {α₁ : atype b} {α₂ : atype b'} → AExp Δ (b , α₁) → (e₁ : bt ⊑ b) → (e₂ : bt ⊑ b')
-- → AExp Δ (bt , ⊎ bt α₁ α₂ e₁ e₂)
-- Tr : ∀ {b b' bt : BT} {α₁ : atype b} {α₂ : atype b'} → AExp Δ (b' , α₂) → (e₁ : bt ⊑ b) → (e₂ : bt ⊑ b')
-- → AExp Δ (bt , ⊎ bt α₁ α₂ e₁ e₂)
-- Fst : ∀ {b b' bt : BT} {α₁ : atype b} {α₂ : atype b'} {e₁ : bt ⊑ b} {e₂ : bt ⊑ b'} → AExp Δ (bt , • bt α₁ α₂ e₁ e₂) → AExp Δ (b , α₁)
-- Snd : ∀ {b b' bt : BT} {α₁ : atype b} {α₂ : atype b'} {e₁ : bt ⊑ b} {e₂ : bt ⊑ b'} → AExp Δ (bt , • bt α₁ α₂ e₁ e₂) → AExp Δ (b' , α₂)
-- Case : ∀ {b b' b'' bt : BT} {α₁ : atype b} {α₂ : atype b'} {α₃ : atype b''} {e₁ : bt ⊑ b} {e₂ : bt ⊑ b'}
-- → AExp Δ (bt , ⊎ bt α₁ α₂ e₁ e₂) → AExp ((b , α₁) ∷ Δ) (b'' , α₃)
-- → AExp ((b' , α₂) ∷ Δ) (b'' , α₃)
-- → bt ⊑ b'' → AExp Δ (b'' , α₃)
-- -- Liftable static terms
-- -- ↑ : ∀ {α} → Liftable α → AExp Δ α → AExp Δ (D (typeof α))
------------
--system two
------------
module annotated-type-two where
open import Data.Bool
open import Data.List
open import Data.Nat
module traditional-representation where
infix 4 _∈_
data _∈_ {A : Set} : A → List A → Set where
hd : ∀ {x xs} → x ∈ (x ∷ xs)
tl : ∀ {x y xs} → x ∈ xs → x ∈ (y ∷ xs)
data BT : Set where
S : BT
D : BT
------------------------------
--binding time annotated types
------------------------------
------------------------------
--Note
--[BType] for ?
--[AType] for annotated type
------------------------------
mutual
data AType : Set where
an : BT → BType → AType
data BType : Set where
BInt : BType
BFun : AType → AType → BType
_•_ : AType → AType → BType
_⊎_ : AType → AType → BType
ACtx = List AType
------------------
--well-formed type
------------------
---------------------
--auxiliaries
---------------------
btof : AType → BT
btof (an a x₁) = a
data _⊑_ : BT → BT → Set where
reflS : S ⊑ S
reflD : D ⊑ D
S≤D : S ⊑ D
-----
--wft
-----
data wft : AType → Set where
wf-int : ∀ {a : BT} → wft (an a BInt)
wf-fun : ∀ {a : BT} {α₁ α₂ : AType} → wft α₁ → wft α₂
→ a ⊑ btof α₁ → a ⊑ btof α₂ → wft (an a (BFun α₁ α₂))
wf-pair : ∀ {a : BT} {α₁ α₂ : AType} → wft α₁ → wft α₂
→ a ⊑ btof α₁ → a ⊑ btof α₂ → wft (an a (α₁ • α₂))
wf-sum : ∀ {a : BT} {α₁ α₂ : AType} → wft α₁ → wft α₂
→ a ⊑ btof α₁ → a ⊑ btof α₂ → wft (an a (α₁ ⊎ α₂))
----------
--Liftable
----------
-----------------------------------------------------------------
--Note
--• liftable defines a subset of annotated expressions whose type
-- annotation can be "lifted" to "D"
--• liftable dynamic types are trivially lifted
--• assume that we only consider the set of well-formed types
-----------------------------------------------------------------
mutual
data Liftable : AType → Set where
--dynamic type can be trivially lifted
D-aty : ∀ {σ} → Liftable (an D σ)
--static integer can be lifted to a dynamic one
--same holds for static pair and sum
S-int : Liftable (an S BInt)
S-pair : ∀ {α₁ α₂} → Liftable α₁ → Liftable α₂
→ Liftable (an S (α₁ • α₂))
S-sum : ∀ {α₁ α₂} → Liftable α₁ → Liftable α₂
→ Liftable (an S (α₁ ⊎ α₂))
--a liftable static functional type must have
--1. dynamic value as input
--2. higher-order static value with dynamic output
--3. higher-order static value as input with no
-- static inputs
S-fun : ∀ {α₁ α₂} → Liftable⁻ α₁ → Liftable α₂
→ Liftable (an S (BFun α₁ α₂))
data Liftable⁻ : AType → Set where
D-aty : ∀ {σ} → Liftable⁻ (an D σ)
S-pair : ∀ {α₁ α₂} → Liftable⁻ α₁ → Liftable⁻ α₂
→ Liftable⁻ (an S (α₁ • α₂))
S-fun : ∀ {α₁ α₂} → Liftable α₁ → Liftable⁻ α₂
→ Liftable⁻ (an S (BFun α₁ α₂))
data liftable : AType → Set where
↑ : ∀ {α} → wft α → Liftable α → liftable α
----------------------------
--typed annotated expression
----------------------------
----------------------------------------------------
--Note
--constructor name begins with an "A" for "annotated"
--typing constructor as [AExp]
--typing context as [Δ]
--"a" for both expression and type annotation
--"α" for [AType]
--"σ" for [BType]
----------------------------------------------------
data AExp (Δ : ACtx) : AType → Set where
Var : ∀ {α} → α ∈ Δ → AExp Δ α
AInt : (a : BT) → ℕ → AExp Δ (an a BInt)
AAdd : (a : BT) → AExp Δ (an a BInt) → AExp Δ (an a BInt) → AExp Δ (an a BInt)
ALam : ∀ {α₁ α₂} → (a : BT) → wft (an a (BFun α₁ α₂)) → AExp (α₁ ∷ Δ) α₂
→ AExp Δ (an a (BFun α₁ α₂))
AApp : ∀ {α₁ α₂} → (a : BT) → wft (an a (BFun α₁ α₂)) → AExp Δ (an a (BFun α₁ α₂))
→ AExp Δ α₁ → AExp Δ α₂
APair : ∀ {α₁ α₂} → (a : BT) → wft (an a (α₁ • α₂)) → AExp Δ α₁ → AExp Δ α₂
→ AExp Δ (an a (α₁ • α₂))
ATl : ∀ {α₁ α₂} → (a : BT) → wft (an a (α₁ ⊎ α₂)) → AExp Δ α₁
→ AExp Δ (an a (α₁ ⊎ α₂))
ATr : ∀ {α₁ α₂} → (a : BT) → wft (an a (α₁ ⊎ α₂)) → AExp Δ α₂
→ AExp Δ (an a (α₁ ⊎ α₂))
ACase : ∀ {α₁ α₂ α₃} {a : BT} → a ⊑ btof α₃ → AExp Δ (an a (α₁ ⊎ α₂)) → AExp (α₁ ∷ Δ) α₃
→ AExp (α₂ ∷ Δ) α₃ → AExp Δ α₃
Lift : ∀ {a} {σ} → liftable (an a σ) → AExp Δ (an a σ) → AExp Δ (an D σ)
module two-level-representation where
---------------
--residual type
---------------
data type : Set where
Int : type
Fun : type → type → type
_•_ : type → type → type
_⊎_ : type → type → type
----------------
--annotated type
----------------
---------------------------------------------
--Note
--• static type constructor starting with "S"
-- except for pair and sum
--• residual type used for building dynamic
-- type
---------------------------------------------
data atype : Set where
SInt : atype
SFun : atype → atype → atype
D : type → atype
_•_ : atype → atype → atype
_⊎_ : atype → atype → atype
btof-γ : atype → BT
btof-γ SInt = S
btof-γ (SFun γ γ₁) = S
btof-γ (D x) = D
btof-γ (γ • γ₁) = S
btof-γ (γ ⊎ γ₁) = S
actx = List atype
----------
--Liftable
----------
--Note
--"τ" for residual type [type]
--"γ" for [atype]
mutual
data Liftok : atype → Set where
D-aty : ∀ τ → Liftok (D τ)
S-int : Liftok SInt
S-sum : ∀ {γ₁ γ₂} → Liftok γ₁ → Liftok γ₂ → Liftok (γ₁ ⊎ γ₂)
S-pair : ∀ {γ₁ γ₂} → Liftok γ₁ → Liftok γ₂ → Liftok (γ₁ • γ₂)
S-fun : ∀ {γ₁ γ₂} → Liftok⁻ γ₁ → Liftok γ₂ → Liftok (SFun γ₁ γ₂)
data Liftok⁻ : atype → Set where
D-aty : ∀ τ → Liftok⁻ (D τ)
_•_ : ∀ {γ₁ γ₂} → Liftok⁻ γ₁ → Liftok⁻ γ₂ → Liftok⁻ (γ₁ • γ₂)
S-fun : ∀ {γ₁ γ₂} → Liftok γ₁ → Liftok⁻ γ₂ → Liftok⁻ (SFun γ₁ γ₂)
----------------------------
--typed two-level annotated expression
----------------------------
--------------------
--auxiliary function
--------------------
typeof : atype → type
typeof SInt = Int
typeof (SFun γ₁ γ₂) = Fun (typeof γ₁) (typeof γ₂)
typeof (D τ) = τ
typeof (γ₁ • γ₂) = typeof γ₁ • typeof γ₂
typeof (γ₁ ⊎ γ₂) = typeof γ₁ ⊎ typeof γ₂
--------
--[aexp]
--------
--Note
--• "γ" for [atype]
--• "τ" for [type]
--• typed terms starting with "S" for "static"
-- and "D" for "dynamic",except for pair
--• "Ω" for typing context
data aexp (Ω : actx) : atype → Set where
Var : ∀ {γ} → γ ∈ Ω → aexp Ω γ
SInt : ℕ → aexp Ω SInt
SAdd : aexp Ω SInt → aexp Ω SInt → aexp Ω SInt
SLam : ∀ {γ₁ γ₂} → aexp (γ₁ ∷ Ω) γ₂ → aexp Ω (SFun γ₁ γ₂)
SApp : ∀ {γ₁ γ₂} → aexp Ω (SFun γ₁ γ₂) → aexp Ω γ₁ → aexp Ω γ₂
DInt : ℕ → aexp Ω (D Int)
DAdd : aexp Ω (D Int) → aexp Ω (D Int) → aexp Ω (D Int)
DLam : ∀ {τ₁ τ₂} → aexp ((D τ₁) ∷ Ω) (D τ₂) → aexp Ω (D (Fun τ₁ τ₂))
DApp : ∀ {τ₁ τ₂} → aexp Ω (D (Fun τ₁ τ₂)) → aexp Ω (D τ₁) → aexp Ω (D τ₂)
-- Static pairs and sums
_,_ : ∀ {γ₁ γ₂} → aexp Ω γ₁ → aexp Ω γ₂ → aexp Ω (γ₁ • γ₂)
STl : ∀ {γ₁ γ₂} → aexp Ω γ₁ → aexp Ω (γ₁ ⊎ γ₂)
STr : ∀ {γ₁ γ₂} → aexp Ω γ₂ → aexp Ω (γ₁ ⊎ γ₂)
SFst : ∀ {γ₁ γ₂} → aexp Ω (γ₁ • γ₂) → aexp Ω γ₁
SSnd : ∀ {γ₁ γ₂} → aexp Ω (γ₁ • γ₂) → aexp Ω γ₂
SCase : ∀ {γ₁ γ₂ γ₃} → aexp Ω (γ₁ ⊎ γ₂) → aexp (γ₁ ∷ Ω) γ₃ → aexp (γ₂ ∷ Ω) γ₃ → aexp Ω γ₃
-- Dynamic pairs and sums
_ḋ_ : ∀ {τ₁ τ₂} → aexp Ω (D τ₁) → aexp Ω (D τ₂) → aexp Ω (D (τ₁ • τ₂))
DTl : ∀ {τ₁ τ₂} → aexp Ω (D τ₁) → aexp Ω (D (τ₁ ⊎ τ₂))
DTr : ∀ {τ₁ τ₂} → aexp Ω (D τ₂) → aexp Ω (D (τ₁ ⊎ τ₂))
DFst : ∀ {τ₁ τ₂} → aexp Ω (D (τ₁ • τ₂)) → aexp Ω (D τ₁)
DSnd : ∀ {τ₁ τ₂} → aexp Ω (D (τ₁ • τ₂)) → aexp Ω (D τ₂)
DCase : ∀ {τ₁ τ₂ τ₃} → aexp Ω (D (τ₁ ⊎ τ₂)) → aexp ((D τ₁) ∷ Ω) (D τ₃) → aexp ((D τ₂) ∷ Ω) (D τ₃) → aexp Ω (D τ₃)
-- Liftable static terms
Lift : ∀ {γ} → Liftok γ → aexp Ω γ → aexp Ω (D (typeof γ))
---------------------------------------------------------------
--Isomorphism between terms typed by [AExp] and terms by [aexp]
---------------------------------------------------------------
module isomorphism where
open import Data.Product
open import Relation.Binary.PropositionalEquality
----------
--Analysis
----------
--consider static integer in [aexp],
--SInt 0 : aexp Ω SInt,∀ Ω
--naturally its counter-part in [AExp] should be,
--AInt S 0 : AExp Δ (an S BInt)
--for dynamic integer,
--DInt 0 : aexp Ω (D Int)
--AInt D 0 : aexp Δ (an D BInt)
--Notice the two kinds of isomorphisms involved in above example
--a. isomorphism w.r.t. types
--b. isomorphism w.r.t. typed terms
---------------------
--a. type isomorphism
---------------------
--a.1. [atype] to [AType]
--integer
--SInt ==> an S BInt
--D Int ==> an D BInt
--function
--SFun (D Int)(D Int) ==> an S (BFun (an D BInt) (an D BInt))
--D (Fun Int Int) ==> an D (BFun (an D BInt) (an D BInt))
------------------------------------
--projection from [atype] to [AType]
------------------------------------
projT₁ : atype → AType
projT₁ SInt = an S BInt
projT₁ (SFun aty aty₁) = an S (BFun (projT₁ aty) (projT₁ aty₁))
projT₁ (D Int) = an D BInt
projT₁ (D (Fun x x₁)) = an D (BFun (projT₁ (D x)) (projT₁ (D x₁)))
projT₁ (D (x • x₁)) = an D (projT₁ (D x) • projT₁ (D x₁))
projT₁ (D (x ⊎ x₁)) = an D (projT₁ (D x) ⊎ projT₁ (D x₁))
projT₁ (aty • aty₁) = an S ((projT₁ aty) • projT₁ aty₁)
projT₁ (aty ⊎ aty₁) = an S ((projT₁ aty) ⊎ projT₁ aty₁)
--a.2. [AType] to [atype]
--imposing [wft] upon types defined in [AType] before projection
--consider the following type,
--an D (BFun (an S BInt) (an S BInt)) which has no counter part
--in [atype] for the following lemma,
-- ∀ γ, wft (projT₁ γ)
--suppose we focus on these types satisfying [wft],
--integer
--an S BInt ==> SInt
--an D BInt ==> D Int
--function
--an S BFun (an D BInt) (an D BInt) ==> SFun (D Int) (D Int)
--an D BFun (an D BInt) (an D BInt) ==> D (Fun Int Int)
------------------------------------------------
--projection from well-formed [AType] to [atype]
------------------------------------------------
--------
--helper
--------
------------------------
--from [atype] to [type]
------------------------
γ→τ : atype → type
γ→τ SInt = Int
γ→τ (SFun aty aty₁) = Fun (γ→τ aty) (γ→τ aty₁)
γ→τ (D x) = x
γ→τ (aty • aty₁) = (γ→τ aty) • (γ→τ aty₁)
γ→τ (aty ⊎ aty₁) = (γ→τ aty) ⊎ (γ→τ aty₁)
projT₂ : (α : AType) → wft α → atype
projT₂ .(an S BInt) (wf-int {S}) = SInt
projT₂ .(an D BInt) (wf-int {D}) = D Int
projT₂ .(an S (BFun α₁ α₂)) (wf-fun {S} {α₁} {α₂} wft wft₁ x x₁) = SFun (projT₂ α₁ wft) (projT₂ α₂ wft₁)
projT₂ .(an D (BFun α₁ α₂)) (wf-fun {D} {α₁} {α₂} wft wft₁ x x₁) = D (Fun (γ→τ (projT₂ α₁ wft)) (γ→τ (projT₂ α₂ wft₁)))
projT₂ .(an S (α₁ • α₂)) (wf-pair {S} {α₁} {α₂} wft wft₁ x x₁) = (projT₂ α₁ wft) • (projT₂ α₂ wft₁)
projT₂ .(an D (α₁ • α₂)) (wf-pair {D} {α₁} {α₂} wft wft₁ x x₁) = D (γ→τ (projT₂ α₁ wft) • γ→τ (projT₂ α₂ wft₁))
projT₂ .(an S (α₁ ⊎ α₂)) (wf-sum {S} {α₁} {α₂} wft wft₁ x x₁) = (projT₂ α₁ wft) ⊎ (projT₂ α₂ wft₁)
projT₂ .(an D (α₁ ⊎ α₂)) (wf-sum {D} {α₁} {α₂} wft wft₁ x x₁) = D (γ→τ (projT₂ α₁ wft) ⊎ γ→τ (projT₂ α₂ wft₁))
-------------------------------------
--lemmas w.r.t. isomorphism of types
-------------------------------------
-----------------------------------------------
--direction one:"starting from type in [atype]"
-----------------------------------------------
-----------------------
--some auxiliary lemmas
-----------------------
S⊑* : ∀ {α} → S ⊑ btof α
S⊑* {an S x₁} = reflS
S⊑* {an D x₁} = S≤D
a-pDatype : ∀ {τ : type} → btof (projT₁ (D τ)) ≡ D
a-pDatype {Int} = refl
a-pDatype {Fun τ τ₁} = refl
a-pDatype {τ • τ₁} = refl
a-pDatype {τ ⊎ τ₁} = refl
D-a-pDatype : ∀ {τ : type} → D ⊑ (btof (projT₁ (D τ)))
D-a-pDatype {τ} rewrite a-pDatype {τ} = reflD
isoT₁ : ∀ (γ : atype) → Σ (wft (projT₁ γ)) \ x → γ ≡ projT₂ (projT₁ γ) x
isoT₁ SInt = wf-int , refl
isoT₁ (SFun γ γ₁) with (proj₂ (isoT₁ γ)) | (proj₂ (isoT₁ γ₁))
... | I | I' = wf-fun (proj₁ (isoT₁ γ)) (proj₁ (isoT₁ γ₁)) (S⊑* {(projT₁ γ)}) (S⊑* {projT₁ γ₁}) , cong₂ SFun I I'
isoT₁ (D Int) = wf-int , refl
isoT₁ (D (Fun x x₁)) = wf-fun (proj₁ (isoT₁ (D x))) (proj₁ (isoT₁ (D x₁))) (D-a-pDatype {x}) (D-a-pDatype {x₁}) ,
cong
D
(cong₂ Fun (cong γ→τ (proj₂ (isoT₁ (D x))))
(cong γ→τ (proj₂ (isoT₁ (D x₁)))))
isoT₁ (D (x • x₁)) = wf-pair (proj₁ (isoT₁ (D x))) (proj₁ (isoT₁ (D x₁))) (D-a-pDatype {x}) (D-a-pDatype {x₁}) ,
cong
D
(cong₂ _•_ (cong γ→τ (proj₂ (isoT₁ (D x))))
(cong γ→τ (proj₂ (isoT₁ (D x₁)))))
isoT₁ (D (x ⊎ x₁)) = wf-sum (proj₁ (isoT₁ (D x))) (proj₁ (isoT₁ (D x₁))) (D-a-pDatype {x}) (D-a-pDatype {x₁}) ,
cong
D
(cong₂ _⊎_ (cong γ→τ (proj₂ (isoT₁ (D x))))
(cong γ→τ (proj₂ (isoT₁ (D x₁)))))
isoT₁ (γ • γ₁) = wf-pair (proj₁ (isoT₁ γ)) (proj₁ (isoT₁ γ₁)) (S⊑* {projT₁ γ}) (S⊑* {projT₁ γ₁}) ,
cong₂ _•_ (proj₂ (isoT₁ γ)) (proj₂ (isoT₁ γ₁))
isoT₁ (γ ⊎ γ₁) = wf-sum (proj₁ (isoT₁ γ)) (proj₁ (isoT₁ γ₁)) (S⊑* {projT₁ γ}) (S⊑* {projT₁ γ₁}) ,
cong₂ _⊎_ (proj₂ (isoT₁ γ)) (proj₂ (isoT₁ γ₁))
-----------------------------------------------------------
--direction two:"starting from type in well-formed [AType]"
-----------------------------------------------------------
-----------------------
--some auxiliary lemmas
-----------------------
eqDγ→τprojT₂ : ∀ {α : AType} {wf : wft α} → D ⊑ btof α → D (γ→τ (projT₂ α wf)) ≡ projT₂ α wf
eqDγ→τprojT₂ {an S BInt} {wf-int} ()
eqDγ→τprojT₂ {an D BInt} {wf-int} e = refl
eqDγ→τprojT₂ {an S (BFun α₁ α₂)} {wf-fun wf wf₁ x x₁} ()
eqDγ→τprojT₂ {an D (BFun α₁ α₂)} {wf-fun wf wf₁ x x₁} e = refl
eqDγ→τprojT₂ {an S (α₁ • α₂)} {wf-pair wf wf₁ x x₁} ()
eqDγ→τprojT₂ {an D (α₁ • α₂)} {wf-pair wf wf₁ x x₁} e = refl
eqDγ→τprojT₂ {an S (α₁ ⊎ α₂)} {wf-sum wf wf₁ x x₁} ()
eqDγ→τprojT₂ {an D (α₁ ⊎ α₂)} {wf-sum wf wf₁ x x₁} e = refl
isoT₂ : ∀ {α : AType} → (wf : wft α) → α ≡ projT₁ (projT₂ α wf)
isoT₂ {an S BInt} wf-int = refl
isoT₂ {an S (BFun x x₁)} (wf-fun wf wf₁ x₂ x₃) = cong₂ an refl (cong₂ BFun (isoT₂ {x} wf) (isoT₂ {x₁} wf₁))
isoT₂ {an S (x • x₁)} (wf-pair wf wf₁ x₂ x₃) = cong₂ an refl (cong₂ _•_ (isoT₂ {x} wf) (isoT₂ {x₁} wf₁))
isoT₂ {an S (x ⊎ x₁)} (wf-sum wf wf₁ x₂ x₃) = cong₂ an refl (cong₂ _⊎_ (isoT₂ {x} wf) (isoT₂ {x₁} wf₁))
isoT₂ {an D BInt} wf-int = refl
isoT₂ {an D (BFun x x₁)} (wf-fun wf wf₁ x₂ x₃) =
cong₂ an refl
(cong₂ BFun
(trans (isoT₂ {x} wf)
(sym (cong projT₁ (eqDγ→τprojT₂ {x} {wf} x₂))))
(trans (isoT₂ {x₁} wf₁)
(sym (cong projT₁ (eqDγ→τprojT₂ {x₁} {wf₁} x₃)))))
isoT₂ {an D (x • x₁)} (wf-pair wf wf₁ x₂ x₃) =
cong₂ an refl
(cong₂ _•_
(trans (isoT₂ {x} wf)
(sym (cong projT₁ (eqDγ→τprojT₂ {x} {wf} x₂))))
(trans (isoT₂ {x₁} wf₁)
(sym (cong projT₁ (eqDγ→τprojT₂ {x₁} {wf₁} x₃)))))
isoT₂ {an D (x ⊎ x₁)} (wf-sum wf wf₁ x₂ x₃) =
cong₂ an refl
(cong₂ _⊎_
(trans (isoT₂ {x} wf)
(sym (cong projT₁ (eqDγ→τprojT₂ {x} {wf} x₂))))
(trans (isoT₂ {x₁} wf₁)
(sym (cong projT₁ (eqDγ→τprojT₂ {x₁} {wf₁} x₃)))))
------------------------------------------------
--lemmas w.r.t. isomorphism of typed expressions
------------------------------------------------
----------------
--some instances
----------------
------------------
--[AExp] to [aexp]
------------------
--Var hd : AExp [an D (BFun (an D BInt) (an D BInt))]
-- (an D (BFun (an D BInt) (an D BInt)))
--==>projt₂*
--Var hd : aexp [D (Fun Int Int)] (D (Fun Int Int))
--*Note that projection from expression in [AExp] to
-- that in [aexp] requires that both the type and the
-- typing environment are well-formed
--AInt S 0 : AExp Δ (an S BInt),∀ Δ
--==>projt₂
--SInt 0 : aexp Ω* SInt,∀ Ω
--*Note that the corresponding typing environment in [aexp] satisfies,
-- Ω = projection of Δ
--ALam S (wf-fun wf-int wf-int *≤D *≤D) (Var hd)
--:AExp [] (an S (BFun (an D BInt) (an D BInt)))
--==>projt₂
--SLam (Var hd) : aexp [] (SFun (D Int) (D Int))
--ALam D (wf-fun wf-int wf-int refl refl) (Var hd)
--:AExp [] (an D (BFun (an D BInt) (an D BInt)))
--==>projt₂
--DLam (Var hd) : aexp [] (D (Fun Int Int))
-----------------------
--summary upon [projt₂]
-----------------------
--• projection only of terms which are typed both by
-- well-formed [AType] and under well-formed Δ
--• the results are typed under Ω which is the projection
-- of Δ
------------------------------------------
--some auxiliary functions and definitions
------------------------------------------
---------------
--Well-formed Δ
---------------
data wfe : ACtx → Set where
wf-[] : wfe []
wf-∷ : ∀ {α : AType} {AEnv : ACtx}
→ wft α → wfe AEnv
→ wfe (α ∷ AEnv)
-----------------------------
--projΔ (similar to [projT₂])
-----------------------------
projΔ : (Δ : ACtx) → wfe Δ → actx
projΔ [] wfe = []
projΔ (x ∷ Δ) (wf-∷ x₁ wfe) = projT₂ x x₁ ∷ projΔ Δ wfe
--------
--projt₂
--------
-----------------------
--some auxiliary lemmas
-----------------------
-- --------
-- --is-≡-α
-- --------
-- is-≡-α : (α₁ α₂ : AType) → Bool
-- is-≡-α (an S BInt) (an S BInt) = true
-- is-≡-α (an S BInt) (an S (BFun x x₁)) = false
-- is-≡-α (an S BInt) (an S (x • x₁)) = false
-- is-≡-α (an S BInt) (an S (x ⊎ x₁)) = false
-- is-≡-α (an S (BFun x x₁)) (an S BInt) = false
-- is-≡-α (an S (BFun x x₁)) (an S (BFun x₂ x₃)) = is-≡-α x x₂ ∧ is-≡-α x₁ x₃
-- is-≡-α (an S (BFun x x₁)) (an S (x₂ • x₃)) = false
-- is-≡-α (an S (BFun x x₁)) (an S (x₂ ⊎ x₃)) = false
-- is-≡-α (an S (x • x₁)) (an S BInt) = false
-- is-≡-α (an S (x • x₁)) (an S (BFun x₂ x₃)) = false
-- is-≡-α (an S (x • x₁)) (an S (x₂ • x₃)) = is-≡-α x x₂ ∧ is-≡-α x₁ x₃
-- is-≡-α (an S (x • x₁)) (an S (x₂ ⊎ x₃)) = false
-- is-≡-α (an S (x ⊎ x₁)) (an S BInt) = false
-- is-≡-α (an S (x ⊎ x₁)) (an S (BFun x₂ x₃)) = false
-- is-≡-α (an S (x ⊎ x₁)) (an S (x₂ • x₃)) = false
-- is-≡-α (an S (x ⊎ x₁)) (an S (x₂ ⊎ x₃)) = is-≡-α x x₂ ∧ is-≡-α x₁ x₃
-- is-≡-α (an S x₁) (an D x₃) = false
-- is-≡-α (an D x₁) (an S x₃) = false
-- is-≡-α (an D BInt) (an D BInt) = true
-- is-≡-α (an D BInt) (an D (BFun x x₁)) = false
-- is-≡-α (an D BInt) (an D (x • x₁)) = false
-- is-≡-α (an D BInt) (an D (x ⊎ x₁)) = false
-- is-≡-α (an D (BFun x x₁)) (an D BInt) = false
-- is-≡-α (an D (BFun x x₁)) (an D (BFun x₂ x₃)) = is-≡-α x x₂ ∧ is-≡-α x₁ x₃
-- is-≡-α (an D (BFun x x₁)) (an D (x₂ • x₃)) = false
-- is-≡-α (an D (BFun x x₁)) (an D (x₂ ⊎ x₃)) = false
-- is-≡-α (an D (x • x₁)) (an D BInt) = false
-- is-≡-α (an D (x • x₁)) (an D (BFun x₂ x₃)) = false
-- is-≡-α (an D (x • x₁)) (an D (x₂ • x₃)) = is-≡-α x x₂ ∧ is-≡-α x₁ x₃
-- is-≡-α (an D (x • x₁)) (an D (x₂ ⊎ x₃)) = false
-- is-≡-α (an D (x ⊎ x₁)) (an D BInt) = false
-- is-≡-α (an D (x ⊎ x₁)) (an D (BFun x₂ x₃)) = false
-- is-≡-α (an D (x ⊎ x₁)) (an D (x₂ • x₃)) = false
-- is-≡-α (an D (x ⊎ x₁)) (an D (x₂ ⊎ x₃)) = is-≡-α x x₂ ∧ is-≡-α x₁ x₃
-- --------
-- --is-≡-τ
-- --------
-- is-≡-τ : (τ₁ τ₂ : type) → Bool
-- is-≡-τ Int Int = true
-- is-≡-τ Int (Fun τ₂ τ₃) = false
-- is-≡-τ Int (τ₂ • τ₃) = false
-- is-≡-τ Int (τ₂ ⊎ τ₃) = false
-- is-≡-τ (Fun τ₁ τ₂) Int = false
-- is-≡-τ (Fun τ₁ τ₂) (Fun τ₃ τ₄) = is-≡-τ τ₁ τ₃ ∧ is-≡-τ τ₂ τ₄
-- is-≡-τ (Fun τ₁ τ₂) (τ₃ • τ₄) = false
-- is-≡-τ (Fun τ₁ τ₂) (τ₃ ⊎ τ₄) = false
-- is-≡-τ (τ₁ • τ₂) Int = false
-- is-≡-τ (τ₁ • τ₂) (Fun τ₃ τ₄) = false
-- is-≡-τ (τ₁ • τ₂) (τ₃ • τ₄) = is-≡-τ τ₁ τ₃ ∧ is-≡-τ τ₂ τ₄
-- is-≡-τ (τ₁ • τ₂) (τ₃ ⊎ τ₄) = false
-- is-≡-τ (τ₁ ⊎ τ₂) Int = false
-- is-≡-τ (τ₁ ⊎ τ₂) (Fun τ₃ τ₄) = false
-- is-≡-τ (τ₁ ⊎ τ₂) (τ₃ • τ₄) = false
-- is-≡-τ (τ₁ ⊎ τ₂) (τ₃ ⊎ τ₄) = is-≡-τ τ₁ τ₃ ∧ is-≡-τ τ₂ τ₄
-- --------
-- --is-≡-γ
-- --------
-- is-≡-γ : (γ₁ γ₂ : atype) → Bool
-- is-≡-γ SInt SInt = true
-- is-≡-γ SInt (SFun γ₂ γ₃) = false
-- is-≡-γ SInt (D x) = false
-- is-≡-γ SInt (γ₂ • γ₃) = false
-- is-≡-γ SInt (γ₂ ⊎ γ₃) = false
-- is-≡-γ (SFun γ₁ γ₂) SInt = false
-- is-≡-γ (SFun γ₁ γ₂) (SFun γ₃ γ₄) = is-≡-γ γ₁ γ₃ ∧ is-≡-γ γ₂ γ₄
-- is-≡-γ (SFun γ₁ γ₂) (D x) = false
-- is-≡-γ (SFun γ₁ γ₂) (γ₃ • γ₄) = false
-- is-≡-γ (SFun γ₁ γ₂) (γ₃ ⊎ γ₄) = false
-- is-≡-γ (D x) SInt = false
-- is-≡-γ (D x) (SFun γ₂ γ₃) = false
-- is-≡-γ (D x) (D x₁) = is-≡-τ x x₁
-- is-≡-γ (D x) (γ₂ • γ₃) = false
-- is-≡-γ (D x) (γ₂ ⊎ γ₃) = false
-- is-≡-γ (γ₁ • γ₂) SInt = false
-- is-≡-γ (γ₁ • γ₂) (SFun γ₃ γ₄) = false
-- is-≡-γ (γ₁ • γ₂) (D x) = false
-- is-≡-γ (γ₁ • γ₂) (γ₃ • γ₄) = is-≡-γ γ₁ γ₃ ∧ is-≡-γ γ₂ γ₄
-- is-≡-γ (γ₁ • γ₂) (γ₃ ⊎ γ₄) = false
-- is-≡-γ (γ₁ ⊎ γ₂) SInt = false
-- is-≡-γ (γ₁ ⊎ γ₂) (SFun γ₃ γ₄) = false
-- is-≡-γ (γ₁ ⊎ γ₂) (D x) = false
-- is-≡-γ (γ₁ ⊎ γ₂) (γ₃ • γ₄) = false
-- is-≡-γ (γ₁ ⊎ γ₂) (γ₃ ⊎ γ₄) = is-≡-γ γ₁ γ₃ ∧ is-≡-γ γ₂ γ₄
-- is-≡-γ→τ : {γ₁ γ₂ : atype} → btof-γ γ₁ ≡ D → btof-γ γ₁ ≡ btof-γ γ₂
-- → is-≡-γ γ₁ γ₂ ≡ is-≡-τ (γ→τ γ₁) (γ→τ γ₂)
-- is-≡-γ→τ {SInt} {SInt} eq eq' = refl
-- is-≡-γ→τ {SInt} {SFun γ₂ γ₃} eq eq' = refl
-- is-≡-γ→τ {SInt} {D x} () ()
-- is-≡-γ→τ {SInt} {γ₂ • γ₃} () eq'
-- is-≡-γ→τ {SInt} {γ₂ ⊎ γ₃} () eq'
-- is-≡-γ→τ {SFun γ₁ γ₂} {SInt} () eq'
-- is-≡-γ→τ {SFun γ₁ γ₂} {SFun γ₃ γ₄} () eq'
-- is-≡-γ→τ {SFun γ₁ γ₂} {D x} () eq'
-- is-≡-γ→τ {SFun γ₁ γ₂} {γ₃ • γ₄} () eq'
-- is-≡-γ→τ {SFun γ₁ γ₂} {γ₃ ⊎ γ₄} () eq'
-- is-≡-γ→τ {D x} {SInt} eq ()
-- is-≡-γ→τ {D x} {SFun γ₂ γ₃} eq ()
-- is-≡-γ→τ {D x} {D x₁} eq eq' = refl
-- is-≡-γ→τ {D x} {γ₂ • γ₃} eq ()
-- is-≡-γ→τ {D x} {γ₂ ⊎ γ₃} eq ()
-- is-≡-γ→τ {γ₁ • γ₂} {SInt} eq eq' = refl
-- is-≡-γ→τ {γ₁ • γ₂} {SFun γ₃ γ₄} () eq'
-- is-≡-γ→τ {γ₁ • γ₂} {D x} eq ()
-- is-≡-γ→τ {γ₁ • γ₂} {γ₃ • γ₄} () eq'
-- is-≡-γ→τ {γ₁ • γ₂} {γ₃ ⊎ γ₄} () eq'
-- is-≡-γ→τ {γ₁ ⊎ γ₂} {SInt} () eq'
-- is-≡-γ→τ {γ₁ ⊎ γ₂} {SFun γ₃ γ₄} () eq'
-- is-≡-γ→τ {γ₁ ⊎ γ₂} {D x} eq ()
-- is-≡-γ→τ {γ₁ ⊎ γ₂} {γ₃ • γ₄} () eq'
-- is-≡-γ→τ {γ₁ ⊎ γ₂} {γ₃ ⊎ γ₄} () eq'
-- btof-γ-projT₂-α : ∀ {a : BT} {σ : BType} {wft : wft (an a σ)}
-- → btof-γ (projT₂ (an a σ) wft) ≡ a
-- btof-γ-projT₂-α {S} {BInt} {wf-int} = refl
-- btof-γ-projT₂-α {D} {BInt} {wf-int} = refl
-- btof-γ-projT₂-α {S} {BFun α₁ α₂} {wf-fun wft wft₁ x x₁} = refl
-- btof-γ-projT₂-α {D} {BFun α₁ α₂} {wf-fun wft wft₁ x x₁} = refl
-- btof-γ-projT₂-α {S} {α₁ • α₂} {wf-pair wft wft₁ x x₁} = refl
-- btof-γ-projT₂-α {D} {α₁ • α₂} {wf-pair wft wft₁ x x₁} = refl
-- btof-γ-projT₂-α {S} {α₁ ⊎ α₂} {wf-sum wft wft₁ x x₁} = refl
-- btof-γ-projT₂-α {D} {α₁ ⊎ α₂} {wf-sum wft wft₁ x x₁} = refl
-- is-≡-projT₂ : {α₁ α₂ : AType} {wft₁ : wft α₁} {wft₂ : wft α₂}
-- → (is-≡-α α₁ α₂) ≡ (is-≡-γ (projT₂ α₁ wft₁) (projT₂ α₂ wft₂))
-- is-≡-projT₂ {an S BInt} {an S BInt} {wf-int} {wf-int} = refl
-- is-≡-projT₂ {an S BInt} {an D BInt} {wf-int} {wf-int} = refl
-- is-≡-projT₂ {an D BInt} {an S BInt} {wf-int} {wf-int} = refl
-- is-≡-projT₂ {an D BInt} {an D BInt} {wf-int} {wf-int} = refl
-- is-≡-projT₂ {an S BInt} {an S (BFun α₁ α₂)} {wf-int} {wf-fun wft₂ wft₃ x x₁} = refl
-- is-≡-projT₂ {an S BInt} {an D (BFun α₁ α₂)} {wf-int} {wf-fun wft₂ wft₃ x x₁} = refl
-- is-≡-projT₂ {an D BInt} {an S (BFun α₁ α₂)} {wf-int} {wf-fun wft₂ wft₃ x x₁} = refl
-- is-≡-projT₂ {an D BInt} {an D (BFun α₁ α₂)} {wf-int} {wf-fun wft₂ wft₃ x x₁} = refl
-- is-≡-projT₂ {an S BInt} {an S (α₁ • α₂)} {wf-int} {wf-pair wft₂ wft₃ x x₁} = refl
-- is-≡-projT₂ {an S BInt} {an D (α₁ • α₂)} {wf-int} {wf-pair wft₂ wft₃ x x₁} = refl
-- is-≡-projT₂ {an D BInt} {an S (α₁ • α₂)} {wf-int} {wf-pair wft₂ wft₃ x x₁} = refl
-- is-≡-projT₂ {an D BInt} {an D (α₁ • α₂)} {wf-int} {wf-pair wft₂ wft₃ x x₁} = refl
-- is-≡-projT₂ {an S BInt} {an S (α₁ ⊎ α₂)} {wf-int} {wf-sum wft₂ wft₃ x x₁} = refl
-- is-≡-projT₂ {an S BInt} {an D (α₁ ⊎ α₂)} {wf-int} {wf-sum wft₂ wft₃ x x₁} = refl
-- is-≡-projT₂ {an D BInt} {an S (α₁ ⊎ α₂)} {wf-int} {wf-sum wft₂ wft₃ x x₁} = refl
-- is-≡-projT₂ {an D BInt} {an D (α₁ ⊎ α₂)} {wf-int} {wf-sum wft₂ wft₃ x x₁} = refl
-- is-≡-projT₂ {an S (BFun α₁ α₃)} {an S BInt} {wf-fun wft₁ wft₂ x x₁} {wf-int} = refl
-- is-≡-projT₂ {an S (BFun α₁ α₃)} {an D BInt} {wf-fun wft₁ wft₂ x x₁} {wf-int} = refl
-- is-≡-projT₂ {an D (BFun α₁ α₃)} {an S BInt} {wf-fun wft₁ wft₂ x x₁} {wf-int} = refl
-- is-≡-projT₂ {an D (BFun α₁ α₃)} {an D BInt} {wf-fun wft₁ wft₂ x x₁} {wf-int} = refl
-- is-≡-projT₂ {an S (BFun α₁ α₃)} {an S (BFun α₂ α₄)} {wf-fun wft₁ wft₂ x x₁} {wf-fun wft₃ wft₄ x₂ x₃}
-- rewrite (is-≡-projT₂ {α₁} {α₂} {wft₁} {wft₃}) | (is-≡-projT₂ {α₃} {α₄} {wft₂} {wft₄}) = refl
-- is-≡-projT₂ {an S (BFun α₁ α₃)} {an D (BFun α₂ α₄)} {wf-fun wft₁ wft₂ x x₁} {wf-fun wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an D (BFun α₁ α₃)} {an S (BFun α₂ α₄)} {wf-fun wft₁ wft₂ x x₁} {wf-fun wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an D (BFun (an D σ₁) (an D σ₃))} {an D (BFun (an D σ₂) (an D σ₄))} {wf-fun wft₁ wft₂ x x₁} {wf-fun wft₃ wft₄ x₂ x₃}
-- rewrite ((is-≡-projT₂ {an D σ₁} {an D σ₂} {wft₁} {wft₃})) | ((is-≡-projT₂ {an D σ₃} {an D σ₄} {wft₂} {wft₄}))
-- | is-≡-γ→τ {projT₂ (an D σ₁) wft₁} {projT₂ (an D σ₂) wft₃}
-- (btof-γ-projT₂-α {D} {σ₁} {wft₁}) (trans (btof-γ-projT₂-α {D} {σ₁} {wft₁}) (sym (btof-γ-projT₂-α {D} {σ₂} {wft₃})))
-- | is-≡-γ→τ {projT₂ (an D σ₃) wft₂} {projT₂ (an D σ₄) wft₄}
-- (btof-γ-projT₂-α {D} {σ₃} {wft₂}) (trans (btof-γ-projT₂-α {D} {σ₃} {wft₂}) (sym (btof-γ-projT₂-α {D} {σ₄} {wft₄})))
-- = refl
-- is-≡-projT₂ {an D (BFun (an D σ₁) (an D σ₃))} {an D (BFun (an D σ₂) (an S σ₄))} {wf-fun wft₁ wft₂ x x₁} {wf-fun wft₃ wft₄ x₂ ()}
-- is-≡-projT₂ {an D (BFun (an D σ₁) (an S σ₃))} {an D (BFun (an D σ₂) (an a₄ σ₄))} {wf-fun wft₁ wft₂ x ()} {wf-fun wft₃ wft₄ x₂ x₃}
-- is-≡-projT₂ {an D (BFun (an D σ₁) (an a₃ σ₃))} {an D (BFun (an S σ₂) (an a₄ σ₄))} {wf-fun wft₁ wft₂ x x₁} {wf-fun wft₃ wft₄ () x₃}
-- is-≡-projT₂ {an D (BFun (an S σ₁) (an a₃ σ₃))} {an D (BFun (an D σ₂) (an a₄ σ₄))} {wf-fun wft₁ wft₂ () x₁} {wf-fun wft₃ wft₄ x₂ x₃}
-- is-≡-projT₂ {an D (BFun (an S σ₁) (an a₃ σ₃))} {an D (BFun (an S σ₂) (an a₄ σ₄))} {wf-fun wft₁ wft₂ () x₁} {wf-fun wft₃ wft₄ () x₃}
-- is-≡-projT₂ {an S (BFun α₁ α₃)} {an S (α₂ • α₄)} {wf-fun wft₁ wft₂ x x₁} {wf-pair wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an S (BFun α₁ α₃)} {an D (α₂ • α₄)} {wf-fun wft₁ wft₂ x x₁} {wf-pair wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an D (BFun α₁ α₃)} {an S (α₂ • α₄)} {wf-fun wft₁ wft₂ x x₁} {wf-pair wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an D (BFun α₁ α₃)} {an D (α₂ • α₄)} {wf-fun wft₁ wft₂ x x₁} {wf-pair wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an S (BFun α₁ α₃)} {an S (α₂ ⊎ α₄)} {wf-fun wft₁ wft₂ x x₁} {wf-sum wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an S (BFun α₁ α₃)} {an D (α₂ ⊎ α₄)} {wf-fun wft₁ wft₂ x x₁} {wf-sum wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an D (BFun α₁ α₃)} {an S (α₂ ⊎ α₄)} {wf-fun wft₁ wft₂ x x₁} {wf-sum wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an D (BFun α₁ α₃)} {an D (α₂ ⊎ α₄)} {wf-fun wft₁ wft₂ x x₁} {wf-sum wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an S (α₁ • α₃)} {an S BInt} {wf-pair wft₁ wft₂ x x₁} {wf-int} = refl
-- is-≡-projT₂ {an S (α₁ • α₃)} {an D BInt} {wf-pair wft₁ wft₂ x x₁} {wf-int} = refl
-- is-≡-projT₂ {an D (α₁ • α₃)} {an S BInt} {wf-pair wft₁ wft₂ x x₁} {wf-int} = refl
-- is-≡-projT₂ {an D (α₁ • α₃)} {an D BInt} {wf-pair wft₁ wft₂ x x₁} {wf-int} = refl
-- is-≡-projT₂ {an S (α₁ • α₃)} {an S (BFun α₂ α₄)} {wf-pair wft₁ wft₂ x x₁} {wf-fun wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an S (α₁ • α₃)} {an D (BFun α₂ α₄)} {wf-pair wft₁ wft₂ x x₁} {wf-fun wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an D (α₁ • α₃)} {an S (BFun α₂ α₄)} {wf-pair wft₁ wft₂ x x₁} {wf-fun wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an D (α₁ • α₃)} {an D (BFun α₂ α₄)} {wf-pair wft₁ wft₂ x x₁} {wf-fun wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an S (α₁ • α₃)} {an S (α₂ • α₄)} {wf-pair wft₁ wft₂ x x₁} {wf-pair wft₃ wft₄ x₂ x₃}
-- rewrite (is-≡-projT₂ {α₁} {α₂} {wft₁} {wft₃}) | (is-≡-projT₂ {α₃} {α₄} {wft₂} {wft₄})
-- = refl
-- is-≡-projT₂ {an S (α₁ • α₃)} {an D (α₂ • α₄)} {wf-pair wft₁ wft₂ x x₁} {wf-pair wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an D (α₁ • α₃)} {an S (α₂ • α₄)} {wf-pair wft₁ wft₂ x x₁} {wf-pair wft₃ wft₄ x₂ x₃} = refl
-- is-≡-projT₂ {an D (α₁ • α₃)} {an D (α₂ • α₄)} {wf-pair wft₁ wft₂ x x₁} {wf-pair wft₃ wft₄ x₂ x₃} = {!!}
-- is-≡-projT₂ {an a (α₁ • α₃)} {(an a₁ (α₂ ⊎ α₄))} {wf-pair wft₁ wft₂ x x₁} {wf-sum wft₃ wft₄ x₂ x₃} = {!!}
-- is-≡-projT₂ {(an a (α₁ ⊎ α₃))} {α₂} {wf-sum wft₁ wft₂ x x₁} {wft'} = {!!}
⊑-≡ : ∀ {a b : BT} → (e : a ⊑ b) → (e' : a ⊑ b) → e ≡ e'
⊑-≡ {S} {S} reflS reflS = refl
⊑-≡ {S} {D} S≤D S≤D = refl
⊑-≡ {D} {S} () e'
⊑-≡ {D} {D} reflD reflD = refl
wft-≡ : ∀ {α : AType} → (α₁ : wft α) → (α₂ : wft α) → α₁ ≡ α₂
wft-≡ wf-int wf-int = refl
wft-≡ (wf-fun wft₁ wft₂ x x₁) (wf-fun wft₃ wft₄ x₂ x₃) rewrite wft-≡ wft₁ wft₃ | wft-≡ wft₂ wft₄ | ⊑-≡ x x₂ | ⊑-≡ x₁ x₃
= refl
wft-≡ (wf-pair wft₁ wft₂ x x₁) (wf-pair wft₃ wft₄ x₂ x₃) rewrite wft-≡ wft₁ wft₃ | wft-≡ wft₂ wft₄ | ⊑-≡ x x₂ | ⊑-≡ x₁ x₃
= refl
wft-≡ (wf-sum wft₁ wft₂ x x₁) (wf-sum wft₃ wft₄ x₂ x₃) rewrite wft-≡ wft₁ wft₃ | wft-≡ wft₂ wft₄ | ⊑-≡ x x₂ | ⊑-≡ x₁ x₃
= refl
id-projT₂&Δ : {α : AType} {Δ : ACtx}
→ (wft : wft α) → (wfe : wfe Δ)
→ (id : α ∈ Δ)
→ projT₂ α wft ∈ (projΔ Δ wfe)
id-projT₂&Δ {α} {[]} wft wfe ()
id-projT₂&Δ {.x} {x ∷ Δ} wft (wf-∷ x₁ wfe) hd rewrite wft-≡ x₁ wft = hd {x = projT₂ x wft} {xs = projΔ Δ wfe}
id-projT₂&Δ {α} {x ∷ Δ} wft (wf-∷ x₁ wfe) (tl x₂) = tl (id-projT₂&Δ wft wfe x₂)
αAExp→wft : ∀ {α : AType} {Δ : ACtx} → (e : AExp Δ α) → wft α
αAExp→wft {α} {Δ} e = {!!}
projt₂ : ∀ {α : AType} {Δ : ACtx} → (wft : wft α) → (wfe : wfe Δ)
→ AExp Δ α → aexp (projΔ Δ wfe) (projT₂ α wft)
projt₂ {an x x₁} wft wfe (Var x₂) = Var (id-projT₂&Δ wft wfe x₂)
projt₂ {an S BInt} wf-int wfe (AInt .S x₁) = SInt x₁
projt₂ {an D BInt} wf-int wfe (AInt .D x₁) = DInt x₁
projt₂ {an S BInt} wf-int wfe (AAdd .S e e₁) = SAdd (projt₂ wf-int wfe e) (projt₂ wf-int wfe e₁)
projt₂ {an D BInt} wf-int wfe (AAdd .D e e₁) = DAdd (projt₂ wf-int wfe e) (projt₂ wf-int wfe e₁)
projt₂ {an S (BFun α₁ α₂)} {Δ} (wf-fun wft wft₁ x x₁) wfe (ALam .S x₂ e) = SLam (projt₂ {α₂} {α₁ ∷ Δ} wft₁ (wf-∷ wft wfe) e)
projt₂ {an D (BFun α₁ α₂)} {Δ} (wf-fun wft wft₁ x x₁) wfe (ALam .D x₂ e) =
DLam myrewrite
where myrewrite : aexp (D (γ→τ (projT₂ α₁ wft)) ∷ projΔ Δ wfe) (D (γ→τ (projT₂ α₂ wft₁)))
myrewrite rewrite (cong₂ aexp (cong₂ (_∷_) {D (γ→τ (projT₂ α₁ wft))} {projT₂ α₁ wft} {projΔ Δ wfe} {projΔ Δ wfe}
(eqDγ→τprojT₂ {α₁} {wft} x) refl) (eqDγ→τprojT₂ {α₂} {wft₁} x₁))
= projt₂ {α₂} {α₁ ∷ Δ} wft₁ (wf-∷ wft wfe) e
projt₂ {an x x₁} wft wfe (AApp {α₁} S (wf-fun x₂ x₃ x₄ x₅) e e₁) rewrite sym (wft-≡ x₃ wft)
= SApp {γ₁ = (projT₂ α₁ x₂)} (projt₂ (wf-fun x₂ x₃ x₄ x₅) wfe e) (projt₂ x₂ wfe e₁)
projt₂ {an S x₁} wft wfe (AApp D (wf-fun x₂ x₃ x ()) e e₁)
projt₂ {an D x₁} wft wfe (AApp {an S x₂} D (wf-fun x₃ x₄ () x₅) e e₁)
projt₂ {an D x₁} {Δ} wft wfe (AApp {an D x₂} D (wf-fun x₃ x₄ x x₅) e e₁)
rewrite sym (wft-≡ x₄ wft)
= myrewrite'
where myrewrite' : aexp (projΔ Δ wfe) (projT₂ (an D x₁) x₄)
myrewrite' rewrite sym (cong₂ aexp {(projΔ Δ wfe)} {(projΔ Δ wfe)} refl (eqDγ→τprojT₂ {an D x₁} {x₄} x₅))
= DApp (projt₂ (wf-fun x₃ x₄ x x₅) wfe e) myrewrite
where myrewrite : aexp (projΔ Δ wfe) (D (γ→τ (projT₂ (an D x₂) x₃)))
myrewrite rewrite cong₂ aexp {(projΔ Δ wfe)} {(projΔ Δ wfe)} refl (eqDγ→τprojT₂ {an D x₂} {x₃} x)
= projt₂ x₃ wfe e₁
projt₂ {an S (α₁ • α₂)} (wf-pair wft wft₁ x x₁) wfe (APair .S x₂ e e₁) = projt₂ wft wfe e , projt₂ wft₁ wfe e₁
projt₂ {an D (α₁ • α₂)} {Δ} (wf-pair wft wft₁ x x₁) wfe (APair .D x₂ e e₁)
= myrewrite1 ḋ myrewrite2
where myrewrite1 : aexp (projΔ Δ wfe) (D (γ→τ (projT₂ α₁ wft)))
myrewrite1 rewrite cong₂ aexp {(projΔ Δ wfe)} {(projΔ Δ wfe)} refl (eqDγ→τprojT₂ {α₁} {wft} x)
= projt₂ wft wfe e
myrewrite2 : aexp (projΔ Δ wfe) (D (γ→τ (projT₂ α₂ wft₁)))
myrewrite2 rewrite cong₂ aexp {(projΔ Δ wfe)} {(projΔ Δ wfe)} refl (eqDγ→τprojT₂ {α₂} {wft₁} x₁)
= projt₂ wft₁ wfe e₁
projt₂ {an S (α₁ ⊎ α₂)} (wf-sum wft wft₁ x x₁) wfe (ATl .S x₂ e) = STl (projt₂ wft wfe e)
projt₂ {an D (α₁ ⊎ α₂)} {Δ} (wf-sum wft wft₁ x x₁) wfe (ATl .D x₂ e)
= DTl myrewrite
where myrewrite : aexp (projΔ Δ wfe) (D (γ→τ (projT₂ α₁ wft)))
myrewrite rewrite cong₂ aexp {(projΔ Δ wfe)} {(projΔ Δ wfe)} refl (eqDγ→τprojT₂ {α₁} {wft} x)
= projt₂ wft wfe e
projt₂ {an S (α₁ ⊎ α₂)} (wf-sum wft wft₁ x x₁) wfe (ATr .S x₂ e) = STr (projt₂ wft₁ wfe e)
projt₂ {an D (α₁ ⊎ α₂)} {Δ} (wf-sum wft wft₁ x x₁) wfe (ATr .D x₂ e)
= DTr myrewrite
where myrewrite : aexp (projΔ Δ wfe) (D (γ→τ (projT₂ α₂ wft₁)))
myrewrite rewrite cong₂ aexp {(projΔ Δ wfe)} {(projΔ Δ wfe)} refl (eqDγ→τprojT₂ {α₂} {wft₁} x₁)
= projt₂ wft₁ wfe e
projt₂ {an x x₁} wft wfe (ACase {α₁} {α₂} {.(an x x₁)} {S} x₂ e e₁ e₂) with αAExp→wft e
projt₂ {an x₂ x₃} wft wfe (ACase {α₁} {α₂} {.(an x₂ x₃)} {S} x₄ e e₁ e₂) | wf-sum WFT WFT₁ x x₁
= SCase {γ₁ = projT₂ α₁ WFT} {γ₂ = projT₂ α₂ WFT₁}
{γ₃ = projT₂ (an x₂ x₃) wft} (projt₂ (wf-sum WFT WFT₁ x x₁) wfe e) (projt₂ wft (wf-∷ WFT wfe) e₁) (projt₂ wft (wf-∷ WFT₁ wfe) e₂)
projt₂ {an S x₁} wft wfe (ACase {α₁} {α₂} {.(an S x₁)} {D} () e e₁ e₂)
projt₂ {an D x₁} wft wfe (ACase {α₁} {α₂} {.(an D x₁)} {D} x₂ e e₁ e₂) with αAExp→wft e
projt₂ {an D x₂} {Δ} wft wfe (ACase {α₁} {α₂} {.(an D x₂)} {D} x₃ e e₁ e₂) | wf-sum WFT WFT₁ x x₁
= myrewrite
where myrewrite : aexp (projΔ Δ wfe) (projT₂ (an D x₂) wft)
myrewrite rewrite sym (cong₂ aexp {(projΔ Δ wfe)} {(projΔ Δ wfe)} refl (eqDγ→τprojT₂ {an D x₂} {wft} x₃))
= DCase (projt₂ (wf-sum WFT WFT₁ x x₁) wfe e) myrewrite1 myrewrite2
where myrewrite1 : aexp (D (γ→τ (projT₂ α₁ WFT)) ∷ projΔ Δ wfe) (D (γ→τ (projT₂ (an D x₂) wft)))
myrewrite1 rewrite (cong₂ aexp (cong₂ (_∷_) {D (γ→τ (projT₂ α₁ WFT))} {projT₂ α₁ WFT} {projΔ Δ wfe} {projΔ Δ wfe}
(eqDγ→τprojT₂ {α₁} {WFT} x) refl) (eqDγ→τprojT₂ {an D x₂} {wft} x₃))
= projt₂ wft (wf-∷ WFT wfe) e₁
myrewrite2 : aexp (D (γ→τ (projT₂ α₂ WFT₁)) ∷ projΔ Δ wfe) (D (γ→τ (projT₂ (an D x₂) wft)))
myrewrite2 rewrite (cong₂ aexp (cong₂ (_∷_) {D (γ→τ (projT₂ α₂ WFT₁))} {projT₂ α₂ WFT₁} {projΔ Δ wfe} {projΔ Δ wfe}
(eqDγ→τprojT₂ {α₂} {WFT₁} x₁) refl) (eqDγ→τprojT₂ {an D x₂} {wft} x₃))
= projt₂ wft (wf-∷ WFT₁ wfe) e₂
projt₂ {an D x₁} wft wfe (Lift x e) = {!!}
|
{
"alphanum_fraction": 0.4597405122,
"avg_line_length": 47.0915331808,
"ext": "agda",
"hexsha": "83139cfb6b550c141286d65fa08f15fee6c8d0e2",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-10-15T09:01:37.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-10-15T09:01:37.000Z",
"max_forks_repo_head_hexsha": "ef878f7fa5afa51fb7a14cd8f7f75da0af1b9deb",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "luminousfennell/polybta",
"max_forks_repo_path": "BTA10.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "ef878f7fa5afa51fb7a14cd8f7f75da0af1b9deb",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "luminousfennell/polybta",
"max_issues_repo_path": "BTA10.agda",
"max_line_length": 146,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "ef878f7fa5afa51fb7a14cd8f7f75da0af1b9deb",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "luminousfennell/polybta",
"max_stars_repo_path": "BTA10.agda",
"max_stars_repo_stars_event_max_datetime": "2019-10-15T04:35:29.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-10-15T04:35:29.000Z",
"num_tokens": 19102,
"size": 41158
}
|
{-# OPTIONS --prop --rewriting #-}
open import Examples.Sorting.Sequential.Comparable
module Examples.Sorting.Sequential.MergeSort (M : Comparable) where
open Comparable M
open import Examples.Sorting.Sequential.Core M
open import Calf costMonoid
open import Calf.Types.Bool
open import Calf.Types.Nat
open import Calf.Types.List
open import Calf.Types.Eq
open import Calf.Types.Bounded costMonoid
open import Calf.Types.BigO costMonoid
open import Relation.Nullary
open import Relation.Nullary.Negation
open import Relation.Binary.PropositionalEquality as Eq using (_≡_; refl; module ≡-Reasoning)
open import Data.Product using (_×_; _,_; ∃)
open import Data.Sum using (inj₁; inj₂)
open import Function
open import Data.Nat as Nat using (ℕ; zero; suc; z≤n; s≤s; _+_; _*_; ⌊_/2⌋; ⌈_/2⌉)
import Data.Nat.Properties as N
open import Data.Nat.Square
open import Data.Nat.Log2
open import Examples.Sorting.Sequential.MergeSort.Split M public
open import Examples.Sorting.Sequential.MergeSort.Merge M public
sort/clocked : cmp (Π nat λ _ → Π (list A) λ _ → F (list A))
sort/clocked zero l = ret l
sort/clocked (suc k) l =
bind (F (list A)) (split l) λ (l₁ , l₂) →
bind (F (list A)) (sort/clocked k l₁) λ l₁' →
bind (F (list A)) (sort/clocked k l₂) λ l₂' →
merge (l₁' , l₂')
sort/clocked/correct : ∀ k l → ⌈log₂ length l ⌉ Nat.≤ k → SortResult (sort/clocked k) l
sort/clocked/correct zero l h u = l , refl , refl , short-sorted (⌈log₂n⌉≡0⇒n≤1 (N.n≤0⇒n≡0 h))
sort/clocked/correct (suc k) l h u =
let (l₁ , l₂ , ≡ , length₁ , length₂ , ↭) = split/correct l u in
let (l₁' , ≡₁ , ↭₁ , sorted₁) = sort/clocked/correct k l₁ (
let open ≤-Reasoning in
begin
⌈log₂ length l₁ ⌉
≡⟨ Eq.cong ⌈log₂_⌉ length₁ ⟩
⌈log₂ ⌊ length l /2⌋ ⌉
≤⟨ log₂-mono (N.⌊n/2⌋≤⌈n/2⌉ (length l)) ⟩
⌈log₂ ⌈ length l /2⌉ ⌉
≤⟨ log₂-suc (length l) h ⟩
k
∎
) u in
let (l₂' , ≡₂ , ↭₂ , sorted₂) = sort/clocked/correct k l₂ (
let open ≤-Reasoning in
begin
⌈log₂ length l₂ ⌉
≡⟨ Eq.cong ⌈log₂_⌉ length₂ ⟩
⌈log₂ ⌈ length l /2⌉ ⌉
≤⟨ log₂-suc (length l) h ⟩
k
∎
) u in
let (l' , ≡' , h-sorted) = merge/correct l₁' l₂' u
(↭' , sorted) = h-sorted sorted₁ sorted₂
in
l' , (
let open ≡-Reasoning in
begin
sort/clocked (suc k) l
≡⟨⟩
(bind (F (list A)) (split l) λ (l₁ , l₂) →
bind (F (list A)) (sort/clocked k l₁) λ l₁' →
bind (F (list A)) (sort/clocked k l₂) λ l₂' →
merge (l₁' , l₂'))
≡⟨ Eq.cong (λ e → bind (F (list A)) e _) ≡ ⟩
(bind (F (list A)) (sort/clocked k l₁) λ l₁' →
bind (F (list A)) (sort/clocked k l₂) λ l₂' →
merge (l₁' , l₂'))
≡⟨ Eq.cong (λ e → bind (F (list A)) e λ l₁' → bind (F (list A)) (sort/clocked k l₂) _) ≡₁ ⟩
(bind (F (list A)) (sort/clocked k l₂) λ l₂' →
merge (l₁' , l₂'))
≡⟨ Eq.cong (λ e → bind (F (list A)) e λ l₂' → merge (l₁' , l₂')) ≡₂ ⟩
merge (l₁' , l₂')
≡⟨ ≡' ⟩
ret l'
∎
) , (
let open PermutationReasoning in
begin
l
↭⟨ ↭ ⟩
l₁ ++ l₂
↭⟨ ++⁺-↭ ↭₁ ↭₂ ⟩
l₁' ++ l₂'
↭⟨ ↭' ⟩
l'
∎
) , sorted
sort/clocked/cost : cmp (Π nat λ _ → Π (list A) λ _ → cost)
sort/clocked/cost zero l = zero
sort/clocked/cost (suc k) l =
bind cost (split l) λ (l₁ , l₂) → split/cost l +
bind cost (sort/clocked k l₁) λ l₁' → sort/clocked/cost k l₁ +
bind cost (sort/clocked k l₂) λ l₂' → sort/clocked/cost k l₂ +
merge/cost/closed (l₁' , l₂')
sort/clocked/cost/closed : cmp (Π nat λ _ → Π (list A) λ _ → cost)
sort/clocked/cost/closed k l = k * length l
sort/clocked/cost≡sort/clocked/cost/closed : ∀ k l → ⌈log₂ length l ⌉ Nat.≤ k → ◯ (sort/clocked/cost k l ≡ sort/clocked/cost/closed k l)
sort/clocked/cost≡sort/clocked/cost/closed zero l h u = refl
sort/clocked/cost≡sort/clocked/cost/closed (suc k) l h u =
let (l₁ , l₂ , ≡ , length₁ , length₂ , ↭) = split/correct l u in
let h₁ : ⌈log₂ length l₁ ⌉ Nat.≤ k
h₁ =
let open ≤-Reasoning in
begin
⌈log₂ length l₁ ⌉
≡⟨ Eq.cong ⌈log₂_⌉ length₁ ⟩
⌈log₂ ⌊ length l /2⌋ ⌉
≤⟨ log₂-mono (N.⌊n/2⌋≤⌈n/2⌉ (length l)) ⟩
⌈log₂ ⌈ length l /2⌉ ⌉
≤⟨ log₂-suc (length l) h ⟩
k
∎
h₂ : ⌈log₂ length l₂ ⌉ Nat.≤ k
h₂ =
let open ≤-Reasoning in
begin
⌈log₂ length l₂ ⌉
≡⟨ Eq.cong ⌈log₂_⌉ length₂ ⟩
⌈log₂ ⌈ length l /2⌉ ⌉
≤⟨ log₂-suc (length l) h ⟩
k
∎
in
let (l₁' , ≡₁ , ↭₁ , sorted₁) = sort/clocked/correct k l₁ h₁ u in
let (l₂' , ≡₂ , ↭₂ , sorted₂) = sort/clocked/correct k l₂ h₂ u in
let open ≡-Reasoning in
begin
sort/clocked/cost (suc k) l
≡⟨⟩
(bind cost (split l) λ (l₁ , l₂) → split/cost l +
bind cost (sort/clocked k l₁) λ l₁' → sort/clocked/cost k l₁ +
bind cost (sort/clocked k l₂) λ l₂' → sort/clocked/cost k l₂ +
merge/cost/closed (l₁' , l₂'))
≡⟨ Eq.cong (λ e → bind cost e _) (≡) ⟩
(split/cost l +
bind cost (sort/clocked k l₁) λ l₁' → sort/clocked/cost k l₁ +
bind cost (sort/clocked k l₂) λ l₂' → sort/clocked/cost k l₂ +
merge/cost/closed (l₁' , l₂'))
≡⟨⟩
(0 +
bind cost (sort/clocked k l₁) λ l₁' → sort/clocked/cost k l₁ +
bind cost (sort/clocked k l₂) λ l₂' → sort/clocked/cost k l₂ +
merge/cost/closed (l₁' , l₂'))
≡⟨ N.+-identityˡ _ ⟩
(bind cost (sort/clocked k l₁) λ l₁' → sort/clocked/cost k l₁ +
bind cost (sort/clocked k l₂) λ l₂' → sort/clocked/cost k l₂ +
merge/cost/closed (l₁' , l₂'))
≡⟨
Eq.cong
(λ e →
bind cost e λ l₁' → sort/clocked/cost k l₁ +
bind cost (sort/clocked k l₂) λ l₂' → sort/clocked/cost k l₂ +
merge/cost/closed (l₁' , l₂'))
≡₁
⟩
(sort/clocked/cost k l₁ +
bind cost (sort/clocked k l₂) λ l₂' → sort/clocked/cost k l₂ +
merge/cost/closed (l₁' , l₂'))
≡⟨
Eq.cong
(λ e →
sort/clocked/cost k l₁ +
bind cost e λ l₂' → sort/clocked/cost k l₂ +
merge/cost/closed (l₁' , l₂'))
≡₂
⟩
sort/clocked/cost k l₁ + (sort/clocked/cost k l₂ + merge/cost/closed (l₁' , l₂'))
≡˘⟨ N.+-assoc (sort/clocked/cost k l₁) (sort/clocked/cost k l₂) (merge/cost/closed (l₁' , l₂')) ⟩
(sort/clocked/cost k l₁ + sort/clocked/cost k l₂) + merge/cost/closed (l₁' , l₂')
≡⟨
Eq.cong (_+ merge/cost/closed (l₁' , l₂')) (
Eq.cong₂ _+_
(sort/clocked/cost≡sort/clocked/cost/closed k l₁ h₁ u)
(sort/clocked/cost≡sort/clocked/cost/closed k l₂ h₂ u)
)
⟩
(sort/clocked/cost/closed k l₁ + sort/clocked/cost/closed k l₂) + merge/cost/closed (l₁' , l₂')
≡⟨⟩
(sort/clocked/cost/closed k l₁ + sort/clocked/cost/closed k l₂) + (length l₁' + length l₂')
≡˘⟨
Eq.cong ((sort/clocked/cost/closed k l₁ + sort/clocked/cost/closed k l₂) +_) (
Eq.cong₂ _+_ (↭-length ↭₁) (↭-length ↭₂)
)
⟩
(sort/clocked/cost/closed k l₁ + sort/clocked/cost/closed k l₂) + (length l₁ + length l₂)
≡⟨⟩
(k * length l₁ + k * length l₂) + (length l₁ + length l₂)
≡⟨
Eq.cong₂
(λ n₁ n₂ → k * n₁ + k * n₂ + (n₁ + n₂))
length₁
length₂
⟩
(k * ⌊ length l /2⌋ + k * ⌈ length l /2⌉) + (⌊ length l /2⌋ + ⌈ length l /2⌉)
≡⟨ N.+-comm _ (⌊ length l /2⌋ + ⌈ length l /2⌉) ⟩
(⌊ length l /2⌋ + ⌈ length l /2⌉) + (k * ⌊ length l /2⌋ + k * ⌈ length l /2⌉)
≡˘⟨ Eq.cong ((⌊ length l /2⌋ + ⌈ length l /2⌉) +_) (N.*-distribˡ-+ k _ _) ⟩
(⌊ length l /2⌋ + ⌈ length l /2⌉) + k * (⌊ length l /2⌋ + ⌈ length l /2⌉)
≡⟨⟩
suc k * (⌊ length l /2⌋ + ⌈ length l /2⌉)
≡⟨ Eq.cong (suc k *_) (N.⌊n/2⌋+⌈n/2⌉≡n (length l)) ⟩
suc k * length l
∎
sort/clocked≤sort/clocked/cost : ∀ k l → IsBounded (list A) (sort/clocked k l) (sort/clocked/cost k l)
sort/clocked≤sort/clocked/cost zero l = bound/ret
sort/clocked≤sort/clocked/cost (suc k) l =
bound/bind _ _ (split≤split/cost l) λ (l₁ , l₂) →
bound/bind _ _ (sort/clocked≤sort/clocked/cost k l₁) λ l₁' →
bound/bind _ _ (sort/clocked≤sort/clocked/cost k l₂) λ l₂' →
merge≤merge/cost/closed (l₁' , l₂')
sort/clocked≤sort/clocked/cost/closed : ∀ k l → ⌈log₂ length l ⌉ Nat.≤ k → IsBounded (list A) (sort/clocked k l) (sort/clocked/cost/closed k l)
sort/clocked≤sort/clocked/cost/closed k l h = bound/relax (λ u → N.≤-reflexive (sort/clocked/cost≡sort/clocked/cost/closed k l h u)) (sort/clocked≤sort/clocked/cost k l)
sort/depth : cmp (Π (list A) λ _ → meta ℕ)
sort/depth l = ⌈log₂ length l ⌉
sort : cmp (Π (list A) λ _ → F (list A))
sort l = sort/clocked (sort/depth l) l
sort/correct : IsSort sort
sort/correct l = sort/clocked/correct (sort/depth l) l N.≤-refl
sort/cost : cmp (Π (list A) λ _ → cost)
sort/cost l = sort/clocked/cost (sort/depth l) l
sort/cost/closed : cmp (Π (list A) λ _ → cost)
sort/cost/closed l = sort/clocked/cost/closed (sort/depth l) l
sort≤sort/cost : ∀ l → IsBounded (list A) (sort l) (sort/cost l)
sort≤sort/cost l = sort/clocked≤sort/clocked/cost (sort/depth l) l
sort≤sort/cost/closed : ∀ l → IsBounded (list A) (sort l) (sort/cost/closed l)
sort≤sort/cost/closed l = sort/clocked≤sort/clocked/cost/closed (sort/depth l) l N.≤-refl
sort/asymptotic : given (list A) measured-via length , sort ∈𝓞(λ n → n * ⌈log₂ n ⌉)
sort/asymptotic = 0 ≤n⇒f[n]≤g[n]via λ l _ →
bound/relax
(λ u → ≤-reflexive (N.*-comm ⌈log₂ length l ⌉ (length l)))
(sort≤sort/cost/closed l)
|
{
"alphanum_fraction": 0.5396088503,
"avg_line_length": 38.7892720307,
"ext": "agda",
"hexsha": "c661568b6d3839bf946bbe1ba87469ecce851e39",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2022-01-29T08:12:01.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-10-06T10:28:24.000Z",
"max_forks_repo_head_hexsha": "e51606f9ca18d8b4cf9a63c2d6caa2efc5516146",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "jonsterling/agda-calf",
"max_forks_repo_path": "src/Examples/Sorting/Sequential/MergeSort.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e51606f9ca18d8b4cf9a63c2d6caa2efc5516146",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Apache-2.0"
],
"max_issues_repo_name": "jonsterling/agda-calf",
"max_issues_repo_path": "src/Examples/Sorting/Sequential/MergeSort.agda",
"max_line_length": 169,
"max_stars_count": 29,
"max_stars_repo_head_hexsha": "e51606f9ca18d8b4cf9a63c2d6caa2efc5516146",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "jonsterling/agda-calf",
"max_stars_repo_path": "src/Examples/Sorting/Sequential/MergeSort.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-22T20:35:11.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-07-14T03:18:28.000Z",
"num_tokens": 4030,
"size": 10124
}
|
module Data.Union.Relation.Binary.Subtype.Instances where
open import Data.List using (List)
open import Data.List.Relation.Binary.Subset.Propositional.Instances using (⦅_⊆_⦆; [_])
open import Data.Union using (Union)
open import Data.Union.Relation.Binary.Subtype
using (_≼_; _,_⊢_≼_; refl; trans; generalize; function)
open import Level using (Level; _⊔_)
private
variable
a b c d f : Level
A : Set a
B : Set b
C : Set c
D : Set d
F : A → Set f
ts ts′ : List A
-- ----------------------------------------------------------------------
-- Wrapped subtypes
infix 4 ⦅_≼_⦆ ⦅_,_⊢_≼_⦆
data ⦅_≼_⦆ {a b} : Set a → Set b → Set (a ⊔ b) where
[_] : A ≼ B → ⦅ A ≼ B ⦆
⦅_,_⊢_≼_⦆ : (A : Set a) → (B : A → Set b) → List A → List A → Set (a ⊔ b)
⦅ A , B ⊢ ts ≼ ts′ ⦆ = ⦅ Union A B ts ≼ Union A B ts′ ⦆
proj : ⦅ A ≼ B ⦆ → A ≼ B
proj [ A≼B ] = A≼B
⊢proj : ⦅ A , F ⊢ ts ≼ ts′ ⦆ → A , F ⊢ ts ≼ ts′
⊢proj [ A,F⊢ts≼ts′ ] = A,F⊢ts≼ts′
-- ----------------------------------------------------------------------
-- Instances
instance
⦃refl⦄ : ⦅ A ≼ A ⦆
⦃refl⦄ = [ refl ]
-- Removed since the transitivity of ⊆ provides this
-- Also now allows for syntax directed instance search :)
-- ⦃trans⦄ : ⦃ ⦅ A ≼ B ⦆ ⦄ → ⦃ ⦅ B ≼ C ⦆ ⦄ → ⦅ A ≼ C ⦆
-- ⦃trans⦄ ⦃ [ A≼B ] ⦄ ⦃ [ B≼C ] ⦄ = [ trans A≼B B≼C ]
⦃generalize⦄ : ⦃ ⦅ ts ⊆ ts′ ⦆ ⦄ → ⦅ A , F ⊢ ts ≼ ts′ ⦆
⦃generalize⦄ ⦃ [ ts⊆ts′ ] ⦄ = [ generalize ts⊆ts′ ]
⦃function⦄ : ⦃ ⦅ C ≼ A ⦆ ⦄ → ⦃ ⦅ B ≼ D ⦆ ⦄ → ⦅ (A → B) ≼ (C → D) ⦆
⦃function⦄ ⦃ [ C≼A ] ⦄ ⦃ [ B≼D ] ⦄ = [ function C≼A B≼D ]
-- ----------------------------------------------------------------------
-- Coercion using instance search
⌊_⌋ : ⦃ ⦅ A ≼ B ⦆ ⦄ → A → B
⌊_⌋ ⦃ [ A≼B ] ⦄ A = A≼B A
|
{
"alphanum_fraction": 0.4436133487,
"avg_line_length": 27.5873015873,
"ext": "agda",
"hexsha": "cfaab33cbb5977792664306d088dd285beb6bc8b",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "921a0dc44a69a74391031ca61568c624ab7f9c94",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "johnyob/agda-union",
"max_forks_repo_path": "src/Data/Union/Relation/Binary/Subtype/Instances.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "921a0dc44a69a74391031ca61568c624ab7f9c94",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "johnyob/agda-union",
"max_issues_repo_path": "src/Data/Union/Relation/Binary/Subtype/Instances.agda",
"max_line_length": 87,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "921a0dc44a69a74391031ca61568c624ab7f9c94",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "johnyob/agda-union",
"max_stars_repo_path": "src/Data/Union/Relation/Binary/Subtype/Instances.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 836,
"size": 1738
}
|
data _≡_ {a} {A : Set a} (x : A) : A → Set a where
refl : x ≡ x
record Σ (A : Set) (B : A → Set) : Set where
constructor _,_
field
proj₁ : A
proj₂ : B proj₁
open Σ
postulate
I : Set
U : I → Set
El : ∀ {i} → U i → Set
Ctxt : Set
Env : Ctxt → Set
Type : Ctxt → Set
Type Γ = Σ I λ i → Env Γ → U i
Value : (Γ : Ctxt) → Type Γ → Set
Value Γ σ = (γ : Env Γ) → El (proj₂ σ γ)
_/id : ∀ {Γ} → Type Γ → Type Γ
(i , σ) /id = i , σ
data [Type] : Set where
[_] : ∀ {Γ} → Type Γ → [Type]
_≅-Type_ : ∀ {Γ} (σ₁ σ₂ : Type Γ) → Set
σ₁ ≅-Type σ₂ = [ σ₁ ] ≡ [ σ₂ ]
data [Value] : Set where
[_] : ∀ {Γ σ} → Value Γ σ → [Value]
_≅-Value_ : ∀ {Γ σ} (v₁ v₂ : Value Γ σ) → Set
v₁ ≅-Value v₂ = [Value].[ v₁ ] ≡ [ v₂ ]
Foo : ∀ {Γ} {σ₁ σ₂ : Type Γ} {v : Value Γ (σ₁ /id)} →
σ₁ ≅-Type σ₂ → v ≅-Value v → Set₁
Foo refl refl = Set
|
{
"alphanum_fraction": 0.483490566,
"avg_line_length": 19.7209302326,
"ext": "agda",
"hexsha": "f253ae6615d7c2eefb4b7f9dfb0258f474bb7ed4",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue1872.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue1872.agda",
"max_line_length": 53,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue1872.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 399,
"size": 848
}
|
{-# OPTIONS --rewriting #-}
module NewEquations where
open import Common.Prelude hiding (map; _++_)
open import Common.Equality
infixr 5 _++_
map : ∀ {A B : Set} → (A → B) → List A → List B
map f [] = []
map f (x ∷ xs) = (f x) ∷ (map f xs)
_++_ : ∀ {A : Set} → List A → List A → List A
[] ++ ys = ys
(x ∷ xs) ++ ys = x ∷ (xs ++ ys)
fold : ∀ {A B : Set} → (A → B → B) → B → List A → B
fold f v [] = v
fold f v (x ∷ xs) = f x (fold f v xs)
++-[] : ∀ {A} {xs : List A} → xs ++ [] ≡ xs
++-[] {xs = []} = refl
++-[] {xs = x ∷ xs} = cong (_∷_ x) ++-[]
++-assoc : ∀ {A} {xs ys zs : List A} → (xs ++ ys) ++ zs ≡ xs ++ (ys ++ zs)
++-assoc {xs = []} = refl
++-assoc {xs = x ∷ xs} = cong (_∷_ x) (++-assoc {xs = xs})
map-id : ∀ {A} {xs : List A} → map (λ x → x) xs ≡ xs
map-id {xs = []} = refl
map-id {xs = x ∷ xs} = cong (_∷_ x) map-id
map-fuse : ∀ {A B C} {f : B → C} {g : A → B} {xs : List A} → map f (map g xs) ≡ map (λ x → f (g x)) xs
map-fuse {xs = []} = refl
map-fuse {xs = x ∷ xs} = cong (_∷_ _) map-fuse
map-++ : ∀ {A B} {f : A → B} {xs ys : List A} → map f (xs ++ ys) ≡ (map f xs) ++ (map f ys)
map-++ {xs = []} = refl
map-++ {xs = x ∷ xs} = cong (_∷_ _) (map-++ {xs = xs})
fold-map : ∀ {A B C} {f : A → B} {c : B → C → C} {n : C} {xs : List A} →
fold c n (map f xs) ≡ fold (λ x → c (f x)) n xs
fold-map {xs = []} = refl
fold-map {c = c} {xs = x ∷ xs} = cong (c _) (fold-map {xs = xs})
fold-++ : ∀ {A B} {c : A → B → B} {n : B} {xs ys : List A} →
fold c n (xs ++ ys) ≡ fold c (fold c n ys) xs
fold-++ {xs = []} = refl
fold-++ {c = c} {xs = x ∷ xs} = cong (c _) (fold-++ {xs = xs})
{-# BUILTIN REWRITE _≡_ #-}
{-# REWRITE ++-[] #-}
{-# REWRITE ++-assoc #-}
{-# REWRITE map-id #-}
{-# REWRITE map-fuse #-}
{-# REWRITE map-++ #-}
{-# REWRITE fold-map #-}
{-# REWRITE fold-++ #-}
record _×_ (A B : Set) : Set where
constructor _,_
field
fst : A
snd : B
swap : ∀ {A B} → A × B → B × A
swap (x , y) = y , x
test₁ : ∀ {A B} {xs : List (A × B)} → map swap (map swap xs) ≡ xs
test₁ = refl
|
{
"alphanum_fraction": 0.4460325283,
"avg_line_length": 28.1805555556,
"ext": "agda",
"hexsha": "751fa62b7188341f9f6e5b421f846c6ab9121723",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "alhassy/agda",
"max_forks_repo_path": "test/Succeed/NewEquations.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "alhassy/agda",
"max_issues_repo_path": "test/Succeed/NewEquations.agda",
"max_line_length": 102,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "alhassy/agda",
"max_stars_repo_path": "test/Succeed/NewEquations.agda",
"max_stars_repo_stars_event_max_datetime": "2015-12-07T20:14:00.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-03-28T14:51:03.000Z",
"num_tokens": 871,
"size": 2029
}
|
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NType2
open import lib.NConnected
open import lib.types.Nat
open import lib.types.Subtype
open import lib.types.Truncation
-- classifying types of automorphism groups of types
module lib.types.BAut where
BAut : ∀ {i} → Type i → Type (lsucc i)
BAut {i} A = Σ (Type i) λ X → Trunc -1 (A == X)
BAut-prop : ∀ {i} (A : Type i) → SubtypeProp (Type i) (lsucc i)
BAut-prop A = ((λ X → Trunc -1 (A == X)) , (λ X → Trunc-level))
pBAut : ∀ {i} → Type i → Ptd (lsucc i)
de⊙ (pBAut A) = BAut A
pt (pBAut A) = A , [ idp ]
BAut-trunc-path : ∀ {i} (A X : Type i) → (tp : Trunc -1 (A == X))
→ Trunc -1 ((A , [ idp ]) == (X , tp) :> BAut A)
BAut-trunc-path {i} A X = Trunc-elim λ p → [ pair= p prop-has-all-paths-↓ ]
BAut-conn : ∀ {i} (A : Type i) → is-connected 0 (BAut A)
fst (has-level-apply (BAut-conn A)) = [ pt (pBAut A) ]
snd (has-level-apply (BAut-conn A)) = Trunc-elim (λ { (X , tp) → <– (=ₜ-equiv [ A , [ idp ] ] [ X , tp ])
(BAut-trunc-path A X tp) })
|
{
"alphanum_fraction": 0.545210385,
"avg_line_length": 36.0322580645,
"ext": "agda",
"hexsha": "e6ca12224092ab74eadd52bd9b57576b71fddbd8",
"lang": "Agda",
"max_forks_count": 50,
"max_forks_repo_forks_event_max_datetime": "2022-02-14T03:03:25.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-10T01:48:08.000Z",
"max_forks_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "AntoineAllioux/HoTT-Agda",
"max_forks_repo_path": "core/lib/types/BAut.agda",
"max_issues_count": 31,
"max_issues_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_issues_repo_issues_event_max_datetime": "2021-10-03T19:15:25.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-03-05T20:09:00.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "AntoineAllioux/HoTT-Agda",
"max_issues_repo_path": "core/lib/types/BAut.agda",
"max_line_length": 105,
"max_stars_count": 294,
"max_stars_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "AntoineAllioux/HoTT-Agda",
"max_stars_repo_path": "core/lib/types/BAut.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-20T13:54:45.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T16:23:23.000Z",
"num_tokens": 403,
"size": 1117
}
|
{-# OPTIONS --without-K #-}
module GroupoidStructure {a} {A : Set a} where
open import PathOperations
open import Types
p·p⁻¹ : {a b : A} (p : a ≡ b) → p · p ⁻¹ ≡ refl
p·p⁻¹ = J (λ _ _ p → p · p ⁻¹ ≡ refl) (λ _ → refl) _ _
p⁻¹·p : {a b : A} (p : a ≡ b) → p ⁻¹ · p ≡ refl
p⁻¹·p = J (λ _ _ p → p ⁻¹ · p ≡ refl) (λ _ → refl) _ _
p·id : {a b : A} (p : a ≡ b) → p · refl ≡ p
p·id = J (λ _ _ p → p · refl ≡ p) (λ _ → refl) _ _
id·p : {a b : A} (p : a ≡ b) → refl · p ≡ p
id·p _ = refl
p·q·r : {a b c d : A} (p : a ≡ b) (q : b ≡ c) (r : c ≡ d) →
p · (q · r) ≡ (p · q) · r
p·q·r {c = c} {d = d} = J
(λ _ b p → (q : b ≡ c) (r : c ≡ d) → p · q · r ≡ (p · q) · r)
(λ b → J
(λ _ c q → (r : c ≡ d) → refl · q · r ≡ (refl · q) · r)
(λ _ _ → refl) _ _)
_ _
|
{
"alphanum_fraction": 0.4005235602,
"avg_line_length": 28.2962962963,
"ext": "agda",
"hexsha": "f7908c7e69baed5ef87e5201c977ab8d9b21ed8b",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7730385adfdbdda38ee8b124be3cdeebb7312c65",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "vituscze/HoTT-lectures",
"max_forks_repo_path": "src/GroupoidStructure.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7730385adfdbdda38ee8b124be3cdeebb7312c65",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "vituscze/HoTT-lectures",
"max_issues_repo_path": "src/GroupoidStructure.agda",
"max_line_length": 63,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "7730385adfdbdda38ee8b124be3cdeebb7312c65",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "vituscze/HoTT-lectures",
"max_stars_repo_path": "src/GroupoidStructure.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 411,
"size": 764
}
|
------------------------------------------------------------------------
-- An example of how Abstract-binding-tree can be used
------------------------------------------------------------------------
{-# OPTIONS --cubical --safe #-}
module README.Abstract-binding-tree where
open import Dec
open import Equality.Path
open import Prelude as P hiding (swap; [_,_]; type-signature)
open import Abstract-binding-tree equality-with-paths
open import Bijection equality-with-J using (_↔_)
open import Equality.Decision-procedures equality-with-J
open import Equivalence equality-with-J using (_≃_)
open import Erased.Cubical equality-with-paths as E
open import Finite-subset.Listed equality-with-paths as L
open import Function-universe equality-with-J as F hiding (id; _∘_)
open import H-level equality-with-J
open import H-level.Closure equality-with-J
open import H-level.Truncation.Propositional equality-with-paths
as Trunc
import Nat equality-with-J as Nat
-- Sorts: expressions and statements.
Sort : Type
Sort = Bool
pattern expr = true
pattern stmt = false
-- Constructors: lambda, application and print.
data Constructor : @0 Sort → Type where
exprᶜ : Bool → Constructor expr
stmtᶜ : ⊤ → Constructor stmt
pattern lamᶜ = exprᶜ true
pattern appᶜ = exprᶜ false
pattern printᶜ = stmtᶜ tt
-- Erased equality of constructors is decidable.
_≟O_ : ∀ {@0 s} → Decidable-erased-equality (Constructor s)
exprᶜ x ≟O exprᶜ y = Dec-Erased-map
(record { to = cong exprᶜ
; from = cong (λ { (exprᶜ x) → x })
})
(Decidable-equality→Decidable-erased-equality
Bool._≟_ x y)
printᶜ ≟O printᶜ = yes [ refl ]
-- Variables are natural numbers.
Var : @0 Sort → Type
Var _ = ℕ
-- A signature.
sig : Signature lzero
sig .Signature.Sort = Sort
sig .Signature.Op = Constructor
sig .Signature.domain lamᶜ = (expr ∷ [] , expr) ∷ []
sig .Signature.domain appᶜ = ([] , expr) ∷ ([] , expr) ∷ []
sig .Signature.domain printᶜ = ([] , expr) ∷ []
sig .Signature.Var = Var
sig .Signature._≟O_ = _≟O_
sig .Signature._≟S_ =
Decidable-equality→Decidable-erased-equality Bool._≟_
sig .Signature._≟V_ =
Decidable-equality→Decidable-erased-equality Nat._≟_
sig .Signature.fresh {s = s} xs = $⟨ L.fresh (L.map proj₂ xs) ⟩
(∃ λ n → n ∉ L.map proj₂ xs) ↝⟨ Σ-map id [_]→ ⟩
(∃ λ n → Erased (n ∉ L.map proj₂ xs)) ↝⟨ (∃-cong λ n → E.map (
n ∉ L.map proj₂ xs ↔⟨ ¬-cong ext ∈map≃ ⟩
¬ ∥ (∃ λ x → x ∈ xs × proj₂ x ≡ n) ∥ ↔⟨ ¬∥∥↔¬ ⟩
¬ (∃ λ x → x ∈ xs × proj₂ x ≡ n) ↝⟨ (λ hyp ∈xs → hyp (_ , ∈xs , refl)) ⟩□
(s , n) ∉ xs □)) ⟩□
(∃ λ n → Erased ((s , n) ∉ xs)) □
open Signature sig public
hiding (Sort; Var; _≟O_)
renaming (var to varᶜ)
private
variable
@0 s : Sort
@0 xs : Vars
@0 A : Type
@0 x : A
-- Pattern synonyms.
pattern varᵖ x wf = varᶜ , x , [ wf ]
pattern lamˢᵖ tˢ =
op lamᶜ (cons (cons (nil tˢ)) nil)
pattern lamᵖ x tˢ t wf =
lamˢᵖ tˢ
, ((x , t) , lift tt)
, [ wf , lift tt ]
pattern appˢᵖ t₁ˢ t₂ˢ =
op appᶜ (cons (nil t₁ˢ) (cons (nil t₂ˢ) nil))
pattern appᵖ t₁ˢ t₂ˢ t₁ t₂ wf₁ wf₂ =
appˢᵖ t₁ˢ t₂ˢ
, (t₁ , t₂ , lift tt)
, [ wf₁ , wf₂ , lift tt ]
pattern printˢᵖ tˢ =
op printᶜ (cons (nil tˢ) nil)
pattern printᵖ tˢ t wf =
printˢᵖ tˢ
, (t , lift tt)
, [ wf , lift tt ]
-- Some (more or less) smart constructors.
var : ∀ {s} (x : Var s) → Term ((s , x) ∷ xs) s
var x = varᵖ x (≡→∈∷ refl)
lam :
(x : Var expr) →
Term ((expr , x) ∷ xs) expr →
Term xs expr
lam x (tˢ , t , [ wf ]) =
lamᵖ x tˢ t (λ _ _ → rename₁-Wf tˢ wf)
app : Term xs expr → Term xs expr → Term xs expr
app (t₁ˢ , t₁ , [ wf₁ ]) (t₂ˢ , t₂ , [ wf₂ ]) =
appᵖ t₁ˢ t₂ˢ t₁ t₂ wf₁ wf₂
print : Term xs expr → Term xs stmt
print (tˢ , t , [ wf ]) = printᵖ tˢ t wf
-- A representation of "λ x. x".
λx→x : Term [] expr
λx→x = lam 0 (var 0)
-- A representation of "λ x y. y y".
λxy→yy : Term [] expr
λxy→yy = lam 1 $ lam 2 $ app (var 2) (var 2)
-- Two representations of "λ x y. x y".
private
λxy→xy : ℕ → ℕ → Term [] expr
λxy→xy x y =
lam x $ lam y $ app (weaken (λ _ → ∈→∈∷) (var x)) (var y)
λxy→xy₁ : Term [] expr
λxy→xy₁ = λxy→xy 2 1
λxy→xy₂ : Term [] expr
λxy→xy₂ = λxy→xy 1 2
-- A representation of "print (λ x y. x y)".
print[λxy→xy] : Term [] stmt
print[λxy→xy] = print λxy→xy₁
-- A third representation of "λ x y. x y".
λxy→xy₃ : Term [] expr
λxy→xy₃ = weaken lemma λxy→xy₁ [ 0 ← λx→x ]
where
@0 lemma : _
lemma =
from-⊎ $
subset?
(decidable→decidable-∥∥
(Decidable-erased-equality≃Decidable-equality _ _≟∃V_))
[]
((expr , 0) ∷ [])
-- The second and third representations of "λ x y. x y" are equal (in
-- erased contexts).
@0 _ : λxy→xy₂ ≡ λxy→xy₃
_ = Wf-proof-irrelevant
-- An interpreter that uses fuel.
eval : ∀ {xs} → ℕ → Term xs s → Term xs s
eval zero t = t
eval (suc n) t = eval′ t
where
apply : ∀ {xs} → @0 s ≡ expr → Term xs s → Term xs s → Term xs s
apply _ (lamᵖ x t₁ˢ′ t₁′ wf₁′) t₂′ =
eval n (subst-Term x t₂′
( t₁ˢ′
, t₁′
, [ body-Wf t₁ˢ′ wf₁′ ]
))
apply s≡expr t₁′ t₂′ =
substᴱ (Term _) (sym s≡expr) $
app (substᴱ (Term _) s≡expr t₁′) (substᴱ (Term _) s≡expr t₂′)
eval′ : ∀ {xs} → Term xs s → Term xs s
eval′ t@(varᵖ _ _) = t
eval′ t@(lamᵖ _ _ _ _) = t
eval′ (printᵖ tˢ t wf) = print (eval′ (tˢ , t , [ wf ]))
eval′ (appᵖ t₁ˢ t₂ˢ t₁ t₂ wf₁ wf₂) = apply refl
(eval′ (t₁ˢ , t₁ , [ wf₁ ]))
(eval′ (t₂ˢ , t₂ , [ wf₂ ]))
-- Simple types.
infixr 6 _⇨_
data Ty : Type where
base : Ty
_⇨_ : Ty → Ty → Ty
-- Contexts.
Ctxt : Vars → Type
Ctxt xs = Block "Ctxt" → ∀ x → x ∈ xs → Ty
private
variable
@0 σ : Ty
@0 Γ : Ctxt xs
-- Extends a context with a new variable. If the variable already
-- exists in the context, then the old binding is removed.
infixl 5 _,_⦂_
_,_⦂_ : ∀ {xs} → Ctxt xs → ∀ x → Ty → Ctxt (x ∷ xs)
(Γ , x ⦂ σ) ⊠ y y∈x∷xs =
case y ≟∃V x of λ where
(yes y≡x) → σ
(no y≢x) → Γ ⊠ y (_≃_.to (∈≢∷≃ (Stable-¬ y≢x)) y∈x∷xs)
-- A type system.
infix 4 _⊢_⦂_
data _⊢_⦂_ : Ctxt xs → Term xs s → Ty → Type where
⊢var : ∀ {s x xs} {Γ : Ctxt ((s , x) ∷ xs)} {t σ} →
t ≡ var x →
σ ≡ Γ ⊠ (s , x) (≡→∈∷ refl) →
Γ ⊢ t ⦂ σ
⊢lam : ∀ {xs} {Γ : Ctxt xs} {x t t′ σ τ} →
Γ , (_ , x) ⦂ σ ⊢ t ⦂ τ →
t′ ≡ lam x t →
Γ ⊢ t′ ⦂ σ ⇨ τ
⊢app : ∀ {xs} {Γ : Ctxt xs} {t₁ t₂ t′ σ τ} →
Γ ⊢ t₁ ⦂ σ ⇨ τ →
Γ ⊢ t₂ ⦂ σ →
t′ ≡ app t₁ t₂ →
Γ ⊢ t′ ⦂ τ
⊢print : ∀ {xs} {Γ : Ctxt xs} {t t′ σ} →
Γ ⊢ t ⦂ σ →
t′ ≡ print t →
Γ ⊢ t′ ⦂ σ
|
{
"alphanum_fraction": 0.527721919,
"avg_line_length": 26.2716981132,
"ext": "agda",
"hexsha": "5bd5374b845952d3ecbed4ec6652f6d4d3ccf7ae",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/equality",
"max_forks_repo_path": "README/Abstract-binding-tree.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/equality",
"max_issues_repo_path": "README/Abstract-binding-tree.agda",
"max_line_length": 90,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/equality",
"max_stars_repo_path": "README/Abstract-binding-tree.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-02T17:18:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-05-21T22:58:50.000Z",
"num_tokens": 2726,
"size": 6962
}
|
module Lib.Bool where
open import Lib.Logic
data Bool : Set where
true : Bool
false : Bool
{-# BUILTIN BOOL Bool #-}
{-# BUILTIN TRUE true #-}
{-# BUILTIN FALSE false #-}
{-# COMPILED_DATA Bool Bool True False #-}
isTrue : Bool -> Set
isTrue true = True
isTrue false = False
isFalse : Bool -> Set
isFalse true = False
isFalse false = True
data Inspect (b : Bool) : Set where
itsTrue : .(isTrue b) -> Inspect b
itsFalse : .(isFalse b) -> Inspect b
inspect : (b : Bool) -> Inspect b
inspect true = itsTrue _
inspect false = itsFalse _
infix 5 if_then_else_
if_then_else_ : {A : Set} -> Bool -> A -> A -> A
if true then x else y = x
if false then x else y = y
not : Bool -> Bool
not true = false
not false = true
infixr 25 _&&_
infixr 22 _||_
_&&_ : Bool -> Bool -> Bool
false && y = false
true && y = y
_||_ : Bool -> Bool -> Bool
false || y = y
true || y = true
|
{
"alphanum_fraction": 0.6252796421,
"avg_line_length": 17.1923076923,
"ext": "agda",
"hexsha": "d60d5585ba277bdfab5c251e73a8e702b87cd8df",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "masondesu/agda",
"max_forks_repo_path": "examples/simple-lib/Lib/Bool.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "masondesu/agda",
"max_issues_repo_path": "examples/simple-lib/Lib/Bool.agda",
"max_line_length": 48,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/agda-kanso",
"max_stars_repo_path": "examples/simple-lib/Lib/Bool.agda",
"max_stars_repo_stars_event_max_datetime": "2019-11-27T04:41:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-11-27T04:41:05.000Z",
"num_tokens": 290,
"size": 894
}
|
-- Andreas, 2020-01-28, issue #4399
-- Pattern @{{_ = p}}@ should not be parsed as cubical partial split.
postulate
A : Set
data T : Set where
tt : T
f : {x : A} {{_ : T}} → Set
f ⦃ _ = tt ⦄ = A
-- Expected: Parse error
-- Not a valid named argument: _ = tt
|
{
"alphanum_fraction": 0.5864661654,
"avg_line_length": 17.7333333333,
"ext": "agda",
"hexsha": "656dc0f4fbfbf171215770ee7f0783e07a9be1b0",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Fail/Issue4399.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Fail/Issue4399.agda",
"max_line_length": 69,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Fail/Issue4399.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 99,
"size": 266
}
|
------------------------------------------------------------------------
-- A universe which includes several kinds of functions
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
module Function-universe
{reflexive} (eq : ∀ {a p} → Equality-with-J a p reflexive) where
open import Bijection eq as Bijection using (_↔_; module _↔_)
open Derived-definitions-and-properties eq
open import Embedding eq as Emb using (Is-embedding; Embedding)
open import Equality.Decidable-UIP eq
open import Equality.Decision-procedures eq
open import Equivalence eq as Eq using (_≃_; module _≃_; Is-equivalence)
import Equivalence.Contractible-preimages eq as CP
open import Equivalence.Erased.Basics eq as EEq using (_≃ᴱ_)
import Equivalence.Half-adjoint eq as HA
open import Erased.Basics as E using (Erased)
open import H-level eq as H-level
open import H-level.Closure eq
open import Injection eq as Injection using (_↣_; module _↣_; Injective)
open import Logical-equivalence as L using (_⇔_; module _⇔_)
open import Nat eq hiding (_≟_)
open import Preimage eq using (_⁻¹_)
open import Prelude as P hiding (id) renaming (_∘_ to _⊚_)
open import Surjection eq as Surjection using (_↠_; Split-surjective)
------------------------------------------------------------------------
-- The universe
-- The universe includes implications, logical equivalences,
-- injections, embeddings, surjections, bijections, equivalences, and
-- equivalences with erased proofs.
data Kind : Type where
implication
logical-equivalence
injection
embedding
surjection
bijection
equivalence
equivalenceᴱ : Kind
-- The interpretation of the universe.
infix 0 _↝[_]_
_↝[_]_ : ∀ {ℓ₁ ℓ₂} → Type ℓ₁ → Kind → Type ℓ₂ → Type _
A ↝[ implication ] B = A → B
A ↝[ logical-equivalence ] B = A ⇔ B
A ↝[ injection ] B = A ↣ B
A ↝[ embedding ] B = Embedding A B
A ↝[ surjection ] B = A ↠ B
A ↝[ bijection ] B = A ↔ B
A ↝[ equivalence ] B = A ≃ B
A ↝[ equivalenceᴱ ] B = A ≃ᴱ B
-- Equivalences can be converted to all kinds of functions.
from-equivalence : ∀ {k a b} {A : Type a} {B : Type b} →
A ≃ B → A ↝[ k ] B
from-equivalence {implication} = _≃_.to
from-equivalence {logical-equivalence} = _≃_.logical-equivalence
from-equivalence {injection} = _≃_.injection
from-equivalence {embedding} = Emb.≃→Embedding
from-equivalence {surjection} = _≃_.surjection
from-equivalence {bijection} = _≃_.bijection
from-equivalence {equivalence} = P.id
from-equivalence {equivalenceᴱ} = EEq.≃→≃ᴱ
-- Bijections can be converted to all kinds of functions.
from-bijection : ∀ {k a b} {A : Type a} {B : Type b} →
A ↔ B → A ↝[ k ] B
from-bijection {implication} = _↔_.to
from-bijection {logical-equivalence} = _↔_.logical-equivalence
from-bijection {injection} = _↔_.injection
from-bijection {embedding} = from-equivalence ⊚ Eq.↔⇒≃
from-bijection {surjection} = _↔_.surjection
from-bijection {bijection} = P.id
from-bijection {equivalence} = Eq.↔⇒≃
from-bijection {equivalenceᴱ} = EEq.≃→≃ᴱ ⊚ Eq.↔⇒≃
-- All kinds of functions can be converted to implications.
to-implication : ∀ {k a b} {@0 A : Type a} {@0 B : Type b} →
A ↝[ k ] B → A → B
to-implication {implication} f =
f
to-implication {logical-equivalence} f =
let record { to = to } = f in to
to-implication {injection} f =
let record { to = to } = f in to
to-implication {embedding} f =
let record { to = to } = f in to
to-implication {surjection} f =
let record
{ logical-equivalence = record
{ to = to
}
} = f
in to
to-implication {bijection} f =
let record
{ surjection = record
{ logical-equivalence = record
{ to = to
}
}
} = f
in to
to-implication {equivalence} f =
let record { to = to } = f in to
to-implication {equivalenceᴱ} f =
_≃ᴱ_.to f
------------------------------------------------------------------------
-- A sub-universe of symmetric kinds of functions
data Symmetric-kind : Type where
logical-equivalence bijection equivalence equivalenceᴱ :
Symmetric-kind
⌊_⌋-sym : Symmetric-kind → Kind
⌊ logical-equivalence ⌋-sym = logical-equivalence
⌊ bijection ⌋-sym = bijection
⌊ equivalence ⌋-sym = equivalence
⌊ equivalenceᴱ ⌋-sym = equivalenceᴱ
inverse : ∀ {k a b} {A : Type a} {B : Type b} →
A ↝[ ⌊ k ⌋-sym ] B → B ↝[ ⌊ k ⌋-sym ] A
inverse {logical-equivalence} = L.inverse
inverse {bijection} = Bijection.inverse
inverse {equivalence} = Eq.inverse
inverse {equivalenceᴱ} = EEq.inverse
-- If there is a symmetric kind of function from A to B, then A and B
-- are logically equivalent.
sym→⇔ :
∀ {k a b} {A : Type a} {B : Type b} →
A ↝[ ⌊ k ⌋-sym ] B → A ⇔ B
sym→⇔ {k = logical-equivalence} = P.id
sym→⇔ {k = bijection} = from-bijection
sym→⇔ {k = equivalence} = from-equivalence
sym→⇔ {k = equivalenceᴱ} = _≃ᴱ_.logical-equivalence
------------------------------------------------------------------------
-- A sub-universe of isomorphisms
data Isomorphism-kind : Type where
bijection equivalence : Isomorphism-kind
⌊_⌋-iso : Isomorphism-kind → Kind
⌊ bijection ⌋-iso = bijection
⌊ equivalence ⌋-iso = equivalence
infix 0 _↔[_]_
_↔[_]_ : ∀ {ℓ₁ ℓ₂} → Type ℓ₁ → Isomorphism-kind → Type ℓ₂ → Type _
A ↔[ k ] B = A ↝[ ⌊ k ⌋-iso ] B
from-isomorphism : ∀ {k₁ k₂ a b} {A : Type a} {B : Type b} →
A ↔[ k₁ ] B → A ↝[ k₂ ] B
from-isomorphism {bijection} = from-bijection
from-isomorphism {equivalence} = from-equivalence
-- Lemma: to-implication after from-isomorphism is the same as
-- to-implication.
to-implication∘from-isomorphism :
∀ {a b} {A : Type a} {B : Type b} k₁ k₂ {A↔B : A ↔[ k₁ ] B} →
to-implication A↔B ≡
to-implication (from-isomorphism {k₂ = k₂} A↔B)
to-implication∘from-isomorphism {A = A} {B} = t∘f
where
t∘f : ∀ k₁ k₂ {A↔B : A ↔[ k₁ ] B} →
to-implication A↔B ≡
to-implication (from-isomorphism {k₂ = k₂} A↔B)
t∘f bijection implication = refl _
t∘f bijection logical-equivalence = refl _
t∘f bijection injection = refl _
t∘f bijection embedding = refl _
t∘f bijection surjection = refl _
t∘f bijection bijection = refl _
t∘f bijection equivalence = refl _
t∘f bijection equivalenceᴱ = refl _
t∘f equivalence implication = refl _
t∘f equivalence logical-equivalence = refl _
t∘f equivalence injection = refl _
t∘f equivalence embedding = refl _
t∘f equivalence surjection = refl _
t∘f equivalence bijection = refl _
t∘f equivalence equivalence = refl _
t∘f equivalence equivalenceᴱ = refl _
------------------------------------------------------------------------
-- Preorder
-- All the different kinds of functions form preorders.
-- Composition.
infixr 9 _∘_
_∘_ : ∀ {k a b c} {A : Type a} {B : Type b} {C : Type c} →
B ↝[ k ] C → A ↝[ k ] B → A ↝[ k ] C
_∘_ {implication} = λ f g → f ⊚ g
_∘_ {logical-equivalence} = L._∘_
_∘_ {injection} = Injection._∘_
_∘_ {embedding} = Emb._∘_
_∘_ {surjection} = Surjection._∘_
_∘_ {bijection} = Bijection._∘_
_∘_ {equivalence} = Eq._∘_
_∘_ {equivalenceᴱ} = EEq._∘_
-- Identity.
id : ∀ {k a} {A : Type a} → A ↝[ k ] A
id {implication} = P.id
id {logical-equivalence} = L.id
id {injection} = Injection.id
id {embedding} = Emb.id
id {surjection} = Surjection.id
id {bijection} = Bijection.id
id {equivalence} = Eq.id
id {equivalenceᴱ} = EEq.id
-- "Equational" reasoning combinators.
infix -1 finally-↝ finally-↔
infix -1 _□
infixr -2 step-↝ step-↔ _↔⟨⟩_
infix -3 $⟨_⟩_
-- For an explanation of why step-↝ and step-↔ are defined in this
-- way, see Equality.step-≡.
step-↝ : ∀ {k a b c} (A : Type a) {B : Type b} {C : Type c} →
B ↝[ k ] C → A ↝[ k ] B → A ↝[ k ] C
step-↝ _ = _∘_
syntax step-↝ A B↝C A↝B = A ↝⟨ A↝B ⟩ B↝C
step-↔ : ∀ {k₁ k₂ a b c} (A : Type a) {B : Type b} {C : Type c} →
B ↝[ k₂ ] C → A ↔[ k₁ ] B → A ↝[ k₂ ] C
step-↔ _ B↝C A↔B = step-↝ _ B↝C (from-isomorphism A↔B)
syntax step-↔ A B↝C A↔B = A ↔⟨ A↔B ⟩ B↝C
_↔⟨⟩_ : ∀ {k a b} (A : Type a) {B : Type b} →
A ↝[ k ] B → A ↝[ k ] B
_ ↔⟨⟩ A↝B = A↝B
_□ : ∀ {k a} (A : Type a) → A ↝[ k ] A
A □ = id
finally-↝ : ∀ {k a b} (A : Type a) (B : Type b) →
A ↝[ k ] B → A ↝[ k ] B
finally-↝ _ _ A↝B = A↝B
syntax finally-↝ A B A↝B = A ↝⟨ A↝B ⟩□ B □
finally-↔ : ∀ {k₁ k₂ a b} (A : Type a) (B : Type b) →
A ↔[ k₁ ] B → A ↝[ k₂ ] B
finally-↔ _ _ A↔B = from-isomorphism A↔B
syntax finally-↔ A B A↔B = A ↔⟨ A↔B ⟩□ B □
$⟨_⟩_ : ∀ {k a b} {@0 A : Type a} {@0 B : Type b} →
A → A ↝[ k ] B → B
$⟨ a ⟩ A↝B = to-implication A↝B a
-- Lemma: to-implication maps id to the identity function.
to-implication-id :
∀ {a} {A : Type a} k →
to-implication {k = k} id ≡ id {A = A}
to-implication-id implication = refl _
to-implication-id logical-equivalence = refl _
to-implication-id injection = refl _
to-implication-id embedding = refl _
to-implication-id surjection = refl _
to-implication-id bijection = refl _
to-implication-id equivalence = refl _
to-implication-id equivalenceᴱ = refl _
-- Lemma: to-implication is homomorphic with respect to _∘_.
to-implication-∘ :
∀ {a b c} {A : Type a} {B : Type b} {C : Type c} →
(k : Kind) {f : A ↝[ k ] B} {g : B ↝[ k ] C} →
to-implication (g ∘ f) ≡ to-implication g ∘ to-implication f
to-implication-∘ implication = refl _
to-implication-∘ logical-equivalence = refl _
to-implication-∘ injection = refl _
to-implication-∘ embedding = refl _
to-implication-∘ surjection = refl _
to-implication-∘ bijection = refl _
to-implication-∘ equivalence = refl _
to-implication-∘ equivalenceᴱ = refl _
-- Lemma: to-implication maps inverse id to the identity function.
to-implication-inverse-id :
∀ {a} {A : Type a} k →
to-implication (inverse {k = k} id) ≡ id {A = A}
to-implication-inverse-id logical-equivalence = refl _
to-implication-inverse-id bijection = refl _
to-implication-inverse-id equivalence = refl _
to-implication-inverse-id equivalenceᴱ = refl _
------------------------------------------------------------------------
-- Conditional extensionality
-- Code that provides support for proving general statements about
-- functions of different kinds, in which the statements involve
-- assumptions of extensionality for some kinds of functions, but not
-- all. For some examples, see ∀-cong and ∀-intro.
-- Kinds for which extensionality is not provided.
data Without-extensionality : Type where
implication logical-equivalence : Without-extensionality
⌊_⌋-without : Without-extensionality → Kind
⌊ implication ⌋-without = implication
⌊ logical-equivalence ⌋-without = logical-equivalence
-- Kinds for which erased extensionality is not provided.
data With-erased-extensionality : Type where
equivalenceᴱ : With-erased-extensionality
⌊_⌋-with-erased : With-erased-extensionality → Kind
⌊ equivalenceᴱ ⌋-with-erased = equivalenceᴱ
-- Kinds for which extensionality is provided.
data With-extensionality : Type where
injection embedding surjection bijection equivalence :
With-extensionality
⌊_⌋-with : With-extensionality → Kind
⌊ injection ⌋-with = injection
⌊ embedding ⌋-with = embedding
⌊ surjection ⌋-with = surjection
⌊ bijection ⌋-with = bijection
⌊ equivalence ⌋-with = equivalence
-- Kinds annotated with information about what kind of extensionality
-- is provided, if any.
data Extensionality-kind : Kind → Type where
without-extensionality : (k : Without-extensionality) →
Extensionality-kind ⌊ k ⌋-without
with-erased-extensionality : (k : With-erased-extensionality) →
Extensionality-kind ⌊ k ⌋-with-erased
with-extensionality : (k : With-extensionality) →
Extensionality-kind ⌊ k ⌋-with
-- Is extensionality provided for the given kind?
extensionality? : (k : Kind) → Extensionality-kind k
extensionality? implication = without-extensionality implication
extensionality? logical-equivalence = without-extensionality
logical-equivalence
extensionality? injection = with-extensionality injection
extensionality? embedding = with-extensionality embedding
extensionality? surjection = with-extensionality surjection
extensionality? bijection = with-extensionality bijection
extensionality? equivalence = with-extensionality equivalence
extensionality? equivalenceᴱ = with-erased-extensionality
equivalenceᴱ
-- Extensionality, but only for certain kinds of functions, and
-- possibly erased.
Extensionality? : Kind → (a b : Level) → Type (lsuc (a ⊔ b))
Extensionality? k a b with extensionality? k
... | without-extensionality _ = ↑ _ ⊤
... | with-erased-extensionality _ = Erased (Extensionality a b)
... | with-extensionality _ = Extensionality a b
-- A variant of _↝[_]_. A ↝[ c ∣ d ] B means that A ↝[ k ] B can be
-- proved for all kinds k, in some cases assuming extensionality (for
-- the levels c and d).
infix 0 _↝[_∣_]_
_↝[_∣_]_ :
∀ {a b} →
Type a → (c d : Level) → Type b → Type (a ⊔ b ⊔ lsuc (c ⊔ d))
A ↝[ c ∣ d ] B = ∀ {k} → Extensionality? k c d → A ↝[ k ] B
-- A variant of _↝[_∣_]_ with erased extensionality assumptions.
infix 0 _↝[_∣_]ᴱ_
_↝[_∣_]ᴱ_ :
∀ {a b} →
Type a → (c d : Level) → Type b → Type (a ⊔ b ⊔ lsuc (c ⊔ d))
A ↝[ c ∣ d ]ᴱ B = ∀ {k} → @0 Extensionality? k c d → A ↝[ k ] B
-- Turns extensionality into conditional extensionality.
forget-ext? : ∀ k {a b} → Extensionality a b → Extensionality? k a b
forget-ext? k with extensionality? k
... | without-extensionality _ = _
... | with-erased-extensionality _ = E.[_]→
... | with-extensionality _ = id
-- A variant of lower-extensionality.
lower-extensionality? :
∀ k {a b} â b̂ →
Extensionality? k (a ⊔ â) (b ⊔ b̂) → Extensionality? k a b
lower-extensionality? k â b̂ with extensionality? k
... | without-extensionality _ = _
... | with-erased-extensionality _ = E.map (lower-extensionality â b̂)
... | with-extensionality _ = lower-extensionality â b̂
-- Some functions that can be used to generalise results.
generalise-ext? :
∀ {a b c d} {A : Type a} {B : Type b} →
(A⇔B : A ⇔ B) →
(Extensionality c d →
let open _⇔_ A⇔B in
(∀ x → to (from x) ≡ x) ×
(∀ x → from (to x) ≡ x)) →
A ↝[ c ∣ d ] B
generalise-ext? A⇔B hyp {k = k} with extensionality? k
... | without-extensionality implication =
λ _ → _⇔_.to A⇔B
... | without-extensionality logical-equivalence =
λ _ → A⇔B
... | with-extensionality _ = λ ext →
from-bijection record
{ surjection = record
{ logical-equivalence = A⇔B
; right-inverse-of = hyp ext .proj₁
}
; left-inverse-of = hyp ext .proj₂
}
... | with-erased-extensionality equivalenceᴱ = λ (E.[ ext ]) →
EEq.↔→≃ᴱ (_⇔_.to A⇔B) (_⇔_.from A⇔B) (hyp ext .proj₁) (hyp ext .proj₂)
generalise-erased-ext? :
∀ {a b c d} {A : Type a} {B : Type b} →
A ⇔ B →
(@0 Extensionality c d → A ↔ B) →
A ↝[ c ∣ d ]ᴱ B
generalise-erased-ext? f⇔ f↔ {k = k} with extensionality? k
... | without-extensionality implication =
λ _ → _⇔_.to f⇔
... | without-extensionality logical-equivalence =
λ _ → f⇔
... | with-extensionality _ = λ ext →
from-isomorphism (f↔ ext)
... | with-erased-extensionality _ = λ ext →
from-isomorphism (f↔ (E.erased ext))
generalise-ext?-prop :
∀ {a b c d} {A : Type a} {B : Type b} →
A ⇔ B →
(Extensionality c d → Is-proposition A) →
(Extensionality c d → Is-proposition B) →
A ↝[ c ∣ d ] B
generalise-ext?-prop f⇔ A-prop B-prop =
generalise-ext?
f⇔
(λ ext →
(λ _ → B-prop ext _ _)
, (λ _ → A-prop ext _ _))
generalise-erased-ext?-prop :
∀ {a b c d} {A : Type a} {B : Type b} →
A ⇔ B →
(@0 Extensionality c d → Is-proposition A) →
(@0 Extensionality c d → Is-proposition B) →
A ↝[ c ∣ d ]ᴱ B
generalise-erased-ext?-prop f⇔ A-prop B-prop =
generalise-erased-ext?
f⇔
(λ ext → _≃_.bijection $
_↠_.from (Eq.≃↠⇔ (A-prop ext) (B-prop ext)) f⇔)
generalise-ext?-sym :
∀ {a b c d} {A : Type a} {B : Type b} →
(∀ {k} → Extensionality? ⌊ k ⌋-sym c d → A ↝[ ⌊ k ⌋-sym ] B) →
A ↝[ c ∣ d ] B
generalise-ext?-sym hyp {k = k} ext with extensionality? k
... | without-extensionality implication =
_⇔_.to $ hyp {k = logical-equivalence} ext
... | without-extensionality logical-equivalence =
hyp {k = logical-equivalence} ext
... | with-extensionality _ =
from-bijection $ hyp {k = bijection} ext
... | with-erased-extensionality equivalenceᴱ =
hyp {k = equivalenceᴱ} ext
generalise-erased-ext?-sym :
∀ {a b c d} {A : Type a} {B : Type b} →
(∀ {k} → @0 Extensionality? ⌊ k ⌋-sym c d → A ↝[ ⌊ k ⌋-sym ] B) →
A ↝[ c ∣ d ]ᴱ B
generalise-erased-ext?-sym hyp = generalise-erased-ext? (hyp _) hyp
-- General results of the kind produced by generalise-ext? are
-- symmetric.
inverse-ext? :
∀ {a b c d} {A : Type a} {B : Type b} →
A ↝[ c ∣ d ] B → B ↝[ c ∣ d ] A
inverse-ext? hyp = generalise-ext?-sym (inverse ⊚ hyp)
inverse-erased-ext? :
∀ {a b c d} {A : Type a} {B : Type b} →
A ↝[ c ∣ d ]ᴱ B → B ↝[ c ∣ d ]ᴱ A
inverse-erased-ext? hyp =
generalise-erased-ext?-sym (λ ext → inverse (hyp ext))
------------------------------------------------------------------------
-- Lots of properties
------------------------------------------------------------------------
-- Properties of the form A ↝[ k ] B, for arbitrary k, are only stated
-- for bijections or equivalences; converting to the other forms is
-- easy.
------------------------------------------------------------------------
-- Equalities can be converted to all kinds of functions
≡⇒↝ : ∀ k {ℓ} {A B : Type ℓ} → A ≡ B → A ↝[ k ] B
≡⇒↝ k = elim (λ {A B} _ → A ↝[ k ] B) (λ _ → id)
abstract
-- Some lemmas that can be used to manipulate expressions involving
-- ≡⇒↝ and refl/sym/trans.
≡⇒↝-refl : ∀ {k a} {A : Type a} →
≡⇒↝ k (refl A) ≡ id
≡⇒↝-refl {k} = elim-refl (λ {A B} _ → A ↝[ k ] B) _
≡⇒↝-sym : ∀ k {ℓ} {A B : Type ℓ} {eq : A ≡ B} →
to-implication (≡⇒↝ ⌊ k ⌋-sym (sym eq)) ≡
to-implication (inverse (≡⇒↝ ⌊ k ⌋-sym eq))
≡⇒↝-sym k {A = A} {eq = eq} = elim¹
(λ eq → to-implication (≡⇒↝ ⌊ k ⌋-sym (sym eq)) ≡
to-implication (inverse (≡⇒↝ ⌊ k ⌋-sym eq)))
(to-implication (≡⇒↝ ⌊ k ⌋-sym (sym (refl A))) ≡⟨ cong (to-implication ∘ ≡⇒↝ ⌊ k ⌋-sym) sym-refl ⟩
to-implication (≡⇒↝ ⌊ k ⌋-sym (refl A)) ≡⟨ cong (to-implication {k = ⌊ k ⌋-sym}) ≡⇒↝-refl ⟩
to-implication {k = ⌊ k ⌋-sym} id ≡⟨ to-implication-id ⌊ k ⌋-sym ⟩
id ≡⟨ sym $ to-implication-inverse-id k ⟩
to-implication (inverse {k = k} id) ≡⟨ cong (to-implication ∘ inverse {k = k}) $ sym ≡⇒↝-refl ⟩∎
to-implication (inverse (≡⇒↝ ⌊ k ⌋-sym (refl A))) ∎)
eq
≡⇒↝-trans : ∀ k {ℓ} {A B C : Type ℓ} {A≡B : A ≡ B} {B≡C : B ≡ C} →
to-implication (≡⇒↝ k (trans A≡B B≡C)) ≡
to-implication (≡⇒↝ k B≡C ∘ ≡⇒↝ k A≡B)
≡⇒↝-trans k {B = B} {A≡B = A≡B} = elim¹
(λ B≡C → to-implication (≡⇒↝ k (trans A≡B B≡C)) ≡
to-implication (≡⇒↝ k B≡C ∘ ≡⇒↝ k A≡B))
(to-implication (≡⇒↝ k (trans A≡B (refl B))) ≡⟨ cong (to-implication ∘ ≡⇒↝ k) $ trans-reflʳ _ ⟩
to-implication (≡⇒↝ k A≡B) ≡⟨ sym $ cong (λ f → f ∘ to-implication (≡⇒↝ k A≡B)) $ to-implication-id k ⟩
to-implication {k = k} id ∘ to-implication (≡⇒↝ k A≡B) ≡⟨ sym $ to-implication-∘ k ⟩
to-implication (id ∘ ≡⇒↝ k A≡B) ≡⟨ sym $ cong (λ f → to-implication (f ∘ ≡⇒↝ k A≡B)) ≡⇒↝-refl ⟩∎
to-implication (≡⇒↝ k (refl B) ∘ ≡⇒↝ k A≡B) ∎)
_
-- One can sometimes "push" ≡⇒↝ through cong.
--
-- This is a generalisation of a lemma due to Thierry Coquand.
≡⇒↝-cong : ∀ {k ℓ p A B} {eq : A ≡ B}
(P : Type ℓ → Type p)
(P-cong : ∀ {A B} → A ↝[ k ] B → P A ↝[ k ] P B) →
P-cong (id {A = A}) ≡ id →
≡⇒↝ _ (cong P eq) ≡ P-cong (≡⇒↝ _ eq)
≡⇒↝-cong {eq = eq} P P-cong P-cong-id = elim¹
(λ eq → ≡⇒↝ _ (cong P eq) ≡ P-cong (≡⇒↝ _ eq))
(≡⇒↝ _ (cong P (refl _)) ≡⟨ cong (≡⇒↝ _) $ cong-refl P ⟩
≡⇒↝ _ (refl _) ≡⟨ elim-refl (λ {A B} _ → A ↝[ _ ] B) _ ⟩
id ≡⟨ sym P-cong-id ⟩
P-cong id ≡⟨ cong P-cong $ sym $
elim-refl (λ {A B} _ → A ↝[ _ ] B) _ ⟩∎
P-cong (≡⇒↝ _ (refl _)) ∎)
eq
-- One can express ≡⇒↝ in terms of subst.
≡⇒↝-in-terms-of-subst :
∀ k {ℓ} {A B : Type ℓ} (A≡B : A ≡ B) →
≡⇒↝ k A≡B ≡ subst (A ↝[ k ]_) A≡B id
≡⇒↝-in-terms-of-subst k {B = B} = elim₁
(λ {A} A≡B → ≡⇒↝ k A≡B ≡ subst (A ↝[ k ]_) A≡B id)
(≡⇒↝ k (refl B) ≡⟨ ≡⇒↝-refl ⟩
id ≡⟨ sym $ subst-refl _ _ ⟩∎
subst (B ↝[ k ]_) (refl B) id ∎)
≡⇒↝-in-terms-of-subst-sym :
∀ k {ℓ} {A B : Type ℓ} (A≡B : A ≡ B) →
≡⇒↝ k A≡B ≡ subst (_↝[ k ] B) (sym A≡B) id
≡⇒↝-in-terms-of-subst-sym k {B = B} = elim₁
(λ {A} A≡B → ≡⇒↝ k A≡B ≡ subst (_↝[ k ] B) (sym A≡B) id)
(≡⇒↝ k (refl B) ≡⟨ ≡⇒↝-refl ⟩
id ≡⟨ sym $ subst-refl _ _ ⟩
subst (_↝[ k ] B) (refl B) id ≡⟨ cong (flip (subst _) _) $ sym sym-refl ⟩∎
subst (_↝[ k ] B) (sym (refl B)) id ∎)
-- One can express subst in terms of ≡⇒↝.
subst-in-terms-of-≡⇒↝ :
∀ k {a p} {A : Type a} {x y} (x≡y : x ≡ y) (P : A → Type p) p →
subst P x≡y p ≡ to-implication (≡⇒↝ k (cong P x≡y)) p
subst-in-terms-of-≡⇒↝ k x≡y P p = elim¹
(λ eq → subst P eq p ≡ to-implication (≡⇒↝ k (cong P eq)) p)
(subst P (refl _) p ≡⟨ subst-refl P p ⟩
p ≡⟨ sym $ cong (_$ p) (to-implication-id k) ⟩
to-implication {k = k} id p ≡⟨ sym $ cong (λ f → to-implication {k = k} f p) ≡⇒↝-refl ⟩
to-implication (≡⇒↝ k (refl _)) p ≡⟨ sym $ cong (λ eq → to-implication (≡⇒↝ k eq) p) $ cong-refl P ⟩∎
to-implication (≡⇒↝ k (cong P (refl _))) p ∎)
x≡y
subst-in-terms-of-inverse∘≡⇒↝ :
∀ k {a p} {A : Type a} {x y} (x≡y : x ≡ y) (P : A → Type p) p →
subst P (sym x≡y) p ≡
to-implication (inverse (≡⇒↝ ⌊ k ⌋-sym (cong P x≡y))) p
subst-in-terms-of-inverse∘≡⇒↝ k x≡y P p =
subst P (sym x≡y) p ≡⟨ subst-in-terms-of-≡⇒↝ ⌊ k ⌋-sym (sym x≡y) P p ⟩
to-implication (≡⇒↝ ⌊ k ⌋-sym (cong P (sym x≡y))) p ≡⟨ cong (λ eq → to-implication (≡⇒↝ ⌊ k ⌋-sym eq) p) (cong-sym P _) ⟩
to-implication (≡⇒↝ ⌊ k ⌋-sym (sym $ cong P x≡y)) p ≡⟨ cong (_$ p) (≡⇒↝-sym k) ⟩∎
to-implication (inverse (≡⇒↝ ⌊ k ⌋-sym (cong P x≡y))) p ∎
-- One can express subst id in terms of ≡⇒↝.
subst-id-in-terms-of-≡⇒↝ :
∀ k {a} {A B : Type a} {A≡B : A ≡ B} {x} →
subst id A≡B x ≡ to-implication (≡⇒↝ k A≡B) x
subst-id-in-terms-of-≡⇒↝ k {A≡B = A≡B} {x = x} =
subst id A≡B x ≡⟨ subst-in-terms-of-≡⇒↝ k _ _ _ ⟩
to-implication (≡⇒↝ k (cong id A≡B)) x ≡⟨ cong (λ eq → to-implication (≡⇒↝ k eq) x) $ sym $ cong-id _ ⟩∎
to-implication (≡⇒↝ k A≡B) x ∎
subst-id-in-terms-of-inverse∘≡⇒↝ :
∀ k {a} {A B : Type a} {A≡B : A ≡ B} {y} →
subst id (sym A≡B) y ≡
to-implication (inverse (≡⇒↝ ⌊ k ⌋-sym A≡B)) y
subst-id-in-terms-of-inverse∘≡⇒↝ k {A≡B = A≡B} {y = y} =
subst id (sym A≡B) y ≡⟨ subst-in-terms-of-inverse∘≡⇒↝ k _ _ _ ⟩
to-implication (inverse (≡⇒↝ ⌊ k ⌋-sym (cong id A≡B))) y ≡⟨ cong (λ eq → to-implication (inverse (≡⇒↝ ⌊ k ⌋-sym eq)) y) $ sym $ cong-id _ ⟩∎
to-implication (inverse (≡⇒↝ ⌊ k ⌋-sym A≡B)) y ∎
to-implication-≡⇒↝ :
∀ k {ℓ} {A B : Type ℓ} (eq : A ≡ B) →
to-implication (≡⇒↝ k eq) ≡ ≡⇒↝ implication eq
to-implication-≡⇒↝ k =
elim (λ eq → to-implication (≡⇒↝ k eq) ≡ ≡⇒↝ implication eq)
(λ A → to-implication (≡⇒↝ k (refl A)) ≡⟨ cong to-implication (≡⇒↝-refl {k = k}) ⟩
to-implication {k = k} id ≡⟨ to-implication-id k ⟩
id ≡⟨ sym ≡⇒↝-refl ⟩∎
≡⇒↝ implication (refl A) ∎)
------------------------------------------------------------------------
-- One can replace the "to" and "from" functions with extensionally
-- equal functions
-- One can replace the "to" function with an extensionally equal
-- function.
with-other-function :
∀ {k a b} {A : Type a} {B : Type b}
(A↝B : A ↝[ k ] B) (f : A → B) →
(∀ x → to-implication A↝B x ≡ f x) →
A ↝[ k ] B
with-other-function {k = implication} _ f _ = f
with-other-function {k = logical-equivalence} A⇔B f _ = record
{ to = f
; from = _⇔_.from A⇔B
}
with-other-function {k = injection} A↣B f ≡f = record
{ to = f
; injective = λ {x = x} {y = y} →
f x ≡ f y →⟨ flip trans (sym $ ≡f y) ∘ trans (≡f x) ⟩
_↣_.to A↣B x ≡ _↣_.to A↣B y →⟨ _↣_.injective A↣B ⟩□
x ≡ y □
}
with-other-function {k = embedding} A↣B f ≡f = record
{ to = f
; is-embedding = λ x y →
_≃_.is-equivalence $
Eq.with-other-function
(x ≡ y ↝⟨ Eq.⟨ _ , Embedding.is-embedding A↣B x y ⟩ ⟩
Embedding.to A↣B x ≡ Embedding.to A↣B y ↝⟨ ≡⇒↝ _ $ cong₂ _≡_ (≡f x) (≡f y) ⟩□
f x ≡ f y □)
(cong f)
(elim
(λ {x = x} {y = y} x≡y →
_≃_.to (≡⇒↝ _ (cong₂ _≡_ (≡f x) (≡f y)))
(cong (Embedding.to A↣B) x≡y) ≡
cong f x≡y)
(λ x →
_≃_.to (≡⇒↝ _ (cong₂ _≡_ (≡f x) (≡f x)))
(cong (Embedding.to A↣B) (refl _)) ≡⟨ cong (_≃_.to (≡⇒↝ _ _)) $
cong-refl _ ⟩
_≃_.to (≡⇒↝ _ (cong₂ _≡_ (≡f x) (≡f x))) (refl _) ≡⟨ cong (_$ _) $
≡⇒↝-trans equivalence ⟩
_≃_.to (≡⇒↝ _ (cong (_ ≡_) (≡f x)))
(_≃_.to (≡⇒↝ _ (cong (_≡ _) (≡f x))) (refl _)) ≡⟨ sym $
trans (subst-in-terms-of-≡⇒↝ equivalence _ _ _) $
cong (_≃_.to (≡⇒↝ _ _)) $
subst-in-terms-of-≡⇒↝ equivalence _ _ _ ⟩
subst (_ ≡_) (≡f x) (subst (_≡ _) (≡f x) (refl _)) ≡⟨ trans (cong (subst (_ ≡_) (≡f x)) $
trans subst-trans-sym $
trans-reflʳ _) $
sym trans-subst ⟩
trans (sym (≡f x)) (≡f x) ≡⟨ trans-symˡ _ ⟩
refl (f x) ≡⟨ sym $ cong-refl _ ⟩∎
cong f (refl x) ∎))
}
with-other-function {k = surjection} A↠B f ≡f = record
{ logical-equivalence = record
{ to = f
; from = _↠_.from A↠B
}
; right-inverse-of = λ x →
f (_↠_.from A↠B x) ≡⟨ sym $ ≡f _ ⟩
_↠_.to A↠B (_↠_.from A↠B x) ≡⟨ _↠_.right-inverse-of A↠B _ ⟩∎
x ∎
}
with-other-function {k = bijection} = Bijection.with-other-function
with-other-function {k = equivalence} = Eq.with-other-function
with-other-function {k = equivalenceᴱ} A≃ᴱB f ≡f =
EEq.with-other-function A≃ᴱB f ≡f
-- The function with-other-function changes the "to" function in the
-- advertised way.
to-implication-with-other-function :
∀ k {a b} {A : Type a} {B : Type b} {A↝B : A ↝[ k ] B} {f : A → B}
{≡f : ∀ x → to-implication A↝B x ≡ f x} {x} →
to-implication (with-other-function A↝B f ≡f) x ≡ f x
to-implication-with-other-function implication = refl _
to-implication-with-other-function logical-equivalence = refl _
to-implication-with-other-function injection = refl _
to-implication-with-other-function embedding = refl _
to-implication-with-other-function surjection = refl _
to-implication-with-other-function bijection = refl _
to-implication-with-other-function equivalence = refl _
to-implication-with-other-function equivalenceᴱ = refl _
-- The function with-other-function does not change the "from"
-- function (if any).
to-implication-inverse-with-other-function :
∀ k {a b} {A : Type a} {B : Type b} {A↝B : A ↝[ ⌊ k ⌋-sym ] B}
{f : A → B} {≡f : ∀ x → to-implication A↝B x ≡ f x} {x} →
to-implication (inverse (with-other-function A↝B f ≡f)) x ≡
to-implication (inverse A↝B) x
to-implication-inverse-with-other-function logical-equivalence = refl _
to-implication-inverse-with-other-function bijection = refl _
to-implication-inverse-with-other-function equivalence = refl _
to-implication-inverse-with-other-function equivalenceᴱ = refl _
-- One can replace the "from" function with an extensionally equal
-- function.
with-other-inverse :
∀ {k a b} {A : Type a} {B : Type b}
(A↝B : A ↝[ ⌊ k ⌋-sym ] B) (f : B → A) →
(∀ x → to-implication (inverse A↝B) x ≡ f x) →
A ↝[ ⌊ k ⌋-sym ] B
with-other-inverse {k = logical-equivalence} A⇔B f _ = record
{ to = _⇔_.to A⇔B
; from = f
}
with-other-inverse {k = bijection} = Bijection.with-other-inverse
with-other-inverse {k = equivalence} = Eq.with-other-inverse
with-other-inverse {k = equivalenceᴱ} A≃ᴱB f ≡f =
EEq.with-other-inverse A≃ᴱB f ≡f
-- The function with-other-inverse does not change the "to" function.
to-implication-with-other-inverse :
∀ k {a b} {A : Type a} {B : Type b} {A↝B : A ↝[ ⌊ k ⌋-sym ] B}
{f : B → A} {≡f : ∀ x → to-implication (inverse A↝B) x ≡ f x} {x} →
to-implication (with-other-inverse A↝B f ≡f) x ≡
to-implication A↝B x
to-implication-with-other-inverse logical-equivalence = refl _
to-implication-with-other-inverse bijection = refl _
to-implication-with-other-inverse equivalence = refl _
to-implication-with-other-inverse equivalenceᴱ = refl _
-- The function with-other-inverse changes the "from" function in the
-- advertised way.
to-implication-inverse-with-other-inverse :
∀ k {a b} {A : Type a} {B : Type b} {A↝B : A ↝[ ⌊ k ⌋-sym ] B}
{f : B → A} {≡f : ∀ x → to-implication (inverse A↝B) x ≡ f x} {x} →
to-implication (inverse (with-other-inverse A↝B f ≡f)) x ≡ f x
to-implication-inverse-with-other-inverse logical-equivalence = refl _
to-implication-inverse-with-other-inverse bijection = refl _
to-implication-inverse-with-other-inverse equivalence = refl _
to-implication-inverse-with-other-inverse equivalenceᴱ = refl _
------------------------------------------------------------------------
-- _⊎_ is a commutative monoid
-- _⊎_ preserves all kinds of functions.
private
⊎-cong-inj : ∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : Type b₁} {B₂ : Type b₂} →
A₁ ↣ A₂ → B₁ ↣ B₂ → A₁ ⊎ B₁ ↣ A₂ ⊎ B₂
⊎-cong-inj A₁↣A₂ B₁↣B₂ = record
{ to = to′
; injective = injective′
}
where
open _↣_
to′ = ⊎-map (to A₁↣A₂) (to B₁↣B₂)
abstract
injective′ : Injective to′
injective′ {x = inj₁ x} {y = inj₁ y} = cong inj₁ ⊚ injective A₁↣A₂ ⊚ ⊎.cancel-inj₁
injective′ {x = inj₂ x} {y = inj₂ y} = cong inj₂ ⊚ injective B₁↣B₂ ⊚ ⊎.cancel-inj₂
injective′ {x = inj₁ x} {y = inj₂ y} = ⊥-elim ⊚ ⊎.inj₁≢inj₂
injective′ {x = inj₂ x} {y = inj₁ y} = ⊥-elim ⊚ ⊎.inj₁≢inj₂ ⊚ sym
⊎-cong-emb : ∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : Type b₁} {B₂ : Type b₂} →
Embedding A₁ A₂ → Embedding B₁ B₂ →
Embedding (A₁ ⊎ B₁) (A₂ ⊎ B₂)
⊎-cong-emb A₁↣A₂ B₁↣B₂ = record
{ to = to′
; is-embedding = is-embedding′
}
where
open Embedding
to′ = ⊎-map (to A₁↣A₂) (to B₁↣B₂)
is-embedding′ : Is-embedding to′
is-embedding′ (inj₁ x) (inj₁ y) =
_≃_.is-equivalence $
Eq.with-other-function
(inj₁ x ≡ inj₁ y ↔⟨ inverse Bijection.≡↔inj₁≡inj₁ ⟩
x ≡ y ↝⟨ Eq.⟨ _ , is-embedding A₁↣A₂ _ _ ⟩ ⟩
to A₁↣A₂ x ≡ to A₁↣A₂ y ↔⟨ Bijection.≡↔inj₁≡inj₁ ⟩□
inj₁ (to A₁↣A₂ x) ≡ inj₁ (to A₁↣A₂ y) □)
_
(λ eq →
cong inj₁ (cong (to A₁↣A₂) (⊎.cancel-inj₁ eq)) ≡⟨ cong-∘ _ _ _ ⟩
cong (inj₁ ⊚ to A₁↣A₂) (⊎.cancel-inj₁ eq) ≡⟨ cong-∘ _ _ _ ⟩
cong (inj₁ ⊚ to A₁↣A₂ ⊚ [ id , const x ]) eq ≡⟨ sym $ trans-reflʳ _ ⟩
trans (cong (inj₁ ⊚ to A₁↣A₂ ⊚ [ id , const x ]) eq) (refl _) ≡⟨ cong-respects-relevant-equality
{f = inj₁ ⊚ to A₁↣A₂ ⊚ [ id , const x ]}
(if_then true else false)
[ (λ _ _ → refl _) , (λ _ ()) ] ⟩
trans (refl _) (cong (⊎-map (to A₁↣A₂) (to B₁↣B₂)) eq) ≡⟨ trans-reflˡ _ ⟩∎
cong (⊎-map (to A₁↣A₂) (to B₁↣B₂)) eq ∎)
is-embedding′ (inj₂ x) (inj₂ y) =
_≃_.is-equivalence $
Eq.with-other-function
(inj₂ x ≡ inj₂ y ↔⟨ inverse Bijection.≡↔inj₂≡inj₂ ⟩
x ≡ y ↝⟨ Eq.⟨ _ , is-embedding B₁↣B₂ _ _ ⟩ ⟩
to B₁↣B₂ x ≡ to B₁↣B₂ y ↔⟨ Bijection.≡↔inj₂≡inj₂ ⟩□
inj₂ (to B₁↣B₂ x) ≡ inj₂ (to B₁↣B₂ y) □)
_
(λ eq →
cong inj₂ (cong (to B₁↣B₂) (⊎.cancel-inj₂ eq)) ≡⟨ cong-∘ _ _ _ ⟩
cong (inj₂ ⊚ to B₁↣B₂) (⊎.cancel-inj₂ eq) ≡⟨ cong-∘ _ _ _ ⟩
cong (inj₂ ⊚ to B₁↣B₂ ⊚ [ const x , id ]) eq ≡⟨ sym $ trans-reflʳ _ ⟩
trans (cong (inj₂ ⊚ to B₁↣B₂ ⊚ [ const x , id ]) eq) (refl _) ≡⟨ cong-respects-relevant-equality
{f = inj₂ ⊚ to B₁↣B₂ ⊚ [ const x , id ]}
(if_then false else true)
[ (λ _ ()) , (λ _ _ → refl _) ] ⟩
trans (refl _) (cong (⊎-map (to A₁↣A₂) (to B₁↣B₂)) eq) ≡⟨ trans-reflˡ _ ⟩∎
cong (⊎-map (to A₁↣A₂) (to B₁↣B₂)) eq ∎)
is-embedding′ (inj₁ x) (inj₂ y) =
_≃_.is-equivalence $
Eq.with-other-function
(inj₁ x ≡ inj₂ y ↔⟨ inverse $ Bijection.⊥↔uninhabited ⊎.inj₁≢inj₂ ⟩
⊥₀ ↔⟨ Bijection.⊥↔uninhabited ⊎.inj₁≢inj₂ ⟩□
inj₁ (to A₁↣A₂ x) ≡ inj₂ (to B₁↣B₂ y) □)
_
(⊥-elim ⊚ ⊎.inj₁≢inj₂)
is-embedding′ (inj₂ x) (inj₁ y) =
_≃_.is-equivalence $
Eq.with-other-function
(inj₂ x ≡ inj₁ y ↔⟨ inverse $ Bijection.⊥↔uninhabited (⊎.inj₁≢inj₂ ⊚ sym) ⟩
⊥₀ ↔⟨ Bijection.⊥↔uninhabited (⊎.inj₁≢inj₂ ⊚ sym) ⟩□
inj₂ (to B₁↣B₂ x) ≡ inj₁ (to A₁↣A₂ y) □)
_
(⊥-elim ⊚ ⊎.inj₁≢inj₂ ⊚ sym)
⊎-cong-surj : ∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : Type b₁} {B₂ : Type b₂} →
A₁ ↠ A₂ → B₁ ↠ B₂ → A₁ ⊎ B₁ ↠ A₂ ⊎ B₂
⊎-cong-surj A₁↠A₂ B₁↠B₂ = record
{ logical-equivalence =
_↠_.logical-equivalence A₁↠A₂
L.⊎-cong
_↠_.logical-equivalence B₁↠B₂
; right-inverse-of =
[ cong inj₁ ⊚ _↠_.right-inverse-of A₁↠A₂
, cong inj₂ ⊚ _↠_.right-inverse-of B₁↠B₂
]
}
⊎-cong-bij : ∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : Type b₁} {B₂ : Type b₂} →
A₁ ↔ A₂ → B₁ ↔ B₂ → A₁ ⊎ B₁ ↔ A₂ ⊎ B₂
⊎-cong-bij A₁↔A₂ B₁↔B₂ = record
{ surjection = ⊎-cong-surj (_↔_.surjection A₁↔A₂)
(_↔_.surjection B₁↔B₂)
; left-inverse-of =
[ cong inj₁ ⊚ _↔_.left-inverse-of A₁↔A₂
, cong inj₂ ⊚ _↔_.left-inverse-of B₁↔B₂
]
}
⊎-cong-≃ :
∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : Type b₁} {B₂ : Type b₂} →
A₁ ≃ A₂ → B₁ ≃ B₂ → (A₁ ⊎ B₁) ≃ (A₂ ⊎ B₂)
⊎-cong-≃ A₁≃A₂ B₁≃B₂ =
from-bijection $ ⊎-cong-bij (from-equivalence A₁≃A₂)
(from-equivalence B₁≃B₂)
⊎-cong-≃ᴱ :
∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : Type b₁} {B₂ : Type b₂} →
A₁ ≃ᴱ A₂ → B₁ ≃ᴱ B₂ → (A₁ ⊎ B₁) ≃ᴱ (A₂ ⊎ B₂)
⊎-cong-≃ᴱ f g =
EEq.[≃]→≃ᴱ (EEq.[proofs] (⊎-cong-≃ (EEq.≃ᴱ→≃ f) (EEq.≃ᴱ→≃ g)))
infixr 1 _⊎-cong_
_⊎-cong_ : ∀ {k a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : Type b₁} {B₂ : Type b₂} →
A₁ ↝[ k ] A₂ → B₁ ↝[ k ] B₂ → A₁ ⊎ B₁ ↝[ k ] A₂ ⊎ B₂
_⊎-cong_ {implication} = ⊎-map
_⊎-cong_ {logical-equivalence} = L._⊎-cong_
_⊎-cong_ {injection} = ⊎-cong-inj
_⊎-cong_ {embedding} = ⊎-cong-emb
_⊎-cong_ {surjection} = ⊎-cong-surj
_⊎-cong_ {bijection} = ⊎-cong-bij
_⊎-cong_ {equivalence} = ⊎-cong-≃
_⊎-cong_ {equivalenceᴱ} = ⊎-cong-≃ᴱ
-- _⊎_ is commutative.
⊎-comm : ∀ {a b} {A : Type a} {B : Type b} → A ⊎ B ↔ B ⊎ A
⊎-comm = record
{ surjection = record
{ logical-equivalence = record
{ to = [ inj₂ , inj₁ ]
; from = [ inj₂ , inj₁ ]
}
; right-inverse-of = [ refl ⊚ inj₁ , refl ⊚ inj₂ ]
}
; left-inverse-of = [ refl ⊚ inj₁ , refl ⊚ inj₂ ]
}
-- _⊎_ is associative.
⊎-assoc : ∀ {a b c} {A : Type a} {B : Type b} {C : Type c} →
A ⊎ (B ⊎ C) ↔ (A ⊎ B) ⊎ C
⊎-assoc = record
{ surjection = record
{ logical-equivalence = record
{ to = [ inj₁ ⊚ inj₁ , [ inj₁ ⊚ inj₂ , inj₂ ] ]
; from = [ [ inj₁ , inj₂ ⊚ inj₁ ] , inj₂ ⊚ inj₂ ]
}
; right-inverse-of =
[ [ refl ⊚ inj₁ ⊚ inj₁ , refl ⊚ inj₁ ⊚ inj₂ ] , refl ⊚ inj₂ ]
}
; left-inverse-of =
[ refl ⊚ inj₁ , [ refl ⊚ inj₂ ⊚ inj₁ , refl ⊚ inj₂ ⊚ inj₂ ] ]
}
-- ⊥ is a left and right identity of _⊎_.
⊎-left-identity : ∀ {a ℓ} {A : Type a} → ⊥ {ℓ = ℓ} ⊎ A ↔ A
⊎-left-identity = record
{ surjection = record
{ logical-equivalence = record
{ to = λ { (inj₁ ()); (inj₂ x) → x }
; from = inj₂
}
; right-inverse-of = refl
}
; left-inverse-of = λ { (inj₁ ()); (inj₂ x) → refl (inj₂ x) }
}
⊎-right-identity : ∀ {a ℓ} {A : Type a} → A ⊎ ⊥ {ℓ = ℓ} ↔ A
⊎-right-identity {A = A} =
A ⊎ ⊥ ↔⟨ ⊎-comm ⟩
⊥ ⊎ A ↔⟨ ⊎-left-identity ⟩□
A □
-- For logical equivalences _⊎_ is also idempotent. (This lemma could
-- be generalised to cover surjections and implications.)
⊎-idempotent : ∀ {a} {A : Type a} → A ⊎ A ⇔ A
⊎-idempotent = record
{ to = [ id , id ]
; from = inj₁
}
-- Lemmas that can be used to simplify binary sums where one of the
-- two type arguments is related to the empty type.
drop-⊥-right :
∀ {k a b} {A : Type a} {B : Type b} →
B ↝[ k ] ⊥₀ → A ⊎ B ↝[ k ] A
drop-⊥-right {A = A} {B} B↔⊥ =
A ⊎ B ↝⟨ id ⊎-cong B↔⊥ ⟩
A ⊎ ⊥ ↔⟨ ⊎-right-identity ⟩□
A □
drop-⊥-left :
∀ {k a b} {A : Type a} {B : Type b} →
A ↝[ k ] ⊥₀ → A ⊎ B ↝[ k ] B
drop-⊥-left {A = A} {B} A↔⊥ =
A ⊎ B ↔⟨ ⊎-comm ⟩
B ⊎ A ↝⟨ drop-⊥-right A↔⊥ ⟩□
B □
------------------------------------------------------------------------
-- _×_ is a commutative monoid with a zero
-- Σ preserves embeddings. (This definition is used in the proof of
-- _×-cong_.)
Σ-preserves-embeddings :
∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂}
(A₁↣A₂ : Embedding A₁ A₂) →
(∀ x → Embedding (B₁ x) (B₂ (Embedding.to A₁↣A₂ x))) →
Embedding (Σ A₁ B₁) (Σ A₂ B₂)
Σ-preserves-embeddings {B₁ = B₁} {B₂} A₁↣A₂ B₁↣B₂ = record
{ to = Σ-map (to A₁↣A₂) (to (B₁↣B₂ _))
; is-embedding = λ { (x₁ , x₂) (y₁ , y₂) →
_≃_.is-equivalence $
Eq.with-other-function
((x₁ , x₂) ≡ (y₁ , y₂) ↝⟨ inverse $ Eq.↔⇒≃ Bijection.Σ-≡,≡↔≡ ⟩
(∃ λ (eq : x₁ ≡ y₁) → subst B₁ eq x₂ ≡ y₂) ↝⟨ Eq.Σ-preserves (Embedding.equivalence A₁↣A₂) (λ eq →
subst B₁ eq x₂ ≡ y₂ ↝⟨ Embedding.equivalence (B₁↣B₂ y₁) ⟩
to (B₁↣B₂ y₁) (subst B₁ eq x₂) ≡ to (B₁↣B₂ y₁) y₂ ↝⟨ ≡⇒↝ _ (cong (_≡ _) $ lemma₁ eq _ y₂) ⟩□
subst B₂ (cong (to A₁↣A₂) eq) (to (B₁↣B₂ x₁) x₂) ≡
to (B₁↣B₂ y₁) y₂ □) ⟩
(∃ λ (eq : to A₁↣A₂ x₁ ≡ to A₁↣A₂ y₁) →
subst B₂ eq (to (B₁↣B₂ x₁) x₂) ≡ to (B₁↣B₂ y₁) y₂) ↝⟨ Eq.↔⇒≃ Bijection.Σ-≡,≡↔≡ ⟩□
(to A₁↣A₂ x₁ , to (B₁↣B₂ x₁) x₂) ≡
(to A₁↣A₂ y₁ , to (B₁↣B₂ y₁) y₂) □)
_
(elim
(λ { {y = _ , y₂} eq →
uncurry Σ-≡,≡→≡
(Σ-map (cong (to A₁↣A₂))
(_≃_.to (≡⇒↝ _ (cong (_≡ _) $ lemma₁ _ _ y₂)) ⊚
cong (to (B₁↣B₂ _)))
(Σ-≡,≡←≡ eq)) ≡
cong (Σ-map (to A₁↣A₂) (to (B₁↣B₂ _))) eq })
(λ _ →
uncurry Σ-≡,≡→≡
(Σ-map (cong (to A₁↣A₂))
(_≃_.to (≡⇒↝ _ (cong (_≡ _) $ lemma₁ _ _ _)) ⊚
cong (to (B₁↣B₂ _)))
(Σ-≡,≡←≡ (refl _))) ≡⟨ cong (λ eq → uncurry Σ-≡,≡→≡
(Σ-map _
(_≃_.to (≡⇒↝ _ (cong (_≡ _) $ lemma₁ _ _ _)) ⊚
cong (to (B₁↣B₂ _)))
eq))
Σ-≡,≡←≡-refl ⟩
Σ-≡,≡→≡
(cong (to A₁↣A₂) (refl _))
(_≃_.to (≡⇒↝ _ (cong (_≡ to (B₁↣B₂ _) _) $ lemma₁ _ _ _))
(cong (to (B₁↣B₂ _)) (subst-refl B₁ _))) ≡⟨ Σ-≡,≡→≡-cong (cong-refl _) (lemma₂ _ _) ⟩
Σ-≡,≡→≡ (refl _) (subst-refl B₂ _) ≡⟨ Σ-≡,≡→≡-refl-subst-refl ⟩
refl _ ≡⟨ sym $ cong-refl _ ⟩∎
cong (Σ-map (to A₁↣A₂) (to (B₁↣B₂ _))) (refl _) ∎)) }
}
where
open Embedding using (to)
lemma₁ : ∀ {x₁ y₁} (_ : x₁ ≡ y₁) → _
lemma₁ = elim
(λ {x₁ y₁} eq → (x₂ : B₁ x₁) (y₂ : B₁ y₁) →
to (B₁↣B₂ y₁) (subst B₁ eq x₂) ≡
subst B₂ (cong (to A₁↣A₂) eq) (to (B₁↣B₂ x₁) x₂))
(λ z₁ x₂ y₂ →
to (B₁↣B₂ z₁) (subst B₁ (refl z₁) x₂) ≡⟨ cong (to (B₁↣B₂ z₁)) $ subst-refl _ _ ⟩
to (B₁↣B₂ z₁) x₂ ≡⟨ sym $ subst-refl _ _ ⟩
subst B₂ (refl (to A₁↣A₂ z₁)) (to (B₁↣B₂ z₁) x₂) ≡⟨ cong (λ eq → subst B₂ eq _) (sym $ cong-refl _) ⟩∎
subst B₂ (cong (to A₁↣A₂) (refl z₁)) (to (B₁↣B₂ z₁) x₂) ∎)
lemma₂ = λ x y →
let eq₁ = cong (flip (subst B₂) _) (sym (cong-refl _))
eq₂ = cong (to (B₁↣B₂ x)) (subst-refl B₁ y)
in
trans eq₁ (_≃_.to (≡⇒↝ _ (cong (_≡ _) $ lemma₁ (refl x) y y)) eq₂) ≡⟨ cong (λ eq → trans eq₁ (_≃_.to (≡⇒↝ _ (cong (_≡ _) (eq y y))) eq₂)) $
elim-refl (λ {x₁ y₁} eq → (x₂ : B₁ x₁) (y₂ : B₁ y₁) →
to (B₁↣B₂ y₁) (subst B₁ eq x₂) ≡
subst B₂ (cong (to A₁↣A₂) eq) (to (B₁↣B₂ x₁) x₂))
_ ⟩
trans eq₁ (_≃_.to (≡⇒↝ _ $ cong (_≡ _) $
trans eq₂ (trans (sym $ subst-refl B₂ _) eq₁))
eq₂) ≡⟨ cong (trans _) $ sym $ subst-in-terms-of-≡⇒↝ equivalence _ _ _ ⟩
trans eq₁ (subst (_≡ _)
(trans eq₂ (trans (sym $ subst-refl B₂ _) eq₁))
eq₂) ≡⟨ cong (λ eq → trans eq₁ (subst (_≡ _) eq eq₂)) $
sym $ sym-sym (trans eq₂ (trans (sym $ subst-refl B₂ _) eq₁)) ⟩
trans eq₁ (subst (_≡ _)
(sym $ sym $
trans eq₂ (trans (sym $ subst-refl B₂ _) eq₁))
eq₂) ≡⟨ cong (trans _) $ subst-trans _ ⟩
trans eq₁ (trans
(sym $ trans eq₂ (trans (sym $ subst-refl B₂ _) eq₁))
eq₂) ≡⟨ cong (λ eq → trans eq₁ (trans eq eq₂)) $
sym-trans eq₂ (trans (sym $ subst-refl B₂ _) eq₁) ⟩
trans eq₁ (trans (trans (sym $ trans (sym $ subst-refl B₂ _) eq₁)
(sym eq₂))
eq₂) ≡⟨ cong (trans _) $ trans-[trans-sym]- _ _ ⟩
trans eq₁ (sym $ trans (sym $ subst-refl B₂ _) eq₁) ≡⟨ cong (trans _) $ sym-trans _ _ ⟩
trans eq₁ (trans (sym eq₁) (sym $ sym $ subst-refl B₂ _)) ≡⟨ trans--[trans-sym] _ _ ⟩
sym $ sym $ subst-refl B₂ _ ≡⟨ sym-sym _ ⟩∎
subst-refl B₂ _ ∎
-- _×_ preserves all kinds of functions.
private
×-cong-inj : ∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : Type b₁} {B₂ : Type b₂} →
A₁ ↣ A₂ → B₁ ↣ B₂ → A₁ × B₁ ↣ A₂ × B₂
×-cong-inj {A₁ = A₁} {A₂} {B₁} {B₂} A₁↣A₂ B₁↣B₂ = record
{ to = to′
; injective = injective′
}
where
open _↣_
to′ : A₁ × B₁ → A₂ × B₂
to′ = Σ-map (to A₁↣A₂) (to B₁↣B₂)
abstract
injective′ : Injective to′
injective′ to′-x≡to′-y =
cong₂ _,_ (injective A₁↣A₂ (cong proj₁ to′-x≡to′-y))
(injective B₁↣B₂ (cong proj₂ to′-x≡to′-y))
×-cong-surj : ∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : Type b₁} {B₂ : Type b₂} →
A₁ ↠ A₂ → B₁ ↠ B₂ → A₁ × B₁ ↠ A₂ × B₂
×-cong-surj A₁↠A₂ B₁↠B₂ = record
{ logical-equivalence =
_↠_.logical-equivalence A₁↠A₂
L.×-cong
_↠_.logical-equivalence B₁↠B₂
; right-inverse-of = uncurry λ x y →
cong₂ _,_ (_↠_.right-inverse-of A₁↠A₂ x)
(_↠_.right-inverse-of B₁↠B₂ y)
}
×-cong-bij : ∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : Type b₁} {B₂ : Type b₂} →
A₁ ↔ A₂ → B₁ ↔ B₂ → A₁ × B₁ ↔ A₂ × B₂
×-cong-bij A₁↔A₂ B₁↔B₂ = record
{ surjection = ×-cong-surj (_↔_.surjection A₁↔A₂)
(_↔_.surjection B₁↔B₂)
; left-inverse-of = uncurry λ x y →
cong₂ _,_ (_↔_.left-inverse-of A₁↔A₂ x)
(_↔_.left-inverse-of B₁↔B₂ y)
}
×-cong-≃ :
∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : Type b₁} {B₂ : Type b₂} →
A₁ ≃ A₂ → B₁ ≃ B₂ → (A₁ × B₁) ≃ (A₂ × B₂)
×-cong-≃ A₁≃A₂ B₁≃B₂ =
from-bijection $ ×-cong-bij (from-equivalence A₁≃A₂)
(from-equivalence B₁≃B₂)
×-cong-≃ᴱ :
∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : Type b₁} {B₂ : Type b₂} →
A₁ ≃ᴱ A₂ → B₁ ≃ᴱ B₂ → (A₁ × B₁) ≃ᴱ (A₂ × B₂)
×-cong-≃ᴱ f g =
EEq.[≃]→≃ᴱ (EEq.[proofs] (×-cong-≃ (EEq.≃ᴱ→≃ f) (EEq.≃ᴱ→≃ g)))
infixr 2 _×-cong_
_×-cong_ : ∀ {k a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : Type b₁} {B₂ : Type b₂} →
A₁ ↝[ k ] A₂ → B₁ ↝[ k ] B₂ → A₁ × B₁ ↝[ k ] A₂ × B₂
_×-cong_ {implication} = λ f g → Σ-map f g
_×-cong_ {logical-equivalence} = L._×-cong_
_×-cong_ {injection} = ×-cong-inj
_×-cong_ {embedding} = λ A₁↣A₂ B₁↣B₂ →
Σ-preserves-embeddings
A₁↣A₂ (λ _ → B₁↣B₂)
_×-cong_ {surjection} = ×-cong-surj
_×-cong_ {bijection} = ×-cong-bij
_×-cong_ {equivalence} = ×-cong-≃
_×-cong_ {equivalenceᴱ} = ×-cong-≃ᴱ
-- The function to-implication is homomorphic with respect to
-- _×-cong_/Σ-map.
to-implication-×-cong :
∀ k {a b c d} {A : Type a} {B : Type b} {C : Type c} {D : Type d}
{A↝B : A ↝[ k ] B} {C↝D : C ↝[ k ] D} →
to-implication (A↝B ×-cong C↝D) ≡
Σ-map (to-implication A↝B) (to-implication C↝D)
to-implication-×-cong implication = refl _
to-implication-×-cong logical-equivalence = refl _
to-implication-×-cong injection = refl _
to-implication-×-cong embedding = refl _
to-implication-×-cong surjection = refl _
to-implication-×-cong bijection = refl _
to-implication-×-cong equivalence = refl _
to-implication-×-cong equivalenceᴱ = refl _
-- _×_ is commutative.
×-comm : ∀ {a b} {A : Type a} {B : Type b} → A × B ↔ B × A
×-comm = record
{ surjection = record
{ logical-equivalence = record
{ to = uncurry λ x y → (y , x)
; from = uncurry λ x y → (y , x)
}
; right-inverse-of = refl
}
; left-inverse-of = refl
}
-- Σ is associative.
open Bijection public using (Σ-assoc)
-- _×_ is associative.
×-assoc : ∀ {a b c} {A : Type a} {B : Type b} {C : Type c} →
A × (B × C) ↔ (A × B) × C
×-assoc = Σ-assoc
-- ⊤ is a left and right identity of _×_ and Σ.
Σ-left-identity : ∀ {a} {A : ⊤ → Type a} → Σ ⊤ A ↔ A tt
Σ-left-identity = record
{ surjection = record
{ logical-equivalence = record
{ to = proj₂
; from = λ x → (tt , x)
}
; right-inverse-of = refl
}
; left-inverse-of = refl
}
×-left-identity : ∀ {a} {A : Type a} → ⊤ × A ↔ A
×-left-identity = Σ-left-identity
×-right-identity : ∀ {a} {A : Type a} → A × ⊤ ↔ A
×-right-identity {A = A} =
A × ⊤ ↔⟨ ×-comm ⟩
⊤ × A ↔⟨ ×-left-identity ⟩□
A □
-- ⊥ is a left and right zero of _×_ and Σ.
Σ-left-zero : ∀ {ℓ₁ a ℓ₂} {A : ⊥ {ℓ = ℓ₁} → Type a} →
Σ ⊥ A ↔ ⊥ {ℓ = ℓ₂}
Σ-left-zero = record
{ surjection = record
{ logical-equivalence = record
{ to = λ { (() , _) }
; from = λ ()
}
; right-inverse-of = λ ()
}
; left-inverse-of = λ { (() , _) }
}
×-left-zero : ∀ {a ℓ₁ ℓ₂} {A : Type a} → ⊥ {ℓ = ℓ₁} × A ↔ ⊥ {ℓ = ℓ₂}
×-left-zero = Σ-left-zero
×-right-zero : ∀ {a ℓ₁ ℓ₂} {A : Type a} → A × ⊥ {ℓ = ℓ₁} ↔ ⊥ {ℓ = ℓ₂}
×-right-zero {A = A} =
A × ⊥ ↔⟨ ×-comm ⟩
⊥ × A ↔⟨ ×-left-zero ⟩□
⊥ □
------------------------------------------------------------------------
-- Some lemmas related to Σ/∃/_×_
-- See also Σ-left-zero and Σ-right-zero above.
-- Σ preserves isomorphisms in its first argument and all kinds of
-- functions in its second argument.
Σ-cong : ∀ {k₁ k₂ a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₁↔A₂ : A₁ ↔[ k₁ ] A₂) →
(∀ x → B₁ x ↝[ k₂ ] B₂ (to-implication A₁↔A₂ x)) →
Σ A₁ B₁ ↝[ k₂ ] Σ A₂ B₂
Σ-cong {equivalence} {implication} = λ A₁≃A₂ B₁→B₂ →
Σ-map (from-isomorphism A₁≃A₂) (B₁→B₂ _)
Σ-cong {bijection} {implication} = λ A₁↔A₂ B₁→B₂ →
Σ-map (from-isomorphism A₁↔A₂) (B₁→B₂ _)
Σ-cong {equivalence} {logical-equivalence} = Surjection.Σ-cong-⇔ ⊚ from-isomorphism
Σ-cong {bijection} {logical-equivalence} = Surjection.Σ-cong-⇔ ⊚ from-isomorphism
Σ-cong {equivalence} {injection} = Eq.∃-preserves-injections
Σ-cong {bijection} {injection} = Eq.∃-preserves-injections ⊚ from-isomorphism
Σ-cong {equivalence} {embedding} = Σ-preserves-embeddings ⊚ from-isomorphism
Σ-cong {bijection} {embedding} = Σ-preserves-embeddings ⊚ from-isomorphism
Σ-cong {equivalence} {surjection} = Surjection.Σ-cong ⊚ from-isomorphism
Σ-cong {bijection} {surjection} = Surjection.Σ-cong ⊚ from-isomorphism
Σ-cong {equivalence} {bijection} = Eq.∃-preserves-bijections
Σ-cong {bijection} {bijection} = Eq.∃-preserves-bijections ⊚ from-isomorphism
Σ-cong {equivalence} {equivalence} = Eq.Σ-preserves
Σ-cong {bijection} {equivalence} = Eq.Σ-preserves ⊚ from-isomorphism
Σ-cong {equivalence} {equivalenceᴱ}
{B₂ = B₂} = λ f g →
EEq.[≃]→≃ᴱ
{to = λ (x , y) → _≃_.to f x , _≃ᴱ_.to (g x) y}
{from = λ (x , y) →
_≃_.from f x
, _≃ᴱ_.from (g (_≃_.from f x))
(subst B₂ (sym (_≃_.right-inverse-of f x)) y)}
(EEq.[proofs]
(Eq.Σ-preserves f (EEq.≃ᴱ→≃ ⊚ g)))
Σ-cong {bijection} {equivalenceᴱ}
{B₂ = B₂} = λ f g →
EEq.[≃]→≃ᴱ
{to = λ (x , y) → _↔_.to f x , _≃ᴱ_.to (g x) y}
{from = λ (x , y) →
_↔_.from f x
, _≃ᴱ_.from (g (_↔_.from f x))
(subst B₂
(sym (_≃_.right-inverse-of (Eq.↔⇒≃ f) x))
y)}
(EEq.[proofs]
(Eq.Σ-preserves (from-isomorphism f)
(EEq.≃ᴱ→≃ ⊚ g)))
-- A variant of Σ-cong.
Σ-cong-contra :
∀ {k₁ k₂ a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₂↔A₁ : A₂ ↔[ k₁ ] A₁) →
(∀ x → B₁ (to-implication A₂↔A₁ x) ↝[ k₂ ] B₂ x) →
Σ A₁ B₁ ↝[ k₂ ] Σ A₂ B₂
Σ-cong-contra {k₁} {k₂} {A₁ = A₁} {A₂} {B₁} {B₂} A₂↔A₁ B₁↝B₂ =
Σ-cong A₁↔A₂ B₁↝B₂′
where
A₁↔A₂ : A₁ ↔ A₂
A₁↔A₂ = inverse $ from-isomorphism A₂↔A₁
B₁↝B₂′ : ∀ x → B₁ x ↝[ k₂ ] B₂ (_↔_.to A₁↔A₂ x)
B₁↝B₂′ x =
B₁ x ↝⟨ ≡⇒↝ _ $ cong B₁ $ sym $ _↔_.left-inverse-of A₁↔A₂ _ ⟩
B₁ (_↔_.from A₁↔A₂ (_↔_.to A₁↔A₂ x)) ↝⟨ ≡⇒↝ _ $ cong (λ f → B₁ (f (_↔_.to A₁↔A₂ x))) $ sym $
to-implication∘from-isomorphism k₁ bijection ⟩
B₁ (to-implication A₂↔A₁ (_↔_.to A₁↔A₂ x)) ↝⟨ B₁↝B₂ (_↔_.to A₁↔A₂ x) ⟩□
B₂ (_↔_.to A₁↔A₂ x) □
-- Variants of special cases of Σ-cong-contra.
Σ-cong-contra-→ :
∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₂↠A₁ : A₂ ↠ A₁) →
(∀ x → B₁ (_↠_.to A₂↠A₁ x) → B₂ x) →
Σ A₁ B₁ → Σ A₂ B₂
Σ-cong-contra-→ {B₁ = B₁} A₂↠A₁ B₁→B₂ =
Σ-map (_↠_.from A₂↠A₁)
(B₁→B₂ _ ∘ subst B₁ (sym $ _↠_.right-inverse-of A₂↠A₁ _))
Σ-cong-contra-⇔ :
∀ {a₁ a₂ b₁ b₂} {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₂↠A₁ : A₂ ↠ A₁) →
(∀ x → B₁ (_↠_.to A₂↠A₁ x) ⇔ B₂ x) →
Σ A₁ B₁ ⇔ Σ A₂ B₂
Σ-cong-contra-⇔ A₂↠A₁ B₁⇔B₂ =
inverse $
Surjection.Σ-cong-⇔ A₂↠A₁ (inverse ⊚ B₁⇔B₂)
-- ∃ preserves all kinds of functions. One could define
-- ∃-cong = Σ-cong Bijection.id, but the resulting "from" functions
-- would contain an unnecessary use of substitutivity, and I want to
-- avoid that.
private
∃-cong-impl : ∀ {a b₁ b₂}
{A : Type a} {B₁ : A → Type b₁} {B₂ : A → Type b₂} →
(∀ x → B₁ x → B₂ x) → ∃ B₁ → ∃ B₂
∃-cong-impl B₁→B₂ = Σ-map id (λ {x} → B₁→B₂ x)
∃-cong-surj : ∀ {a b₁ b₂}
{A : Type a} {B₁ : A → Type b₁} {B₂ : A → Type b₂} →
(∀ x → B₁ x ↠ B₂ x) → ∃ B₁ ↠ ∃ B₂
∃-cong-surj B₁↠B₂ = record
{ logical-equivalence = L.∃-cong (_↠_.logical-equivalence ⊚ B₁↠B₂)
; right-inverse-of = uncurry λ x y →
cong (_,_ x) (_↠_.right-inverse-of (B₁↠B₂ x) y)
}
∃-cong-bij : ∀ {a b₁ b₂}
{A : Type a} {B₁ : A → Type b₁} {B₂ : A → Type b₂} →
(∀ x → B₁ x ↔ B₂ x) → ∃ B₁ ↔ ∃ B₂
∃-cong-bij B₁↔B₂ = record
{ surjection = ∃-cong-surj (_↔_.surjection ⊚ B₁↔B₂)
; left-inverse-of = uncurry λ x y →
cong (_,_ x) (_↔_.left-inverse-of (B₁↔B₂ x) y)
}
∃-cong-≃ᴱ :
∀ {a b₁ b₂}
{A : Type a} {B₁ : A → Type b₁} {B₂ : A → Type b₂} →
(∀ x → B₁ x ≃ᴱ B₂ x) → ∃ B₁ ≃ᴱ ∃ B₂
∃-cong-≃ᴱ f = EEq.[≃]→≃ᴱ (EEq.[proofs] (Eq.∃-cong (EEq.≃ᴱ→≃ ⊚ f)))
∃-cong : ∀ {k a b₁ b₂}
{A : Type a} {B₁ : A → Type b₁} {B₂ : A → Type b₂} →
(∀ x → B₁ x ↝[ k ] B₂ x) → ∃ B₁ ↝[ k ] ∃ B₂
∃-cong {implication} = ∃-cong-impl
∃-cong {logical-equivalence} = L.∃-cong
∃-cong {injection} = Σ-cong Bijection.id
∃-cong {embedding} = Σ-preserves-embeddings Emb.id
∃-cong {surjection} = ∃-cong-surj
∃-cong {bijection} = ∃-cong-bij
∃-cong {equivalence} = Eq.∃-cong
∃-cong {equivalenceᴱ} = ∃-cong-≃ᴱ
private
-- ∃-cong also works for _×_, in which case it is a more general
-- variant of id ×-cong_:
×-cong₂ : ∀ {k a b₁ b₂}
{A : Type a} {B₁ : Type b₁} {B₂ : Type b₂} →
(A → B₁ ↝[ k ] B₂) → A × B₁ ↝[ k ] A × B₂
×-cong₂ = ∃-cong
-- The following lemma is a more general variant of _×-cong id.
×-cong₁ : ∀ {k a₁ a₂ b}
{A₁ : Type a₁} {A₂ : Type a₂} {B : Type b} →
(B → A₁ ↝[ k ] A₂) → A₁ × B ↝[ k ] A₂ × B
×-cong₁ {A₁ = A₁} {A₂} {B} A₁↔A₂ =
A₁ × B ↔⟨ ×-comm ⟩
B × A₁ ↝⟨ ∃-cong A₁↔A₂ ⟩
B × A₂ ↔⟨ ×-comm ⟩□
A₂ × B □
-- Lemmas that can be used to simplify sigma types where one of the
-- two type arguments is (conditionally) related to the unit type.
drop-⊤-right : ∀ {k a b} {A : Type a} {B : A → Type b} →
((x : A) → B x ↝[ k ] ⊤) → Σ A B ↝[ k ] A
drop-⊤-right {A = A} {B} B↝⊤ =
Σ A B ↝⟨ ∃-cong B↝⊤ ⟩
A × ⊤ ↔⟨ ×-right-identity ⟩□
A □
drop-⊤-left-× : ∀ {k a b} {A : Type a} {B : Type b} →
(B → A ↝[ k ] ⊤) → A × B ↝[ k ] B
drop-⊤-left-× {A = A} {B} A↝⊤ =
A × B ↔⟨ ×-comm ⟩
B × A ↝⟨ drop-⊤-right A↝⊤ ⟩□
B □
drop-⊤-left-Σ : ∀ {a b} {A : Type a} {B : A → Type b} →
(A↔⊤ : A ↔ ⊤) →
Σ A B ↔ B (_↔_.from A↔⊤ tt)
drop-⊤-left-Σ {A = A} {B} A↔⊤ =
Σ A B ↝⟨ inverse $ Σ-cong (inverse A↔⊤) (λ _ → id) ⟩
Σ ⊤ (B ∘ _↔_.from A↔⊤) ↝⟨ Σ-left-identity ⟩□
B (_↔_.from A↔⊤ tt) □
-- Currying.
currying :
∀ {a b c} {A : Type a} {B : A → Type b} {C : Σ A B → Type c} →
((p : Σ A B) → C p) ↔ ((x : A) (y : B x) → C (x , y))
currying = record
{ surjection = record
{ logical-equivalence = record { to = curry; from = uncurry }
; right-inverse-of = refl
}
; left-inverse-of = refl
}
-- Some lemmas relating functions from binary sums and pairs of
-- functions.
Π⊎↠Π×Π :
∀ {a b c} {A : Type a} {B : Type b} {C : A ⊎ B → Type c} →
((x : A ⊎ B) → C x)
↠
((x : A) → C (inj₁ x)) × ((y : B) → C (inj₂ y))
Π⊎↠Π×Π = record
{ logical-equivalence = record
{ to = λ f → f ⊚ inj₁ , f ⊚ inj₂
; from = uncurry [_,_]
}
; right-inverse-of = refl
}
Π⊎↔Π×Π :
∀ {a b c} {A : Type a} {B : Type b} {C : A ⊎ B → Type c} →
((x : A ⊎ B) → C x)
↝[ a ⊔ b ∣ c ]
((x : A) → C (inj₁ x)) × ((y : B) → C (inj₂ y))
Π⊎↔Π×Π =
generalise-ext?
(_↠_.logical-equivalence Π⊎↠Π×Π)
(λ ext →
refl
, (λ _ → apply-ext ext [ refl ⊚ _ , refl ⊚ _ ]))
-- ∃ distributes "from the left" over _⊎_.
∃-⊎-distrib-left :
∀ {a b c} {A : Type a} {B : A → Type b} {C : A → Type c} →
(∃ λ x → B x ⊎ C x) ↔ ∃ B ⊎ ∃ C
∃-⊎-distrib-left = record
{ surjection = record
{ logical-equivalence = record
{ to = uncurry λ x → [ inj₁ ⊚ _,_ x , inj₂ ⊚ _,_ x ]
; from = [ Σ-map id inj₁ , Σ-map id inj₂ ]
}
; right-inverse-of = [ refl ⊚ inj₁ , refl ⊚ inj₂ ]
}
; left-inverse-of =
uncurry λ x → [ refl ⊚ _,_ x ⊚ inj₁ , refl ⊚ _,_ x ⊚ inj₂ ]
}
-- ∃ also distributes "from the right" over _⊎_.
∃-⊎-distrib-right :
∀ {a b c} {A : Type a} {B : Type b} {C : A ⊎ B → Type c} →
Σ (A ⊎ B) C ↔ Σ A (C ⊚ inj₁) ⊎ Σ B (C ⊚ inj₂)
∃-⊎-distrib-right {A = A} {B} {C} = record
{ surjection = record
{ logical-equivalence = record
{ to = to
; from = from
}
; right-inverse-of = [ refl ⊚ inj₁ , refl ⊚ inj₂ ]
}
; left-inverse-of = from∘to
}
where
to : Σ (A ⊎ B) C → Σ A (C ⊚ inj₁) ⊎ Σ B (C ⊚ inj₂)
to (inj₁ x , y) = inj₁ (x , y)
to (inj₂ x , y) = inj₂ (x , y)
from = [ Σ-map inj₁ id , Σ-map inj₂ id ]
from∘to : ∀ p → from (to p) ≡ p
from∘to (inj₁ x , y) = refl _
from∘to (inj₂ x , y) = refl _
-- ∃ is "commutative".
∃-comm : ∀ {a b c} {A : Type a} {B : Type b} {C : A → B → Type c} →
(∃ λ x → ∃ λ y → C x y) ↔ (∃ λ y → ∃ λ x → C x y)
∃-comm = record
{ surjection = record
{ logical-equivalence = record
{ to = uncurry λ x → uncurry λ y z → (y , (x , z))
; from = uncurry λ x → uncurry λ y z → (y , (x , z))
}
; right-inverse-of = refl
}
; left-inverse-of = refl
}
-- One can introduce an existential by also introducing an equality.
∃-intro : ∀ {a b} {A : Type a} (B : A → Type b) (x : A) →
B x ↔ ∃ λ y → B y × y ≡ x
∃-intro B x = _≃_.bijection $ Eq.↔→≃
(λ b → x , b , refl _)
(λ (y , b , y≡x) → subst B y≡x b)
(λ (y , b , y≡x) →
sym $
Σ-≡,≡→≡
y≡x
(subst (λ y → B y × y ≡ x) y≡x (b , y≡x) ≡⟨ push-subst-, _ _ ⟩
subst B y≡x b , subst (_≡ x) y≡x y≡x ≡⟨ cong (_ ,_) subst-trans-sym ⟩
subst B y≡x b , trans (sym y≡x) y≡x ≡⟨ cong (_ ,_) $ trans-symˡ _ ⟩∎
subst B y≡x b , refl x ∎))
(subst-refl B)
-- A variant of ∃-intro.
other-∃-intro :
∀ {a b} {A : Type a} (B : A → Type b) (x : A) →
B x ≃ ∃ λ y → B y × x ≡ y
other-∃-intro B x = Eq.↔→≃
(λ b → x , b , refl _)
(λ (y , b , x≡y) → subst B (sym x≡y) b)
(λ (y , b , x≡y) →
Σ-≡,≡→≡
x≡y
(subst (λ y → B y × x ≡ y) x≡y (subst B (sym x≡y) b , refl x) ≡⟨ push-subst-, _ _ ⟩
subst B x≡y (subst B (sym x≡y) b) , subst (x ≡_) x≡y (refl x) ≡⟨ cong₂ _,_
(subst-subst-sym _ _ _)
(trans (sym trans-subst) $
trans-reflˡ _) ⟩∎
b , x≡y ∎))
(λ b →
subst B (sym (refl _)) b ≡⟨ cong (flip (subst B) _) sym-refl ⟩
subst B (refl _) b ≡⟨ subst-refl _ _ ⟩∎
b ∎)
-- Another variant of ∃-intro.
∃-introduction :
∀ {a b} {A : Type a} {x : A} (B : (y : A) → x ≡ y → Type b) →
B x (refl x) ↔ ∃ λ y → ∃ λ (x≡y : x ≡ y) → B y x≡y
∃-introduction {x = x} B =
B x (refl x) ↝⟨ ∃-intro (uncurry B) _ ⟩
(∃ λ { (y , x≡y) → B y x≡y × (y , x≡y) ≡ (x , refl x) }) ↝⟨ (∃-cong λ _ → ∃-cong λ _ →
_⇔_.to contractible⇔↔⊤ $
⇒≡ 0 (other-singleton-contractible x)) ⟩
(∃ λ { (y , x≡y) → B y x≡y × ⊤ }) ↝⟨ (∃-cong λ _ → ×-right-identity) ⟩
(∃ λ { (y , x≡y) → B y x≡y }) ↝⟨ inverse Σ-assoc ⟩□
(∃ λ y → ∃ λ x≡y → B y x≡y) □
-- A non-dependent variant of Σ-≡,≡↔≡.
--
-- This property used to be defined in terms of Σ-≡,≡↔≡, but was
-- changed in order to make it compute in a different way.
≡×≡↔≡ : ∀ {a b} {A : Type a} {B : Type b} {p₁ p₂ : A × B} →
(proj₁ p₁ ≡ proj₁ p₂ × proj₂ p₁ ≡ proj₂ p₂) ↔ (p₁ ≡ p₂)
≡×≡↔≡ {B = B} {p₁} {p₂} = record
{ surjection = record
{ logical-equivalence = record
{ to = uncurry (cong₂ _,_)
; from = λ eq → cong proj₁ eq , cong proj₂ eq
}
; right-inverse-of = λ eq →
cong₂ _,_ (cong proj₁ eq) (cong proj₂ eq) ≡⟨ cong₂-cong-cong _ _ _,_ ⟩
cong (λ p → proj₁ p , proj₂ p) eq ≡⟨⟩
cong id eq ≡⟨ sym $ cong-id _ ⟩∎
eq ∎
}
; left-inverse-of = λ { (eq₁ , eq₂) →
cong proj₁ (cong₂ _,_ eq₁ eq₂) , cong proj₂ (cong₂ _,_ eq₁ eq₂) ≡⟨ cong₂ _,_ (cong-proj₁-cong₂-, eq₁ eq₂) (cong-proj₂-cong₂-, eq₁ eq₂) ⟩∎
eq₁ , eq₂ ∎
}
}
-- If one is given an equality between pairs, where the second
-- components of the pairs are propositional, then one can restrict
-- attention to the first components.
ignore-propositional-component :
∀ {a b} {A : Type a} {B : A → Type b} {p q : Σ A B} →
Is-proposition (B (proj₁ q)) →
(proj₁ p ≡ proj₁ q) ↔ (p ≡ q)
ignore-propositional-component {B = B} {p₁ , p₂} {q₁ , q₂} Bq₁-prop =
(p₁ ≡ q₁) ↝⟨ inverse ×-right-identity ⟩
(p₁ ≡ q₁ × ⊤) ↝⟨ ∃-cong (λ _ → inverse $ _⇔_.to contractible⇔↔⊤ (+⇒≡ Bq₁-prop)) ⟩
(∃ λ (eq : p₁ ≡ q₁) → subst B eq p₂ ≡ q₂) ↝⟨ Bijection.Σ-≡,≡↔≡ ⟩□
((p₁ , p₂) ≡ (q₁ , q₂)) □
-- Contractible commutes with _×_ (assuming extensionality).
Contractible-commutes-with-× :
∀ {x y} {X : Type x} {Y : Type y} →
Contractible (X × Y) ↝[ x ⊔ y ∣ x ⊔ y ]
(Contractible X × Contractible Y)
Contractible-commutes-with-× {x = x} {y} =
generalise-ext?-prop
(record
{ to = λ cX×Y →
lemma cX×Y ,
lemma (H-level.respects-surjection
(_↔_.surjection ×-comm) 0 cX×Y)
; from = λ { ((x , eq₁) , (y , eq₂)) →
(x , y) ,
λ { (x′ , y′) →
(x , y) ≡⟨ cong₂ _,_ (eq₁ x′) (eq₂ y′) ⟩∎
(x′ , y′) ∎ } }
})
Contractible-propositional
(λ ext → ×-closure 1 (Contractible-propositional
(lower-extensionality y y ext))
(Contractible-propositional
(lower-extensionality x x ext)))
where
lemma : ∀ {x y} {X : Type x} {Y : Type y} →
Contractible (X × Y) → Contractible X
lemma ((x , y) , eq) = x , λ x′ →
x ≡⟨⟩
proj₁ (x , y) ≡⟨ cong proj₁ (eq (x′ , y)) ⟩∎
proj₁ (x′ , y) ∎
------------------------------------------------------------------------
-- Some lemmas relating equality of certain kinds of functions to
-- pointwise equality of the underlying functions
-- Equality of equivalences is isomorphic to pointwise equality of the
-- underlying functions (assuming extensionality).
≃-to-≡↔≡ :
∀ {a b} →
Extensionality (a ⊔ b) (a ⊔ b) →
{A : Type a} {B : Type b} {p q : A ≃ B} →
(∀ x → _≃_.to p x ≡ _≃_.to q x) ↔ p ≡ q
≃-to-≡↔≡ {a} {b} ext {p = p} {q} =
(∀ x → _≃_.to p x ≡ _≃_.to q x) ↔⟨ Eq.extensionality-isomorphism (lower-extensionality b a ext) ⟩
_≃_.to p ≡ _≃_.to q ↝⟨ ignore-propositional-component (Eq.propositional ext _) ⟩
(_≃_.to p , _≃_.is-equivalence p) ≡ (_≃_.to q , _≃_.is-equivalence q) ↔⟨ Eq.≃-≡ (Eq.↔⇒≃ Eq.≃-as-Σ) ⟩□
p ≡ q □
-- A variant of the previous result for which both directions compute
-- in certain ways.
≃-to-≡≃≡ :
∀ {a b} →
Extensionality (a ⊔ b) (a ⊔ b) →
Extensionality a b →
{A : Type a} {B : Type b} {p q : A ≃ B} →
(∀ x → _≃_.to p x ≡ _≃_.to q x) ≃ (p ≡ q)
≃-to-≡≃≡ ext₁ ext₂ {p = p} {q = q} =
Eq.↔→≃
(Eq.lift-equality ext₁ ⊚ apply-ext (Eq.good-ext ext₂))
(flip $ cong ⊚ flip _≃_.to)
(elim¹
(λ p≡q →
Eq.lift-equality ext₁
(apply-ext (Eq.good-ext ext₂)
(λ x → cong (λ eq → _≃_.to eq x) p≡q)) ≡
p≡q)
(Eq.lift-equality ext₁
(apply-ext (Eq.good-ext ext₂)
(λ x → cong (λ eq → _≃_.to eq x) (refl _))) ≡⟨ (cong (Eq.lift-equality ext₁) $
cong (apply-ext (Eq.good-ext ext₂)) $
apply-ext ext₂ λ _ →
cong-refl _) ⟩
Eq.lift-equality ext₁
(apply-ext (Eq.good-ext ext₂) (λ _ → refl _)) ≡⟨ cong (Eq.lift-equality ext₁) $
Eq.good-ext-refl ext₂ _ ⟩
Eq.lift-equality ext₁ (refl _) ≡⟨ Eq.lift-equality-refl ext₁ ⟩
cong Eq.⟨ _≃_.to p ,_⟩ _ ≡⟨ cong (cong Eq.⟨ _≃_.to p ,_⟩) $
mono₁ 1 (Eq.propositional ext₁ _) _ _ ⟩
cong Eq.⟨ _≃_.to p ,_⟩ (refl _) ≡⟨ cong-refl _ ⟩∎
refl _ ∎))
(λ p≡q → apply-ext ext₂ λ x →
cong (λ eq → _≃_.to eq x)
(Eq.lift-equality ext₁
(apply-ext (Eq.good-ext ext₂) p≡q)) ≡⟨ elim¹
(λ {g} p≡g →
(eq : Is-equivalence g) →
cong (λ eq → _≃_.to eq x)
(Eq.lift-equality ext₁ {q = Eq.⟨ _ , eq ⟩} p≡g) ≡
ext⁻¹ p≡g x)
(λ eq →
cong (λ eq → _≃_.to eq x)
(Eq.lift-equality ext₁ (refl _)) ≡⟨ cong (cong _) $ Eq.lift-equality-refl ext₁ ⟩
cong (λ eq → _≃_.to eq x)
(cong Eq.⟨ _≃_.to p ,_⟩ _) ≡⟨ cong-∘ _ _ _ ⟩
cong (const (_≃_.to p x)) _ ≡⟨ cong-const _ ⟩
refl _ ≡⟨ sym $ cong-refl _ ⟩∎
ext⁻¹ (refl _) x ∎)
(apply-ext (Eq.good-ext ext₂) p≡q)
_ ⟩
ext⁻¹ (apply-ext (Eq.good-ext ext₂) p≡q) x ≡⟨ cong (_$ x) $
_≃_.left-inverse-of (Eq.extensionality-isomorphism ext₂) _ ⟩∎
p≡q x ∎)
-- Equality of equivalences is isomorphic to pointwise equality of the
-- underlying /inverse/ functions (assuming extensionality).
≃-from-≡↔≡ :
∀ {a b} →
Extensionality (a ⊔ b) (a ⊔ b) →
{A : Type a} {B : Type b} {p q : A ≃ B} →
(∀ x → _≃_.from p x ≡ _≃_.from q x) ↔ p ≡ q
≃-from-≡↔≡ ext {p = p} {q} =
(∀ x → _≃_.from p x ≡ _≃_.from q x) ↝⟨ ≃-to-≡↔≡ ext ⟩
inverse p ≡ inverse q ↔⟨ Eq.≃-≡ (Eq.↔⇒≃ (Eq.inverse-isomorphism ext)) ⟩□
p ≡ q □
-- Equality of bijections between a set and a type is isomorphic to
-- pointwise equality of the underlying functions (assuming
-- extensionality).
↔-to-≡↔≡ :
∀ {a b} →
Extensionality (a ⊔ b) (a ⊔ b) →
{A : Type a} {B : Type b} {p q : A ↔ B} →
Is-set A →
(∀ x → _↔_.to p x ≡ _↔_.to q x) ↔ p ≡ q
↔-to-≡↔≡ ext {p = p} {q} A-set =
(∀ x → _↔_.to p x ≡ _↔_.to q x) ↝⟨ id ⟩
(∀ x → _≃_.to (Eq.↔⇒≃ p) x ≡ _≃_.to (Eq.↔⇒≃ q) x) ↝⟨ ≃-to-≡↔≡ ext ⟩
Eq.↔⇒≃ p ≡ Eq.↔⇒≃ q ↔⟨ Eq.≃-≡ (Eq.↔⇒≃ (Eq.↔↔≃ ext A-set)) ⟩□
p ≡ q □
-- Equality of bijections between a set and a type is isomorphic to
-- pointwise equality of the underlying /inverse/ functions (assuming
-- extensionality).
↔-from-≡↔≡ :
∀ {a b} →
Extensionality (a ⊔ b) (a ⊔ b) →
{A : Type a} {B : Type b} {p q : A ↔ B} →
Is-set A →
(∀ x → _↔_.from p x ≡ _↔_.from q x) ↔ p ≡ q
↔-from-≡↔≡ ext {p = p} {q} A-set =
(∀ x → _↔_.from p x ≡ _↔_.from q x) ↝⟨ id ⟩
(∀ x → _≃_.from (Eq.↔⇒≃ p) x ≡ _≃_.from (Eq.↔⇒≃ q) x) ↝⟨ ≃-from-≡↔≡ ext ⟩
Eq.↔⇒≃ p ≡ Eq.↔⇒≃ q ↔⟨ Eq.≃-≡ (Eq.↔⇒≃ (Eq.↔↔≃ ext A-set)) ⟩□
p ≡ q □
-- Equality of embeddings is isomorphic to pointwise equality of the
-- underlying functions (assuming extensionality).
Embedding-to-≡↔≡ :
∀ {a b} →
Extensionality (a ⊔ b) (a ⊔ b) →
{A : Type a} {B : Type b} {p q : Embedding A B} →
(∀ x → Embedding.to p x ≡ Embedding.to q x) ↔ p ≡ q
Embedding-to-≡↔≡ {a} {b} ext {p = p} {q} =
(∀ x → Embedding.to p x ≡ Embedding.to q x) ↔⟨ Eq.extensionality-isomorphism (lower-extensionality b a ext) ⟩
Embedding.to p ≡ Embedding.to q ↝⟨ ignore-propositional-component (Emb.Is-embedding-propositional ext) ⟩
(Embedding.to p , Embedding.is-embedding p) ≡
(Embedding.to q , Embedding.is-embedding q) ↔⟨ Eq.≃-≡ (Eq.↔⇒≃ Emb.Embedding-as-Σ) ⟩□
p ≡ q □
------------------------------------------------------------------------
-- _⊎_ and _×_ form a commutative semiring
-- _×_ distributes from the left over _⊎_.
×-⊎-distrib-left : ∀ {a b c} {A : Type a} {B : Type b} {C : Type c} →
A × (B ⊎ C) ↔ (A × B) ⊎ (A × C)
×-⊎-distrib-left = ∃-⊎-distrib-left
-- _×_ distributes from the right over _⊎_.
×-⊎-distrib-right : ∀ {a b c} {A : Type a} {B : Type b} {C : Type c} →
(A ⊎ B) × C ↔ (A × C) ⊎ (B × C)
×-⊎-distrib-right = ∃-⊎-distrib-right
------------------------------------------------------------------------
-- Some lemmas related to functions
-- The non-dependent function space preserves non-dependent functions
-- (contravariantly for the domain).
→-cong-→ : ∀ {a b c d}
{A : Type a} {B : Type b} {C : Type c} {D : Type d} →
(B → A) → (C → D) → (A → C) → (B → D)
→-cong-→ B→A C→D = (C→D ∘_) ∘ (_∘ B→A)
-- The non-dependent function space preserves split surjections
-- (assuming extensionality).
→-cong-↠ : ∀ {a b c d} → Extensionality b d →
{A : Type a} {B : Type b} {C : Type c} {D : Type d} →
A ↠ B → C ↠ D → (A → C) ↠ (B → D)
→-cong-↠ {a} {b} {c} {d} ext A↠B C↠D = record
{ logical-equivalence = logical-equiv
; right-inverse-of = right-inv
}
where
open _↠_
logical-equiv = L.→-cong (_↠_.logical-equivalence A↠B)
(_↠_.logical-equivalence C↠D)
abstract
right-inv :
∀ f → _⇔_.to logical-equiv (_⇔_.from logical-equiv f) ≡ f
right-inv f = apply-ext ext λ x →
to C↠D (from C↠D (f (to A↠B (from A↠B x)))) ≡⟨ right-inverse-of C↠D _ ⟩
f (to A↠B (from A↠B x)) ≡⟨ cong f $ right-inverse-of A↠B _ ⟩∎
f x ∎
private
-- Lemmas used in the implementation of →-cong.
→-cong-↔ : ∀ {a b c d}
{A : Type a} {B : Type b} {C : Type c} {D : Type d} →
Extensionality (a ⊔ b) (c ⊔ d) →
A ↔ B → C ↔ D → (A → C) ↔ (B → D)
→-cong-↔ {a} {b} {c} {d} ext A↔B C↔D = record
{ surjection = surj
; left-inverse-of = left-inv
}
where
open _↔_
surj = →-cong-↠ (lower-extensionality a c ext)
(_↔_.surjection A↔B)
(_↔_.surjection C↔D)
abstract
left-inv :
∀ f → _↠_.from surj (_↠_.to surj f) ≡ f
left-inv f = apply-ext (lower-extensionality b d ext) λ x →
from C↔D (to C↔D (f (from A↔B (to A↔B x)))) ≡⟨ left-inverse-of C↔D _ ⟩
f (from A↔B (to A↔B x)) ≡⟨ cong f $ left-inverse-of A↔B _ ⟩∎
f x ∎
→-cong-≃ :
∀ {a b c d}
{A : Type a} {B : Type b} {C : Type c} {D : Type d} →
Extensionality (a ⊔ b) (c ⊔ d) →
A ≃ B → C ≃ D → (A → C) ≃ (B → D)
→-cong-≃ ext A≃B C≃D = record
{ to = to
; is-equivalence = from , proofs
}
where
A→C≃B→D =
Eq.↔⇒≃ (→-cong-↔ ext (_≃_.bijection A≃B) (_≃_.bijection C≃D))
to = _≃_.to A→C≃B→D
from = _≃_.from A→C≃B→D
abstract
proofs : HA.Proofs to from
proofs = proj₂ (_≃_.is-equivalence A→C≃B→D)
→-cong-≃ᴱ :
∀ {a b c d}
{A : Type a} {B : Type b} {C : Type c} {D : Type d} →
Erased (Extensionality (a ⊔ b) (c ⊔ d)) →
A ≃ᴱ B → C ≃ᴱ D → (A → C) ≃ᴱ (B → D)
→-cong-≃ᴱ E.[ ext ] f g =
EEq.[≃]→≃ᴱ (EEq.[proofs] (→-cong-≃ ext (EEq.≃ᴱ→≃ f) (EEq.≃ᴱ→≃ g)))
-- The non-dependent function space preserves symmetric kinds of
-- functions (in some cases assuming extensionality).
→-cong : ∀ {k a b c d} →
Extensionality? ⌊ k ⌋-sym (a ⊔ b) (c ⊔ d) →
{A : Type a} {B : Type b} {C : Type c} {D : Type d} →
A ↝[ ⌊ k ⌋-sym ] B → C ↝[ ⌊ k ⌋-sym ] D →
(A → C) ↝[ ⌊ k ⌋-sym ] (B → D)
→-cong {logical-equivalence} _ = L.→-cong
→-cong {bijection} ext = →-cong-↔ ext
→-cong {equivalence} ext = →-cong-≃ ext
→-cong {equivalenceᴱ} ext = →-cong-≃ᴱ ext
-- A variant of →-cong.
→-cong₁ :
∀ {k₁ k₂ a b c} →
Extensionality? k₂ (a ⊔ b) c →
{A : Type a} {B : Type b} {C : Type c} →
A ↔[ k₁ ] B → (A → C) ↝[ k₂ ] (B → C)
→-cong₁ ext hyp = generalise-ext?-sym
(λ ext → →-cong ext (from-bijection (from-isomorphism hyp)) id)
ext
private
-- Lemmas used in the implementation of ∀-cong.
∀-cong-→ :
∀ {a b₁ b₂} {A : Type a} {B₁ : A → Type b₁} {B₂ : A → Type b₂} →
(∀ x → B₁ x → B₂ x) →
((x : A) → B₁ x) → ((x : A) → B₂ x)
∀-cong-→ B₁→B₂ = B₁→B₂ _ ⊚_
∀-cong-bij :
∀ {a b₁ b₂} →
Extensionality a (b₁ ⊔ b₂) →
{A : Type a} {B₁ : A → Type b₁} {B₂ : A → Type b₂} →
(∀ x → B₁ x ↔ B₂ x) →
((x : A) → B₁ x) ↔ ((x : A) → B₂ x)
∀-cong-bij {b₂ = b₂} ext B₁↔B₂ = record
{ surjection = surj
; left-inverse-of = left-inverse-of
}
where
surj = Surjection.∀-cong ext (_↔_.surjection ⊚ B₁↔B₂)
abstract
left-inverse-of : ∀ f → _↠_.from surj (_↠_.to surj f) ≡ f
left-inverse-of = λ f →
apply-ext (lower-extensionality lzero b₂ ext) λ x →
_↔_.from (B₁↔B₂ x) (_↔_.to (B₁↔B₂ x) (f x)) ≡⟨ _↔_.left-inverse-of (B₁↔B₂ x) (f x) ⟩∎
f x ∎
∀-cong-eq :
∀ {a b₁ b₂} →
Extensionality a (b₁ ⊔ b₂) →
{A : Type a} {B₁ : A → Type b₁} {B₂ : A → Type b₂} →
(∀ x → B₁ x ≃ B₂ x) →
((x : A) → B₁ x) ≃ ((x : A) → B₂ x)
∀-cong-eq ext = Eq.↔⇒≃ ⊚ ∀-cong-bij ext ⊚ (_≃_.bijection ⊚_)
∀-cong-eqᴱ :
∀ {a b₁ b₂} →
Erased (Extensionality a (b₁ ⊔ b₂)) →
{A : Type a} {B₁ : A → Type b₁} {B₂ : A → Type b₂} →
(∀ x → B₁ x ≃ᴱ B₂ x) →
((x : A) → B₁ x) ≃ᴱ ((x : A) → B₂ x)
∀-cong-eqᴱ E.[ ext ] f =
EEq.[≃]→≃ᴱ (EEq.[proofs] (∀-cong-eq ext (EEq.≃ᴱ→≃ ⊚ f)))
∀-cong-inj :
∀ {a b₁ b₂} →
Extensionality a (b₁ ⊔ b₂) →
{A : Type a} {B₁ : A → Type b₁} {B₂ : A → Type b₂} →
(∀ x → B₁ x ↣ B₂ x) →
((x : A) → B₁ x) ↣ ((x : A) → B₂ x)
∀-cong-inj {b₁ = b₁} {b₂} ext B₁↣B₂ = record
{ to = to
; injective = injective
}
where
to = ∀-cong-→ (_↣_.to ⊚ B₁↣B₂)
abstract
injective : Injective to
injective {x = f} {y = g} =
(λ x → _↣_.to (B₁↣B₂ x) (f x)) ≡ (λ x → _↣_.to (B₁↣B₂ x) (g x)) ↔⟨ inverse $ Eq.extensionality-isomorphism
(lower-extensionality lzero b₁ ext) ⟩
(∀ x → _↣_.to (B₁↣B₂ x) (f x) ≡ _↣_.to (B₁↣B₂ x) (g x)) ↝⟨ ∀-cong-→ (λ x → _↣_.injective (B₁↣B₂ x)) ⟩
(∀ x → f x ≡ g x) ↔⟨ Eq.extensionality-isomorphism
(lower-extensionality lzero b₂ ext) ⟩□
f ≡ g □
∀-cong-emb :
∀ {a b₁ b₂} →
Extensionality a (b₁ ⊔ b₂) →
{A : Type a} {B₁ : A → Type b₁} {B₂ : A → Type b₂} →
(∀ x → Embedding (B₁ x) (B₂ x)) →
Embedding ((x : A) → B₁ x) ((x : A) → B₂ x)
∀-cong-emb {b₁ = b₁} {b₂} ext B₁↣B₂ = record
{ to = to
; is-embedding = is-embedding
}
where
to = ∀-cong-→ (Embedding.to ⊚ B₁↣B₂)
ext₂ = lower-extensionality lzero b₁ ext
abstract
is-embedding : Is-embedding to
is-embedding f g = _≃_.is-equivalence $
Eq.with-other-function
(f ≡ g ↝⟨ inverse $ Eq.extensionality-isomorphism
(lower-extensionality lzero b₂ ext) ⟩
(∀ x → f x ≡ g x) ↝⟨ ∀-cong-eq ext (λ x →
Eq.⟨ _ , Embedding.is-embedding (B₁↣B₂ x) (f x) (g x) ⟩) ⟩
(∀ x → Embedding.to (B₁↣B₂ x) (f x) ≡
Embedding.to (B₁↣B₂ x) (g x)) ↝⟨ Eq.extensionality-isomorphism ext₂ ⟩□
(λ x → Embedding.to (B₁↣B₂ x) (f x)) ≡
(λ x → Embedding.to (B₁↣B₂ x) (g x)) □)
_
(λ f≡g →
apply-ext (Eq.good-ext ext₂)
(λ x → cong (Embedding.to (B₁↣B₂ x)) (ext⁻¹ f≡g x)) ≡⟨⟩
apply-ext (Eq.good-ext ext₂)
(λ x → cong (Embedding.to (B₁↣B₂ x)) (cong (_$ x) f≡g)) ≡⟨ cong (apply-ext (Eq.good-ext ext₂)) (apply-ext ext₂ λ _ →
cong-∘ _ _ _) ⟩
apply-ext (Eq.good-ext ext₂)
(λ x → cong (λ h → Embedding.to (B₁↣B₂ x) (h x)) f≡g) ≡⟨ cong (apply-ext (Eq.good-ext ext₂)) (apply-ext ext₂ λ _ → sym $
cong-∘ _ _ _) ⟩
apply-ext (Eq.good-ext ext₂)
(λ x → cong (_$ x)
(cong (λ h x → Embedding.to (B₁↣B₂ x) (h x))
f≡g)) ≡⟨⟩
apply-ext (Eq.good-ext ext₂)
(ext⁻¹ (cong (λ h x → Embedding.to (B₁↣B₂ x) (h x)) f≡g)) ≡⟨ _≃_.right-inverse-of (Eq.extensionality-isomorphism ext₂) _ ⟩∎
cong (λ h x → Embedding.to (B₁↣B₂ x) (h x)) f≡g ∎)
-- Π preserves all kinds of functions in its second argument (in some
-- cases assuming extensionality).
∀-cong :
∀ {k a b₁ b₂} →
Extensionality? k a (b₁ ⊔ b₂) →
{A : Type a} {B₁ : A → Type b₁} {B₂ : A → Type b₂} →
(∀ x → B₁ x ↝[ k ] B₂ x) →
((x : A) → B₁ x) ↝[ k ] ((x : A) → B₂ x)
∀-cong {implication} = λ _ → ∀-cong-→
∀-cong {logical-equivalence} = λ _ → L.∀-cong
∀-cong {injection} = ∀-cong-inj
∀-cong {embedding} = ∀-cong-emb
∀-cong {surjection} = Surjection.∀-cong
∀-cong {bijection} = ∀-cong-bij
∀-cong {equivalence} = ∀-cong-eq
∀-cong {equivalenceᴱ} = ∀-cong-eqᴱ
-- The implicit variant of Π preserves all kinds of functions in its
-- second argument (in some cases assuming extensionality).
implicit-∀-cong :
∀ {k a b₁ b₂} →
Extensionality? k a (b₁ ⊔ b₂) →
{A : Type a} {B₁ : A → Type b₁} {B₂ : A → Type b₂} →
(∀ {x} → B₁ x ↝[ k ] B₂ x) →
({x : A} → B₁ x) ↝[ k ] ({x : A} → B₂ x)
implicit-∀-cong ext {A} {B₁} {B₂} B₁↝B₂ =
({x : A} → B₁ x) ↔⟨ Bijection.implicit-Π↔Π ⟩
((x : A) → B₁ x) ↝⟨ ∀-cong ext (λ _ → B₁↝B₂) ⟩
((x : A) → B₂ x) ↔⟨ inverse Bijection.implicit-Π↔Π ⟩□
({x : A} → B₂ x) □
-- Two generalisations of ∀-cong for non-dependent functions.
Π-cong-contra-→ :
∀ {a₁ a₂ b₁ b₂}
{A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₂→A₁ : A₂ → A₁) →
(∀ x → B₁ (A₂→A₁ x) → B₂ x) →
((x : A₁) → B₁ x) → ((x : A₂) → B₂ x)
Π-cong-contra-→ {B₁ = B₁} {B₂} A₂→A₁ B₁→B₂ f x =
$⟨ f (A₂→A₁ x) ⟩
B₁ (A₂→A₁ x) ↝⟨ B₁→B₂ x ⟩
B₂ x □
Π-cong-→ :
∀ {a₁ a₂ b₁ b₂}
{A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₁↠A₂ : A₁ ↠ A₂) →
(∀ x → B₁ x → B₂ (_↠_.to A₁↠A₂ x)) →
((x : A₁) → B₁ x) → ((x : A₂) → B₂ x)
Π-cong-→ {B₁ = B₁} {B₂} A₁↠A₂ B₁→B₂ f x =
$⟨ f (_↠_.from A₁↠A₂ x) ⟩
B₁ (_↠_.from A₁↠A₂ x) ↝⟨ B₁→B₂ (_↠_.from A₁↠A₂ x) ⟩
B₂ (_↠_.to A₁↠A₂ (_↠_.from A₁↠A₂ x)) ↝⟨ subst B₂ (_↠_.right-inverse-of A₁↠A₂ x) ⟩□
B₂ x □
-- Two generalisations of ∀-cong for logical equivalences.
Π-cong-⇔ :
∀ {a₁ a₂ b₁ b₂}
{A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₁↠A₂ : A₁ ↠ A₂) →
(∀ x → B₁ x ⇔ B₂ (_↠_.to A₁↠A₂ x)) →
((x : A₁) → B₁ x) ⇔ ((x : A₂) → B₂ x)
Π-cong-⇔ {A₁ = A₁} {A₂} {B₁} {B₂} A₁↠A₂ B₁⇔B₂ = record
{ to = Π-cong-→ A₁↠A₂ (_⇔_.to ⊚ B₁⇔B₂)
; from = Π-cong-contra-→ (_↠_.to A₁↠A₂) (_⇔_.from ⊚ B₁⇔B₂)
}
Π-cong-contra-⇔ :
∀ {a₁ a₂ b₁ b₂}
{A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₂↠A₁ : A₂ ↠ A₁) →
(∀ x → B₁ (_↠_.to A₂↠A₁ x) ⇔ B₂ x) →
((x : A₁) → B₁ x) ⇔ ((x : A₂) → B₂ x)
Π-cong-contra-⇔ {A₁ = A₁} {A₂} {B₁} {B₂} A₂↠A₁ B₁⇔B₂ = record
{ to = Π-cong-contra-→ (_↠_.to A₂↠A₁) (_⇔_.to ⊚ B₁⇔B₂)
; from = Π-cong-→ A₂↠A₁ (_⇔_.from ⊚ B₁⇔B₂)
}
-- A generalisation of ∀-cong for split surjections.
Π-cong-↠ :
∀ {a₁ a₂ b₁ b₂} →
Extensionality a₂ b₂ →
∀ {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₁↠A₂ : A₁ ↠ A₂) →
(∀ x → B₁ x ↠ B₂ (_↠_.to A₁↠A₂ x)) →
((x : A₁) → B₁ x) ↠ ((x : A₂) → B₂ x)
Π-cong-↠ ext {B₂ = B₂} A₁↠A₂ B₁↠B₂ = record
{ logical-equivalence = equiv
; right-inverse-of = to∘from
}
where
equiv = Π-cong-⇔ A₁↠A₂ (_↠_.logical-equivalence ⊚ B₁↠B₂)
abstract
to∘from : ∀ f → _⇔_.to equiv (_⇔_.from equiv f) ≡ f
to∘from f = apply-ext ext λ x →
subst B₂ (_↠_.right-inverse-of A₁↠A₂ x)
(_↠_.to (B₁↠B₂ (_↠_.from A₁↠A₂ x))
(_↠_.from (B₁↠B₂ (_↠_.from A₁↠A₂ x))
(f (_↠_.to A₁↠A₂ (_↠_.from A₁↠A₂ x))))) ≡⟨ cong (subst B₂ (_↠_.right-inverse-of A₁↠A₂ x)) $ _↠_.right-inverse-of (B₁↠B₂ _) _ ⟩
subst B₂ (_↠_.right-inverse-of A₁↠A₂ x)
(f (_↠_.to A₁↠A₂ (_↠_.from A₁↠A₂ x))) ≡⟨ dcong f _ ⟩∎
f x ∎
-- A generalisation of ∀-cong for injections.
Π-cong-contra-↣ :
∀ {a₁ a₂ b₁ b₂} →
Extensionality a₁ b₁ →
∀ {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₂↠A₁ : A₂ ↠ A₁) →
(∀ x → B₁ (_↠_.to A₂↠A₁ x) ↣ B₂ x) →
((x : A₁) → B₁ x) ↣ ((x : A₂) → B₂ x)
Π-cong-contra-↣ ext A₂↠A₁ B₁↣B₂ = record
{ to = to
; injective = injective
}
where
to = Π-cong-contra-→ (_↠_.to A₂↠A₁) (_↣_.to ⊚ B₁↣B₂)
abstract
injective : Injective to
injective {x = f} {y = g} to-f≡to-g = apply-ext ext λ x →
let x′ = _↠_.to A₂↠A₁ (_↠_.from A₂↠A₁ x) in
$⟨ to-f≡to-g ⟩
(λ x → _↣_.to (B₁↣B₂ x) (f (_↠_.to A₂↠A₁ x))) ≡
(λ x → _↣_.to (B₁↣B₂ x) (g (_↠_.to A₂↠A₁ x))) ↝⟨ cong (_$ _) ⟩
_↣_.to (B₁↣B₂ (_↠_.from A₂↠A₁ x)) (f x′) ≡
_↣_.to (B₁↣B₂ (_↠_.from A₂↠A₁ x)) (g x′) ↝⟨ _↣_.injective (B₁↣B₂ _) ⟩
f x′ ≡ g x′ ↝⟨ subst (λ x → f x ≡ g x) $ _↠_.right-inverse-of A₂↠A₁ x ⟩□
f x ≡ g x □
private
-- Lemmas used in the implementations of Π-cong and Π-cong-contra.
Π-cong-contra-↠ :
∀ {a₁ a₂ b₁ b₂} →
Extensionality a₂ b₂ →
∀ {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₂≃A₁ : A₂ ≃ A₁) →
(∀ x → B₁ (_≃_.to A₂≃A₁ x) ↠ B₂ x) →
((x : A₁) → B₁ x) ↠ ((x : A₂) → B₂ x)
Π-cong-contra-↠ ext {B₁ = B₁} A₂≃A₁ B₁↠B₂ = record
{ logical-equivalence = equiv
; right-inverse-of = to∘from
}
where
equiv = Π-cong-contra-⇔ (_≃_.surjection A₂≃A₁)
(_↠_.logical-equivalence ⊚ B₁↠B₂)
abstract
to∘from : ∀ f → _⇔_.to equiv (_⇔_.from equiv f) ≡ f
to∘from f = apply-ext ext λ x →
_↠_.to (B₁↠B₂ x)
(subst B₁ (_≃_.right-inverse-of A₂≃A₁ (_≃_.to A₂≃A₁ x))
(_↠_.from (B₁↠B₂ (_≃_.from A₂≃A₁ (_≃_.to A₂≃A₁ x)))
(f (_≃_.from A₂≃A₁ (_≃_.to A₂≃A₁ x))))) ≡⟨ cong (λ eq → _↠_.to (B₁↠B₂ x)
(subst B₁ eq (_↠_.from (B₁↠B₂ _) (f _)))) $ sym $
_≃_.left-right-lemma A₂≃A₁ _ ⟩
_↠_.to (B₁↠B₂ x)
(subst B₁ (cong (_≃_.to A₂≃A₁) $ _≃_.left-inverse-of A₂≃A₁ x)
(_↠_.from (B₁↠B₂ (_≃_.from A₂≃A₁ (_≃_.to A₂≃A₁ x)))
(f (_≃_.from A₂≃A₁ (_≃_.to A₂≃A₁ x))))) ≡⟨ cong (_↠_.to (B₁↠B₂ x)) $ sym $ subst-∘ _ _ _ ⟩
_↠_.to (B₁↠B₂ x)
(subst (B₁ ∘ _≃_.to A₂≃A₁) (_≃_.left-inverse-of A₂≃A₁ x)
(_↠_.from (B₁↠B₂ (_≃_.from A₂≃A₁ (_≃_.to A₂≃A₁ x)))
(f (_≃_.from A₂≃A₁ (_≃_.to A₂≃A₁ x))))) ≡⟨ cong (_↠_.to (B₁↠B₂ x)) $
dcong (λ x → _↠_.from (B₁↠B₂ x) (f x)) _ ⟩
_↠_.to (B₁↠B₂ x) (_↠_.from (B₁↠B₂ x) (f x)) ≡⟨ _↠_.right-inverse-of (B₁↠B₂ x) _ ⟩∎
f x ∎
Π-cong-↔ :
∀ {a₁ a₂ b₁ b₂} →
Extensionality (a₁ ⊔ a₂) (b₁ ⊔ b₂) →
∀ {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₁≃A₂ : A₁ ≃ A₂) →
(∀ x → B₁ x ↔ B₂ (_≃_.to A₁≃A₂ x)) →
((x : A₁) → B₁ x) ↔ ((x : A₂) → B₂ x)
Π-cong-↔ {a₁} {a₂} {b₁} {b₂} ext {B₂ = B₂} A₁≃A₂ B₁↔B₂ = record
{ surjection = surj
; left-inverse-of = from∘to
}
where
surj = Π-cong-↠ (lower-extensionality a₁ b₁ ext)
(_≃_.surjection A₁≃A₂) (_↔_.surjection ⊚ B₁↔B₂)
abstract
from∘to : ∀ f → _↠_.from surj (_↠_.to surj f) ≡ f
from∘to =
_↠_.right-inverse-of $
Π-cong-contra-↠ (lower-extensionality a₂ b₂ ext)
{B₁ = B₂}
A₁≃A₂
(_↔_.surjection ⊚ inverse ⊚ B₁↔B₂)
Π-cong-contra-↔ :
∀ {a₁ a₂ b₁ b₂} →
Extensionality (a₁ ⊔ a₂) (b₁ ⊔ b₂) →
∀ {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₂≃A₁ : A₂ ≃ A₁) →
(∀ x → B₁ (_≃_.to A₂≃A₁ x) ↔ B₂ x) →
((x : A₁) → B₁ x) ↔ ((x : A₂) → B₂ x)
Π-cong-contra-↔ {a₁} {a₂} {b₁} {b₂} ext {B₂ = B₂} A₂≃A₁ B₁↔B₂ = record
{ surjection = surj
; left-inverse-of = from∘to
}
where
surj = Π-cong-contra-↠ (lower-extensionality a₁ b₁ ext)
A₂≃A₁ (_↔_.surjection ⊚ B₁↔B₂)
abstract
from∘to : ∀ f → _↠_.from surj (_↠_.to surj f) ≡ f
from∘to =
_↠_.right-inverse-of $
Π-cong-↠ (lower-extensionality a₂ b₂ ext)
(_≃_.surjection A₂≃A₁)
(_↔_.surjection ⊚ inverse ⊚ B₁↔B₂)
Π-cong-≃ :
∀ {a₁ a₂ b₁ b₂} →
Extensionality (a₁ ⊔ a₂) (b₁ ⊔ b₂) →
∀ {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₁≃A₂ : A₁ ≃ A₂) →
(∀ x → B₁ x ≃ B₂ (_≃_.to A₁≃A₂ x)) →
((x : A₁) → B₁ x) ≃ ((x : A₂) → B₂ x)
Π-cong-≃ ext A₁≃A₂ =
from-isomorphism ⊚ Π-cong-↔ ext A₁≃A₂ ⊚ (from-isomorphism ⊚_)
Π-cong-≃ᴱ :
∀ {a₁ a₂ b₁ b₂} →
Erased (Extensionality (a₁ ⊔ a₂) (b₁ ⊔ b₂)) →
∀ {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₁≃A₂ : A₁ ≃ A₂) →
(∀ x → B₁ x ≃ᴱ B₂ (_≃_.to A₁≃A₂ x)) →
((x : A₁) → B₁ x) ≃ᴱ ((x : A₂) → B₂ x)
Π-cong-≃ᴱ E.[ ext ] {B₂ = B₂} f g =
EEq.[≃]→≃ᴱ
{to = λ h x → subst B₂ (_≃_.right-inverse-of f x)
(_≃ᴱ_.to (g (_≃_.from f x)) (h (_≃_.from f x)))}
{from = λ h x → _≃ᴱ_.from (g x) (h (_≃_.to f x))}
(EEq.[proofs] (Π-cong-≃ ext f (EEq.≃ᴱ→≃ ⊚ g)))
Π-cong-contra-≃ :
∀ {a₁ a₂ b₁ b₂} →
Extensionality (a₁ ⊔ a₂) (b₁ ⊔ b₂) →
∀ {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₂≃A₁ : A₂ ≃ A₁) →
(∀ x → B₁ (_≃_.to A₂≃A₁ x) ≃ B₂ x) →
((x : A₁) → B₁ x) ≃ ((x : A₂) → B₂ x)
Π-cong-contra-≃ ext A₂≃A₁ =
from-isomorphism ⊚ Π-cong-contra-↔ ext A₂≃A₁ ⊚ (from-isomorphism ⊚_)
Π-cong-contra-≃ᴱ :
∀ {a₁ a₂ b₁ b₂} →
Erased (Extensionality (a₁ ⊔ a₂) (b₁ ⊔ b₂)) →
∀ {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₂≃A₁ : A₂ ≃ A₁) →
(∀ x → B₁ (_≃_.to A₂≃A₁ x) ≃ᴱ B₂ x) →
((x : A₁) → B₁ x) ≃ᴱ ((x : A₂) → B₂ x)
Π-cong-contra-≃ᴱ E.[ ext ] {B₁ = B₁} f g =
EEq.[≃]→≃ᴱ
{to = λ h x → _≃ᴱ_.to (g x) (h (_≃_.to f x))}
{from = λ h x → subst B₁ (_≃_.right-inverse-of f x)
(_≃ᴱ_.from (g (_≃_.from f x))
(h (_≃_.from f x)))}
(EEq.[proofs] (Π-cong-contra-≃ ext f (EEq.≃ᴱ→≃ ⊚ g)))
Π-cong-↣ :
∀ {a₁ a₂ b₁ b₂} →
Extensionality a₁ b₁ →
∀ {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₁≃A₂ : A₁ ≃ A₂) →
(∀ x → B₁ x ↣ B₂ (_≃_.to A₁≃A₂ x)) →
((x : A₁) → B₁ x) ↣ ((x : A₂) → B₂ x)
Π-cong-↣ ext {A₁} {A₂} {B₁} {B₂} A₁≃A₂ =
(∀ x → B₁ x ↣ B₂ (_≃_.to A₁≃A₂ x)) ↝⟨ Π-cong-contra-→ (_≃_.from A₁≃A₂) (λ _ → id) ⟩
(∀ x → B₁ (_≃_.from A₁≃A₂ x) ↣ B₂ (_≃_.to A₁≃A₂ (_≃_.from A₁≃A₂ x))) ↝⟨ (∀-cong _ λ _ →
subst ((B₁ _ ↣_) ⊚ B₂) (_≃_.right-inverse-of A₁≃A₂ _)) ⟩
(∀ x → B₁ (_≃_.from A₁≃A₂ x) ↣ B₂ x) ↝⟨ Π-cong-contra-↣ ext (_≃_.surjection $ inverse A₁≃A₂) ⟩□
((x : A₁) → B₁ x) ↣ ((x : A₂) → B₂ x) □
Π-cong-contra-Emb :
∀ {a₁ a₂ b₁ b₂} →
Extensionality (a₁ ⊔ a₂) (b₁ ⊔ b₂) →
∀ {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₂≃A₁ : A₂ ≃ A₁) →
(∀ x → Embedding (B₁ (_≃_.to A₂≃A₁ x)) (B₂ x)) →
Embedding ((x : A₁) → B₁ x) ((x : A₂) → B₂ x)
Π-cong-contra-Emb {a₁} {a₂} {b₁} {b₂} ext A₂≃A₁ B₁↣B₂ = record
{ to = to
; is-embedding = is-embedding
}
where
to = Π-cong-contra-→ (_≃_.to A₂≃A₁) (Embedding.to ⊚ B₁↣B₂)
abstract
ext₁₁ : Extensionality a₁ b₁
ext₁₁ = lower-extensionality a₂ b₂ ext
ext₂₁ : Extensionality a₂ b₁
ext₂₁ = lower-extensionality a₁ b₂ ext
ext₂₂ : Extensionality a₂ b₂
ext₂₂ = lower-extensionality a₁ b₁ ext
is-embedding : Is-embedding to
is-embedding f g =
_≃_.is-equivalence $
Eq.with-other-function
(f ≡ g ↝⟨ inverse $ Eq.extensionality-isomorphism ext₁₁ ⟩
(∀ x → f x ≡ g x) ↝⟨ (inverse $ Π-cong-≃ ext A₂≃A₁ λ x →
inverse $ Embedding.equivalence (B₁↣B₂ x)) ⟩
(∀ x → Embedding.to (B₁↣B₂ x) (f (_≃_.to A₂≃A₁ x)) ≡
Embedding.to (B₁↣B₂ x) (g (_≃_.to A₂≃A₁ x))) ↝⟨ Eq.extensionality-isomorphism ext₂₂ ⟩
(λ {x} → Embedding.to (B₁↣B₂ x)) ⊚ f ⊚ _≃_.to A₂≃A₁ ≡
(λ {x} → Embedding.to (B₁↣B₂ x)) ⊚ g ⊚ _≃_.to A₂≃A₁ ↔⟨⟩
to f ≡ to g □)
_
(λ f≡g →
apply-ext (Eq.good-ext ext₂₂)
(cong (Embedding.to (B₁↣B₂ _)) ⊚
ext⁻¹ f≡g ⊚ _≃_.to A₂≃A₁) ≡⟨ sym $ Eq.cong-post-∘-good-ext ext₂₁ ext₂₂ _ ⟩
cong (Embedding.to (B₁↣B₂ _) ⊚_)
(apply-ext (Eq.good-ext ext₂₁)
(ext⁻¹ f≡g ⊚ _≃_.to A₂≃A₁)) ≡⟨ cong (cong (Embedding.to (B₁↣B₂ _) ⊚_)) $ sym $
Eq.cong-pre-∘-good-ext ext₂₁ ext₁₁ _ ⟩
cong (Embedding.to (B₁↣B₂ _) ⊚_)
(cong (_⊚ _≃_.to A₂≃A₁)
(apply-ext (Eq.good-ext ext₁₁) (ext⁻¹ f≡g))) ≡⟨ cong-∘ _ _ _ ⟩
cong to (apply-ext (Eq.good-ext ext₁₁) (ext⁻¹ f≡g)) ≡⟨ cong (cong to) $
_≃_.right-inverse-of (Eq.extensionality-isomorphism ext₁₁) _ ⟩∎
cong to f≡g ∎)
Π-cong-Emb :
∀ {a₁ a₂ b₁ b₂} →
Extensionality (a₁ ⊔ a₂) (b₁ ⊔ b₂) →
∀ {A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₁≃A₂ : A₁ ≃ A₂) →
(∀ x → Embedding (B₁ x) (B₂ (_≃_.to A₁≃A₂ x))) →
Embedding ((x : A₁) → B₁ x) ((x : A₂) → B₂ x)
Π-cong-Emb ext {A₁} {A₂} {B₁} {B₂} A₁≃A₂ =
(∀ x → Embedding (B₁ x) (B₂ (_≃_.to A₁≃A₂ x))) ↝⟨ Π-cong-contra-→ (_≃_.from A₁≃A₂) (λ _ → id) ⟩
(∀ x → Embedding (B₁ (_≃_.from A₁≃A₂ x))
(B₂ (_≃_.to A₁≃A₂ (_≃_.from A₁≃A₂ x)))) ↝⟨ (∀-cong _ λ _ → subst (Embedding (B₁ _) ⊚ B₂) (_≃_.right-inverse-of A₁≃A₂ _)) ⟩
(∀ x → Embedding (B₁ (_≃_.from A₁≃A₂ x)) (B₂ x)) ↝⟨ Π-cong-contra-Emb ext (inverse A₁≃A₂) ⟩□
Embedding ((x : A₁) → B₁ x) ((x : A₂) → B₂ x) □
-- A generalisation of ∀-cong.
Π-cong :
∀ {k₁ k₂ a₁ a₂ b₁ b₂} →
Extensionality? k₂ (a₁ ⊔ a₂) (b₁ ⊔ b₂) →
{A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₁↔A₂ : A₁ ↔[ k₁ ] A₂) →
(∀ x → B₁ x ↝[ k₂ ] B₂ (to-implication A₁↔A₂ x)) →
((x : A₁) → B₁ x) ↝[ k₂ ] ((x : A₂) → B₂ x)
Π-cong {k₁} {k₂} {a₁} {a₂} {b₁} {b₂}
ext {A₁} {A₂} {B₁} {B₂} A₁↔A₂ B₁↝B₂ =
helper k₂ ext (B₁↝B₂′ k₁ A₁↔A₂ B₁↝B₂)
where
-- The first four clauses are included as optimisations intended to
-- make some proof terms easier to work with. These clauses cover
-- every possible use of B₁↝B₂′ in the expression above.
B₁↝B₂′ :
∀ k₁ (A₁↔A₂ : A₁ ↔[ k₁ ] A₂) →
(∀ x → B₁ x ↝[ k₂ ] B₂ (to-implication A₁↔A₂ x)) →
∀ k x →
B₁ x ↝[ k₂ ] B₂ (to-implication {k = k} (from-isomorphism A₁↔A₂) x)
B₁↝B₂′ bijection _ B₁↝B₂ equivalence = B₁↝B₂
B₁↝B₂′ bijection _ B₁↝B₂ surjection = B₁↝B₂
B₁↝B₂′ equivalence _ B₁↝B₂ equivalence = B₁↝B₂
B₁↝B₂′ equivalence _ B₁↝B₂ surjection = B₁↝B₂
B₁↝B₂′ k₁ A₁↔A₂ B₁↝B₂ k = λ x →
B₁ x ↝⟨ B₁↝B₂ x ⟩
B₂ (to-implication A₁↔A₂ x) ↝⟨ ≡⇒↝ _ $ cong (λ f → B₂ (f x)) $
to-implication∘from-isomorphism k₁ k ⟩□
B₂ (to-implication {k = k} (from-isomorphism A₁↔A₂) x) □
A₁↝A₂ : ∀ {k} → A₁ ↝[ k ] A₂
A₁↝A₂ = from-isomorphism A₁↔A₂
l₁ = lower-extensionality a₁ b₁
l₂ = lower-extensionality a₂ b₂
helper :
∀ k₂ →
Extensionality? k₂ (a₁ ⊔ a₂) (b₁ ⊔ b₂) →
(∀ k x → B₁ x ↝[ k₂ ]
B₂ (to-implication {k = k} (from-isomorphism A₁↔A₂) x)) →
((x : A₁) → B₁ x) ↝[ k₂ ] ((x : A₂) → B₂ x)
helper implication _ = Π-cong-→ A₁↝A₂ ⊚ (_$ surjection)
helper logical-equivalence _ = Π-cong-⇔ A₁↝A₂ ⊚ (_$ surjection)
helper injection ext = Π-cong-↣ (l₂ ext) A₁↝A₂ ⊚ (_$ equivalence)
helper embedding ext = Π-cong-Emb ext A₁↝A₂ ⊚ (_$ equivalence)
helper surjection ext = Π-cong-↠ (l₁ ext) A₁↝A₂ ⊚ (_$ surjection)
helper bijection ext = Π-cong-↔ ext A₁↝A₂ ⊚ (_$ equivalence)
helper equivalence ext = Π-cong-≃ ext A₁↝A₂ ⊚ (_$ equivalence)
helper equivalenceᴱ ext = Π-cong-≃ᴱ ext A₁↝A₂ ⊚ (_$ equivalence)
-- A variant of Π-cong.
Π-cong-contra :
∀ {k₁ k₂ a₁ a₂ b₁ b₂} →
Extensionality? k₂ (a₁ ⊔ a₂) (b₁ ⊔ b₂) →
{A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₂↔A₁ : A₂ ↔[ k₁ ] A₁) →
(∀ x → B₁ (to-implication A₂↔A₁ x) ↝[ k₂ ] B₂ x) →
((x : A₁) → B₁ x) ↝[ k₂ ] ((x : A₂) → B₂ x)
Π-cong-contra {k₁} {k₂} {a₁} {a₂} {b₁} {b₂}
ext {A₁} {A₂} {B₁} {B₂} A₂↔A₁ B₁↝B₂ =
helper k₂ ext (B₁↝B₂′ k₁ A₂↔A₁ B₁↝B₂)
where
-- The first six clauses are included as optimisations intended to
-- make some proof terms easier to work with. These clauses cover
-- every possible use of B₁↝B₂′ in the expression above.
B₁↝B₂′ :
∀ k₁ (A₂↔A₁ : A₂ ↔[ k₁ ] A₁) →
(∀ x → B₁ (to-implication A₂↔A₁ x) ↝[ k₂ ] B₂ x) →
∀ k x →
B₁ (to-implication {k = k} (from-isomorphism A₂↔A₁) x) ↝[ k₂ ] B₂ x
B₁↝B₂′ bijection _ B₁↝B₂ equivalence = B₁↝B₂
B₁↝B₂′ bijection _ B₁↝B₂ implication = B₁↝B₂
B₁↝B₂′ bijection _ B₁↝B₂ surjection = B₁↝B₂
B₁↝B₂′ equivalence _ B₁↝B₂ equivalence = B₁↝B₂
B₁↝B₂′ equivalence _ B₁↝B₂ implication = B₁↝B₂
B₁↝B₂′ equivalence _ B₁↝B₂ surjection = B₁↝B₂
B₁↝B₂′ k₁ A₂↔A₁ B₁↝B₂ k = λ x →
B₁ (to-implication {k = k} (from-isomorphism A₂↔A₁) x) ↝⟨ ≡⇒↝ _ $ cong (λ f → B₁ (f x)) $ sym $ to-implication∘from-isomorphism k₁ k ⟩
B₁ (to-implication A₂↔A₁ x) ↝⟨ B₁↝B₂ x ⟩□
B₂ x □
A₂↝A₁ : ∀ {k} → A₂ ↝[ k ] A₁
A₂↝A₁ = from-isomorphism A₂↔A₁
l₁ = lower-extensionality a₁ b₁
l₂ = lower-extensionality a₂ b₂
helper :
∀ k₂ →
Extensionality? k₂ (a₁ ⊔ a₂) (b₁ ⊔ b₂) →
(∀ k x → B₁ (to-implication {k = k} (from-isomorphism A₂↔A₁) x)
↝[ k₂ ]
B₂ x) →
((x : A₁) → B₁ x) ↝[ k₂ ] ((x : A₂) → B₂ x)
helper implication _ = Π-cong-contra-→ A₂↝A₁ ⊚ (_$ implication)
helper logical-equivalence _ = Π-cong-contra-⇔ A₂↝A₁ ⊚ (_$ surjection)
helper injection ext = Π-cong-contra-↣ (l₂ ext) A₂↝A₁ ⊚ (_$ surjection)
helper embedding ext = Π-cong-contra-Emb ext A₂↝A₁ ⊚ (_$ equivalence)
helper surjection ext = Π-cong-contra-↠ (l₁ ext) A₂↝A₁ ⊚ (_$ equivalence)
helper bijection ext = Π-cong-contra-↔ ext A₂↝A₁ ⊚ (_$ equivalence)
helper equivalence ext = Π-cong-contra-≃ ext A₂↝A₁ ⊚ (_$ equivalence)
helper equivalenceᴱ ext = Π-cong-contra-≃ᴱ ext A₂↝A₁ ⊚ (_$ equivalence)
-- A variant of Π-cong for implicit Πs.
implicit-Π-cong :
∀ {k₁ k₂ a₁ a₂ b₁ b₂} →
Extensionality? k₂ (a₁ ⊔ a₂) (b₁ ⊔ b₂) →
{A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₁↔A₂ : A₁ ↔[ k₁ ] A₂) →
(∀ x → B₁ x ↝[ k₂ ] B₂ (to-implication A₁↔A₂ x)) →
({x : A₁} → B₁ x) ↝[ k₂ ] ({x : A₂} → B₂ x)
implicit-Π-cong ext {A₁} {A₂} {B₁} {B₂} A₁↔A₂ B₁↝B₂ =
({x : A₁} → B₁ x) ↔⟨ Bijection.implicit-Π↔Π ⟩
((x : A₁) → B₁ x) ↝⟨ Π-cong ext A₁↔A₂ B₁↝B₂ ⟩
((x : A₂) → B₂ x) ↔⟨ inverse Bijection.implicit-Π↔Π ⟩□
({x : A₂} → B₂ x) □
-- A variant of Π-cong-contra for implicit Πs.
implicit-Π-cong-contra :
∀ {k₁ k₂ a₁ a₂ b₁ b₂} →
Extensionality? k₂ (a₁ ⊔ a₂) (b₁ ⊔ b₂) →
{A₁ : Type a₁} {A₂ : Type a₂}
{B₁ : A₁ → Type b₁} {B₂ : A₂ → Type b₂} →
(A₂↔A₁ : A₂ ↔[ k₁ ] A₁) →
(∀ x → B₁ (to-implication A₂↔A₁ x) ↝[ k₂ ] B₂ x) →
({x : A₁} → B₁ x) ↝[ k₂ ] ({x : A₂} → B₂ x)
implicit-Π-cong-contra ext {A₁} {A₂} {B₁} {B₂} A₁↔A₂ B₁↝B₂ =
({x : A₁} → B₁ x) ↔⟨ Bijection.implicit-Π↔Π ⟩
((x : A₁) → B₁ x) ↝⟨ Π-cong-contra ext A₁↔A₂ B₁↝B₂ ⟩
((x : A₂) → B₂ x) ↔⟨ inverse Bijection.implicit-Π↔Π ⟩□
({x : A₂} → B₂ x) □
Π-left-identity : ∀ {a} {A : ⊤ → Type a} → ((x : ⊤) → A x) ↔ A tt
Π-left-identity = record
{ surjection = record
{ logical-equivalence = record
{ to = λ f → f tt
; from = λ x _ → x
}
; right-inverse-of = refl
}
; left-inverse-of = refl
}
-- A variant of Π-left-identity.
Π-left-identity-↑ :
∀ {a ℓ} {A : ↑ ℓ ⊤ → Type a} → ((x : ↑ ℓ ⊤) → A x) ↔ A (lift tt)
Π-left-identity-↑ = record
{ surjection = record
{ logical-equivalence = record
{ to = λ f → f (lift tt)
; from = λ x _ → x
}
; right-inverse-of = refl
}
; left-inverse-of = refl
}
-- A lemma that can be used to simplify a pi type where the domain is
-- isomorphic to the unit type.
drop-⊤-left-Π :
∀ {k a b} {A : Type a} {B : A → Type b} →
Extensionality? k a b →
(A↔⊤ : A ↔ ⊤) →
((x : A) → B x) ↝[ k ] B (_↔_.from A↔⊤ tt)
drop-⊤-left-Π {A = A} {B} ext A↔⊤ =
((x : A) → B x) ↝⟨ Π-cong-contra ext (inverse A↔⊤) (λ _ → id) ⟩
((x : ⊤) → B (_↔_.from A↔⊤ x)) ↔⟨ Π-left-identity ⟩□
B (_↔_.from A↔⊤ tt) □
→-right-zero : ∀ {a} {A : Type a} → (A → ⊤) ↔ ⊤
→-right-zero = record
{ surjection = record
{ logical-equivalence = record
{ to = λ _ → tt
; from = λ _ _ → tt
}
; right-inverse-of = λ _ → refl tt
}
; left-inverse-of = λ _ → refl (λ _ → tt)
}
-- A lemma relating function types with the empty type as domain and
-- the unit type.
Π⊥↔⊤ : ∀ {ℓ a} {A : ⊥ {ℓ = ℓ} → Type a} →
((x : ⊥) → A x) ↝[ ℓ ∣ a ] ⊤
Π⊥↔⊤ = generalise-ext?
(record
{ to = _
; from = λ _ x → ⊥-elim x
})
(λ ext →
(λ _ → refl _)
, (λ _ → apply-ext ext (λ x → ⊥-elim x)))
-- A lemma relating ¬ ⊥ and ⊤.
¬⊥↔⊤ : ∀ {ℓ} → ¬ ⊥ {ℓ = ℓ} ↝[ ℓ ∣ lzero ] ⊤
¬⊥↔⊤ = Π⊥↔⊤
-- Simplification lemmas for types of the form A → A → B.
→→↠→ :
∀ {a b} {A : Type a} {B : Type b} →
(A → A → B) ↠ (A → B)
→→↠→ = record
{ logical-equivalence = record
{ to = λ f x → f x x
; from = λ f x _ → f x
}
; right-inverse-of = refl
}
→→proposition↔→ :
∀ {a b} {A : Type a} {B : Type b} →
Extensionality a (a ⊔ b) →
Is-proposition B →
(A → A → B) ↔ (A → B)
→→proposition↔→ {a} ext B-prop = record
{ surjection = →→↠→
; left-inverse-of = λ f →
apply-ext ext λ x →
(Π-closure (lower-extensionality lzero a ext) 1 λ _ →
B-prop) _ _
}
-- If A is inhabited, then there is a split surjection from A → B to
-- B.
inhabited→↠ :
∀ {a b} {A : Type a} {B : Type b} →
A → (A → B) ↠ B
inhabited→↠ x = record
{ logical-equivalence = record
{ to = _$ x
; from = const
}
; right-inverse-of = refl
}
-- If A is inhabited and B is a proposition, then A → B and B are
-- isomorphic (assuming extensionality).
inhabited→proposition↔ :
∀ {a b} {A : Type a} {B : Type b} →
Extensionality a b →
Is-proposition B →
A → (A → B) ↔ B
inhabited→proposition↔ ext B-prop x = record
{ surjection = inhabited→↠ x
; left-inverse-of = λ f →
apply-ext ext λ y →
f x ≡⟨ B-prop _ _ ⟩∎
f y ∎
}
-- Π is "commutative".
Π-comm : ∀ {a b c} {A : Type a} {B : Type b} {C : A → B → Type c} →
(∀ x y → C x y) ↔ (∀ y x → C x y)
Π-comm = record
{ surjection = record
{ logical-equivalence = record { to = flip; from = flip }
; right-inverse-of = refl
}
; left-inverse-of = refl
}
-- Π and Σ commute (in a certain sense).
open Bijection public using (ΠΣ-comm)
-- The implicit variant of Π and Σ commute (in a certain sense).
implicit-ΠΣ-comm :
∀ {a b c} {A : Type a} {B : A → Type b} {C : (x : A) → B x → Type c} →
(∀ {x} → ∃ λ (y : B x) → C x y)
↔
(∃ λ (f : ∀ {x} → B x) → ∀ {x} → C x f)
implicit-ΠΣ-comm {A = A} {B} {C} =
(∀ {x} → ∃ λ (y : B x) → C x y) ↝⟨ Bijection.implicit-Π↔Π ⟩
(∀ x → ∃ λ (y : B x) → C x y) ↝⟨ ΠΣ-comm ⟩
(∃ λ (f : ∀ x → B x) → ∀ x → C x (f x)) ↝⟨ inverse $ Σ-cong Bijection.implicit-Π↔Π (λ _ → Bijection.implicit-Π↔Π) ⟩□
(∃ λ (f : ∀ {x} → B x) → ∀ {x} → C x f) □
-- Some variants of De Morgan's laws.
¬⊎↠¬×¬ :
∀ {a b} {A : Type a} {B : Type b} →
¬ (A ⊎ B) ↠ ¬ A × ¬ B
¬⊎↠¬×¬ = record
{ logical-equivalence = record
{ to = λ ¬[A⊎B] → ¬[A⊎B] ∘ inj₁ , ¬[A⊎B] ∘ inj₂
; from = λ (¬A , ¬B) → [ ¬A , ¬B ]
}
; right-inverse-of = refl
}
¬⊎↔¬×¬ :
∀ {a b} {A : Type a} {B : Type b} →
¬ (A ⊎ B) ↝[ a ⊔ b ∣ lzero ] ¬ A × ¬ B
¬⊎↔¬×¬ = generalise-ext?
(_↠_.logical-equivalence ¬⊎↠¬×¬)
(λ ext →
refl
, (λ _ → apply-ext ext [ (λ _ → refl _) , (λ _ → refl _) ]))
¬⊎¬→׬ :
∀ {a b} {A : Type a} {B : Type b} →
¬ A ⊎ ¬ B → ¬ (A × B)
¬⊎¬→׬ = [ (_∘ proj₁) , (_∘ proj₂) ]
¬⊎¬⇔¬× :
∀ {a b} {A : Type a} {B : Type b} →
Dec (¬ A) → Dec (¬ B) →
¬ A ⊎ ¬ B ⇔ ¬ (A × B)
¬⊎¬⇔¬× (yes ¬A) _ = record
{ to = ¬⊎¬→׬
; from = λ _ → inj₁ ¬A
}
¬⊎¬⇔¬× _ (yes ¬B) = record
{ to = ¬⊎¬→׬
; from = λ _ → inj₂ ¬B
}
¬⊎¬⇔¬× (no ¬¬A) (no ¬¬B) = record
{ to = ¬⊎¬→׬
; from = λ ¬[A×B] →
⊥-elim $
¬¬A λ a →
¬¬B λ b →
¬[A×B] (a , b)
}
¬⊎¬↠¬× :
∀ {a b} {A : Type a} {B : Type b} →
Extensionality (a ⊔ b) lzero →
Dec (¬ A) → Dec (¬ B) →
¬ A ⊎ ¬ B ↠ ¬ (A × B)
¬⊎¬↠¬× ext dec-¬A dec-¬B = record
{ logical-equivalence = ¬⊎¬⇔¬× dec-¬A dec-¬B
; right-inverse-of = λ _ → ¬-propositional ext _ _
}
-- A variant of extensionality-isomorphism for functions with implicit
-- arguments.
implicit-extensionality-isomorphism :
∀ {k a b} →
Extensionality a b →
{A : Type a} {B : A → Type b} {f g : {x : A} → B x} →
(∀ x → f {x} ≡ g {x}) ↔[ k ] ((λ {x} → f {x}) ≡ g)
implicit-extensionality-isomorphism ext {f = f} {g} =
(∀ x → f {x} ≡ g {x}) ↔⟨ Eq.extensionality-isomorphism ext ⟩
((λ x → f {x}) ≡ (λ x → g {x})) ↔⟨ inverse $ Eq.≃-≡ (Eq.↔⇒≃ (inverse Bijection.implicit-Π↔Π)) ⟩□
((λ {x} → f {x}) ≡ g) □
private
-- The forward direction of
-- implicit-extensionality-isomorphism {k = bijection} computes in a
-- certain way.
--
-- Note that (at the time of writing) the proof below fails if the
-- two occurrences of "inverse" in the previous proof are removed.
to-implicit-extensionality-isomorphism :
∀ {a b}
(ext : Extensionality a b) {A : Type a} {B : A → Type b}
{f g : {x : A} → B x} (f≡g : ∀ x → f {x} ≡ g {x}) →
_↔_.to (implicit-extensionality-isomorphism ext) f≡g
≡
implicit-extensionality (Eq.good-ext ext) f≡g
to-implicit-extensionality-isomorphism _ _ = refl _
-- The Yoneda lemma, as given in the HoTT book, but specialised to the
-- opposite of the category of sets and functions, and with some
-- naturality properties omitted. (The proof uses extensionality.)
yoneda :
∀ {a b X} →
Extensionality (lsuc a) (lsuc a ⊔ b) →
(F : Set a → Set b) →
(map : ∀ {A B} → (⌞ A ⌟ → ⌞ B ⌟) → ⌞ F A ⌟ → ⌞ F B ⌟) →
(∀ {A} {x : ⌞ F A ⌟} → map id x ≡ x) →
(∀ {A B C f g x} →
(map {A = B} {B = C} f ∘ map {A = A} g) x ≡ map (f ∘ g) x) →
⌞ F X ⌟
↔
∃ λ (γ : ∀ Y → (⌞ X ⌟ → ⌞ Y ⌟) → ⌞ F Y ⌟) →
∀ Y₁ Y₂ f g → map f (γ Y₁ g) ≡ γ Y₂ (f ∘ g)
yoneda {a} {X = X} ext F map map-id map-∘ = record
{ surjection = record
{ logical-equivalence = record
{ to = λ x → (λ _ f → map f x) , λ _ _ f g →
map f (map g x) ≡⟨ map-∘ ⟩∎
map (f ∘ g) x ∎
; from = λ { (γ , _) → γ X id }
}
; right-inverse-of = λ { (γ , h) → Σ-≡,≡→≡
((λ _ f → map f (γ X id)) ≡⟨ (apply-ext (lower-extensionality lzero (lsuc a) ext) λ Y →
apply-ext (lower-extensionality _ (lsuc a) ext) λ f →
h X Y f id) ⟩∎
(λ Y f → γ Y f) ∎)
((Π-closure ext 1 λ _ →
Π-closure (lower-extensionality lzero (lsuc a) ext) 1 λ Y₂ →
Π-closure (lower-extensionality _ (lsuc a) ext) 1 λ _ →
Π-closure (lower-extensionality _ (lsuc a) ext) 1 λ _ →
proj₂ (F Y₂)) _ _) }
}
; left-inverse-of = λ x →
map id x ≡⟨ map-id ⟩∎
x ∎
}
-- There is a (split) surjection from products of equality
-- isomorphisms to equalities.
Π≡↔≡-↠-≡ : ∀ k {a} {A : Type a} (x y : A) →
(∀ z → (z ≡ x) ↔[ k ] (z ≡ y)) ↠ (x ≡ y)
Π≡↔≡-↠-≡ k x y = record
{ logical-equivalence = record { to = to; from = from }
; right-inverse-of = to∘from
}
where
to : (∀ z → (z ≡ x) ↔[ k ] (z ≡ y)) → x ≡ y
to f = to-implication (f x) (refl x)
from′ : x ≡ y → ∀ z → (z ≡ x) ↔ (z ≡ y)
from′ x≡y z = record
{ surjection = record
{ logical-equivalence = record
{ to = λ z≡x → trans z≡x x≡y
; from = λ z≡y → trans z≡y (sym x≡y)
}
; right-inverse-of = λ z≡y → trans-[trans-sym]- z≡y x≡y
}
; left-inverse-of = λ z≡x → trans-[trans]-sym z≡x x≡y
}
from : x ≡ y → ∀ z → (z ≡ x) ↔[ k ] (z ≡ y)
from x≡y z = from-bijection (from′ x≡y z)
abstract
to∘from : ∀ x≡y → to (from x≡y) ≡ x≡y
to∘from x≡y =
to (from x≡y) ≡⟨ sym $ cong (λ f → f (refl x)) $ to-implication∘from-isomorphism bijection ⌊ k ⌋-iso ⟩
trans (refl x) x≡y ≡⟨ trans-reflˡ _ ⟩∎
x≡y ∎
-- Products of equivalences of equalities are isomorphic to equalities
-- (assuming extensionality).
Π≡≃≡-↔-≡ :
∀ {a} {A : Type a} (x y : A) →
(∀ z → (z ≡ x) ≃ (z ≡ y)) ↝[ a ∣ a ] (x ≡ y)
Π≡≃≡-↔-≡ {a = a} x y =
generalise-ext?
(_↠_.logical-equivalence surj)
(λ ext →
_↠_.right-inverse-of surj
, from∘to ext)
where
surj = Π≡↔≡-↠-≡ equivalence x y
open _↠_ surj
abstract
from∘to :
Extensionality a a →
∀ f → from (to f) ≡ f
from∘to ext f =
apply-ext ext λ z → Eq.lift-equality ext $ apply-ext ext λ z≡x →
trans z≡x (_≃_.to (f x) (refl x)) ≡⟨ elim (λ {u v} u≡v →
(f : ∀ z → (z ≡ v) ≃ (z ≡ y)) →
trans u≡v (_≃_.to (f v) (refl v)) ≡
_≃_.to (f u) u≡v)
(λ _ _ → trans-reflˡ _)
z≡x f ⟩∎
_≃_.to (f z) z≡x ∎
-- One can introduce a universal quantifier by also introducing an
-- equality (perhaps assuming extensionality).
∀-intro :
∀ {a b} {A : Type a} {x : A} (B : (y : A) → x ≡ y → Type b) →
B x (refl x) ↝[ a ∣ a ⊔ b ] (∀ y (x≡y : x ≡ y) → B y x≡y)
∀-intro {a = a} {b = b} {A = A} {x = x} B =
generalise-ext? ∀-intro-⇔ (λ ext → to∘from ext , from∘to ext)
where
∀-intro-⇔ : B x (refl x) ⇔ (∀ y (x≡y : x ≡ y) → B y x≡y)
∀-intro-⇔ = record
{ to = λ b y x≡y →
subst (uncurry B)
(proj₂ (other-singleton-contractible x) (y , x≡y))
b
; from = λ f → f x (refl x)
}
abstract
from∘to :
Extensionality a (a ⊔ b) →
∀ b → _⇔_.from ∀-intro-⇔ (_⇔_.to ∀-intro-⇔ b) ≡ b
from∘to ext b =
subst (uncurry B)
(proj₂ (other-singleton-contractible x) (x , refl x)) b ≡⟨ cong (λ eq → subst (uncurry B) eq b) $
other-singleton-contractible-refl x ⟩
subst (uncurry B) (refl (x , refl x)) b ≡⟨ subst-refl (uncurry B) _ ⟩∎
b ∎
to∘from :
Extensionality a (a ⊔ b) →
∀ b → _⇔_.to ∀-intro-⇔ (_⇔_.from ∀-intro-⇔ b) ≡ b
to∘from ext f =
apply-ext ext λ y →
apply-ext (lower-extensionality lzero a ext) λ x≡y →
elim¹ (λ {y} x≡y →
subst (uncurry B)
(proj₂ (other-singleton-contractible x)
(y , x≡y))
(f x (refl x)) ≡
f y x≡y)
(subst (uncurry B)
(proj₂ (other-singleton-contractible x)
(x , refl x))
(f x (refl x)) ≡⟨ from∘to ext (f x (refl x)) ⟩∎
f x (refl x) ∎)
x≡y
private
-- The following proof is perhaps easier to follow, but the
-- resulting "from" functions are more complicated than the one used
-- in ∀-intro. (If subst reduced in the usual way when applied to
-- refl, then the two functions would perhaps be definitionally
-- equal.)
--
-- This proof is based on one presented by Egbert Rijke in "A type
-- theoretical Yoneda lemma"
-- (http://homotopytypetheory.org/2012/05/02/a-type-theoretical-yoneda-lemma/).
∀-intro′ :
∀ {a b} {A : Type a} {x : A} (B : (y : A) → x ≡ y → Type b) →
B x (refl x) ↝[ a ∣ a ⊔ b ] (∀ y (x≡y : x ≡ y) → B y x≡y)
∀-intro′ {a = a} {x = x} B {k = k} ext =
B x (refl x) ↔⟨ inverse Π-left-identity ⟩
(⊤ → B x (refl x)) ↝⟨ Π-cong-contra (lower-extensionality? k lzero a ext)
(_⇔_.to contractible⇔↔⊤ c) (λ _ → id) ⟩
((∃ λ y → x ≡ y) → B x (refl x)) ↔⟨ currying ⟩
(∀ y (x≡y : x ≡ y) → B x (refl x)) ↝⟨ (∀-cong ext λ y →
∀-cong (lower-extensionality? k lzero a ext) λ x≡y → from-isomorphism $
Eq.subst-as-equivalence (uncurry B) (proj₂ c (y , x≡y))) ⟩□
(∀ y (x≡y : x ≡ y) → B y x≡y) □
where
c : Contractible (∃ λ y → x ≡ y)
c = other-singleton-contractible x
-- One can introduce a (non-dependent) function argument of the same
-- type as another one if the codomain is propositional (assuming
-- extensionality).
→-intro :
∀ {a p} {A : Type a} {P : A → Type p} →
Extensionality a (a ⊔ p) →
(∀ x → Is-proposition (P x)) →
(∀ x → P x) ↔ (A → ∀ x → P x)
→-intro {a = a} ext P-prop = record
{ surjection = record
{ logical-equivalence = record
{ to = λ f _ x → f x
; from = λ f x → f x x
}
; right-inverse-of = λ _ →
(Π-closure ext 1 λ _ →
Π-closure (lower-extensionality a a ext) 1 λ _ →
P-prop _) _ _
}
; left-inverse-of = refl
}
-- Logical equivalences can be expressed as pairs of functions.
⇔↔→×→ :
∀ {a b} {A : Type a} {B : Type b} →
(A ⇔ B) ↔ (A → B) × (B → A)
⇔↔→×→ = record
{ surjection = record
{ logical-equivalence = record
{ to = λ f → _⇔_.to f , _⇔_.from f
; from = λ { (to , from) → record { to = to; from = from } }
}
; right-inverse-of = refl
}
; left-inverse-of = refl
}
------------------------------------------------------------------------
-- A lemma related to _≃_
-- The operator _⇔_ preserves symmetric kinds of functions.
⇔-cong :
∀ {k a b c d} {A : Type a} {B : Type b} {C : Type c} {D : Type d} →
Extensionality? ⌊ k ⌋-sym (a ⊔ b ⊔ c ⊔ d) (a ⊔ b ⊔ c ⊔ d) →
A ↝[ ⌊ k ⌋-sym ] B → C ↝[ ⌊ k ⌋-sym ] D →
(A ⇔ C) ↝[ ⌊ k ⌋-sym ] (B ⇔ D)
⇔-cong {k = k} {a = a} {b = b} {c = c} {d = d}
{A = A} {B = B} {C = C} {D = D} ext A↝B C↝D =
A ⇔ C ↔⟨ ⇔↔→×→ ⟩
(A → C) × (C → A) ↝⟨ →-cong (lower-extensionality? ⌊ k ⌋-sym (c ⊔ d) (a ⊔ b) ext) A↝B C↝D
×-cong
→-cong (lower-extensionality? ⌊ k ⌋-sym (a ⊔ b) (c ⊔ d) ext) C↝D A↝B ⟩
(B → D) × (D → B) ↔⟨ inverse ⇔↔→×→ ⟩□
B ⇔ D □
------------------------------------------------------------------------
-- Some lemmas related to _≃_
-- Contractibility is isomorphic to equivalence to the unit type
-- (assuming extensionality).
contractible↔≃⊤ :
∀ {a} {A : Type a} →
Extensionality a a →
Contractible A ↔ (A ≃ ⊤)
contractible↔≃⊤ ext = record
{ surjection = record
{ logical-equivalence = record
{ to = Eq.↔⇒≃ ∘ _⇔_.to contractible⇔↔⊤
; from = _⇔_.from contractible⇔↔⊤ ∘ _≃_.bijection
}
; right-inverse-of = λ _ →
Eq.lift-equality ext (refl _)
}
; left-inverse-of = λ _ → Contractible-propositional ext _ _
}
-- Equivalence to the empty type is equivalent to not being inhabited
-- (assuming extensionality).
≃⊥≃¬ :
∀ {a ℓ} {A : Type a} →
Extensionality (a ⊔ ℓ) (a ⊔ ℓ) →
(A ≃ ⊥ {ℓ = ℓ}) ≃ (¬ A)
≃⊥≃¬ {ℓ = ℓ} {A} ext =
_↔_.to (Eq.⇔↔≃ ext (Eq.right-closure ext 0 ⊥-propositional)
(¬-propositional
(lower-extensionality ℓ _ ext))) (record
{ to = λ eq a → ⊥-elim (_≃_.to eq a)
; from = λ ¬a → A ↔⟨ inverse (Bijection.⊥↔uninhabited ¬a) ⟩□
⊥ □
})
-- If f and g are pointwise equal, then HA.Proofs f f⁻¹ and
-- HA.Proofs g f⁻¹ are equivalent (assuming extensionality).
Proofs-cong :
∀ {a b} {A : Type a} {B : Type b} {f g : A → B} {f⁻¹ : B → A} →
Extensionality (a ⊔ b) (a ⊔ b) →
(∀ x → f x ≡ g x) →
HA.Proofs f f⁻¹ ≃ HA.Proofs g f⁻¹
Proofs-cong
{a = a} {b = b} {f = f} {g = g} {f⁻¹ = f⁻¹} ext f≡g =
Σ-cong (∀-cong (lower-extensionality a a ext) λ _ →
≡⇒↝ equivalence $ cong (_≡ _) $ f≡g _) λ f-f⁻¹ →
Σ-cong (∀-cong (lower-extensionality b b ext) λ _ →
≡⇒↝ equivalence $ cong (_≡ _) $ cong f⁻¹ $ f≡g _) λ f⁻¹-f →
∀-cong (lower-extensionality b a ext) λ x → ≡⇒↝ _
(cong f (f⁻¹-f x) ≡ f-f⁻¹ (f x) ≡⟨ lemma f-f⁻¹ f⁻¹-f _ ⟩
trans (ext⁻¹ (ext″ f≡g) (f⁻¹ (g x)))
(cong g (trans (sym (cong f⁻¹ (ext⁻¹ (ext″ f≡g) x)))
(f⁻¹-f x))) ≡
f-f⁻¹ (g x) ≡⟨ cong (_≡ _) $
cong₂ (λ p q →
trans (p (f⁻¹ (g x)))
(cong g (trans (sym (cong f⁻¹ (q x))) (f⁻¹-f x))))
(_≃_.left-inverse-of (Eq.extensionality-isomorphism ext′) f≡g)
(_≃_.left-inverse-of (Eq.extensionality-isomorphism ext′) f≡g) ⟩
trans (f≡g (f⁻¹ (g x)))
(cong g (trans (sym (cong f⁻¹ (f≡g x))) (f⁻¹-f x))) ≡
f-f⁻¹ (g x) ≡⟨ [trans≡]≡[≡trans-symˡ] _ _ _ ⟩
cong g (trans (sym (cong f⁻¹ (f≡g x))) (f⁻¹-f x)) ≡
trans (sym (f≡g (f⁻¹ (g x)))) (f-f⁻¹ (g x)) ≡⟨ sym $ cong₂ (λ p q → cong g p ≡ q)
subst-trans-sym
subst-trans-sym ⟩
cong g (subst (_≡ x) (cong f⁻¹ (f≡g x)) (f⁻¹-f x)) ≡
subst (_≡ g x) (f≡g (f⁻¹ (g x))) (f-f⁻¹ (g x)) ≡⟨ cong₂ (λ p q → cong g p ≡ q)
(subst-in-terms-of-≡⇒↝ equivalence _ _ _)
(subst-in-terms-of-≡⇒↝ equivalence _ _ _) ⟩∎
cong g
(_≃_.to (≡⇒↝ _ (cong (_≡ x) (cong f⁻¹ (f≡g x)))) (f⁻¹-f x)) ≡
_≃_.to (≡⇒↝ _ (cong (_≡ g x) (f≡g (f⁻¹ (g x))))) (f-f⁻¹ (g x)) ∎)
where
ext′ = lower-extensionality b a ext
ext″ = apply-ext $ Eq.good-ext ext′
lemma :
∀ {x} f-f⁻¹ f⁻¹-f f≡g →
(cong f (f⁻¹-f x) ≡ f-f⁻¹ (f x))
≡
(trans (ext⁻¹ f≡g (f⁻¹ (g x)))
(cong g (trans (sym (cong f⁻¹ (ext⁻¹ f≡g x))) (f⁻¹-f x))) ≡
f-f⁻¹ (g x))
lemma {x = x} f-f⁻¹ f⁻¹-f = elim¹
(λ {g} f≡g →
(cong f (f⁻¹-f x) ≡ f-f⁻¹ (f x))
≡
(trans (ext⁻¹ f≡g (f⁻¹ (g x)))
(cong g (trans (sym (cong f⁻¹ (ext⁻¹ f≡g x))) (f⁻¹-f x))) ≡
f-f⁻¹ (g x)))
(cong (_≡ f-f⁻¹ (f x))
(cong f (f⁻¹-f x) ≡⟨ cong (cong f) $ sym $
trans (cong (flip trans _) $
trans (cong sym $ cong-refl _) $
sym-refl) $
trans-reflˡ _ ⟩
cong f (trans (sym (cong f⁻¹ (refl (f x)))) (f⁻¹-f x)) ≡⟨ sym $ trans-reflˡ _ ⟩
trans (refl (f (f⁻¹ (f x))))
(cong f (trans (sym (cong f⁻¹ (refl (f x)))) (f⁻¹-f x))) ≡⟨ sym $
cong₂ (λ p q →
trans p (cong f (trans (sym (cong f⁻¹ q)) (f⁻¹-f x))))
(ext⁻¹-refl _)
(ext⁻¹-refl _) ⟩∎
trans (ext⁻¹ (refl f) (f⁻¹ (f x)))
(cong f (trans (sym (cong f⁻¹ (ext⁻¹ (refl f) x))) (f⁻¹-f x))) ∎))
-- Is-equivalence preserves equality, if we see _≃_ as a form of
-- equality (assuming extensionality).
Is-equivalence-cong :
∀ {k a b} {A : Type a} {B : Type b} {f g : A → B} →
Extensionality? k (a ⊔ b) (a ⊔ b) →
(∀ x → f x ≡ g x) →
Is-equivalence f ↝[ k ] Is-equivalence g
Is-equivalence-cong ext f≡g =
generalise-ext?-prop
(record
{ to = Eq.respects-extensional-equality f≡g
; from = Eq.respects-extensional-equality (sym ⊚ f≡g)
})
(λ ext → Eq.propositional ext _)
(λ ext → Eq.propositional ext _)
ext
-- Is-equivalence is pointwise equivalent to CP.Is-equivalence
-- (assuming extensionality).
Is-equivalence≃Is-equivalence-CP :
∀ {a b} {A : Type a} {B : Type b} {f : A → B} →
Is-equivalence f ↝[ a ⊔ b ∣ a ⊔ b ] CP.Is-equivalence f
Is-equivalence≃Is-equivalence-CP =
generalise-ext?
HA.Is-equivalence⇔Is-equivalence-CP
(λ ext →
let bij = HA.Is-equivalence↔Is-equivalence-CP ext in
_↔_.right-inverse-of bij , _↔_.left-inverse-of bij)
-- Two notions of equivalence are pointwise equivalent (assuming
-- extensionality).
≃≃≃-CP :
∀ {a b} {A : Type a} {B : Type b} →
(A ≃ B) ↝[ a ⊔ b ∣ a ⊔ b ] (A CP.≃ B)
≃≃≃-CP {A = A} {B = B} ext =
A ≃ B ↔⟨ Eq.≃-as-Σ ⟩
(∃ λ (f : A → B) → Is-equivalence f) ↝⟨ (∃-cong λ _ → Is-equivalence≃Is-equivalence-CP ext) ⟩□
(∃ λ (f : A → B) → CP.Is-equivalence f) □
-- _≃_ is commutative (assuming extensionality).
≃-comm :
∀ {a b} {A : Type a} {B : Type b} →
A ≃ B ↝[ a ⊔ b ∣ a ⊔ b ] B ≃ A
≃-comm =
generalise-ext?
Eq.inverse-logical-equivalence
(λ ext →
let bij = Eq.inverse-isomorphism ext in
_↔_.right-inverse-of bij , _↔_.left-inverse-of bij)
-- Two consequences of the two-out-of-three property.
Is-equivalence≃Is-equivalence-∘ˡ :
∀ {a b c} {A : Type a} {B : Type b} {C : Type c}
{f : B → C} {g : A → B} →
Is-equivalence f →
Is-equivalence g ↝[ a ⊔ b ⊔ c ∣ a ⊔ b ⊔ c ] Is-equivalence (f ∘ g)
Is-equivalence≃Is-equivalence-∘ˡ {b = b} {c = c} f-eq =
generalise-ext?-prop
(record
{ to = flip (Eq.Two-out-of-three.f-g (Eq.two-out-of-three _ _))
f-eq
; from = Eq.Two-out-of-three.g-g∘f (Eq.two-out-of-three _ _) f-eq
})
(flip Eq.propositional _ ⊚ lower-extensionality c c)
(flip Eq.propositional _ ⊚ lower-extensionality b b)
Is-equivalence≃Is-equivalence-∘ʳ :
∀ {a b c} {A : Type a} {B : Type b} {C : Type c}
{f : B → C} {g : A → B} →
Is-equivalence g →
Is-equivalence f ↝[ a ⊔ b ⊔ c ∣ a ⊔ b ⊔ c ] Is-equivalence (f ∘ g)
Is-equivalence≃Is-equivalence-∘ʳ {a = a} {b = b} g-eq =
generalise-ext?-prop
(record
{ to = Eq.Two-out-of-three.f-g (Eq.two-out-of-three _ _) g-eq
; from = flip
(Eq.Two-out-of-three.g∘f-f (Eq.two-out-of-three _ _))
g-eq
})
(flip Eq.propositional _ ⊚ lower-extensionality a a)
(flip Eq.propositional _ ⊚ lower-extensionality b b)
------------------------------------------------------------------------
-- Lemmas related to _↠_
-- An alternative characterisation of split surjections.
↠↔∃-Split-surjective :
∀ {a b} {A : Type a} {B : Type b} →
(A ↠ B) ↔ ∃ λ (f : A → B) → Split-surjective f
↠↔∃-Split-surjective = record
{ surjection = record
{ logical-equivalence = record
{ to = λ f → _↠_.to f , _↠_.split-surjective f
; from = λ { (f , s) → record
{ logical-equivalence = record
{ to = f
; from = proj₁ ⊚ s
}
; right-inverse-of = proj₂ ⊚ s
} }
}
; right-inverse-of = λ _ → refl _
}
; left-inverse-of = λ _ → refl _
}
------------------------------------------------------------------------
-- Lemmas related to _↣_
-- An alternative characterisation of injections.
↣↔∃-Injective :
∀ {a b} {A : Type a} {B : Type b} →
(A ↣ B) ↔ ∃ λ (f : A → B) → Injective f
↣↔∃-Injective = record
{ surjection = record
{ logical-equivalence = record
{ to = λ f → _↣_.to f , _↣_.injective f
; from = λ (f , i) → record
{ to = f
; injective = i
}
}
; right-inverse-of = λ _ → refl _
}
; left-inverse-of = λ _ → refl _
}
------------------------------------------------------------------------
-- Lemmas related to _≡_
-- Equality is commutative.
open Bijection public using (≡-comm)
-- The following two lemmas are based on Example 2.4.8 in the HoTT
-- book.
-- The function trans x≡y is the to component of an isomorphism.
trans-isomorphism :
∀ {a} {A : Type a} {x y z : A} →
x ≡ y → y ≡ z ↔ x ≡ z
trans-isomorphism x≡y = record
{ surjection = record
{ logical-equivalence = record
{ to = trans x≡y
; from = trans (sym x≡y)
}
; right-inverse-of = trans--[trans-sym] _
}
; left-inverse-of = trans-sym-[trans] _
}
-- The function flip trans x≡y is the to component of an isomorphism.
flip-trans-isomorphism :
∀ {a} {A : Type a} {x y z : A} →
x ≡ y → z ≡ x ↔ z ≡ y
flip-trans-isomorphism x≡y = record
{ surjection = record
{ logical-equivalence = record
{ to = flip trans x≡y
; from = flip trans (sym x≡y)
}
; right-inverse-of = λ _ → trans-[trans-sym]- _ _
}
; left-inverse-of = λ _ → trans-[trans]-sym _ _
}
-- Equality expression rearrangement lemmas.
from≡↔≡to : ∀ {a b} →
{A : Type a} {B : Type b}
(A≃B : A ≃ B) {x : B} {y : A} →
(_≃_.from A≃B x ≡ y) ↔ (x ≡ _≃_.to A≃B y)
from≡↔≡to A≃B {x} {y} =
(_≃_.from A≃B x ≡ y) ↔⟨ inverse $ Eq.≃-≡ A≃B ⟩
(_≃_.to A≃B (_≃_.from A≃B x) ≡ _≃_.to A≃B y) ↝⟨ ≡⇒↝ _ $ cong (λ z → z ≡ _≃_.to A≃B y) $ _≃_.right-inverse-of A≃B x ⟩□
(x ≡ _≃_.to A≃B y) □
to∘≡↔≡from∘ : ∀ {a b c} →
Extensionality a (b ⊔ c) →
{A : Type a} {B : A → Type b} {C : A → Type c}
(B≃C : ∀ {x} → B x ≃ C x)
{f : (x : A) → B x} {g : (x : A) → C x} →
(_≃_.to B≃C ⊚ f ≡ g) ↔ (f ≡ _≃_.from B≃C ⊚ g)
to∘≡↔≡from∘ ext B≃C =
from≡↔≡to (∀-cong ext (λ _ → inverse B≃C))
∘from≡↔≡∘to : ∀ {a b c} →
Extensionality (a ⊔ b) c →
{A : Type a} {B : Type b} {C : Type c}
(A≃B : A ≃ B) {f : A → C} {g : B → C} →
(f ∘ _≃_.from A≃B ≡ g) ↔ (f ≡ g ∘ _≃_.to A≃B)
∘from≡↔≡∘to ext A≃B = from≡↔≡to (→-cong₁ ext (inverse A≃B))
∘from≡↔≡∘to′ :
∀ {a b c} →
Extensionality (a ⊔ b) c →
{A : Type a} {B : Type b} {C : A → Type c}
(A≃B : A ≃ B)
{f : (x : A) → C x} {g : (x : B) → C (_≃_.from A≃B x)} →
(f ⊚ _≃_.from A≃B ≡ g) ↔
(f ≡ subst C (_≃_.left-inverse-of A≃B _) ⊚ g ⊚ _≃_.to A≃B)
∘from≡↔≡∘to′ {a = a} {b = b} ext {C = C} A≃B {f = f} {g = g} =
f ⊚ _≃_.from A≃B ≡ g ↝⟨ ≡⇒↝ _ $ cong (_≡ g) $ apply-ext (lower-extensionality a lzero ext)
lemma ⟩
subst (C ⊚ _≃_.from A≃B) (_≃_.right-inverse-of A≃B _) ⊚
_≃_.from (≡⇒↝ _ $ cong C (_≃_.left-inverse-of A≃B _)) ⊚
f ⊚ _≃_.from A≃B ≡
g ↝⟨ from≡↔≡to
(Π-cong-contra ext A≃B λ x →
≡⇒↝ _ $ cong C (_≃_.left-inverse-of A≃B x)) ⟩
f ≡
_≃_.to (≡⇒↝ _ $ cong C (_≃_.left-inverse-of A≃B _)) ⊚ g ⊚ _≃_.to A≃B ↝⟨ (≡⇒↝ _ $ cong (f ≡_) $ apply-ext (lower-extensionality b lzero ext) λ _ →
sym $ subst-in-terms-of-≡⇒↝ equivalence _ _ _) ⟩□
f ≡ subst C (_≃_.left-inverse-of A≃B _) ⊚ g ⊚ _≃_.to A≃B □
where
lemma : ∀ _ → _
lemma x =
f (_≃_.from A≃B x) ≡⟨ sym $ _≃_.right-inverse-of equiv _ ⟩
_≃_.to equiv (_≃_.from equiv (f (_≃_.from A≃B x))) ≡⟨ sym $ subst-in-terms-of-≡⇒↝ equivalence _ _ _ ⟩
subst C (_≃_.left-inverse-of A≃B (_≃_.from A≃B x))
(_≃_.from equiv (f (_≃_.from A≃B x))) ≡⟨ cong (λ eq → subst C eq (_≃_.from equiv (f (_≃_.from A≃B x)))) $ sym $
_≃_.right-left-lemma A≃B _ ⟩
subst C (cong (_≃_.from A≃B) (_≃_.right-inverse-of A≃B x))
(_≃_.from equiv (f (_≃_.from A≃B x))) ≡⟨ sym $ subst-∘ _ _ (_≃_.right-inverse-of A≃B x) ⟩∎
subst (C ⊚ _≃_.from A≃B) (_≃_.right-inverse-of A≃B x)
(_≃_.from equiv (f (_≃_.from A≃B x))) ∎
where
equiv = ≡⇒↝ _ $ cong C (_≃_.left-inverse-of A≃B (_≃_.from A≃B x))
------------------------------------------------------------------------
-- Some lemmas related to _⁻¹_
-- A fibre of a composition can be expressed as a pair of fibres.
∘⁻¹≃ :
∀ {a b c} {A : Type a} {B : Type b} {C : Type c} {z} →
(f : B → C) (g : A → B) →
f ∘ g ⁻¹ z ≃ ∃ λ ((y , _) : f ⁻¹ z) → g ⁻¹ y
∘⁻¹≃ {z = z} f g =
f ∘ g ⁻¹ z ↔⟨⟩
(∃ λ a → f (g a) ≡ z) ↔⟨ (∃-cong λ _ → other-∃-intro _ _) ⟩
(∃ λ a → ∃ λ y → f y ≡ z × g a ≡ y) ↔⟨ (∃-cong λ _ → Σ-assoc) ⟩
(∃ λ a → ∃ λ ((y , _) : f ⁻¹ z) → g a ≡ y) ↔⟨ ∃-comm ⟩□
(∃ λ ((y , _) : f ⁻¹ z) → g ⁻¹ y) □
-- The type of fibres of Σ-map P.id f over a pair is equivalent to the
-- fibres of f over the pair's second component.
--
-- This is Theorem 4.7.6 from the HoTT book.
Σ-map-id-⁻¹≃⁻¹ :
∀ {a p q} {A : Type a} {P : A → Type p} {Q : A → Type q}
{f : ∀ {x} → P x → Q x} {x : A} {y : Q x} →
Σ-map P.id f ⁻¹ _,_ {B = Q} x y ≃ f ⁻¹ y
Σ-map-id-⁻¹≃⁻¹ {Q = Q} {f = f} {x = x} {y = y} =
Σ-map P.id f ⁻¹ (x , y) ↔⟨⟩
(∃ λ (u , v) → (u , f v) ≡ (x , y)) ↔⟨ inverse Bijection.Σ-assoc ⟩
(∃ λ u → ∃ λ v → (u , f v) ≡ (x , y)) ↔⟨ (∃-cong λ _ → ∃-cong λ _ → inverse
Bijection.Σ-≡,≡↔≡) ⟩
(∃ λ u → ∃ λ v → ∃ λ (p : u ≡ x) → subst Q p (f v) ≡ y) ↔⟨ (∃-cong λ _ → ∃-comm) ⟩
(∃ λ u → ∃ λ (p : u ≡ x) → ∃ λ v → subst Q p (f v) ≡ y) ↔⟨ Bijection.Σ-assoc ⟩
(∃ λ ((_ , p) : ∃ λ u → u ≡ x) → ∃ λ v → subst Q p (f v) ≡ y) ↔⟨ drop-⊤-left-Σ $
_⇔_.to contractible⇔↔⊤ $
singleton-contractible _ ⟩
(∃ λ v → subst Q (refl _) (f v) ≡ y) ↝⟨ (∃-cong λ _ → ≡⇒↝ _ $ cong (_≡ _) $
subst-refl _ _) ⟩
(∃ λ v → f v ≡ y) ↔⟨⟩
f ⁻¹ y □
------------------------------------------------------------------------
-- Lemmas related to ↑
-- ↑ _ preserves all kinds of functions.
private
↑-cong-→ :
∀ {a b c} {B : Type b} {C : Type c} →
(B → C) → ↑ a B → ↑ a C
↑-cong-→ B→C = lift ⊚ B→C ⊚ lower
↑-cong-↣ :
∀ {a b c} {B : Type b} {C : Type c} →
B ↣ C → ↑ a B ↣ ↑ a C
↑-cong-↣ {a} B↣C = record
{ to = to′
; injective = injective′
}
where
open _↣_ B↣C
to′ = ↑-cong-→ {a = a} to
abstract
injective′ : Injective to′
injective′ = cong lift ⊚ injective ⊚ cong lower
↑-cong-Embedding :
∀ {a b c} {B : Type b} {C : Type c} →
Embedding B C → Embedding (↑ a B) (↑ a C)
↑-cong-Embedding {a} {B = B} B↣C = record
{ to = ↑-cong-→ to
; is-embedding = λ x y →
_≃_.is-equivalence $
Eq.with-other-function
(x ≡ y ↔⟨⟩
lift (lower x) ≡ lift (lower y) ↔⟨ inverse lift-lemma ⟩
lower x ≡ lower y ↝⟨ Eq.⟨ _ , is-embedding _ _ ⟩ ⟩
to (lower x) ≡ to (lower y) ↔⟨ lift-lemma ⟩□
lift (to (lower x)) ≡ lift (to (lower y)) □)
_
(λ p → cong lift (cong to (cong lower p)) ≡⟨ cong-∘ _ _ _ ⟩
cong (lift ⊚ to) (cong lower p) ≡⟨ cong-∘ _ _ _ ⟩∎
cong (lift ⊚ to ⊚ lower) p ∎)
}
where
open Embedding B↣C
lift-lemma : ∀ {ℓ a} {A : Type a} {x y : A} →
(x ≡ y) ↔ (lift {ℓ = ℓ} x ≡ lift y)
lift-lemma {ℓ} = record
{ surjection = record
{ logical-equivalence = record
{ to = cong lift
; from = cong lower
}
; right-inverse-of = λ eq →
cong lift (cong lower eq) ≡⟨ cong-∘ _ _ _ ⟩
cong (lift ⊚ lower) eq ≡⟨ sym (cong-id _) ⟩∎
eq ∎
}
; left-inverse-of = λ eq →
cong lower (cong lift eq) ≡⟨ cong-∘ _ _ _ ⟩
cong (lower {ℓ = ℓ} ⊚ lift) eq ≡⟨ sym (cong-id _) ⟩∎
eq ∎
}
↑-cong-↠ :
∀ {a b c} {B : Type b} {C : Type c} →
B ↠ C → ↑ a B ↠ ↑ a C
↑-cong-↠ {a} B↠C = record
{ logical-equivalence = logical-equivalence′
; right-inverse-of = right-inverse-of′
}
where
open _↠_ B↠C renaming (logical-equivalence to logical-equiv)
logical-equivalence′ = L.↑-cong {a = a} logical-equiv
abstract
right-inverse-of′ : ∀ x →
_⇔_.to logical-equivalence′
(_⇔_.from logical-equivalence′ x) ≡
x
right-inverse-of′ = cong lift ⊚ right-inverse-of ⊚ lower
↑-cong-↔ :
∀ {a b c} {B : Type b} {C : Type c} →
B ↔ C → ↑ a B ↔ ↑ a C
↑-cong-↔ {a} B↔C = record
{ surjection = surjection′
; left-inverse-of = left-inverse-of′
}
where
open _↔_ B↔C renaming (surjection to surj)
surjection′ = ↑-cong-↠ {a = a} surj
abstract
left-inverse-of′ :
∀ x → _↠_.from surjection′ (_↠_.to surjection′ x) ≡ x
left-inverse-of′ = cong lift ⊚ left-inverse-of ⊚ lower
↑-cong-≃ :
∀ {a b c} {B : Type b} {C : Type c} →
B ≃ C → ↑ a B ≃ ↑ a C
↑-cong-≃ = from-bijection ∘ ↑-cong-↔ ∘ from-equivalence
↑-cong-≃ᴱ :
∀ {a b c} {B : Type b} {C : Type c} →
B ≃ᴱ C → ↑ a B ≃ᴱ ↑ a C
↑-cong-≃ᴱ f = EEq.[≃]→≃ᴱ (EEq.[proofs] (↑-cong-≃ (EEq.≃ᴱ→≃ f)))
↑-cong : ∀ {k a b c} {B : Type b} {C : Type c} →
B ↝[ k ] C → ↑ a B ↝[ k ] ↑ a C
↑-cong {implication} = ↑-cong-→
↑-cong {logical-equivalence} = L.↑-cong
↑-cong {injection} = ↑-cong-↣
↑-cong {embedding} = ↑-cong-Embedding
↑-cong {surjection} = ↑-cong-↠
↑-cong {bijection} = ↑-cong-↔
↑-cong {equivalence} = ↑-cong-≃
↑-cong {equivalenceᴱ} = ↑-cong-≃ᴱ
------------------------------------------------------------------------
-- Lemmas related to unit types
-- The type of equalities tt ≡ tt is isomorphic to the unit type.
tt≡tt↔⊤ : tt ≡ tt ↔ ⊤
tt≡tt↔⊤ = _⇔_.to contractible⇔↔⊤ $
propositional⇒inhabited⇒contractible
(mono (zero≤ 2) ⊤-contractible) (refl _)
-- Unit is equivalent to ⊤.
--
-- The forward direction of the equivalence returns the supplied value
-- of type Unit.
Unit≃⊤ : Unit → Unit ≃ ⊤
Unit≃⊤ x =
Eq.↔→≃ _ (λ _ → x) refl
(λ { ⊠ → unblock x (_≡ ⊠) (refl _) })
------------------------------------------------------------------------
-- Lemmas related to ⊥
-- All instances of ⊥ are isomorphic.
⊥↔⊥ : ∀ {ℓ₁ ℓ₂} → ⊥ {ℓ = ℓ₁} ↔ ⊥ {ℓ = ℓ₂}
⊥↔⊥ = Bijection.⊥↔uninhabited ⊥-elim
-- All instances of A → ⊥ are isomorphic to ¬ A.
¬↔→⊥ : ∀ {a ℓ} {A : Type a} →
¬ A ↝[ a ∣ ℓ ] (A → ⊥ {ℓ = ℓ})
¬↔→⊥ {A = A} ext =
(A → ⊥₀) ↝⟨ (∀-cong ext λ _ → from-isomorphism ⊥↔⊥) ⟩□
(A → ⊥) □
-- A type cannot be logically equivalent to its own negation.
¬[⇔¬] : ∀ {a} {A : Type a} → ¬ (A ⇔ ¬ A)
¬[⇔¬] {A = A} =
A ⇔ ¬ A ↝⟨ (λ eq → (λ a → _⇔_.to eq a a) , eq) ⟩
¬ A × (A ⇔ ¬ A) ↝⟨ (λ { (¬a , eq) → ¬a , _⇔_.from eq ¬a }) ⟩
¬ A × A ↝⟨ uncurry _$_ ⟩□
⊥ □
-- If two types are logically equivalent, then their negations are
-- equivalent (assuming extensionality).
¬-cong-⇔ :
∀ {a b} {A : Type a} {B : Type b} →
Extensionality (a ⊔ b) lzero →
A ⇔ B → (¬ A) ≃ (¬ B)
¬-cong-⇔ {a} {b} ext A⇔B =
_↠_.from
(Eq.≃↠⇔ (¬-propositional (lower-extensionality b lzero ext))
(¬-propositional (lower-extensionality a lzero ext)))
(→-cong _ A⇔B id)
-- Symmetric kinds of functions are preserved by ¬_ (assuming
-- extensionality).
¬-cong :
∀ {k a b} {A : Type a} {B : Type b} →
Extensionality (a ⊔ b) lzero →
A ↝[ ⌊ k ⌋-sym ] B → (¬ A) ↝[ ⌊ k ⌋-sym ] (¬ B)
¬-cong ext A↝B = from-equivalence (¬-cong-⇔ ext (sym→⇔ A↝B))
-- If B can be decided, given that A is inhabited, then A → B is
-- logically equivalent to ¬ B → ¬ A.
→⇔¬→¬ :
∀ {a b} {A : Type a} {B : Type b} →
(A → Dec B) →
(A → B) ⇔ (¬ B → ¬ A)
→⇔¬→¬ _ ._⇔_.to = flip _∘_
→⇔¬→¬ dec ._⇔_.from ¬B→¬A A with dec A
… | yes B = B
… | no ¬B = ⊥-elim $ ¬B→¬A ¬B A
-- If B is additionally a proposition (assuming that A is inhabited),
-- then the two types are equivalent (assuming extensionality).
→≃¬→¬ :
∀ {a b} {A : Type a} {B : Type b} →
(Extensionality (a ⊔ b) (a ⊔ b) → A → Is-proposition B) →
(A → Dec B) →
(A → B) ↝[ a ⊔ b ∣ a ⊔ b ] (¬ B → ¬ A)
→≃¬→¬ {a = a} {b = b} prop dec =
generalise-ext?-prop
(→⇔¬→¬ dec)
(λ ext → Π-closure (lower-extensionality b a ext) 1 (prop ext))
(λ ext → Π-closure (lower-extensionality a b ext) 1 λ _ →
¬-propositional (lower-extensionality b _ ext))
------------------------------------------------------------------------
-- Lemmas related to H-level
-- H-level and H-level′ are pointwise isomorphic (assuming
-- extensionality).
H-level↔H-level′ :
∀ {a} {A : Type a} {n} →
H-level n A ↝[ a ∣ a ] H-level′ n A
H-level↔H-level′ {n = n} =
generalise-ext?-prop
H-level⇔H-level′
(λ ext → H-level-propositional ext _)
(λ ext → H-level′-propositional ext n)
-- H-level n preserves isomorphisms (assuming extensionality).
H-level-cong :
∀ {k₁ k₂ a b} {A : Type a} {B : Type b} →
Extensionality? k₂ (a ⊔ b) (a ⊔ b) →
∀ n → A ↔[ k₁ ] B → H-level n A ↝[ k₂ ] H-level n B
H-level-cong {a = a} {b} ext n A↔B′ =
generalise-ext?-prop
(record
{ to = respects-surjection (_↔_.surjection A↔B) n
; from = respects-surjection (_↔_.surjection (inverse A↔B)) n
})
(λ ext → H-level-propositional (lower-extensionality b b ext) n)
(λ ext → H-level-propositional (lower-extensionality a a ext) n)
ext
where
A↔B = from-isomorphism A↔B′
-- H-level′ n preserves isomorphisms (assuming extensionality).
H-level′-cong :
∀ {k₁ k₂ a b} {A : Type a} {B : Type b} →
Extensionality? k₂ (a ⊔ b) (a ⊔ b) →
∀ n → A ↔[ k₁ ] B → H-level′ n A ↝[ k₂ ] H-level′ n B
H-level′-cong {k₂ = k₂} {a = a} {b = b} {A = A} {B = B} ext n A↔B =
H-level′ n A ↝⟨ inverse-ext? H-level↔H-level′ (lower-extensionality? k₂ b b ext) ⟩
H-level n A ↝⟨ H-level-cong ext n A↔B ⟩
H-level n B ↝⟨ H-level↔H-level′ (lower-extensionality? k₂ a a ext) ⟩□
H-level′ n B □
-- There is an isomorphism between (x y : A) → H-level n (x ≡ y) and
-- H-level (suc n) A (assuming extensionality).
≡↔+ :
∀ {a} {A : Type a} n →
((x y : A) → H-level n (x ≡ y)) ↝[ a ∣ a ] H-level (suc n) A
≡↔+ {A = A} n ext =
((x y : A) → H-level n (x ≡ y)) ↝⟨ (∀-cong ext λ _ → ∀-cong ext λ _ → H-level↔H-level′ ext) ⟩
((x y : A) → H-level′ n (x ≡ y)) ↔⟨⟩
H-level′ (suc n) A ↝⟨ inverse-ext? H-level↔H-level′ ext ⟩□
H-level (suc n) A □
-- Some lemmas relating equivalences A ≃ B with types of the form
-- ∀ C → H-level n C → (A → C) ≃ (B → C).
→≃→↠≃ :
∀ n {ℓ} {A B : Type ℓ} →
Extensionality ℓ ℓ →
(hA : H-level n A) (hB : H-level n B) →
(∃ λ (f : (C : Type ℓ) → H-level n C → (A → C) ≃ (B → C)) →
((C : Type ℓ) (hC : H-level n C) (g : A → C) →
g ∘ _≃_.to (f A hA) id ≡ _≃_.to (f C hC) g) ×
((C : Type ℓ) (hC : H-level n C) (g : B → C) →
g ∘ _≃_.from (f B hB) id ≡ _≃_.from (f C hC) g))
↠
(A ≃ B)
→≃→↠≃ _ {A = A} {B} ext hA hB = record
{ logical-equivalence = record
{ from = λ A≃B → (λ _ _ → →-cong₁ ext A≃B)
, (λ _ _ g → refl (g ∘ _≃_.from A≃B))
, (λ _ _ g → refl (g ∘ _≃_.to A≃B))
; to = λ { (A→≃B→ , ∘to≡ , ∘from≡) → Eq.↔⇒≃ (record
{ surjection = record
{ logical-equivalence = record
{ to = _≃_.from (A→≃B→ B hB) id
; from = _≃_.to (A→≃B→ A hA) id
}
; right-inverse-of = λ x →
_≃_.from (A→≃B→ B hB) id (_≃_.to (A→≃B→ A hA) id x) ≡⟨⟩
(_≃_.from (A→≃B→ B hB) id ∘ _≃_.to (A→≃B→ A hA) id) x ≡⟨ cong (_$ x) $ ∘to≡ _ _ _ ⟩
(_≃_.to (A→≃B→ B hB) (_≃_.from (A→≃B→ B hB) id)) x ≡⟨ cong (_$ x) $ _≃_.right-inverse-of (A→≃B→ B hB) _ ⟩∎
x ∎
}
; left-inverse-of = λ x →
_≃_.to (A→≃B→ A hA) id (_≃_.from (A→≃B→ B hB) id x) ≡⟨⟩
(_≃_.to (A→≃B→ A hA) id ∘ _≃_.from (A→≃B→ B hB) id) x ≡⟨ cong (_$ x) $ ∘from≡ _ _ _ ⟩
(_≃_.from (A→≃B→ A hA) (_≃_.to (A→≃B→ A hA) id)) x ≡⟨ cong (_$ x) $ _≃_.left-inverse-of (A→≃B→ A hA) _ ⟩∎
x ∎
}) }
}
; right-inverse-of = λ A≃B → _↔_.to (≃-to-≡↔≡ ext) λ x →
refl (_≃_.to A≃B x)
}
-- The following property can be generalised.
→≃→↔≃ :
∀ {ℓ} {A B : Type ℓ} →
Extensionality (lsuc ℓ) ℓ →
(hA : Is-set A) (hB : Is-set B) →
(∃ λ (f : (C : Type ℓ) → Is-set C → (A → C) ≃ (B → C)) →
((C : Type ℓ) (hC : Is-set C) (g : A → C) →
g ∘ _≃_.to (f A hA) id ≡ _≃_.to (f C hC) g) ×
((C : Type ℓ) (hC : Is-set C) (g : B → C) →
g ∘ _≃_.from (f B hB) id ≡ _≃_.from (f C hC) g))
↔
(A ≃ B)
→≃→↔≃ {A = A} {B} ext hA hB = record
{ surjection = →≃→↠≃ 2 ext′ hA hB
; left-inverse-of = λ { (A→≃B→ , ∘to≡ , _) →
Σ-≡,≡→≡
(apply-ext ext λ C →
apply-ext ext′ λ hC →
_↔_.to (≃-to-≡↔≡ ext′) λ f →
f ∘ _≃_.to (A→≃B→ A hA) id ≡⟨ ∘to≡ _ _ _ ⟩∎
_≃_.to (A→≃B→ C (hC {_})) f ∎)
((×-closure 1
(Π-closure ext 1 λ _ →
Π-closure ext′ 1 λ hC →
Π-closure ext′ 1 λ _ →
Π-closure ext′ 2 λ _ → hC {_})
(Π-closure ext 1 λ _ →
Π-closure ext′ 1 λ hC →
Π-closure ext′ 1 λ _ →
Π-closure ext′ 2 λ _ → hC {_})) _ _) }
}
where
ext′ = lower-extensionality _ lzero ext
------------------------------------------------------------------------
-- Lemmas related to Dec
-- A preservation lemma for Dec.
Dec-cong :
∀ {k a b} {A : Type a} {B : Type b} →
Extensionality? ⌊ k ⌋-sym (a ⊔ b) lzero →
A ↝[ ⌊ k ⌋-sym ] B →
Dec A ↝[ ⌊ k ⌋-sym ] Dec B
Dec-cong {A = A} {B = B} ext A↝B =
A ⊎ ¬ A ↝⟨ A↝B ⊎-cong →-cong ext A↝B id ⟩□
B ⊎ ¬ B □
-- A preservation lemma for Decidable.
Decidable-cong :
∀ {k₁ k₂ k₃ a₁ b₁ p₁ a₂ b₂ p₂}
{A₁ : Type a₁} {B₁ : Type b₁} {P₁ : A₁ → B₁ → Type p₁}
{A₂ : Type a₂} {B₂ : Type b₂} {P₂ : A₂ → B₂ → Type p₂} →
Extensionality? ⌊ k₃ ⌋-sym (a₁ ⊔ a₂ ⊔ b₁ ⊔ b₂ ⊔ p₁ ⊔ p₂)
(b₁ ⊔ b₂ ⊔ p₁ ⊔ p₂) →
(A₁↔A₂ : A₁ ↔[ k₁ ] A₂)
(B₁↔B₂ : B₁ ↔[ k₂ ] B₂) →
(∀ x y →
P₁ x y
↝[ ⌊ k₃ ⌋-sym ]
P₂ (to-implication A₁↔A₂ x) (to-implication B₁↔B₂ y)) →
Decidable P₁ ↝[ ⌊ k₃ ⌋-sym ] Decidable P₂
Decidable-cong
{k₃ = k₃} {a₁} {b₁} {p₁} {a₂} {b₂} {p₂} {P₁ = P₁} {P₂ = P₂}
ext A₁↔A₂ B₁↔B₂ P₁↝P₂ =
(∀ x y → Dec (P₁ x y)) ↝⟨ (Π-cong (lower-extensionality? ⌊ k₃ ⌋-sym (b₁ ⊔ b₂ ⊔ p₁ ⊔ p₂) lzero ext) A₁↔A₂ λ x →
Π-cong (lower-extensionality? ⌊ k₃ ⌋-sym (a₁ ⊔ a₂ ⊔ p₁ ⊔ p₂) (b₁ ⊔ b₂) ext) B₁↔B₂ λ y →
Dec-cong (lower-extensionality? ⌊ k₃ ⌋-sym (a₁ ⊔ a₂ ⊔ b₁ ⊔ b₂) _ ext) (P₁↝P₂ x y)) ⟩□
(∀ x y → Dec (P₂ x y)) □
-- A preservation lemma for Decidable-equality.
Decidable-equality-cong :
∀ {k₁ k₂ a b} {A : Type a} {B : Type b} →
Extensionality? k₂ (a ⊔ b) (a ⊔ b) →
A ↔[ k₁ ] B →
Decidable-equality A ↝[ k₂ ] Decidable-equality B
Decidable-equality-cong ext A↔B =
generalise-ext?
(Decidable-cong _ A≃B A≃B lemma)
(λ ext →
let bij = Decidable-cong ext A≃B A≃B lemma in
_↔_.right-inverse-of bij , _↔_.left-inverse-of bij)
ext
where
A≃B = from-isomorphism A↔B
lemma : ∀ {k} _ _ → _ ↝[ k ] _
lemma x y =
x ≡ y ↔⟨ inverse $ Eq.≃-≡ A≃B ⟩□
_≃_.to A≃B x ≡ _≃_.to A≃B y □
------------------------------------------------------------------------
-- Lemmas related to if
-- A generalisation of if-encoding (which is defined below).
if-lemma : ∀ {a b p} {A : Type a} {B : Type b} (P : Bool → Type p) →
A ↔ P true → B ↔ P false →
∀ b → T b × A ⊎ T (not b) × B ↔ P b
if-lemma {A = A} {B} P A↔ B↔ true =
⊤ × A ⊎ ⊥ × B ↔⟨ ×-left-identity ⊎-cong ×-left-zero ⟩
A ⊎ ⊥₀ ↔⟨ ⊎-right-identity ⟩
A ↔⟨ A↔ ⟩
P true □
if-lemma {A = A} {B} P A↔ B↔ false =
⊥ × A ⊎ ⊤ × B ↔⟨ ×-left-zero ⊎-cong ×-left-identity ⟩
⊥₀ ⊎ B ↔⟨ ⊎-left-identity ⟩
B ↔⟨ B↔ ⟩
P false □
-- An encoding of if_then_else_ in terms of _⊎_, _×_, T and not.
if-encoding : ∀ {ℓ} {A B : Type ℓ} →
∀ b → (if b then A else B) ↔ T b × A ⊎ T (not b) × B
if-encoding {A = A} {B} =
inverse ⊚ if-lemma (λ b → if b then A else B) id id
------------------------------------------------------------------------
-- Properties related to ℕ
-- The natural numbers are isomorphic to the natural numbers extended
-- with another element.
ℕ↔ℕ⊎⊤ : ℕ ↔ ℕ ⊎ ⊤
ℕ↔ℕ⊎⊤ = record
{ surjection = record
{ logical-equivalence = record
{ to = ℕ-rec (inj₂ tt) (λ n _ → inj₁ n)
; from = [ suc , const zero ]
}
; right-inverse-of = [ refl ⊚ inj₁ , refl ⊚ inj₂ ]
}
; left-inverse-of = ℕ-rec (refl 0) (λ n _ → refl (suc n))
}
private
-- Two consequences of ℕ↔ℕ⊎⊤.
Σℕ≃′ :
∀ {p} {P : ℕ → Type p} →
(∃ λ n → P n) ≃ (P zero ⊎ ∃ λ n → P (suc n))
Σℕ≃′ {P = P} =
(∃ λ n → P n) ↝⟨ (Σ-cong-contra (inverse ℕ↔ℕ⊎⊤) λ _ → id) ⟩
(∃ λ (x : ℕ ⊎ ⊤) → P (_↔_.from ℕ↔ℕ⊎⊤ x)) ↔⟨ ∃-⊎-distrib-right ⟩
(∃ λ (n : ℕ) → P (suc n)) ⊎ ⊤ × P zero ↔⟨ ⊎-comm ⟩
⊤ × P zero ⊎ (∃ λ (n : ℕ) → P (suc n)) ↔⟨ ×-left-identity ⊎-cong id ⟩□
P zero ⊎ (∃ λ (n : ℕ) → P (suc n)) □
Πℕ≃′ :
∀ {p} {P : ℕ → Type p} →
(∀ n → P n) ↝[ lzero ∣ p ] (P zero × ∀ n → P (suc n))
Πℕ≃′ {P = P} ext =
(∀ n → P n) ↝⟨ (Π-cong-contra ext (inverse ℕ↔ℕ⊎⊤) λ _ → id) ⟩
((x : ℕ ⊎ ⊤) → P (_↔_.from ℕ↔ℕ⊎⊤ x)) ↝⟨ Π⊎↔Π×Π ext ⟩
((n : ℕ) → P (suc n)) × (⊤ → P zero) ↔⟨ ×-comm ⟩
(⊤ → P zero) × ((n : ℕ) → P (suc n)) ↔⟨ Π-left-identity ×-cong id ⟩□
P zero × ((n : ℕ) → P (suc n)) □
-- Variants of Σℕ≃′ and Πℕ≃′ which, at the time of writing, have
-- "better" computational behaviour.
Σℕ≃ :
∀ {p} {P : ℕ → Type p} →
(∃ λ n → P n) ≃ (P zero ⊎ ∃ λ n → P (suc n))
Σℕ≃ {P = P} = Eq.↔→≃
(λ where
(zero , p) → inj₁ p
(suc n , p) → inj₂ (n , p))
[ (zero ,_) , Σ-map suc id ]
[ (λ _ → refl _) , (λ _ → refl _) ]
(λ where
(zero , _) → refl _
(suc _ , _) → refl _)
Πℕ≃ :
∀ {p} {P : ℕ → Type p} →
(∀ n → P n) ↝[ lzero ∣ p ] (P zero × ∀ n → P (suc n))
Πℕ≃ {P = P} =
generalise-ext?
Πℕ⇔
(λ ext →
refl
, (λ _ →
apply-ext ext $
ℕ-case (refl _) (λ _ → refl _)))
where
Πℕ⇔ : _ ⇔ _
Πℕ⇔ ._⇔_.to f = f zero , f ⊚ suc
Πℕ⇔ ._⇔_.from = uncurry ℕ-case
-- ℕ is isomorphic to ℕ ⊎ ℕ.
ℕ↔ℕ⊎ℕ : ℕ ↔ ℕ ⊎ ℕ
ℕ↔ℕ⊎ℕ = record
{ surjection = record
{ logical-equivalence = record
{ to = to
; from = from
}
; right-inverse-of = to∘from
}
; left-inverse-of = from∘to
}
where
step : ℕ ⊎ ℕ → ℕ ⊎ ℕ
step = [ inj₂ , inj₁ ∘ suc ]
to : ℕ → ℕ ⊎ ℕ
to zero = inj₁ zero
to (suc n) = step (to n)
double : ℕ → ℕ
double zero = zero
double (suc n) = suc (suc (double n))
from : ℕ ⊎ ℕ → ℕ
from = [ double , suc ∘ double ]
from∘to : ∀ n → from (to n) ≡ n
from∘to zero = zero ∎
from∘to (suc n) with to n | from∘to n
... | inj₁ m | eq =
suc (double m) ≡⟨ cong suc eq ⟩∎
suc n ∎
... | inj₂ m | eq =
suc (suc (double m)) ≡⟨ cong suc eq ⟩∎
suc n ∎
to∘double : ∀ n → to (double n) ≡ inj₁ n
to∘double zero = inj₁ zero ∎
to∘double (suc n) =
to (double (suc n)) ≡⟨⟩
to (suc (suc (double n))) ≡⟨⟩
step (step (to (double n))) ≡⟨ cong (step ∘ step) (to∘double n) ⟩
step (step (inj₁ n)) ≡⟨⟩
inj₁ (suc n) ∎
to∘from : ∀ x → to (from x) ≡ x
to∘from =
[ to∘double
, (λ n →
to (from (inj₂ n)) ≡⟨⟩
to (suc (double n)) ≡⟨⟩
step (to (double n)) ≡⟨ cong step (to∘double n) ⟩
step (inj₁ n) ≡⟨⟩
inj₂ n ∎)
]
-- ℕ is isomorphic to ℕ².
ℕ↔ℕ² : ℕ ↔ ℕ × ℕ
ℕ↔ℕ² = record
{ surjection = record
{ logical-equivalence = record
{ to = to
; from = from
}
; right-inverse-of = to∘from
}
; left-inverse-of = from∘to
}
where
step : ℕ × ℕ → ℕ × ℕ
step (m , zero) = (zero , suc m)
step (m , suc n) = (suc m , n)
to : ℕ → ℕ × ℕ
to zero = (zero , zero)
to (suc n) = step (to n)
-- The function from′ is defined by lexicographic induction on first
-- sum, and then m.
from′ : (m n sum : ℕ) → n + m ≡ sum → ℕ
from′ zero zero _ _ = zero
from′ zero (suc n) zero eq = ⊥-elim (0≢+ (sym eq))
from′ zero (suc n) (suc sum) eq = suc (from′ n zero sum (cancel-suc
(suc n ≡⟨ cong suc (sym +-right-identity) ⟩
suc (n + 0) ≡⟨ eq ⟩∎
suc sum ∎)))
from′ (suc m) n sum eq = suc (from′ m (suc n) sum
(suc n + m ≡⟨ suc+≡+suc n ⟩
n + suc m ≡⟨ eq ⟩∎
sum ∎))
from : ℕ × ℕ → ℕ
from (m , n) = from′ m n _ (refl _)
from′-irr : ∀ m {n sum₁ eq₁ sum₂ eq₂} →
from′ m n sum₁ eq₁ ≡ from′ m n sum₂ eq₂
from′-irr m {n} {sum₁} {eq₁} {sum₂} {eq₂} =
from′ m n sum₁ eq₁ ≡⟨ cong (uncurry (from′ m n)) (Σ-≡,≡→≡ lemma (ℕ-set _ _)) ⟩∎
from′ m n sum₂ eq₂ ∎
where
lemma =
sum₁ ≡⟨ sym eq₁ ⟩
n + m ≡⟨ eq₂ ⟩∎
sum₂ ∎
from∘step : ∀ p → from (step p) ≡ suc (from p)
from∘step (m , zero) = from (zero , suc m) ≡⟨ cong suc (from′-irr m) ⟩∎
suc (from (m , zero)) ∎
from∘step (m , suc n) = from (suc m , n) ≡⟨ cong suc (from′-irr m) ⟩∎
suc (from (m , suc n)) ∎
from∘to : ∀ n → from (to n) ≡ n
from∘to zero = refl _
from∘to (suc n) =
from (to (suc n)) ≡⟨⟩
from (step (to n)) ≡⟨ from∘step (to n) ⟩
suc (from (to n)) ≡⟨ cong suc (from∘to n) ⟩∎
suc n ∎
to∘from′ : ∀ m n sum eq → to (from′ m n sum eq) ≡ (m , n)
to∘from′ zero zero _ _ = refl _
to∘from′ zero (suc n) zero eq = ⊥-elim (0≢+ (sym eq))
to∘from′ zero (suc n) (suc sum) eq =
step (to (from′ n zero _ _)) ≡⟨ cong step (to∘from′ n zero sum _) ⟩
step (n , zero) ≡⟨⟩
(zero , suc n) ∎
to∘from′ (suc m) n sum eq =
step (to (from′ m (suc n) _ _)) ≡⟨ cong step (to∘from′ m (suc n) sum _) ⟩
step (m , suc n) ≡⟨⟩
(suc m , n) ∎
to∘from : ∀ p → to (from p) ≡ p
to∘from _ = to∘from′ _ _ _ _
-- Some isomorphisms related to equality of natural numbers.
zero≡zero↔ : zero ≡ zero ↔ ⊤
zero≡zero↔ =
_≃_.bijection $
_↠_.from (Eq.≃↠⇔ ℕ-set (mono₁ 0 ⊤-contractible)) $
record { to = _; from = λ _ → refl _ }
zero≡suc↔ : ∀ {n} → zero ≡ suc n ↔ ⊥₀
zero≡suc↔ =
_≃_.bijection $
_↠_.from (Eq.≃↠⇔ ℕ-set ⊥-propositional) $
record { to = 0≢+; from = ⊥-elim }
suc≡zero↔ : ∀ {m} → suc m ≡ zero ↔ ⊥₀
suc≡zero↔ {m} =
suc m ≡ zero ↝⟨ ≡-comm ⟩
zero ≡ suc m ↝⟨ zero≡suc↔ ⟩□
⊥ □
suc≡suc↔ : ∀ {m n} → suc m ≡ suc n ↔ m ≡ n
suc≡suc↔ =
_≃_.bijection $
_↠_.from (Eq.≃↠⇔ ℕ-set ℕ-set) $
record { to = cancel-suc; from = cong suc }
-- The equality test Nat._==_ gives the right result.
T[==]↔≡ : {m n : ℕ} → T (m == n) ↔ m ≡ n
T[==]↔≡ {m = zero} {n = zero} =
T (zero == zero) ↔⟨⟩
⊤ ↝⟨ inverse zero≡zero↔ ⟩□
zero ≡ zero □
T[==]↔≡ {m = zero} {n = suc n} =
T (zero == suc n) ↔⟨⟩
⊥ ↝⟨ inverse zero≡suc↔ ⟩□
zero ≡ suc n □
T[==]↔≡ {m = suc m} {n = zero} =
T (suc m == zero) ↔⟨⟩
⊥ ↝⟨ inverse suc≡zero↔ ⟩□
suc m ≡ zero □
T[==]↔≡ {m = suc m} {n = suc n} =
T (suc m == suc n) ↔⟨⟩
T (m == n) ↝⟨ T[==]↔≡ ⟩
m ≡ n ↝⟨ inverse suc≡suc↔ ⟩□
suc m ≡ suc n □
-- Some isomorphisms related to the ordering of natural numbers.
zero≤↔ : ∀ {n} → zero ≤ n ↔ ⊤
zero≤↔ =
_≃_.bijection $
_↠_.from (Eq.≃↠⇔ ≤-propositional (mono₁ 0 ⊤-contractible)) $
record { to = _; from = λ _ → zero≤ _ }
<zero↔ : ∀ {n} → n < zero ↔ ⊥
<zero↔ =
_≃_.bijection $
_↠_.from (Eq.≃↠⇔ ≤-propositional ⊥-propositional) $
record { to = ≮0 _; from = ⊥-elim }
suc≤suc↔ : ∀ {m n} → suc m ≤ suc n ↔ m ≤ n
suc≤suc↔ =
_≃_.bijection $
_↠_.from (Eq.≃↠⇔ ≤-propositional ≤-propositional) $
record { to = suc≤suc⁻¹; from = suc≤suc }
≤↔<⊎≡ : ∀ {m n} → m ≤ n ↔ m < n ⊎ m ≡ n
≤↔<⊎≡ =
_≃_.bijection $
_↠_.from (Eq.≃↠⇔ ≤-propositional
(⊎-closure-propositional
<→≢ ≤-propositional ℕ-set)) $
record { to = ≤→<⊎≡; from = [ <→≤ , ≤-refl′ ] }
≤↔≡0⊎0<×≤ : ∀ {m n} → m ≤ n ↔ m ≡ 0 ⊎ 0 < m × m ≤ n
≤↔≡0⊎0<×≤ {zero} {n} =
0 ≤ n ↝⟨ zero≤↔ ⟩
⊤ ↝⟨ inverse ⊎-right-identity ⟩
⊤ ⊎ ⊥₀ ↝⟨ id ⊎-cong inverse ×-left-zero ⟩
⊤ ⊎ (⊥ × 0 ≤ n) ↝⟨ inverse (_⇔_.to contractible⇔↔⊤ (propositional⇒inhabited⇒contractible ℕ-set (refl _)))
⊎-cong
inverse <zero↔ ×-cong id ⟩□
0 ≡ 0 ⊎ 0 < 0 × 0 ≤ n □
≤↔≡0⊎0<×≤ {suc m} {n} =
m < n ↝⟨ inverse ×-left-identity ⟩
⊤ × m < n ↝⟨ inverse zero≤↔ ×-cong id ⟩
0 ≤ m × m < n ↝⟨ inverse ⊎-left-identity ⟩
⊥₀ ⊎ 0 ≤ m × m < n ↝⟨ Bijection.⊥↔uninhabited (0≢+ ∘ sym) ⊎-cong inverse suc≤suc↔ ×-cong id ⟩□
1 + m ≡ 0 ⊎ 0 < 1 + m × m < n □
≤↔min≡ : ∀ {m n} → m ≤ n ↔ min m n ≡ m
≤↔min≡ =
_≃_.bijection $
_↠_.from (Eq.≃↠⇔ ≤-propositional ℕ-set) $
≤⇔min≡
≤↔max≡ : ∀ {m n} → m ≤ n ↔ max m n ≡ n
≤↔max≡ =
_≃_.bijection $
_↠_.from (Eq.≃↠⇔ ≤-propositional ℕ-set) $
≤⇔max≡
∃0<↔∃suc :
∀ {p} {P : ℕ → Type p} →
(∃ λ n → 0 < n × P n) ↔ (∃ λ n → P (suc n))
∃0<↔∃suc {P = P} = record
{ surjection = record
{ logical-equivalence = record
{ to = Σ-map pred λ where
{zero} (0<0 , _) → ⊥-elim (≮0 _ 0<0)
{suc _} (_ , p) → p
; from = Σ-map suc (λ p → suc≤suc (zero≤ _) , p)
}
; right-inverse-of = refl
}
; left-inverse-of = λ where
(zero , 0<0 , p) → ⊥-elim (≮0 _ 0<0)
(suc n , 0<+ , p) →
Σ-≡,≡→≡ (refl _)
(trans (subst-refl _ _)
(_↔_.to ≡×≡↔≡
( ≤-propositional _ _
, refl _
)))
}
∃<↔∃0<×≤ : ∀ {n} → (∃ λ m → m < n) ↔ (∃ λ m → 0 < m × m ≤ n)
∃<↔∃0<×≤ {n} =
(∃ λ m → m < n) ↔⟨⟩
(∃ λ m → suc m ≤ n) ↝⟨ inverse ∃0<↔∃suc ⟩□
(∃ λ m → 0 < m × m ≤ n) □
-- The ordering test Nat._<=_ gives the right result.
T[<=]↔≤ : {m n : ℕ} → T (m <= n) ↔ m ≤ n
T[<=]↔≤ {m = zero} {n = n} =
T (zero <= n) ↔⟨⟩
⊤ ↝⟨ inverse zero≤↔ ⟩□
zero ≤ n □
T[<=]↔≤ {m = suc m} {n = zero} =
T (suc m <= zero) ↔⟨⟩
⊥ ↝⟨ inverse <zero↔ ⟩□
suc m ≤ zero □
T[<=]↔≤ {m = suc m} {n = suc n} =
T (suc m <= suc n) ↔⟨⟩
T (m <= n) ↝⟨ T[<=]↔≤ ⟩
m ≤ n ↝⟨ inverse suc≤suc↔ ⟩□
suc m ≤ suc n □
-- Equality or distinctness of two natural numbers is isomorphic to
-- the unit type.
≡⊎Distinct↔⊤ : ∀ m n → m ≡ n ⊎ Distinct m n ↔ ⊤
≡⊎Distinct↔⊤ m n =
_⇔_.to contractible⇔↔⊤ $
propositional⇒inhabited⇒contractible
(⊎-closure-propositional
(λ m≡n m≢n → _⇔_.to Distinct⇔≢ m≢n m≡n)
ℕ-set
(Distinct-propositional m n))
(≡⊎Distinct m n)
-- Distinct is pointwise logically equivalent to _≢_, and in the
-- presence of extensionality the two definitions are pointwise
-- isomorphic.
Distinct↔≢ : ∀ {m n} → Distinct m n ↝[ lzero ∣ lzero ] m ≢ n
Distinct↔≢ {m = m} {n} =
generalise-ext?-prop
Distinct⇔≢
(λ _ → Distinct-propositional m n)
¬-propositional
------------------------------------------------------------------------
-- Left cancellation for _⊎_
-- In general _⊎_ is not left cancellative.
¬-⊎-left-cancellative :
∀ k → ¬ ((A B C : Type) → A ⊎ B ↝[ k ] A ⊎ C → B ↝[ k ] C)
¬-⊎-left-cancellative k cancel =
¬B→C $ to-implication $ cancel A B C (from-bijection A⊎B↔A⊎C)
where
A = ℕ
B = ⊤
C = ⊥
A⊎B↔A⊎C : A ⊎ B ↔ A ⊎ C
A⊎B↔A⊎C =
ℕ ⊎ ⊤ ↔⟨ inverse ℕ↔ℕ⊎⊤ ⟩
ℕ ↔⟨ inverse ⊎-right-identity ⟩
ℕ ⊎ ⊥ □
¬B→C : ¬ (B → C)
¬B→C B→C = B→C tt
-- However, it is left cancellative for certain well-behaved
-- bijections.
-- A function is "well-behaved" if any "left" element which is the
-- image of a "right" element is in turn not mapped to another "left"
-- element.
Well-behaved : ∀ {a b c} {A : Type a} {B : Type b} {C : Type c} →
(A ⊎ B → A ⊎ C) → Type _
Well-behaved f =
∀ {b a a′} → f (inj₂ b) ≡ inj₁ a → f (inj₁ a) ≢ inj₁ a′
private
-- Some helper functions.
module ⊎-left-cancellative
{a b c} {A : Type a} {B : Type b} {C : Type c}
(f : A ⊎ B → A ⊎ C)
(hyp : Well-behaved f)
where
mutual
g : B → C
g b = g′ (inspect (f (inj₂ b)))
g′ : ∀ {b} → Other-singleton (f (inj₂ b)) → C
g′ (inj₂ c , _) = c
g′ (inj₁ a , eq) = g″ eq (inspect (f (inj₁ a)))
g″ : ∀ {a b} →
f (inj₂ b) ≡ inj₁ a → Other-singleton (f (inj₁ a)) → C
g″ _ (inj₂ c , _) = c
g″ eq₁ (inj₁ _ , eq₂) = ⊥-elim $ hyp eq₁ eq₂
⊎-left-cancellative :
∀ {a b c} {A : Type a} {B : Type b} {C : Type c}
(f : A ⊎ B ↔ A ⊎ C) →
Well-behaved (_↔_.to f) →
Well-behaved (_↔_.from f) →
B ↔ C
⊎-left-cancellative {A = A} = λ inv to-hyp from-hyp → record
{ surjection = record
{ logical-equivalence = record
{ to = g (to inv) to-hyp
; from = g (from inv) from-hyp
}
; right-inverse-of = g∘g (inverse inv) from-hyp to-hyp
}
; left-inverse-of = g∘g inv to-hyp from-hyp
}
where
open _↔_
open ⊎-left-cancellative
abstract
g∘g : ∀ {b c} {B : Type b} {C : Type c}
(f : A ⊎ B ↔ A ⊎ C) →
(to-hyp : Well-behaved (to f)) →
(from-hyp : Well-behaved (from f)) →
∀ b → g (from f) from-hyp (g (to f) to-hyp b) ≡ b
g∘g f to-hyp from-hyp b = g∘g′
where
g∘g′ : g (from f) from-hyp (g (to f) to-hyp b) ≡ b
g∘g′ with inspect (to f (inj₂ b))
g∘g′ | inj₂ c , eq₁ with inspect (from f (inj₂ c))
g∘g′ | inj₂ c , eq₁ | inj₂ b′ , eq₂ = ⊎.cancel-inj₂ (
inj₂ b′ ≡⟨ sym eq₂ ⟩
from f (inj₂ c) ≡⟨ to-from f eq₁ ⟩∎
inj₂ b ∎)
g∘g′ | inj₂ c , eq₁ | inj₁ a , eq₂ = ⊥-elim $ ⊎.inj₁≢inj₂ (
inj₁ a ≡⟨ sym eq₂ ⟩
from f (inj₂ c) ≡⟨ to-from f eq₁ ⟩∎
inj₂ b ∎)
g∘g′ | inj₁ a , eq₁ with inspect (to f (inj₁ a))
g∘g′ | inj₁ a , eq₁ | inj₁ a′ , eq₂ = ⊥-elim $ to-hyp eq₁ eq₂
g∘g′ | inj₁ a , eq₁ | inj₂ c , eq₂ with inspect (from f (inj₂ c))
g∘g′ | inj₁ a , eq₁ | inj₂ c , eq₂ | inj₂ b′ , eq₃ = ⊥-elim $ ⊎.inj₁≢inj₂ (
inj₁ a ≡⟨ sym $ to-from f eq₂ ⟩
from f (inj₂ c) ≡⟨ eq₃ ⟩∎
inj₂ b′ ∎)
g∘g′ | inj₁ a , eq₁ | inj₂ c , eq₂ | inj₁ a′ , eq₃ with inspect (from f (inj₁ a′))
g∘g′ | inj₁ a , eq₁ | inj₂ c , eq₂ | inj₁ a′ , eq₃ | inj₁ a″ , eq₄ = ⊥-elim $ from-hyp eq₃ eq₄
g∘g′ | inj₁ a , eq₁ | inj₂ c , eq₂ | inj₁ a′ , eq₃ | inj₂ b′ , eq₄ = ⊎.cancel-inj₂ (
let lemma =
inj₁ a′ ≡⟨ sym eq₃ ⟩
from f (inj₂ c) ≡⟨ to-from f eq₂ ⟩∎
inj₁ a ∎
in
inj₂ b′ ≡⟨ sym eq₄ ⟩
from f (inj₁ a′) ≡⟨ cong (from f ⊚ inj₁) $ ⊎.cancel-inj₁ lemma ⟩
from f (inj₁ a) ≡⟨ to-from f eq₁ ⟩∎
inj₂ b ∎)
-- _⊎_ is left cancellative (for bijections) if the left argument is
-- the unit type.
⊎-left-cancellative-⊤ :
∀ {a b} {A : Type a} {B : Type b} →
(⊤ ⊎ A) ↔ (⊤ ⊎ B) → A ↔ B
⊎-left-cancellative-⊤ = λ ⊤⊎A↔⊤⊎B →
⊎-left-cancellative ⊤⊎A↔⊤⊎B
(wb ⊤⊎A↔⊤⊎B)
(wb $ inverse ⊤⊎A↔⊤⊎B)
where
open _↔_
abstract
wb : ∀ {a b} {A : Type a} {B : Type b}
(⊤⊎A↔⊤⊎B : (⊤ ⊎ A) ↔ (⊤ ⊎ B)) →
Well-behaved (_↔_.to ⊤⊎A↔⊤⊎B)
wb ⊤⊎A↔⊤⊎B {b = b} eq₁ eq₂ = ⊎.inj₁≢inj₂ (
inj₁ tt ≡⟨ sym $ to-from ⊤⊎A↔⊤⊎B eq₂ ⟩
from ⊤⊎A↔⊤⊎B (inj₁ tt) ≡⟨ to-from ⊤⊎A↔⊤⊎B eq₁ ⟩∎
inj₂ b ∎)
-- If the codomain of ⊎-left-cancellative-⊤ is paired up with a value
-- in ⊤ ⊎ B, then the function can be strengthened to a bijection
-- (assuming both decidability of equality of values in B and
-- extensionality).
[⊤⊎↔⊤⊎]↔[⊤⊎×↔] :
∀ {a b} {A : Type a} {B : Type b} →
Decidable-equality B →
((⊤ ⊎ A) ↔ (⊤ ⊎ B)) ↝[ a ⊔ b ∣ a ⊔ b ] (⊤ ⊎ B) × (A ↔ B)
[⊤⊎↔⊤⊎]↔[⊤⊎×↔] {a = a} {b = b} {A = A} {B = B} _≟B_ =
generalise-ext? [⊤⊎↔⊤⊎]⇔[⊤⊎×↔] (λ ext → to∘from ext , from∘to ext)
where
_≟_ : Decidable-equality (⊤ ⊎ B)
_≟_ = ⊎.Dec._≟_ ⊤._≟_ _≟B_
if-not : ∀ {a p} {A : Type a} {P : Type p} (d : Dec P) (t e : A) →
¬ P → if d then t else e ≡ e
if-not (yes p) t e ¬p = ⊥-elim (¬p p)
if-not (no _) t e ¬p = refl _
to : (⊤ ⊎ A) ↔ (⊤ ⊎ B) → (⊤ ⊎ B) × (A ↔ B)
to ⊤⊎A↔⊤⊎B = _↔_.to ⊤⊎A↔⊤⊎B (inj₁ tt) , ⊎-left-cancellative-⊤ ⊤⊎A↔⊤⊎B
from : (⊤ ⊎ B) × (A ↔ B) → (⊤ ⊎ A) ↔ (⊤ ⊎ B)
from (⊤⊎B , A↔B) = record
{ surjection = record
{ logical-equivalence = record
{ to = t ⊤⊎B
; from = f ⊤⊎B
}
; right-inverse-of = t∘f ⊤⊎B
}
; left-inverse-of = f∘t ⊤⊎B
}
where
t : ⊤ ⊎ B → ⊤ ⊎ A → ⊤ ⊎ B
t ⊤⊎B (inj₁ tt) = ⊤⊎B
t ⊤⊎B (inj₂ a) =
let b = inj₂ (_↔_.to A↔B a) in
if b ≟ ⊤⊎B then inj₁ tt else b
f : ⊤ ⊎ B → ⊤ ⊎ B → ⊤ ⊎ A
f ⊤⊎B (inj₁ tt) = [ const (inj₁ tt) , inj₂ ∘ _↔_.from A↔B ] ⊤⊎B
f ⊤⊎B (inj₂ b) =
if ⊤⊎B ≟ inj₂ b then inj₁ tt else inj₂ (_↔_.from A↔B b)
abstract
t∘f : ∀ ⊤⊎B x → t ⊤⊎B (f ⊤⊎B x) ≡ x
t∘f (inj₁ tt) (inj₁ tt) = refl _
t∘f (inj₁ tt) (inj₂ b′) = inj₂ (_↔_.to A↔B (_↔_.from A↔B b′)) ≡⟨ cong inj₂ $ _↔_.right-inverse-of A↔B _ ⟩∎
inj₂ b′ ∎
t∘f (inj₂ b) (inj₁ tt) with _↔_.to A↔B (_↔_.from A↔B b) ≟B b
t∘f (inj₂ b) (inj₁ tt) | yes _ = refl _
t∘f (inj₂ b) (inj₁ tt) | no b≢b = ⊥-elim $ b≢b (
_↔_.to A↔B (_↔_.from A↔B b) ≡⟨ _↔_.right-inverse-of A↔B _ ⟩∎
b ∎)
t∘f (inj₂ b) (inj₂ b′) with b ≟B b′
t∘f (inj₂ b) (inj₂ b′) | yes b≡b′ = inj₂ b ≡⟨ cong inj₂ b≡b′ ⟩∎
inj₂ b′ ∎
t∘f (inj₂ b) (inj₂ b′) | no b≢b′ =
t (inj₂ b) (inj₂ (_↔_.from A↔B b′)) ≡⟨⟩
if inj₂ (_↔_.to A↔B (_↔_.from A↔B b′)) ≟ inj₂ b then inj₁ tt
else inj₂ (_↔_.to A↔B (_↔_.from A↔B b′)) ≡⟨ cong (λ b′ → if inj₂ b′ ≟ inj₂ b then inj₁ tt else inj₂ b′) $
_↔_.right-inverse-of A↔B _ ⟩
if inj₂ b′ ≟ inj₂ b then inj₁ tt else inj₂ b′ ≡⟨ if-not (inj₂ b′ ≟ inj₂ b) (inj₁ tt) _ (b≢b′ ∘ sym ∘ ⊎.cancel-inj₂) ⟩∎
inj₂ b′ ∎
f∘t : ∀ ⊤⊎B x → f ⊤⊎B (t ⊤⊎B x) ≡ x
f∘t (inj₁ tt) (inj₁ tt) = refl _
f∘t (inj₁ tt) (inj₂ a) = inj₂ (_↔_.from A↔B (_↔_.to A↔B a)) ≡⟨ cong inj₂ $ _↔_.left-inverse-of A↔B _ ⟩∎
inj₂ a ∎
f∘t (inj₂ b) (inj₁ tt) with b ≟B b
f∘t (inj₂ b) (inj₁ tt) | yes _ = refl _
f∘t (inj₂ b) (inj₁ tt) | no b≢b = ⊥-elim $ b≢b (refl _)
f∘t (inj₂ b) (inj₂ a) with _↔_.to A↔B a ≟B b
f∘t (inj₂ b) (inj₂ a) | yes to-a≡b = inj₂ (_↔_.from A↔B b) ≡⟨ cong inj₂ $ _↔_.to-from A↔B to-a≡b ⟩∎
inj₂ a ∎
f∘t (inj₂ b) (inj₂ a) | no to-a≢b with b ≟B _↔_.to A↔B a
f∘t (inj₂ b) (inj₂ a) | no to-a≢b | yes b≡to-a = ⊥-elim $ to-a≢b
(_↔_.to A↔B a ≡⟨ sym b≡to-a ⟩∎
b ∎)
f∘t (inj₂ b) (inj₂ a) | no to-a≢b | no b≢to-a =
inj₂ (_↔_.from A↔B (_↔_.to A↔B a)) ≡⟨ cong inj₂ $ _↔_.left-inverse-of A↔B _ ⟩∎
inj₂ a ∎
[⊤⊎↔⊤⊎]⇔[⊤⊎×↔] : ((⊤ ⊎ A) ↔ (⊤ ⊎ B)) ⇔ (⊤ ⊎ B) × (A ↔ B)
[⊤⊎↔⊤⊎]⇔[⊤⊎×↔] = record
{ to = to
; from = from
}
to∘from :
Extensionality (a ⊔ b) (a ⊔ b) →
∀ x → to (from x) ≡ x
to∘from ext (⊤⊎B , A↔B) =
cong (⊤⊎B ,_) (_↔_.to (↔-to-≡↔≡ ext A-set) (lemma ⊤⊎B))
where
A-set : Is-set A
A-set = $⟨ _≟B_ ⟩
Decidable-equality B ↝⟨ decidable⇒set ⟩
Is-set B ↝⟨ H-level.respects-surjection
(_↔_.surjection $ inverse A↔B) 2 ⟩□
Is-set A □
lemma :
∀ ⊤⊎B a →
_↔_.to (⊎-left-cancellative-⊤ (from (⊤⊎B , A↔B))) a ≡ _↔_.to A↔B a
lemma (inj₁ tt) a = refl _
lemma (inj₂ b) a with inspect (_↔_.to (from (inj₂ b , A↔B))
(inj₂ a))
lemma (inj₂ b) a | (inj₁ tt , eq) with _↔_.to A↔B a ≟B b
lemma (inj₂ b) a | (inj₁ tt , eq) | yes to-a≡b = sym to-a≡b
lemma (inj₂ b) a | (inj₁ tt , eq) | no _ = ⊥-elim $ ⊎.inj₁≢inj₂ $ sym eq
lemma (inj₂ b) a | (inj₂ _ , eq) with _↔_.to A↔B a ≟B b
lemma (inj₂ b) a | (inj₂ _ , eq) | yes _ = ⊥-elim $ ⊎.inj₁≢inj₂ eq
lemma (inj₂ b) a | (inj₂ _ , eq) | no _ = ⊎.cancel-inj₂ $ sym eq
from∘to :
Extensionality (a ⊔ b) (a ⊔ b) →
∀ x → from (to x) ≡ x
from∘to ext ⊤⊎A↔⊤⊎B = _↔_.to (↔-to-≡↔≡ ext ⊤⊎A-set) lemma₁
where
open ⊎-left-cancellative
⊤⊎A-set : Is-set (⊤ ⊎ A)
⊤⊎A-set = $⟨ _≟B_ ⟩
Decidable-equality B ↝⟨ decidable⇒set ⟩
Is-set B ↝⟨ ⊎-closure 0 (mono (zero≤ 2) ⊤-contractible) ⟩
Is-set (⊤ ⊎ B) ↝⟨ H-level.respects-surjection
(_↔_.surjection $ inverse ⊤⊎A↔⊤⊎B) 2 ⟩□
Is-set (⊤ ⊎ A) □
mutual
lemma₁ : ∀ ⊤⊎A →
_↔_.to (from (to ⊤⊎A↔⊤⊎B)) ⊤⊎A ≡ _↔_.to ⊤⊎A↔⊤⊎B ⊤⊎A
lemma₁ (inj₁ tt) = refl _
lemma₁ (inj₂ a) = lemma₂ (inspect _) (inspect _)
lemma₂ :
∀ {a} {wb : Well-behaved (_↔_.to ⊤⊎A↔⊤⊎B)}
(x : Other-singleton (_↔_.to ⊤⊎A↔⊤⊎B (inj₂ a)))
(y : Other-singleton (_↔_.to ⊤⊎A↔⊤⊎B (inj₁ tt))) →
let b = g′ (_↔_.to ⊤⊎A↔⊤⊎B) wb x in
if inj₂ b ≟ proj₁ y then inj₁ tt else inj₂ b ≡ proj₁ x
lemma₂ {a} (inj₁ tt , eq₁) (inj₁ tt , eq₂) = ⊥-elim $ ⊎.inj₁≢inj₂ (
inj₁ tt ≡⟨ sym $ _↔_.left-inverse-of ⊤⊎A↔⊤⊎B _ ⟩
_↔_.from ⊤⊎A↔⊤⊎B (_↔_.to ⊤⊎A↔⊤⊎B (inj₁ tt)) ≡⟨ cong (_↔_.from ⊤⊎A↔⊤⊎B) eq₂ ⟩
_↔_.from ⊤⊎A↔⊤⊎B (inj₁ tt) ≡⟨ cong (_↔_.from ⊤⊎A↔⊤⊎B) $ sym eq₁ ⟩
_↔_.from ⊤⊎A↔⊤⊎B (_↔_.to ⊤⊎A↔⊤⊎B (inj₂ a)) ≡⟨ _↔_.left-inverse-of ⊤⊎A↔⊤⊎B _ ⟩∎
inj₂ a ∎)
lemma₂ (inj₁ tt , eq₁) (inj₂ b′ , eq₂) = lemma₃ eq₁ (inspect _) eq₂ (inj₂ _ ≟ inj₂ b′)
lemma₂ (inj₂ b , eq₁) (inj₁ tt , eq₂) = refl _
lemma₂ (inj₂ b , eq₁) (inj₂ b′ , eq₂) with b ≟B b′
lemma₂ (inj₂ b , eq₁) (inj₂ b′ , eq₂) | no _ = refl _
lemma₂ {a} (inj₂ b , eq₁) (inj₂ b′ , eq₂) | yes b≡b′ =
⊥-elim $ ⊎.inj₁≢inj₂ (
inj₁ tt ≡⟨ sym $ _↔_.left-inverse-of ⊤⊎A↔⊤⊎B _ ⟩
_↔_.from ⊤⊎A↔⊤⊎B (_↔_.to ⊤⊎A↔⊤⊎B (inj₁ tt)) ≡⟨ cong (_↔_.from ⊤⊎A↔⊤⊎B) eq₂ ⟩
_↔_.from ⊤⊎A↔⊤⊎B (inj₂ b′) ≡⟨ cong (_↔_.from ⊤⊎A↔⊤⊎B ∘ inj₂) $ sym b≡b′ ⟩
_↔_.from ⊤⊎A↔⊤⊎B (inj₂ b) ≡⟨ cong (_↔_.from ⊤⊎A↔⊤⊎B) $ sym eq₁ ⟩
_↔_.from ⊤⊎A↔⊤⊎B (_↔_.to ⊤⊎A↔⊤⊎B (inj₂ a)) ≡⟨ _↔_.left-inverse-of ⊤⊎A↔⊤⊎B _ ⟩∎
inj₂ a ∎)
lemma₃ :
∀ {a b′} {wb : Well-behaved (_↔_.to ⊤⊎A↔⊤⊎B)}
(eq : _↔_.to ⊤⊎A↔⊤⊎B (inj₂ a) ≡ inj₁ tt)
(x : Other-singleton (_↔_.to ⊤⊎A↔⊤⊎B (inj₁ tt))) →
proj₁ x ≡ inj₂ b′ →
let b = g″ (_↔_.to ⊤⊎A↔⊤⊎B) wb eq x in
(d : Dec (inj₂ {A = ⊤} b ≡ inj₂ b′)) →
if d then inj₁ tt else inj₂ b ≡ inj₁ tt
lemma₃ eq₁ (inj₁ _ , eq₂) eq₃ _ = ⊥-elim $ ⊎.inj₁≢inj₂ eq₃
lemma₃ eq₁ (inj₂ b″ , eq₂) eq₃ (yes b″≡b′) = refl _
lemma₃ eq₁ (inj₂ b″ , eq₂) eq₃ (no b″≢b′) = ⊥-elim $ b″≢b′ eq₃
|
{
"alphanum_fraction": 0.4486350187,
"avg_line_length": 37.2425972927,
"ext": "agda",
"hexsha": "f083e0bb93e7c34844c8f1a9a5e317517735b254",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/equality",
"max_forks_repo_path": "src/Function-universe.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/equality",
"max_issues_repo_path": "src/Function-universe.agda",
"max_line_length": 148,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/equality",
"max_stars_repo_path": "src/Function-universe.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-02T17:18:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-05-21T22:58:50.000Z",
"num_tokens": 73799,
"size": 176083
}
|
module Ambient where
open import Relation.Nullary
using (yes; no)
open import Data.String
using (String; _≟_)
open import Data.Bool
using (Bool; true; false)
open import Relation.Binary.PropositionalEquality
using (_≢_; refl)
renaming (_≡_ to _≡≡_)
open import Data.List
using (List; []; _∷_; _++_; filter)
-- Local modules ---------------------------------------------------------------
open import Common
using (Id)
open import Capability
using (Capability; `_; In; Out; Open; ε; _∙_)
renaming (_[_/_] to _[_/_]-capa; freeVar to freeVar-capa)
-- Process Definition ----------------------------------------------------------
infix 40 _[_/_]
infixr 30 Λ_∙_
infix 20 _[_]
infixr 10 _||_
data Process : Set where
ν_∙_ : Id → Process → Process -- Restriction
Zero : Process -- Inactivity
_||_ : Process → Process → Process -- Composition
!_ : Process → Process -- Replication
_[_] : Capability → Process → Process -- Ambient
_∙_ : Capability → Process → Process -- Action
Λ_∙_ : Id → Process → Process -- Input Action
<_> : Capability → Process -- Message
-- Free variable ---------------------------------------------------------------
_-_ : List Id → Id → List Id
[] - _ = []
(x ∷ xs) - y with x ≟ y
... | yes _ = xs - y
... | no _ = x ∷ (xs - y)
freeVar : Process → List Id
freeVar (ν x ∙ P) = freeVar P
freeVar Zero = []
freeVar (P || Q) = (freeVar P) ++ (freeVar Q)
freeVar (! P) = freeVar P
freeVar (M [ P ]) = (freeVar-capa M) ++ (freeVar P)
freeVar (M ∙ P) = (freeVar-capa M) ++ (freeVar P)
freeVar (Λ x ∙ P) = (freeVar P) - x
freeVar (< M >) = freeVar-capa M
_∉_ : Id → List Id → Set
y ∉ l = member y l ≡≡ false
where member : Id → List Id → Bool -- Should propably use the List filter instead!
member y [] = false
member y (x ∷ xs) with x ≟ y
... | yes _ = true
... | no _ = member y xs
-- Process substitution --------------------------------------------------------
_[_/_] : Process → Id → Capability → Process
Zero [ _ / _ ] = Zero
(P || Q) [ x / M ] = P [ x / M ] || Q [ x / M ]
(! P) [ x / M ] = ! (P [ x / M ])
(x [ P ]) [ y / M ] = (x [ y / M ]-capa) [ P [ y / M ] ]
(ν x ∙ P) [ y / M ] with x ≟ y
... | yes _ = ν x ∙ P
... | no _ = ν x ∙ (P [ y / M ])
< N > [ x / M ] = < N [ x / M ]-capa >
(Λ x ∙ P) [ y / M ] with x ≟ y
... | yes _ = Λ x ∙ P
... | no _ = Λ x ∙ (P [ y / M ])
( N ∙ P) [ x / M ] = (N [ x / M ]-capa) ∙ (P [ x / M ])
module Test where
a = "a"
b = "b"
------------------------------------------------------------------------------
_ : (` a [ < ` b > ]) [ b / Open a ] ≡≡ ` a [ < Open a > ]
_ = refl
_ : (< ` a > || < ` b >) [ b / Open a ] ≡≡ < ` a > || < Open a >
_ = refl
-- Congruence ------------------------------------------------------------------
infix 5 _≡_
data _≡_ : Process → Process → Set where
Struct-Refl : ∀ {P}
-----
→ P ≡ P
Struct-Symm : ∀ {P Q}
→ P ≡ Q
-----
→ Q ≡ P
Struct-Trans : ∀ {P Q R}
→ P ≡ Q → Q ≡ R
-------------
→ P ≡ R
Struct-Res : ∀ {n P Q}
→ P ≡ Q
-----------------
→ ν n ∙ P ≡ ν n ∙ Q
Struct-Par : ∀ {P Q R}
→ P ≡ Q
---------------
→ P || R ≡ Q || R
Struct-Repl : ∀ {P Q}
→ P ≡ Q
---------
→ ! P ≡ ! Q
Struct-Amb : ∀ {M P Q}
→ P ≡ Q
-----------------
→ M [ P ] ≡ M [ Q ]
Struct-Action : ∀ {M P Q}
→ P ≡ Q
-------------
→ M ∙ P ≡ M ∙ Q
Struct-Input : ∀ {x P Q}
→ P ≡ Q
---------------------
→ Λ x ∙ P ≡ Λ x ∙ Q
Struct-Comm : ∀ {P Q}
→ P ≡ Q
-----
→ Q ≡ P
Struct-Assoc : ∀ {P Q R}
-----------------------------
→ (P || Q) || R ≡ P || (Q || R)
Struct-ResRes : ∀ {n m P}
→ n ≢ m
-----------------------------
→ ν n ∙ ν m ∙ P ≡ ν m ∙ ν n ∙ P
Struct-ResPar : ∀ {n P Q}
→ n ∉ freeVar(P)
-----------------------------
→ ν n ∙ (P || Q) ≡ P || ν n ∙ Q
Struct-ResAmb : ∀ {n m P}
→ n ≢ m
-----------------------------------
→ ν n ∙ (` m [ P ]) ≡ ` m [ ν n ∙ P ]
Struct-ZeroPar : ∀ {P}
-------------
→ P || Zero ≡ P
Struct-ZeroRes : ∀ {n}
-----------------
→ ν n ∙ Zero ≡ Zero
Struct-ZeroRep : ! Zero ≡ Zero
Struct-ε : ---------------
ε ∙ Zero ≡ Zero
Struct-∙ : ∀ {M M' P}
---------------------------
→ (M ∙ M') ∙ P ≡ M ∙ (M' ∙ P)
-- Reduction rules -------------------------------------------------------------
infix 5 _~>_
data _~>_ : Process → Process → Set where
Red-In : ∀ {m n P Q R}
-----------------------------------------------------------------
→ ` m [ In n ∙ P || Q ] || ` n [ R ] ~> ` n [ ` m [ P || Q ] || R ]
Red-Out : ∀ {m n P Q R}
------------------------------------------------------------------
→ ` m [ ` n [ Out m ∙ P || R ] || Q ] ~> ` m [ Q ] || ` n [ P || R ]
Red-Open : ∀ {m P Q}
---------------------------------
→ ` m [ P ] || Open m ∙ Q ~> P || Q
Red-I/O : ∀ {M x P}
---------------------------------
→ < M > || Λ x ∙ P ~> P [ x / M ]
Red-Par : ∀ {P Q R}
→ P ~> Q
------------------
→ P || R ~> Q || R
Red-Res : ∀ {n P Q}
→ P ~> Q
--------------------
→ ν n ∙ P ~> ν n ∙ Q
Red-Amb : ∀ {M P Q}
→ P ~> Q
--------------------
→ M [ P ] ~> M [ Q ]
Red-≡ : ∀ {P P' Q Q'}
→ P' ≡ P → P ~> Q → Q ≡ Q'
-------------------------
→ P' ~> Q'
--------------------------------------------------------------------------------
|
{
"alphanum_fraction": 0.2844814534,
"avg_line_length": 28.4698275862,
"ext": "agda",
"hexsha": "3401ef5d5334a83bd2f34862e3383abe1a2ebdbc",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "a81447af3ab2ba898bb7d57be71369abbba12d81",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "d-plaindoux/colca",
"max_forks_repo_path": "src/Ambient.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "a81447af3ab2ba898bb7d57be71369abbba12d81",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "d-plaindoux/colca",
"max_issues_repo_path": "src/Ambient.agda",
"max_line_length": 87,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "a81447af3ab2ba898bb7d57be71369abbba12d81",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "d-plaindoux/colca",
"max_stars_repo_path": "src/Ambient.agda",
"max_stars_repo_stars_event_max_datetime": "2021-05-04T09:35:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-03-12T18:31:14.000Z",
"num_tokens": 1904,
"size": 6605
}
|
------------------------------------------------------------------------
-- The untyped SKI combinator calculus
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module FOmegaInt.Undecidable.SK where
open import Data.Bool
open import Data.Product as Prod using (_,_; ∃; _×_)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Relation.Binary.Construct.Closure.ReflexiveTransitive
open import Relation.Binary.PropositionalEquality
------------------------------------------------------------------------
-- The untyped SK(I) combinator calculus
infixl 9 _·_
infixl 4 _≡SK_ _≤SK?_ _⇛[_]_ _⇛[_]*_ _⇛≤_ _⇛≤*_ _⇛≥_ _⇛≥*_ _⇛≤*≤⇚_
-- Terms of the SK combinator calculus.
data SKTerm : Set where
S : SKTerm
K : SKTerm
_·_ : SKTerm → SKTerm → SKTerm
-- Equality of SK terms.
data _≡SK_ : SKTerm → SKTerm → Set where
≡-refl : ∀ {t} → t ≡SK t
≡-trans : ∀ {s t u} → s ≡SK t → t ≡SK u → s ≡SK u
≡-sym : ∀ {s t} → s ≡SK t → t ≡SK s
≡-Sred : ∀ {s t u} → S · s · t · u ≡SK s · u · (t · u)
≡-Kred : ∀ {s t} → K · s · t ≡SK s
≡-· : ∀ {s₁ s₂ t₁ t₂} →
s₁ ≡SK s₂ → t₁ ≡SK t₂ → s₁ · t₁ ≡SK s₂ · t₂
-- A well-known encoding of the I combinator.
I : SKTerm
I = S · K · K
-- Some admissible equality rules.
≡-Ired : ∀ {t} → I · t ≡SK t
≡-Ired = ≡-trans ≡-Sred ≡-Kred
≡-Sexp : ∀ {s t u} → s · u · (t · u) ≡SK S · s · t · u
≡-Sexp = ≡-sym ≡-Sred
≡-Kexp : ∀ {s t} → s ≡SK K · s · t
≡-Kexp = ≡-sym ≡-Kred
≡-Iexp : ∀ {t} → t ≡SK I · t
≡-Iexp = ≡-sym ≡-Ired
------------------------------------------------------------------------
-- A variant of the untyped SK calculus with extra term formers
data SK?Term : Set where
⊥ : SK?Term -- degenerate term
⊤ : SK?Term -- degenerate term
S : SK?Term
K : SK?Term
_·_ : SK?Term → SK?Term → SK?Term
-- An SK? term is pure if it is an SK term.
data Pure : SK?Term → Set where
S : Pure S
K : Pure K
_·_ : ∀ {s t} → Pure s → Pure t → Pure (s · t)
-- A partial order on SK? terms that resembles subtyping.
data _≤SK?_ : SK?Term → SK?Term → Set where
≤?-refl : ∀ {t} → t ≤SK? t
≤?-trans : ∀ {s t u} → s ≤SK? t → t ≤SK? u → s ≤SK? u
≤?-⊥ : ∀ {t} → ⊥ ≤SK? t
≤?-⊤ : ∀ {t} → t ≤SK? ⊤
≤?-Sred : ∀ {s t u} → S · s · t · u ≤SK? s · u · (t · u)
≤?-Kred : ∀ {s t} → K · s · t ≤SK? s
≤?-Sexp : ∀ {s t u} → s · u · (t · u) ≤SK? S · s · t · u
≤?-Kexp : ∀ {s t} → s ≤SK? K · s · t
≤?-· : ∀ {s₁ s₂ t₁ t₂} →
s₁ ≤SK? s₂ → t₁ ≤SK? t₂ → s₁ · t₁ ≤SK? s₂ · t₂
-- Parallel one-step and multi-step reduction of SK? terms, possibly
-- containing instances of ⊥-elim and ⊤-intro.
--
-- The `i' index in `_⇛[ i ]_' indicates whether the relation is
-- increasing (true) or decreasing (false). The increasing
-- single/multi-step relations are (strict) subrelations of _≤SK?_,
-- while the decreasing ones are subrelations of _≥SK?_ (i.e. the
-- inverse of _≤SK?_).
data _⇛[_]_ : SK?Term → Bool → SK?Term → Set where
⇛-refl : ∀ {t i} → t ⇛[ i ] t
⇛-Sred : ∀ {s₁ s₂ t₁ t₂ u₁ u₂ i} →
s₁ ⇛[ i ] s₂ → t₁ ⇛[ i ] t₂ → u₁ ⇛[ i ] u₂ →
S · s₁ · t₁ · u₁ ⇛[ i ] s₂ · u₂ · (t₂ · u₂)
⇛-Kred : ∀ {s₁ s₂ t i} → s₁ ⇛[ i ] s₂ → K · s₁ · t ⇛[ i ] s₂
⇛-· : ∀ {s₁ s₂ t₁ t₂ i} →
s₁ ⇛[ i ] s₂ → t₁ ⇛[ i ] t₂ → s₁ · t₁ ⇛[ i ] s₂ · t₂
⇛-⊥ : ∀ {t} → ⊥ ⇛[ true ] t
⇛-⊤ : ∀ {t} → ⊤ ⇛[ false ] t
_⇛[_]*_ : SK?Term → Bool → SK?Term → Set
s ⇛[ i ]* t = (Star _⇛[ i ]_) s t
_⇛≤_ : SK?Term → SK?Term → Set
_⇛≤_ = _⇛[ true ]_
_⇛≤*_ : SK?Term → SK?Term → Set
_⇛≤*_ = _⇛[ true ]*_
_⇛≥_ : SK?Term → SK?Term → Set
_⇛≥_ = _⇛[ false ]_
_⇛≥*_ : SK?Term → SK?Term → Set
_⇛≥*_ = _⇛[ false ]*_
-- A combination of the two multi-step reductions that is equivalent
-- to _≤SK?_ modulo "squashing" of intermediate terms (see ≤SK?--⇛≤*≤⇚
-- below).
_⇛≤*≤⇚_ : SK?Term → SK?Term → Set
s ⇛≤*≤⇚ t = ∃ λ u → s ⇛≤* u × t ⇛≥* u
-- SK terms are SK? terms
inject : SKTerm → SK?Term
inject S = S
inject K = K
inject (s · t) = inject s · inject t
inject-Pure : ∀ t → Pure (inject t)
inject-Pure S = S
inject-Pure K = K
inject-Pure (s · t) = inject-Pure s · inject-Pure t
-- The inverse of inject on pure terms.
inject⁻¹ : ∀ {t} → Pure t → SKTerm
inject⁻¹ S = S
inject⁻¹ K = K
inject⁻¹ (p · q) = inject⁻¹ p · inject⁻¹ q
inject⁻¹-inject-Pure : ∀ t → inject⁻¹ (inject-Pure t) ≡ t
inject⁻¹-inject-Pure S = refl
inject⁻¹-inject-Pure K = refl
inject⁻¹-inject-Pure (s · t) =
cong₂ _·_ (inject⁻¹-inject-Pure s) (inject⁻¹-inject-Pure t)
inject⁻¹-unique : ∀ {t} → (p q : Pure t) → inject⁻¹ p ≡ inject⁻¹ q
inject⁻¹-unique S S = refl
inject⁻¹-unique K K = refl
inject⁻¹-unique (p₁ · p₂) (q₁ · q₂) =
cong₂ _·_ (inject⁻¹-unique p₁ q₁) (inject⁻¹-unique p₂ q₂)
-- Equality of SK terms is a subrelation of the SK? term order and its
-- inverse.
mutual
≡SK-≤SK? : ∀ {s t} → s ≡SK t → inject s ≤SK? inject t
≡SK-≤SK? ≡-refl = ≤?-refl
≡SK-≤SK? (≡-trans s≡t t≡u) = ≤?-trans (≡SK-≤SK? s≡t) (≡SK-≤SK? t≡u)
≡SK-≤SK? (≡-sym s≡t) = ≡SK-≥SK? s≡t
≡SK-≤SK? ≡-Sred = ≤?-Sred
≡SK-≤SK? ≡-Kred = ≤?-Kred
≡SK-≤SK? (≡-· s₁≡t₁ s₂≡t₂) = ≤?-· (≡SK-≤SK? s₁≡t₁) (≡SK-≤SK? s₂≡t₂)
≡SK-≥SK? : ∀ {s t} → s ≡SK t → inject t ≤SK? inject s
≡SK-≥SK? ≡-refl = ≤?-refl
≡SK-≥SK? (≡-trans s≡t t≡u) = ≤?-trans (≡SK-≥SK? t≡u) (≡SK-≥SK? s≡t)
≡SK-≥SK? (≡-sym s≡t) = ≡SK-≤SK? s≡t
≡SK-≥SK? ≡-Sred = ≤?-Sexp
≡SK-≥SK? ≡-Kred = ≤?-Kexp
≡SK-≥SK? (≡-· s₁≡t₁ s₂≡t₂) = ≤?-· (≡SK-≥SK? s₁≡t₁) (≡SK-≥SK? s₂≡t₂)
-- Admissible constructors for multi-step reduction
⇛*-· : ∀ {ab s₁ s₂ t₁ t₂} →
s₁ ⇛[ ab ]* s₂ → t₁ ⇛[ ab ]* t₂ → s₁ · t₁ ⇛[ ab ]* s₂ · t₂
⇛*-· ε ε = ε
⇛*-· ε (t₁⇛t₂ ◅ t₂⇛*t₃) = (⇛-· ⇛-refl t₁⇛t₂) ◅ (⇛*-· ε t₂⇛*t₃)
⇛*-· (s₁⇛s₂ ◅ s₂⇛*s₃) ε = (⇛-· s₁⇛s₂ ⇛-refl) ◅ (⇛*-· s₂⇛*s₃ ε)
⇛*-· (s₁⇛s₂ ◅ s₂⇛*s₃) (t₁⇛t₂ ◅ t₂⇛*t₃) = (⇛-· s₁⇛s₂ t₁⇛t₂) ◅ (⇛*-· s₂⇛*s₃ t₂⇛*t₃)
-- A Church-Rosser theorem for SK? reductions.
⇛-CR : ∀ {s t₁ t₂} → s ⇛≤ t₁ → s ⇛≥ t₂ → ∃ λ u → t₁ ⇛≥ u × t₂ ⇛≤ u
⇛-CR ⇛-refl s⇛t₂ = _ , s⇛t₂ , ⇛-refl
⇛-CR (⇛-Sred s₁⇛t₁₁ s₂⇛t₂₁ s₃⇛t₃₁) (⇛-Sred s₁⇛t₁₂ s₂⇛t₂₂ s₃⇛t₃₂) =
let u₁ , t₁₁⇛u₁ , t₁₂⇛u₁ = ⇛-CR s₁⇛t₁₁ s₁⇛t₁₂
u₂ , t₂₁⇛u₂ , t₂₂⇛u₂ = ⇛-CR s₂⇛t₂₁ s₂⇛t₂₂
u₃ , t₃₁⇛u₃ , t₃₂⇛u₃ = ⇛-CR s₃⇛t₃₁ s₃⇛t₃₂
in u₁ · u₃ · (u₂ · u₃) ,
⇛-· (⇛-· t₁₁⇛u₁ t₃₁⇛u₃) (⇛-· t₂₁⇛u₂ t₃₁⇛u₃) ,
⇛-· (⇛-· t₁₂⇛u₁ t₃₂⇛u₃) (⇛-· t₂₂⇛u₂ t₃₂⇛u₃)
⇛-CR (⇛-Sred s₁⇛t₁₁ s₂⇛t₂₁ s₃⇛t₃₁) (⇛-· ⇛-refl s₃⇛t₃₂) =
let u₃ , t₃₁⇛u₃ , t₃₂⇛u₃ = ⇛-CR s₃⇛t₃₁ s₃⇛t₃₂
in _ · u₃ · (_ · u₃) ,
⇛-· (⇛-· ⇛-refl t₃₁⇛u₃) (⇛-· ⇛-refl t₃₁⇛u₃) ,
⇛-Sred s₁⇛t₁₁ s₂⇛t₂₁ t₃₂⇛u₃
⇛-CR (⇛-Sred s₁⇛t₁₁ s₂⇛t₂₁ s₃⇛t₃₁) (⇛-· (⇛-· ⇛-refl s₂⇛t₂₂) s₃⇛t₃₂) =
let u₂ , t₂₁⇛u₂ , t₂₂⇛u₂ = ⇛-CR s₂⇛t₂₁ s₂⇛t₂₂
u₃ , t₃₁⇛u₃ , t₃₂⇛u₃ = ⇛-CR s₃⇛t₃₁ s₃⇛t₃₂
in _ · u₃ · (u₂ · u₃) ,
⇛-· (⇛-· ⇛-refl t₃₁⇛u₃) (⇛-· t₂₁⇛u₂ t₃₁⇛u₃) ,
⇛-Sred s₁⇛t₁₁ t₂₂⇛u₂ t₃₂⇛u₃
⇛-CR (⇛-Sred s₁⇛t₁₁ s₂⇛t₂₁ s₃⇛t₃₁)
(⇛-· (⇛-· (⇛-· ⇛-refl s₁⇛t₁₂) s₂⇛t₂₂) s₃⇛t₃₂) =
let u₁ , t₁₁⇛u₁ , t₁₂⇛u₁ = ⇛-CR s₁⇛t₁₁ s₁⇛t₁₂
u₂ , t₂₁⇛u₂ , t₂₂⇛u₂ = ⇛-CR s₂⇛t₂₁ s₂⇛t₂₂
u₃ , t₃₁⇛u₃ , t₃₂⇛u₃ = ⇛-CR s₃⇛t₃₁ s₃⇛t₃₂
in u₁ · u₃ · (u₂ · u₃) ,
⇛-· (⇛-· t₁₁⇛u₁ t₃₁⇛u₃) (⇛-· t₂₁⇛u₂ t₃₁⇛u₃) ,
⇛-Sred t₁₂⇛u₁ t₂₂⇛u₂ t₃₂⇛u₃
⇛-CR (⇛-Kred s⇛t₁) (⇛-Kred s⇛t₂) =
let u , t₁⇛u , t₂⇛u = ⇛-CR s⇛t₁ s⇛t₂
in u , t₁⇛u , t₂⇛u
⇛-CR (⇛-Kred s₁⇛t₁₁) (⇛-· ⇛-refl _) = _ , ⇛-refl , ⇛-Kred s₁⇛t₁₁
⇛-CR (⇛-Kred s₁⇛t₁₁) (⇛-· (⇛-· ⇛-refl s₁⇛t₂₁) _) =
let u₁ , t₁₁⇛u₁ , t₂₁⇛u₁ = ⇛-CR s₁⇛t₁₁ s₁⇛t₂₁
in u₁ , t₁₁⇛u₁ , ⇛-Kred t₂₁⇛u₁
⇛-CR (⇛-· ⇛-refl s₃⇛t₃₁) (⇛-Sred s₁⇛t₁₂ s₂⇛t₂₂ s₃⇛t₃₂) =
let u₃ , t₃₁⇛u₃ , t₃₂⇛u₃ = ⇛-CR s₃⇛t₃₁ s₃⇛t₃₂
in _ · u₃ · (_ · u₃) ,
⇛-Sred s₁⇛t₁₂ s₂⇛t₂₂ t₃₁⇛u₃ ,
⇛-· (⇛-· ⇛-refl t₃₂⇛u₃) (⇛-· ⇛-refl t₃₂⇛u₃)
⇛-CR (⇛-· (⇛-· ⇛-refl s₂⇛t₂₁) s₃⇛t₃₁) (⇛-Sred s₁⇛t₁₂ s₂⇛t₂₂ s₃⇛t₃₂) =
let u₂ , t₂₁⇛u₂ , t₂₂⇛u₂ = ⇛-CR s₂⇛t₂₁ s₂⇛t₂₂
u₃ , t₃₁⇛u₃ , t₃₂⇛u₃ = ⇛-CR s₃⇛t₃₁ s₃⇛t₃₂
in _ · u₃ · (u₂ · u₃) ,
⇛-Sred s₁⇛t₁₂ t₂₁⇛u₂ t₃₁⇛u₃ ,
⇛-· (⇛-· ⇛-refl t₃₂⇛u₃) (⇛-· t₂₂⇛u₂ t₃₂⇛u₃)
⇛-CR (⇛-· (⇛-· (⇛-· ⇛-refl s₁⇛t₁₁) s₂⇛t₂₁) s₃⇛t₃₁)
(⇛-Sred s₁⇛t₁₂ s₂⇛t₂₂ s₃⇛t₃₂) =
let u₁ , t₁₁⇛u₁ , t₁₂⇛u₁ = ⇛-CR s₁⇛t₁₁ s₁⇛t₁₂
u₂ , t₂₁⇛u₂ , t₂₂⇛u₂ = ⇛-CR s₂⇛t₂₁ s₂⇛t₂₂
u₃ , t₃₁⇛u₃ , t₃₂⇛u₃ = ⇛-CR s₃⇛t₃₁ s₃⇛t₃₂
in u₁ · u₃ · (u₂ · u₃) ,
⇛-Sred t₁₁⇛u₁ t₂₁⇛u₂ t₃₁⇛u₃ ,
⇛-· (⇛-· t₁₂⇛u₁ t₃₂⇛u₃) (⇛-· t₂₂⇛u₂ t₃₂⇛u₃)
⇛-CR (⇛-· ⇛-refl _) (⇛-Kred s₁⇛t₂₁) =
_ , ⇛-Kred s₁⇛t₂₁ , ⇛-refl
⇛-CR (⇛-· (⇛-· ⇛-refl s₁⇛t₁₁) _) (⇛-Kred s₁⇛t₂₁) =
let u₁ , t₁₁⇛u₁ , t₂₁⇛u₁ = ⇛-CR s₁⇛t₁₁ s₁⇛t₂₁
in u₁ , ⇛-Kred t₁₁⇛u₁ , t₂₁⇛u₁
{-# CATCHALL #-}
⇛-CR (⇛-· s₁⇛t₁₁ s₂⇛t₂₁) (⇛-· s₁⇛t₁₂ s₂⇛t₂₂) =
let u₁ , t₁₁⇛u₁ , t₁₂⇛u₁ = ⇛-CR s₁⇛t₁₁ s₁⇛t₁₂
u₂ , t₂₁⇛u₂ , t₂₂⇛u₂ = ⇛-CR s₂⇛t₂₁ s₂⇛t₂₂
in u₁ · u₂ , ⇛-· t₁₁⇛u₁ t₂₁⇛u₂ , ⇛-· t₁₂⇛u₁ t₂₂⇛u₂
{-# CATCHALL #-}
⇛-CR s⇛t₁ ⇛-refl = _ , ⇛-refl , s⇛t₁
⇛-⇛*-CR : ∀ {s t₁ t₂} → s ⇛≤ t₁ → s ⇛≥* t₂ → ∃ λ u → t₁ ⇛≥* u × t₂ ⇛≤ u
⇛-⇛*-CR s⇛≤t ε = _ , ε , s⇛≤t
⇛-⇛*-CR s⇛≤u₁ (s⇛≥t₁ ◅ t₁⇛≥*t₂) =
let u₂ , u₁⇛≥u₂ , t₁⇛≤u₂ = ⇛-CR s⇛≤u₁ s⇛≥t₁
u₃ , u₂⇛≥*u₃ , t₂⇛≤u₃ = ⇛-⇛*-CR t₁⇛≤u₂ t₁⇛≥*t₂
in u₃ , u₁⇛≥u₂ ◅ u₂⇛≥*u₃ , t₂⇛≤u₃
⇛*-CR : ∀ {s t₁ t₂} → s ⇛≤* t₁ → s ⇛≥* t₂ → ∃ λ u → t₁ ⇛≥* u × t₂ ⇛≤* u
⇛*-CR ε s⇛≥*t = _ , s⇛≥*t , ε
⇛*-CR (s⇛≤t₁ ◅ t₁⇛≤*t₂) s⇛≥*u₁ =
let u₂ , t₁⇛≥*u₂ , u₁⇛≤u₂ = ⇛-⇛*-CR s⇛≤t₁ s⇛≥*u₁
u₃ , t₂⇛≥*u₃ , u₂⇛≤*u₃ = ⇛*-CR t₁⇛≤*t₂ t₁⇛≥*u₂
in u₃ , t₂⇛≥*u₃ , u₁⇛≤u₂ ◅ u₂⇛≤*u₃
-- Thanks to Church-Rosser, thee combined multi-step reduction is
-- transitive.
⇛≤*≤⇚-trans : ∀ {s t u} → s ⇛≤*≤⇚ t → t ⇛≤*≤⇚ u → s ⇛≤*≤⇚ u
⇛≤*≤⇚-trans (v , s⇛≤*v , t⇛≥*v) (w , t⇛≤*w , u⇛≥*w) =
let u′ , w⇛≥*u′ , v⇛≤*u′ = ⇛*-CR t⇛≤*w t⇛≥*v
in u′ , (s⇛≤*v ◅◅ v⇛≤*u′ , u⇛≥*w ◅◅ w⇛≥*u′)
-- The order on SK? terms is a subrelation of the combined multi-step
-- reduction (modulo squashing).
--
-- The two orders are in fact equivalent, but we don't need that
-- result here, so we omit its proof. Instead we will establish that
-- the two relations are both equivalent to _≡SK_ on pure SK terms
-- (see inject-⇛≤*≤⇚-≡SK below).
≤SK?--⇛≤*≤⇚ : ∀ {s t} → s ≤SK? t → s ⇛≤*≤⇚ t
≤SK?--⇛≤*≤⇚ ≤?-refl = (_ , ε , ε)
≤SK?--⇛≤*≤⇚ (≤?-trans s≤t t≤u) =
⇛≤*≤⇚-trans (≤SK?--⇛≤*≤⇚ s≤t) (≤SK?--⇛≤*≤⇚ t≤u)
≤SK?--⇛≤*≤⇚ ≤?-⊥ = (_ , ⇛-⊥ ◅ ε , ε)
≤SK?--⇛≤*≤⇚ ≤?-⊤ = (_ , ε , ⇛-⊤ ◅ ε)
≤SK?--⇛≤*≤⇚ ≤?-Sred = _ , ⇛-Sred ⇛-refl ⇛-refl ⇛-refl ◅ ε , ε
≤SK?--⇛≤*≤⇚ ≤?-Kred = _ , ⇛-Kred ⇛-refl ◅ ε , ε
≤SK?--⇛≤*≤⇚ ≤?-Sexp = _ , ε , ⇛-Sred ⇛-refl ⇛-refl ⇛-refl ◅ ε
≤SK?--⇛≤*≤⇚ ≤?-Kexp = _ , ε , ⇛-Kred ⇛-refl ◅ ε
≤SK?--⇛≤*≤⇚ (≤?-· s₁≤t₁ s₂≤t₂) =
let u₁ , s₁⇛u₁ , t₁⇛u₁ = ≤SK?--⇛≤*≤⇚ s₁≤t₁
u₂ , s₂⇛u₂ , t₂⇛u₂ = ≤SK?--⇛≤*≤⇚ s₂≤t₂
in u₁ · u₂ , ⇛*-· s₁⇛u₁ s₂⇛u₂ , ⇛*-· t₁⇛u₁ t₂⇛u₂
-- Reduction preserves pure terms.
⇛-Pure : ∀ {ab s t} (ps : Pure s) → s ⇛[ ab ] t →
∃ λ pt → inject⁻¹ ps ≡SK inject⁻¹ {t} pt
⇛-Pure p ⇛-refl = p , ≡-refl
⇛-Pure (S · ps₁ · pt₁ · pu₁) (⇛-Sred s₁⇛s₂ t₁⇛t₂ u₁⇛u₂) =
let ps₂ , s₁≡s₂ = ⇛-Pure ps₁ s₁⇛s₂
pt₂ , t₁≡t₂ = ⇛-Pure pt₁ t₁⇛t₂
pu₂ , u₁≡u₂ = ⇛-Pure pu₁ u₁⇛u₂
in ps₂ · pu₂ · (pt₂ · pu₂) ,
≡-trans (≡-· (≡-· (≡-· ≡-refl s₁≡s₂) t₁≡t₂) u₁≡u₂) ≡-Sred
⇛-Pure (K · ps₁ · _) (⇛-Kred s₁⇛s₂) =
let ps₂ , s₁≡s₂ = ⇛-Pure ps₁ s₁⇛s₂
in ps₂ , ≡-trans ≡-Kred s₁≡s₂
⇛-Pure (ps · pt) (⇛-· s₁⇛s₂ t₁⇛t₂) =
Prod.zip _·_ ≡-· (⇛-Pure ps s₁⇛s₂) (⇛-Pure pt t₁⇛t₂)
⇛*-Pure : ∀ {ab s t} (ps : Pure s) → s ⇛[ ab ]* t →
∃ λ pt → inject⁻¹ ps ≡SK inject⁻¹ {t} pt
⇛*-Pure p ε = p , ≡-refl
⇛*-Pure ps (s⇛t ◅ t⇛*u) =
let pt , s≡t = ⇛-Pure ps s⇛t
pu , t≡u = ⇛*-Pure pt t⇛*u
in pu , ≡-trans s≡t t≡u
-- The combined multi-step reduction is a subrelation of ≡SK on pure terms.
inject-⇛≤*≤⇚-≡SK : ∀ {s t} → inject s ⇛≤*≤⇚ inject t → s ≡SK t
inject-⇛≤*≤⇚-≡SK {s} {t} (u , s⇛≤*u , t⇛≥*u) =
let pu , s≡u = ⇛*-Pure (inject-Pure s) s⇛≤*u
pu′ , t≡u = ⇛*-Pure (inject-Pure t) t⇛≥*u
in ≡-trans (subst (_≡SK (inject⁻¹ pu)) (inject⁻¹-inject-Pure s) s≡u)
(subst₂ (_≡SK_) (inject⁻¹-unique pu′ pu) (inject⁻¹-inject-Pure t)
(≡-sym t≡u))
-- The order on SK? terms is a subrelation of the equality on pure SK
-- terms.
--
-- NOTE. This establishes a circular equivalence between the three
-- relations _≡SK_, _⇛≤*≤⇚_ and _≤SK?_ when restricted to pure SK
-- terms:
--
-- _≡SK_ ⊆ _≤SK?_ ⊆ _⇛≤*≤⇚_ ⊆ _≡SK_
--
-- This equivalence will allow us to encode/extract equivalence proofs
-- on (pure) SK terms from typing derivations.
inject-≤SK?-≡SK : ∀ {s t} → inject s ≤SK? inject t → s ≡SK t
inject-≤SK?-≡SK {s} {t} s≤t = inject-⇛≤*≤⇚-≡SK (≤SK?--⇛≤*≤⇚ s≤t)
|
{
"alphanum_fraction": 0.4705882353,
"avg_line_length": 35.8571428571,
"ext": "agda",
"hexsha": "dcb120169094163c31b226995e21346bf823fae2",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2021-05-14T10:25:05.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-05-13T22:29:48.000Z",
"max_forks_repo_head_hexsha": "ae20dac2a5e0c18dff2afda4c19954e24d73a24f",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Blaisorblade/f-omega-int-agda",
"max_forks_repo_path": "src/FOmegaInt/Undecidable/SK.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "ae20dac2a5e0c18dff2afda4c19954e24d73a24f",
"max_issues_repo_issues_event_max_datetime": "2021-05-14T08:54:39.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-05-14T08:09:40.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Blaisorblade/f-omega-int-agda",
"max_issues_repo_path": "src/FOmegaInt/Undecidable/SK.agda",
"max_line_length": 81,
"max_stars_count": 12,
"max_stars_repo_head_hexsha": "ae20dac2a5e0c18dff2afda4c19954e24d73a24f",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Blaisorblade/f-omega-int-agda",
"max_stars_repo_path": "src/FOmegaInt/Undecidable/SK.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-27T05:53:06.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-06-13T16:05:35.000Z",
"num_tokens": 8186,
"size": 12801
}
|
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020 Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import Optics.All
open import LibraBFT.Prelude
open import LibraBFT.Hash
open import LibraBFT.Lemmas
open import LibraBFT.Base.KVMap
open import LibraBFT.Base.PKCS
open import LibraBFT.Abstract.Types
open EpochConfig
open import LibraBFT.Impl.NetworkMsg
open import LibraBFT.Impl.Consensus.Types
open import LibraBFT.Impl.Util.Crypto
open import LibraBFT.Impl.Handle sha256 sha256-cr
open import LibraBFT.Concrete.System.Parameters
open import LibraBFT.Yasm.Base
open import LibraBFT.Yasm.AvailableEpochs using (AvailableEpochs ; lookup'; lookup'')
open import LibraBFT.Yasm.System ConcSysParms
open import LibraBFT.Yasm.Properties ConcSysParms
-- In this module, we define two "implementation obligations"
-- (ImplObligationᵢ for i ∈ {1 , 2}), which are predicates over
-- reachable states of a system defined by
-- 'LibraBFT.Concrete.System.Parameters'. These two properties relate
-- votes sent by the same sender, ensuring that if they are for the
-- same epoch and round, then they vote for the same blockID; the
-- first relates a vote output by the handler to a vote sent
-- previously, and the second relates two votes both sent by the
-- handler.
--
-- We then prove that, if an implementation satisfies these two
-- semantic obligations, along with a structural one about messages
-- sent by honest peers in the implementation, then the implemenation
-- satisfies the LibraBFT.Abstract.Properties.VotesOnce invariant.
module LibraBFT.Concrete.Properties.VotesOnce where
-- TODO-3: This may not be the best way to state the implementation obligation. Why not reduce
-- this as much as possible before giving the obligation to the implementation? For example, this
-- will still require the implementation to deal with hash collisons (v and v' could be different,
-- but yield the same bytestring and therefore same signature). Also, avoid the need for the
-- implementation to reason about messages sent by step-cheat, or give it something to make this
-- case easy to eliminate.
ImplObligation₁ : Set₁
ImplObligation₁ =
∀{e pid sndr s' outs pk}{pre : SystemState e}
→ ReachableSystemState pre
-- For any honest call to /handle/ or /init/,
→ StepPeerState pid (availEpochs pre) (msgPool pre) (Map-lookup pid (peerStates pre)) s' outs
→ ∀{v m v' m'} → Meta-Honest-PK pk
-- For signed every vote v of every outputted message
→ v ⊂Msg m → m ∈ outs → (sig : WithVerSig pk v)
-- If v is really new and valid
-- Note that this does not directly exclude possibility of previous message with
-- same signature, but sent by someone else. We could prove it implies it though.
→ ¬ (MsgWithSig∈ pk (ver-signature sig) (msgPool pre)) → ValidPartForPK (availEpochs pre) v pk
-- And if there exists another v' that has been sent before
→ v' ⊂Msg m' → (sndr , m') ∈ (msgPool pre) → WithVerSig pk v'
-- If v and v' share the same epoch and round
→ (v ^∙ vEpoch) ≡ (v' ^∙ vEpoch)
→ (v ^∙ vProposed ∙ biRound) ≡ (v' ^∙ vProposed ∙ biRound)
----------------------------------------------------------
-- Then an honest implemenation promises v and v' vote for the same blockId.
→ (v ^∙ vProposed ∙ biId) ≡ (v' ^∙ vProposed ∙ biId)
ImplObligation₂ : Set₁
ImplObligation₂ =
∀{e pid s' outs pk}{pre : SystemState e}
→ ReachableSystemState pre
-- For any honest call to /handle/ or /init/,
→ StepPeerState pid (availEpochs pre) (msgPool pre) (Map-lookup pid (peerStates pre)) s' outs
→ ∀{v m v' m'} → Meta-Honest-PK pk
-- For every vote v represented in a message output by the call
→ v ⊂Msg m → m ∈ outs → (sig : WithVerSig pk v)
-- If v is really new and valid
→ ¬ (MsgWithSig∈ pk (ver-signature sig) (msgPool pre)) → ValidPartForPK (availEpochs pre) v pk
-- And if there exists another v' that is also new and valid
→ v' ⊂Msg m' → m' ∈ outs → (sig' : WithVerSig pk v')
→ ¬ (MsgWithSig∈ pk (ver-signature sig') (msgPool pre)) → ValidPartForPK (availEpochs pre) v' pk
-- If v and v' share the same epoch and round
→ (v ^∙ vEpoch) ≡ (v' ^∙ vEpoch)
→ (v ^∙ vProposed ∙ biRound) ≡ (v' ^∙ vProposed ∙ biRound)
----------------------------------------------------------
-- Then, an honest implemenation promises v and v' vote for the same blockId.
→ (v ^∙ vProposed ∙ biId) ≡ (v' ^∙ vProposed ∙ biId)
-- Next, we prove that, given the necessary obligations,
module Proof
(sps-corr : StepPeerState-AllValidParts)
(Impl-VO1 : ImplObligation₁)
(Impl-VO2 : ImplObligation₂)
where
-- Any reachable state satisfies the VO rule for any epoch in the system.
module _ {e}(st : SystemState e)(r : ReachableSystemState st)(eid : Fin e) where
-- Bring in 'unwind', 'ext-unforgeability' and friends
open Structural sps-corr
-- Bring in ConcSystemState
open import LibraBFT.Concrete.System sps-corr
open PerState st r
open PerEpoch eid
open import LibraBFT.Abstract.Obligations.VotesOnce 𝓔 Hash _≟Hash_ (ConcreteVoteEvidence 𝓔) as VO
-- The VO proof is done by induction on the execution trace leading to 'st'. In
-- Agda, this is 'r : RechableSystemState st' above. We will use induction to
-- construct a predicate Pred'' below, which holds for every state on the trace.
private
-- First we specify the predicate we need: it relates two votes verified
-- by the same public key, such that both are elements of the same message pool
Pred'' : PK → Vote → Vote → SentMessages → Set
Pred'' pk v v' pool
= Meta-Honest-PK pk
→ (ver : WithVerSig pk v) → MsgWithSig∈ pk (ver-signature ver) pool
→ (ver' : WithVerSig pk v') → MsgWithSig∈ pk (ver-signature ver') pool
→ v ^∙ vEpoch ≡ v' ^∙ vEpoch
→ v ^∙ vRound ≡ v' ^∙ vRound
→ v ^∙ vProposedId ≡ v' ^∙ vProposedId
-- Usually, we want to universally quantify Pred'' over arbitrary votes and pks
Pred' : SentMessages → Set
Pred' pool = ∀{pk}{v v' : Vote} → Pred'' pk v v' pool
-- Finally, we state Pred' in terms of SystemSate
Pred : ∀{e} → SystemState e → Set
Pred = Pred' ∘ msgPool
-------------------
-- * Base Case * --
-------------------
-- Pred above is trivially true for the initial state: there are no messages in the pool
Pred₀ : Pred initialState
Pred₀ _ _ ()
--------------------------------------------------
-- * Inductive Case: New Epochs in the System * --
--------------------------------------------------
-- Because pushEpoch does not alter the msgPool, the proof is trivial.
Pred𝓔 : ∀{e}{st : SystemState e}(𝓔 : EpochConfigFor e) → Pred st → Pred (pushEpoch 𝓔 st)
Pred𝓔 𝓔 p = p
----------------------------------------------
-- * Inductive Case: Transition by a Peer * --
----------------------------------------------
-- From this point onwards, it might be easier to read this proof starting at 'voo'
-- at the end of the file. Next, we provide an overview the proof.
--
-- We wish to prove that, for any two votes v and v' cast by an honest α in the message pool of
-- a state st, if v and v' have equal rounds and epochs, then they vote for the same block. As
-- we have seen above, the base case and the case for a new epoch in the system are
-- trivial. Next, we look at the PeerStep case.
--
-- The induction hypothesis tells us that the property holds in the pre-state. Next, we reason
-- about the post-state. We start by analyzing whether v and v' have been sent as outputs of
-- the PeerStep under scrutiny or were already in the pool before (captured by the PredStep
-- function). There are four possibilities:
--
-- i) v and v' were aleady present in the msgPool before: use induction hypothesis.
-- ii) v and v' are both in the output produced by the PeerStep under scrutiny.
-- iii) v was present before, but v' is new.
-- iv) v' was present before, but v is new.
--
-- Case (i) is trivial; cases (iii) and (iv) are symmetric and reduce to an implementation
-- obligation (Impl-VO1) and case (ii) reduces to a different implementation obligation (Impl-VO2).
--
-- The proofs of cases (iii) and (iv) are in PredStep-wlog-ht and PredStep-wlog-ht'. The 'ht'
-- suffix refers to 'Here-There' as in one vote is "here" and the other is old, or "there". We
-- first analyze whether the new vote is really new or a replay; sps-cor provides us this
-- information. If the new vote is, in fact, a replay of an old message, we have two old
-- messages and can call the induction hypothesis. If it is really new, we must rely on the
-- implementation obligation. But to do so, we must prove that the old vote was also sent by
-- the same peer. We can see that is the case by reasoning about PK-inj and IsValidEpochMember.
--
-- Finally, the proof of case (ii) also branches on whether either of the "new" votes
-- are replays or are really new. In case at least one is a replay we fallback to cases (iii) and (iv)
-- or just call the induction hypothesis when both are replays.
-- When both votes are in fact new, we rely on Impl-VO2 to conclude.
--
-- In both PredSetp-wlog-ht and PredStep-wlog-hh, we must eliminate the possibility of
-- either vote being produced by a cheat step. This is easy because we received
-- a proof that the PK in question is honest, hence, it must be the case that a cheat
-- step is at most replaying these votes, not producing them. Producing them would
-- require the cheater to forge a signature. This is the purpose of the isCheat constraint.
PredStep-wlog-ht' : ∀{e pid pid' s' outs pk}{pre : SystemState e}
→ ReachableSystemState pre
→ Pred pre
→ StepPeerState pid (availEpochs pre) (msgPool pre) (Map-lookup pid (peerStates pre)) s' outs
→ ∀{v m v' m'}
→ v ⊂Msg m → m ∈ outs
→ v' ⊂Msg m' → (pid' , m') ∈ msgPool pre
→ WithVerSig pk v → WithVerSig pk v' → Meta-Honest-PK pk
→ (v ^∙ vEpoch) ≡ (v' ^∙ vEpoch)
→ (v ^∙ vProposed ∙ biRound) ≡ (v' ^∙ vProposed ∙ biRound)
→ (v ^∙ vProposed ∙ biId) ≡ (v' ^∙ vProposed ∙ biId)
PredStep-wlog-ht' {pre = pre} preach hip ps {v} v⊂m m∈outs v'⊂m' m'∈pool ver ver' hpk eids≡ r≡
-- (1) The first step is branching on whether 'v' above is a /new/ vote or not.
-- (1.1) If it's new:
with sps-corr preach hpk ps m∈outs v⊂m ver
...| inj₁ (vValid , vNew)
with honestPartValid preach hpk v'⊂m' m'∈pool ver'
...| v'Old , vOldValid
with sameHonestSig⇒sameVoteData hpk ver' (msgSigned v'Old) (sym (msgSameSig v'Old))
...| inj₁ abs = ⊥-elim (meta-sha256-cr abs)
...| inj₂ refl = Impl-VO1 preach ps hpk v⊂m m∈outs ver vNew vValid
(msg⊆ v'Old) (msg∈pool v'Old)
(msgSigned v'Old) eids≡ r≡
-- (1.1) If 'v' is not new, then there exists a msg sent with the
-- same signature.
PredStep-wlog-ht' preach hip ps {v} v⊂m m∈outs v'⊂m' m'∈pool ver ver' hpk e≡ r≡
| inj₂ vOld
with honestPartValid preach hpk v'⊂m' m'∈pool ver'
...| sv' , _ = hip hpk ver vOld ver' sv' e≡ r≡
-- Here we prove a modified version of Pred'' where we assume w.l.o.g that
-- one vote is sent by "pstep" and another was present in the prestate.
PredStep-wlog-ht
: ∀{e pid st' outs}{pre : SystemState e}
→ ReachableSystemState pre
→ (pstep : StepPeer pre pid st' outs)
→ Pred pre
→ ∀{pk v v'}
-- Below is a inline expansion of "Pred'' pk v v' (msgPool (StepPeer-post pstep))",
-- but with the added information that one vote (v) was sent by pstep whereas the
-- other (v') was in the pool of the prestate.
→ let pool = msgPool (StepPeer-post pstep)
in Meta-Honest-PK pk
→ (ver : WithVerSig pk v )(sv : MsgWithSig∈ pk (ver-signature ver ) pool)
→ (msgSender sv , msgWhole sv) ∈ List-map (pid ,_) outs
→ (ver' : WithVerSig pk v')(sv' : MsgWithSig∈ pk (ver-signature ver') pool)
→ (msgSender sv' , msgWhole sv') ∈ msgPool pre
→ v ^∙ vEpoch ≡ v' ^∙ vEpoch
→ v ^∙ vRound ≡ v' ^∙ vRound
→ v ^∙ vProposedId ≡ v' ^∙ vProposedId
PredStep-wlog-ht preach (step-cheat fm isCheat) hip hpk ver sv (here refl) ver' sv' furtherBack' epoch≡ r≡
with isCheat (msg⊆ sv) (msgSigned sv)
...| inj₁ abs = ⊥-elim (hpk abs) -- The key was honest by hypothesis.
...| inj₂ sentb4
-- the cheater replayed the message; which means the message was sent before this
-- step; hence, call induction hypothesis.
with msgSameSig sv
...| refl = hip hpk ver sentb4 ver' (MsgWithSig∈-transp sv' furtherBack') epoch≡ r≡
PredStep-wlog-ht preach (step-honest x) hip hpk ver sv thisStep ver' sv' furtherBack' epoch≡ r≡
with sameHonestSig⇒sameVoteData hpk ver (msgSigned sv) (sym (msgSameSig sv))
...| inj₁ abs = ⊥-elim (meta-sha256-cr abs)
...| inj₂ refl
with sameHonestSig⇒sameVoteData hpk ver' (msgSigned sv') (sym (msgSameSig sv'))
...| inj₁ abs = ⊥-elim (meta-sha256-cr abs)
...| inj₂ refl
= PredStep-wlog-ht' preach hip x
(msg⊆ sv) (Any-map (cong proj₂) (Any-map⁻ thisStep))
(msg⊆ sv') furtherBack'
(msgSigned sv) (msgSigned sv') hpk epoch≡ r≡
-- Analogous to PredStep-wlog-ht', but here we must reason about two messages that are in the
-- outputs of a step.
PredStep-hh' : ∀{e pid s' outs pk}{pre : SystemState e}
→ ReachableSystemState pre → Pred pre
→ StepPeerState pid (availEpochs pre) (msgPool pre) (Map-lookup pid (peerStates pre)) s' outs
→ ∀{v m v' m'}
→ v ⊂Msg m → m ∈ outs
→ v' ⊂Msg m' → m' ∈ outs
→ WithVerSig pk v → WithVerSig pk v' → Meta-Honest-PK pk
→ (v ^∙ vEpoch) ≡ (v' ^∙ vEpoch)
→ (v ^∙ vProposed ∙ biRound) ≡ (v' ^∙ vProposed ∙ biRound)
→ (v ^∙ vProposed ∙ biId) ≡ (v' ^∙ vProposed ∙ biId)
-- Since the step is from an honest peer, we can check whether the messages are in fact
-- new or not.
PredStep-hh' preach hip ps {v} v⊂m m∈outs v'⊂m' m'∈outs ver ver' hpk e≡ r≡
with sps-corr preach hpk ps m∈outs v⊂m ver | sps-corr preach hpk ps m'∈outs v'⊂m' ver'
-- (A) Both are old: call induction hypothesis
...| inj₂ vOld | inj₂ v'Old = hip hpk ver vOld ver' v'Old e≡ r≡
-- (B) One is new, one is old: use PredStep-wlog-ht'
PredStep-hh' preach hip ps {v} v⊂m m∈outs v'⊂m' m'∈outs ver ver' hpk e≡ r≡
| inj₁ (vValid , vNew) | inj₂ v'Old
with sameHonestSig⇒sameVoteData hpk ver' (msgSigned v'Old) (sym (msgSameSig v'Old))
...| inj₁ abs = ⊥-elim (meta-sha256-cr abs)
...| inj₂ refl
= PredStep-wlog-ht' preach hip ps v⊂m m∈outs (msg⊆ v'Old) (msg∈pool v'Old) ver (msgSigned v'Old) hpk e≡ r≡
-- (C) One is old, one is new: use PredStep-wlog-ht'
PredStep-hh' preach hip ps {v} v⊂m m∈outs v'⊂m' m'∈outs ver ver' hpk e≡ r≡
| inj₂ vOld | inj₁ (v'Valid , v'New)
with sameHonestSig⇒sameVoteData hpk ver (msgSigned vOld) (sym (msgSameSig vOld))
...| inj₁ abs = ⊥-elim (meta-sha256-cr abs)
...| inj₂ refl
= sym (PredStep-wlog-ht' preach hip ps v'⊂m' m'∈outs (msg⊆ vOld) (msg∈pool vOld) ver' (msgSigned vOld) hpk (sym e≡) (sym r≡))
-- (D) Finally, both votes are new in this step. The proof is then trivially
-- forwarded to the implementation obligation.
PredStep-hh' preach hip ps {v} v⊂m m∈outs v'⊂m' m'∈outs ver ver' hpk e≡ r≡
| inj₁ (vValid , vNew) | inj₁ (v'Valid , v'New)
= Impl-VO2 preach ps hpk v⊂m m∈outs ver vNew vValid v'⊂m' m'∈outs ver' v'New v'Valid e≡ r≡
PredStep-hh
: ∀{e pid st' outs}{pre : SystemState e}
→ ReachableSystemState pre
→ (pstep : StepPeer pre pid st' outs)
→ Pred pre
→ ∀{pk v v'}
→ let pool = msgPool (StepPeer-post pstep)
in Meta-Honest-PK pk
→ (ver : WithVerSig pk v )(sv : MsgWithSig∈ pk (ver-signature ver ) pool)
→ (msgSender sv , msgWhole sv) ∈ List-map (pid ,_) outs
→ (ver' : WithVerSig pk v')(sv' : MsgWithSig∈ pk (ver-signature ver') pool)
→ (msgSender sv' , msgWhole sv') ∈ List-map (pid ,_) outs
→ v ^∙ vEpoch ≡ v' ^∙ vEpoch
→ v ^∙ vRound ≡ v' ^∙ vRound
→ v ^∙ vProposedId ≡ v' ^∙ vProposedId
PredStep-hh preach (step-cheat fm isCheat) hip hpk ver sv (here refl) ver' sv' (here refl) epoch≡ r≡
with isCheat (msg⊆ sv) (msgSigned sv)
...| inj₁ abs = ⊥-elim (hpk abs) -- The key was honest by hypothesis.
...| inj₂ sentb4
with isCheat (msg⊆ sv') (msgSigned sv')
...| inj₁ abs = ⊥-elim (hpk abs) -- The key was honest by hypothesis.
...| inj₂ sentb4'
with msgSameSig sv | msgSameSig sv'
...| refl | refl = hip hpk ver sentb4 ver' sentb4' epoch≡ r≡
PredStep-hh preach (step-honest x) hip hpk ver sv thisStep ver' sv' thisStep' epoch≡ r≡
with sameHonestSig⇒sameVoteData hpk ver (msgSigned sv) (sym (msgSameSig sv))
...| inj₁ abs = ⊥-elim (meta-sha256-cr abs)
...| inj₂ refl
with sameHonestSig⇒sameVoteData hpk ver' (msgSigned sv') (sym (msgSameSig sv'))
...| inj₁ abs = ⊥-elim (meta-sha256-cr abs)
...| inj₂ refl
= PredStep-hh' preach hip x
(msg⊆ sv ) (Any-map (cong proj₂) (Any-map⁻ thisStep))
(msg⊆ sv') (Any-map (cong proj₂) (Any-map⁻ thisStep'))
(msgSigned sv) (msgSigned sv') hpk epoch≡ r≡
PredStep : ∀{e pid st' outs}{pre : SystemState e}
→ ReachableSystemState pre
→ (pstep : StepPeer pre pid st' outs)
→ Pred pre
→ Pred (StepPeer-post pstep)
PredStep {e} {pid} {st'} {outs} {pre} preach pstep hip hpk ver sv ver' sv' epoch≡ r≡
-- First we check when have the votes been sent:
with Any-++⁻ (List-map (pid ,_) outs) {msgPool pre} (msg∈pool sv)
| Any-++⁻ (List-map (pid ,_) outs) {msgPool pre} (msg∈pool sv')
-- (A) Neither vote has been sent by the step under scrutiny: invoke inductive hypothesis
...| inj₂ furtherBack | inj₂ furtherBack'
= hip hpk ver (MsgWithSig∈-transp sv furtherBack)
ver' (MsgWithSig∈-transp sv' furtherBack') epoch≡ r≡
-- (B) One vote was cast here; the other was cast in the past.
PredStep {e} {pid} {st'} {outs} {pre} preach pstep hip hpk ver sv ver' sv' epoch≡ r≡
| inj₁ thisStep | inj₂ furtherBack'
= PredStep-wlog-ht preach pstep hip hpk ver sv thisStep ver' sv' furtherBack' epoch≡ r≡
-- (C) Symmetric to (B)
PredStep {e} {pid} {st'} {outs} {pre} preach pstep hip hpk ver sv ver' sv' epoch≡ r≡
| inj₂ furtherBack | inj₁ thisStep'
= sym (PredStep-wlog-ht preach pstep hip hpk ver' sv' thisStep' ver sv furtherBack (sym epoch≡) (sym r≡))
-- (D) Both votes were cast here
PredStep {e} {pid} {st'} {outs} {pre} preach pstep hip hpk ver sv ver' sv' epoch≡ r≡
| inj₁ thisStep | inj₁ thisStep'
= PredStep-hh preach pstep hip hpk ver sv thisStep ver' sv' thisStep' epoch≡ r≡
voo : VO.Type ConcSystemState
voo hpk refl sv refl sv' round≡
with Step*-Step-fold Pred (λ {e} {st} _ → Pred𝓔 {e} {st}) PredStep Pred₀ r
...| res
with vmsg≈v (vmFor sv) | vmsg≈v (vmFor sv')
...| refl | refl
= res hpk (vmsgSigned (vmFor sv))
(mkMsgWithSig∈ (nm (vmFor sv)) (cv (vmFor sv)) (cv∈nm (vmFor sv))
_ (nmSentByAuth sv) (vmsgSigned (vmFor sv)) refl)
(vmsgSigned (vmFor sv'))
(mkMsgWithSig∈ (nm (vmFor sv')) (cv (vmFor sv')) (cv∈nm (vmFor sv'))
_ (nmSentByAuth sv') (vmsgSigned (vmFor sv')) refl)
(trans (vmsgEpoch (vmFor sv)) (sym (vmsgEpoch (vmFor sv'))))
round≡
|
{
"alphanum_fraction": 0.6210817759,
"avg_line_length": 52.2635658915,
"ext": "agda",
"hexsha": "609830bdd8066304fdda11b4d75a251a85997d19",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b7dd98dd90d98fbb934ef8cb4f3314940986790d",
"max_forks_repo_licenses": [
"UPL-1.0"
],
"max_forks_repo_name": "lisandrasilva/bft-consensus-agda-1",
"max_forks_repo_path": "LibraBFT/Concrete/Properties/VotesOnce.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b7dd98dd90d98fbb934ef8cb4f3314940986790d",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"UPL-1.0"
],
"max_issues_repo_name": "lisandrasilva/bft-consensus-agda-1",
"max_issues_repo_path": "LibraBFT/Concrete/Properties/VotesOnce.agda",
"max_line_length": 132,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "b7dd98dd90d98fbb934ef8cb4f3314940986790d",
"max_stars_repo_licenses": [
"UPL-1.0"
],
"max_stars_repo_name": "lisandrasilva/bft-consensus-agda-1",
"max_stars_repo_path": "LibraBFT/Concrete/Properties/VotesOnce.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 6458,
"size": 20226
}
|
{-# OPTIONS --cubical-compatible #-}
data D : Set → Set₁ where
c : (@0 A : Set) → D A
|
{
"alphanum_fraction": 0.5505617978,
"avg_line_length": 17.8,
"ext": "agda",
"hexsha": "9a96f2a7ca2e97998c413452d1d5a732b1833507",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "KDr2/agda",
"max_forks_repo_path": "test/Fail/Issue5434-1.agda",
"max_issues_count": 6,
"max_issues_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_issues_repo_issues_event_max_datetime": "2021-11-24T08:31:10.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-10-18T08:12:24.000Z",
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "KDr2/agda",
"max_issues_repo_path": "test/Fail/Issue5434-1.agda",
"max_line_length": 36,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "KDr2/agda",
"max_stars_repo_path": "test/Fail/Issue5434-1.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 30,
"size": 89
}
|
module ANF where
open import Data.List
open import Data.List.All
open import Typing
open import DSyntax
open import Syntax
-- transform a direct style expression into and anf expression
anf : ∀ {φ t} → DExpr φ t → Expr φ t
anf (var x) = var x
anf (nat unr-φ i) = nat unr-φ i
anf (unit unr-φ) = unit unr-φ
anf (pair sp de de₁) = letbind sp (anf de) (letbind (rght (split-all-left _)) (anf de₁) (pair (rght (left [])) (here []) (here [])))
anf (letpair sp de de₁) = letbind sp (anf de) (letpair (left (split-all-right _)) (here []) (anf de₁))
anf (fork de) = fork (anf de)
anf (new unr-φ s) = new unr-φ s
anf (send sp de de₁) = letbind sp (anf de) (letbind (rght (split-all-left _)) (anf de₁) (send (rght (left [])) (here []) (here [])))
anf (recv de) = letbind (split-all-left _) (anf de) (recv (here []))
anf (close de) = letbind (split-all-left _) (anf de) (close (here []))
anf (wait de) = letbind (split-all-left _) (anf de) (wait (here []))
anf (select lab de) = letbind (split-all-left _) (anf de) (select lab (here []))
anf (branch sp de de₁ de₂) = letbind sp (anf de) (branch (left (split-all-right _)) (here []) (anf de₁) (anf de₂))
anf (ulambda unr-φ de) = ulambda (split-all-left _) unr-φ [] (anf de)
anf (llambda de) = llambda (split-all-left _) [] (anf de)
anf (app sp de de₁) = letbind sp (anf de) (letbind (rght (split-all-left _)) (anf de₁) (app (rght (left [])) (here []) (here [])))
anf (subsume de t≤t') = subsume (anf de) t≤t'
|
{
"alphanum_fraction": 0.6331034483,
"avg_line_length": 48.3333333333,
"ext": "agda",
"hexsha": "98a1088760dfe98bdd1b43f7143554f9538a9095",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "c2213909c8a308fb1c1c1e4e789d65ba36f6042c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "peterthiemann/definitional-session",
"max_forks_repo_path": "src/ANF.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c2213909c8a308fb1c1c1e4e789d65ba36f6042c",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "peterthiemann/definitional-session",
"max_issues_repo_path": "src/ANF.agda",
"max_line_length": 132,
"max_stars_count": 9,
"max_stars_repo_head_hexsha": "c2213909c8a308fb1c1c1e4e789d65ba36f6042c",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "peterthiemann/definitional-session",
"max_stars_repo_path": "src/ANF.agda",
"max_stars_repo_stars_event_max_datetime": "2021-01-18T08:10:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-01-19T16:33:27.000Z",
"num_tokens": 545,
"size": 1450
}
|
{-# OPTIONS --without-K #-}
open import homotopy.3x3.Common
open import homotopy.3x3.PushoutPushout
module homotopy.3x3.Transpose where
open M using (Pushout^2)
type-of : ∀ {i} {A : Type i} (u : A) → Type i
type-of {A = A} _ = A
module _ {i} (d : Span^2 {i}) where
open Span^2 d
transpose-f : (f : type-of H₁₁ → _) (g : type-of H₃₃ → _) → Span^2
transpose-f f g = span^2 A₀₀ A₂₀ A₄₀ A₀₂ A₂₂ A₄₂ A₀₄ A₂₄ A₄₄
f₁₀ f₃₀ f₁₂ f₃₂ f₁₄ f₃₄ f₀₁ f₀₃ f₂₁ f₂₃ f₄₁ f₄₃
(f H₁₁) H₃₁ H₁₃ (g H₃₃)
transpose : Span^2
transpose = span^2 A₀₀ A₂₀ A₄₀ A₀₂ A₂₂ A₄₂ A₀₄ A₂₄ A₄₄
f₁₀ f₃₀ f₁₂ f₃₂ f₁₄ f₃₄ f₀₁ f₀₃ f₂₁ f₂₃ f₄₁ f₄₃
(! ∘ H₁₁) H₃₁ H₁₃ (! ∘ H₃₃)
ch1 : ∀ {i j} {A : Type i} {x y : A} {p : x == y} {f g : A → Type j} {a : f x → g x} {b : f y → g y}
→ (a == b [ (λ u → f u → g u) ↓ p ]) → (a == b [ (λ u → fst u → snd u) ↓ pair×= (ap f p) (ap g p)])
ch1 {p = idp} α = α
ch2 : ∀ {i j} {X : Type i} {x y : X} {p : x == y}
{A B₁ B₂ C : X → Type j}
{f₁ : (x : X) → A x → B₁ x} {g₁ : (x : X) → B₁ x → C x}
{f₂ : (x : X) → A x → B₂ x} {g₂ : (x : X) → B₂ x → C x}
{a : _} {b : _}
→ (a == b [ (λ z → (x : A z) → g₁ z (f₁ z x) == g₂ z (f₂ z x)) ↓ p ])
→ (a == b [ (λ u → (x : SquareFunc.A u) → SquareFunc.g₁ u (SquareFunc.f₁ u x) == SquareFunc.g₂ u (SquareFunc.f₂ u x))
↓ square=-raw (ap A p) (ap B₁ p) (ap B₂ p) (ap C p) (ch1 (apd f₁ p)) (ch1 (apd f₂ p)) (ch1 (apd g₁ p)) (ch1 (apd g₂ p)) ])
ch2 {p = idp} α = α
ap-span^2=-priv : ∀ {i} {d d' : Span^2 {i}} (p : d == d')
→ ap transpose p == span^2=-raw (ap Span^2.A₀₀ p) (ap Span^2.A₂₀ p) (ap Span^2.A₄₀ p)
(ap Span^2.A₀₂ p) (ap Span^2.A₂₂ p) (ap Span^2.A₄₂ p)
(ap Span^2.A₀₄ p) (ap Span^2.A₂₄ p) (ap Span^2.A₄₄ p)
(ch1 (apd Span^2.f₁₀ p)) (ch1 (apd Span^2.f₃₀ p))
(ch1 (apd Span^2.f₁₂ p)) (ch1 (apd Span^2.f₃₂ p))
(ch1 (apd Span^2.f₁₄ p)) (ch1 (apd Span^2.f₃₄ p))
(ch1 (apd Span^2.f₀₁ p)) (ch1 (apd Span^2.f₀₃ p))
(ch1 (apd Span^2.f₂₁ p)) (ch1 (apd Span^2.f₂₃ p))
(ch1 (apd Span^2.f₄₁ p)) (ch1 (apd Span^2.f₄₃ p))
(ch2 (ap↓ (λ u → ! ∘ u) (apd Span^2.H₁₁ p))) (ch2 (apd Span^2.H₃₁ p))
(ch2 (apd Span^2.H₁₃ p)) (ch2 (ap↓ (λ u → ! ∘ u) (apd Span^2.H₃₃ p)))
ap-span^2=-priv {i} {d} {.d} idp = idp
ap-span^2=-priv2 : ∀ {i}
{A₀₀ A₀₀' : Type i} (eq-A₀₀ : A₀₀ == A₀₀')
{A₀₂ A₀₂' : Type i} (eq-A₀₂ : A₀₂ == A₀₂')
{A₀₄ A₀₄' : Type i} (eq-A₀₄ : A₀₄ == A₀₄')
{A₂₀ A₂₀' : Type i} (eq-A₂₀ : A₂₀ == A₂₀')
{A₂₂ A₂₂' : Type i} (eq-A₂₂ : A₂₂ == A₂₂')
{A₂₄ A₂₄' : Type i} (eq-A₂₄ : A₂₄ == A₂₄')
{A₄₀ A₄₀' : Type i} (eq-A₄₀ : A₄₀ == A₄₀')
{A₄₂ A₄₂' : Type i} (eq-A₄₂ : A₄₂ == A₄₂')
{A₄₄ A₄₄' : Type i} (eq-A₄₄ : A₄₄ == A₄₄')
{f₀₁ : A₀₂ → A₀₀} {f₀₁' : A₀₂' → A₀₀'} (eq-f₀₁ : f₀₁ == f₀₁' [ (λ u → fst u → snd u) ↓ pair×= eq-A₀₂ eq-A₀₀ ])
{f₀₃ : A₀₂ → A₀₄} {f₀₃' : A₀₂' → A₀₄'} (eq-f₀₃ : f₀₃ == f₀₃' [ (λ u → fst u → snd u) ↓ pair×= eq-A₀₂ eq-A₀₄ ])
{f₂₁ : A₂₂ → A₂₀} {f₂₁' : A₂₂' → A₂₀'} (eq-f₂₁ : f₂₁ == f₂₁' [ (λ u → fst u → snd u) ↓ pair×= eq-A₂₂ eq-A₂₀ ])
{f₂₃ : A₂₂ → A₂₄} {f₂₃' : A₂₂' → A₂₄'} (eq-f₂₃ : f₂₃ == f₂₃' [ (λ u → fst u → snd u) ↓ pair×= eq-A₂₂ eq-A₂₄ ])
{f₄₁ : A₄₂ → A₄₀} {f₄₁' : A₄₂' → A₄₀'} (eq-f₄₁ : f₄₁ == f₄₁' [ (λ u → fst u → snd u) ↓ pair×= eq-A₄₂ eq-A₄₀ ])
{f₄₃ : A₄₂ → A₄₄} {f₄₃' : A₄₂' → A₄₄'} (eq-f₄₃ : f₄₃ == f₄₃' [ (λ u → fst u → snd u) ↓ pair×= eq-A₄₂ eq-A₄₄ ])
{f₁₀ : A₂₀ → A₀₀} {f₁₀' : A₂₀' → A₀₀'} (eq-f₁₀ : f₁₀ == f₁₀' [ (λ u → fst u → snd u) ↓ pair×= eq-A₂₀ eq-A₀₀ ])
{f₃₀ : A₂₀ → A₄₀} {f₃₀' : A₂₀' → A₄₀'} (eq-f₃₀ : f₃₀ == f₃₀' [ (λ u → fst u → snd u) ↓ pair×= eq-A₂₀ eq-A₄₀ ])
{f₁₂ : A₂₂ → A₀₂} {f₁₂' : A₂₂' → A₀₂'} (eq-f₁₂ : f₁₂ == f₁₂' [ (λ u → fst u → snd u) ↓ pair×= eq-A₂₂ eq-A₀₂ ])
{f₃₂ : A₂₂ → A₄₂} {f₃₂' : A₂₂' → A₄₂'} (eq-f₃₂ : f₃₂ == f₃₂' [ (λ u → fst u → snd u) ↓ pair×= eq-A₂₂ eq-A₄₂ ])
{f₁₄ : A₂₄ → A₀₄} {f₁₄' : A₂₄' → A₀₄'} (eq-f₁₄ : f₁₄ == f₁₄' [ (λ u → fst u → snd u) ↓ pair×= eq-A₂₄ eq-A₀₄ ])
{f₃₄ : A₂₄ → A₄₄} {f₃₄' : A₂₄' → A₄₄'} (eq-f₃₄ : f₃₄ == f₃₄' [ (λ u → fst u → snd u) ↓ pair×= eq-A₂₄ eq-A₄₄ ])
{H₁₁ : (x : A₂₂) → f₁₀ (f₂₁ x) == f₀₁ (f₁₂ x)} {H₁₁' : (x : A₂₂') → f₁₀' (f₂₁' x) == f₀₁' (f₁₂' x)}
(eq-H₁₁ : H₁₁ == H₁₁' [ (λ u → ((x : SquareFunc.A u) → SquareFunc.g₁ u (SquareFunc.f₁ u x) == SquareFunc.g₂ u (SquareFunc.f₂ u x)))
↓ square=-raw eq-A₂₂ eq-A₂₀ eq-A₀₂ eq-A₀₀ eq-f₂₁ eq-f₁₂ eq-f₁₀ eq-f₀₁ ])
{H₁₃ : (x : A₂₂) → f₀₃ (f₁₂ x) == f₁₄ (f₂₃ x)} {H₁₃' : (x : A₂₂') → f₀₃' (f₁₂' x) == f₁₄' (f₂₃' x)}
(eq-H₁₃ : H₁₃ == H₁₃' [ (λ u → ((x : SquareFunc.A u) → SquareFunc.g₁ u (SquareFunc.f₁ u x) == SquareFunc.g₂ u (SquareFunc.f₂ u x)))
↓ square=-raw eq-A₂₂ eq-A₀₂ eq-A₂₄ eq-A₀₄ eq-f₁₂ eq-f₂₃ eq-f₀₃ eq-f₁₄ ])
{H₃₁ : (x : A₂₂) → f₃₀ (f₂₁ x) == f₄₁ (f₃₂ x)} {H₃₁' : (x : A₂₂') → f₃₀' (f₂₁' x) == f₄₁' (f₃₂' x)}
(eq-H₃₁ : H₃₁ == H₃₁' [ (λ u → ((x : SquareFunc.A u) → SquareFunc.g₁ u (SquareFunc.f₁ u x) == SquareFunc.g₂ u (SquareFunc.f₂ u x)))
↓ square=-raw eq-A₂₂ eq-A₂₀ eq-A₄₂ eq-A₄₀ eq-f₂₁ eq-f₃₂ eq-f₃₀ eq-f₄₁ ])
{H₃₃ : (x : A₂₂) → f₄₃ (f₃₂ x) == f₃₄ (f₂₃ x)} {H₃₃' : (x : A₂₂') → f₄₃' (f₃₂' x) == f₃₄' (f₂₃' x)}
(eq-H₃₃ : H₃₃ == H₃₃' [ (λ u → ((x : SquareFunc.A u) → SquareFunc.g₁ u (SquareFunc.f₁ u x) == SquareFunc.g₂ u (SquareFunc.f₂ u x)))
↓ square=-raw eq-A₂₂ eq-A₄₂ eq-A₂₄ eq-A₄₄ eq-f₃₂ eq-f₂₃ eq-f₄₃ eq-f₃₄ ])
→ ap transpose (span^2=-raw eq-A₀₀ eq-A₀₂ eq-A₀₄ eq-A₂₀ eq-A₂₂ eq-A₂₄ eq-A₄₀ eq-A₄₂ eq-A₄₄ eq-f₀₁ eq-f₀₃ eq-f₂₁ eq-f₂₃ eq-f₄₁ eq-f₄₃ eq-f₁₀ eq-f₃₀ eq-f₁₂ eq-f₃₂ eq-f₁₄ eq-f₃₄ eq-H₁₁ eq-H₁₃ eq-H₃₁ eq-H₃₃)
== span^2=-raw eq-A₀₀ eq-A₂₀ eq-A₄₀ eq-A₀₂ eq-A₂₂ eq-A₄₂ eq-A₀₄ eq-A₂₄ eq-A₄₄ eq-f₁₀ eq-f₃₀ eq-f₁₂ eq-f₃₂ eq-f₁₄ eq-f₃₄ eq-f₀₁ eq-f₀₃ eq-f₂₁ eq-f₂₃ eq-f₄₁ eq-f₄₃ (square-thing _ _ _ _ _ _ _ _ (ap↓ (λ u → ! ∘ u) eq-H₁₁)) eq-H₃₁ eq-H₁₃ (square-thing _ _ _ _ _ _ _ _ (ap↓ (λ u → ! ∘ u) eq-H₃₃))
ap-span^2=-priv2 idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp = idp
module _ {i} (d : Span^2 {i}) where
open Span^2 d
transpose-transpose : transpose (transpose d) == d
transpose-transpose = span^2=-raw idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp
(λ= (!-! ∘ Span^2.H₁₁ d)) idp idp (λ= (!-! ∘ Span^2.H₃₃ d))
module _ {i} (d : Span^2 {i}) where
transpose-equiv : Span^2 {i} ≃ Span^2
transpose-equiv = equiv transpose transpose transpose-transpose transpose-transpose
module _ {i} (d : Span^2 {i}) where
open Span^2 d
d' : (H₁₁' : type-of H₁₁) (H₃₃' : type-of H₃₃) → Span^2
d' H₁₁' H₃₃' = record d {H₁₁ = H₁₁'; H₃₃ = H₃₃'}
e : {H₁₁' : type-of H₁₁} (eq₁ : H₁₁ == H₁₁') {H₃₃' : type-of H₃₃} (eq₃ : H₃₃ == H₃₃') (c : M.A₂∙ (d' H₁₁' H₃₃'))
→ left (M.f₁∙ (d' H₁₁' H₃₃') c) == right (M.f₃∙ (d' H₁₁' H₃₃') c)
e {H₁₁'} eq₁ {H₃₃'} eq₃ = E.f module _ where
e-glue : {H₁₁' : type-of H₁₁} (eq₁ : H₁₁ == H₁₁') {H₃₃' : type-of H₃₃} (eq₃ : H₃₃ == H₃₃') (c : Span^2.A₂₂ (d' H₁₁' H₃₃'))
→ glue (left (f₂₁ c)) == glue (right (f₂₃ c)) [ (λ z → left (M.f₁∙ (d' H₁₁' H₃₃') z) == right (M.f₃∙ (d' H₁₁' H₃₃') z)) ↓ glue c ]
e-glue idp idp c = apd glue (glue c)
module E = PushoutElim {P = λ c → left (M.f₁∙ (d' H₁₁' H₃₃') c) == right (M.f₃∙ (d' H₁₁' H₃₃') c) :> Pushout^2 d} (glue ∘ left) (glue ∘ right) (e-glue eq₁ eq₃)
module F {H₁₁' : type-of H₁₁} (eq₁ : H₁₁ == H₁₁') {H₃₃' : type-of H₃₃} (eq₃ : H₃₃ == H₃₃')
= PushoutRec {d = M.v-h-span (d' H₁₁' H₃₃')} {D = Pushout^2 d}
left right (e eq₁ eq₃)
tr-tr-fun : Pushout^2 (transpose (transpose d)) → Pushout^2 d
tr-tr-fun = F.f (! (λ= (!-! ∘ H₁₁))) (! (λ= (!-! ∘ H₃₃)))
lemma12 : (c : M.A₂∙ d) → e idp idp c == glue c
lemma12 = Pushout-elim (λ a → idp) (λ b → idp) (λ c → ↓-=-in (! (E.glue-β idp idp c)))
result' : {H₁₁' : type-of H₁₁} (eq₁ : H₁₁ == H₁₁') {H₃₃' : type-of H₃₃} (eq₃ : H₃₃ == H₃₃') (x : Pushout^2 (d' H₁₁' H₃₃'))
→ transport Pushout^2 (span^2=-raw idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp (! eq₁) idp idp (! eq₃) :> (d' H₁₁' H₃₃' == d)) x == F.f eq₁ eq₃ x
result' idp idp = Pushout-elim (λ a → idp) (λ b → idp) (λ c → ↓-='-in (F.glue-β idp idp c ∙ lemma12 c ∙ ! (ap-idf (glue c))))
result : {H₁₁' : type-of H₁₁} (eq₁ : H₁₁' == H₁₁) {H₃₃' : type-of H₃₃} (eq₃ : H₃₃' == H₃₃) (x : Pushout^2 (d' H₁₁' H₃₃'))
→ transport Pushout^2 (span^2=-raw idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp eq₁ idp idp eq₃ :> (d' H₁₁' H₃₃' == d)) x == F.f (! eq₁) (! eq₃) x
result eq₁ eq₃ x = ap (λ u → transport Pushout^2 (span^2=-raw idp idp idp idp idp idp idp idp idp idp idp idp idp
idp idp idp idp idp idp idp idp (fst u) idp idp (snd u) :> (_ == d)) x)
(pair×= (! (!-! eq₁)) (! (!-! eq₃)))
∙ result' (! eq₁) (! eq₃) x
result2 : (x : Pushout^2 (transpose (transpose d))) → transport Pushout^2 (transpose-transpose d) x == tr-tr-fun x
result2 = result (λ= (!-! ∘ Span^2.H₁₁ d)) (λ= (!-! ∘ Span^2.H₃₃ d))
-- module _ {i} where
-- postulate
-- to : (d : Span^2 {i}) → Pushout^2 d → Pushout^2 (transpose d)
-- from : (d : Span^2 {i}) → Pushout^2 (transpose d) → Pushout^2 d
-- from d = tr-tr-fun d ∘ to (transpose d)
-- postulate
-- from-to : (d : Span^2 {i}) (x : Pushout^2 d) → from d (to d x) == x
-- lemma3 : {d d' : Span^2 {i}} (p : d == d') (x : Pushout^2 d) → transport (Pushout^2 ∘ transpose) p (to d x) == to d' (transport Pushout^2 p x)
-- lemma3 {d} {.d} idp x = idp
-- lemma34 : (d : Span^2 {i}) (x : Pushout^2 (transpose (transpose d))) → transport (Pushout^2 ∘ transpose) (transpose-transpose d) (to (transpose (transpose d)) x) == to d (tr-tr-fun d x)
-- lemma34 d x = lemma3 (transpose-transpose d) x ∙ ap (to d) (result2 d x)
-- lm2 : (d : Span^2 {i}) → ap transpose (transpose-transpose d) == transpose-transpose (transpose d)
-- lm2 d = ap-span^2=-priv2 idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp
-- (! (! (λ= (!-! ∘ Span^2.H₁₁ d)))) idp idp (! (! (λ= (!-! ∘ Span^2.H₃₃ d)))) ∙ ap (λ u → span^2=-raw idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp idp (fst u) idp idp (snd u)) (pair×= (lm3 (Span^2.H₁₁ d)) (lm3 (Span^2.H₃₃ d))) where
-- lm3 : ∀ {i j} {A : Type i} {B : Type j} {f g : A → B} (p : (a : A) → f a == g a)
-- → ap (λ f → ! ∘ f) (! (! (λ= (!-! ∘ p)))) == ! (! (λ= (!-! ∘ ! ∘ p)))
-- lm3 p = transport (λ u → ap (λ f → ! ∘ f) (! (! (λ= (!-! ∘ u)))) == ! (! (λ= (!-! ∘ ! ∘ u)))) (λ= (app=-β p)) (lm3' (λ= p)) where
-- lm3' : ∀ {i j} {A : Type i} {B : Type j} {f g : A → B} (p : f == g)
-- → ap (λ f → ! ∘ f) (! (! (λ= (!-! ∘ app= p)))) == ! (! (λ= (!-! ∘ ! ∘ app= p)))
-- lm3' idp = ap (λ u → ap (λ u → ! ∘ u) (! (! u))) (! (λ=-η idp)) ∙ ap (! ∘ !) (λ=-η idp)
-- lemma345 : (d : Span^2 {i}) (x : Pushout^2 (transpose (transpose (transpose d))))
-- → transport (Pushout^2 ∘ transpose) (transpose-transpose d) x == tr-tr-fun (transpose d) x
-- lemma345 d x =
-- transport (Pushout^2 ∘ transpose) (transpose-transpose d) x
-- =⟨ ap (λ u → coe u x) (ap-∘ Pushout^2 transpose (transpose-transpose d)) ⟩
-- transport Pushout^2 (ap transpose (transpose-transpose d)) x
-- =⟨ ap (λ u → transport Pushout^2 u x) (lm2 d) ⟩
-- transport Pushout^2 (transpose-transpose (transpose d)) x
-- =⟨ result2 (transpose d) x ⟩
-- tr-tr-fun (transpose d) x ∎
-- to-from : (d : Span^2 {i}) (x : Pushout^2 (transpose d)) → to d (from d x) == x
-- to-from d x =
-- to d (tr-tr-fun d (to (transpose d) x))
-- =⟨ ! (lemma34 d (to (transpose d) x)) ⟩
-- transport (Pushout^2 ∘ transpose) (transpose-transpose d) (to (transpose (transpose d)) (to (transpose d) x))
-- =⟨ lemma345 d (to (transpose (transpose d)) (to (transpose d) x)) ⟩
-- tr-tr-fun (transpose d) (to (transpose (transpose d)) (to (transpose d) x))
-- =⟨ from-to (transpose d) x ⟩
-- x ∎
|
{
"alphanum_fraction": 0.5030861723,
"avg_line_length": 63.6479591837,
"ext": "agda",
"hexsha": "22cfacdd9945131f2e169d8532962c055c6df568",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nicolaikraus/HoTT-Agda",
"max_forks_repo_path": "homotopy/3x3/Transpose.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nicolaikraus/HoTT-Agda",
"max_issues_repo_path": "homotopy/3x3/Transpose.agda",
"max_line_length": 294,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "f8fa68bf753d64d7f45556ca09d0da7976709afa",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "UlrikBuchholtz/HoTT-Agda",
"max_stars_repo_path": "homotopy/3x3/Transpose.agda",
"max_stars_repo_stars_event_max_datetime": "2021-06-30T00:17:55.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-06-30T00:17:55.000Z",
"num_tokens": 6244,
"size": 12475
}
|
module Issue443 where
module M (A : Set) where
record R : Set where
field
a : A
postulate
A : Set
I : A → Set
i : (x : A) → I x
r : M.R A
a = M.R.a A r
Foo : Set₁
Foo with i (M.R.a A r)
Foo | _ = Set
|
{
"alphanum_fraction": 0.5223214286,
"avg_line_length": 11.7894736842,
"ext": "agda",
"hexsha": "ab6bd1c38913a69e5c948b88ebae991c6186adb3",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "20596e9dd9867166a64470dd24ea68925ff380ce",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "np/agda-git-experiment",
"max_forks_repo_path": "test/succeed/Issue443.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "20596e9dd9867166a64470dd24ea68925ff380ce",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "np/agda-git-experiment",
"max_issues_repo_path": "test/succeed/Issue443.agda",
"max_line_length": 24,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/agda-kanso",
"max_stars_repo_path": "test/succeed/Issue443.agda",
"max_stars_repo_stars_event_max_datetime": "2019-11-27T04:41:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-11-27T04:41:05.000Z",
"num_tokens": 92,
"size": 224
}
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.RingSolver.CommRingHornerForms where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat using (ℕ)
open import Cubical.Data.FinData
open import Cubical.Data.Vec
open import Cubical.Data.Bool using (Bool; true; false; if_then_else_; _and_)
open import Cubical.Algebra.RingSolver.RawRing
open import Cubical.Algebra.RingSolver.RawAlgebra renaming (⟨_⟩ to ⟨_⟩ₐ)
open import Cubical.Algebra.RingSolver.AlmostRing renaming (⟨_⟩ to ⟨_⟩ᵣ)
private
variable
ℓ ℓ′ : Level
{-
This defines the type of multivariate Polynomials over the RawRing R.
The construction is based on the algebraic fact
R[X₀][X₁]⋯[Xₙ] ≅ R[X₀,⋯,Xₙ]
BUT: Contrary to algebraic convetions, we will give 'Xₙ' the lowest index
in the definition of 'Variable' below. So if 'Variable n R k' is identified
with 'Xₖ', then the RawRing we construct should rather be denoted with
R[Xₙ][Xₙ₋₁]⋯[X₀]
or, to be precise about the evaluation order:
(⋯((R[Xₙ])[Xₙ₋₁])⋯)[X₀]
-}
data IteratedHornerForms (A : RawAlgebra ℤAsRawRing ℓ) : ℕ → Type ℓ where
const : ℤ → IteratedHornerForms A ℕ.zero
0H : {n : ℕ} → IteratedHornerForms A (ℕ.suc n)
_·X+_ : {n : ℕ} → IteratedHornerForms A (ℕ.suc n) → IteratedHornerForms A n
→ IteratedHornerForms A (ℕ.suc n)
module _ (A : RawAlgebra ℤAsRawRing ℓ′) where
open RawRing ℤAsRawRing
isZero : {n : ℕ} → IteratedHornerForms A n
→ Bool
isZero (const (pos ℕ.zero)) = true
isZero (const (pos (ℕ.suc _))) = false
isZero (const (negsuc _)) = false
isZero 0H = true
isZero (P ·X+ P₁) = false
eval : {A : RawAlgebra ℤAsRawRing ℓ′}
(n : ℕ) (P : IteratedHornerForms A n)
→ Vec ⟨ A ⟩ₐ n → ⟨ A ⟩ₐ
eval {A = A} ℕ.zero (const r) [] = RawAlgebra.scalar A r
eval {A = A} .(ℕ.suc _) 0H (_ ∷ _) = RawAlgebra.0r A
eval {A = A} (ℕ.suc n) (P ·X+ Q) (x ∷ xs) =
let open RawAlgebra A
P' = (eval (ℕ.suc n) P (x ∷ xs))
Q' = eval n Q xs
in if (isZero A P)
then Q'
else P' · x + Q'
module IteratedHornerOperations (A : RawAlgebra ℤAsRawRing ℓ) where
open RawRing ℤAsRawRing
private
1H' : (n : ℕ) → IteratedHornerForms A n
1H' ℕ.zero = const 1r
1H' (ℕ.suc n) = 0H ·X+ 1H' n
0H' : (n : ℕ) → IteratedHornerForms A n
0H' ℕ.zero = const 0r
0H' (ℕ.suc n) = 0H
1ₕ : {n : ℕ} → IteratedHornerForms A n
1ₕ {n = n} = 1H' n
0ₕ : {n : ℕ} → IteratedHornerForms A n
0ₕ {n = n} = 0H' n
X : (n : ℕ) (k : Fin n) → IteratedHornerForms A n
X (ℕ.suc m) zero = 1ₕ ·X+ 0ₕ
X (ℕ.suc m) (suc k) = 0ₕ ·X+ X m k
_+ₕ_ : {n : ℕ} → IteratedHornerForms A n → IteratedHornerForms A n
→ IteratedHornerForms A n
(const r) +ₕ (const s) = const (r + s)
0H +ₕ Q = Q
(P ·X+ r) +ₕ 0H = P ·X+ r
(P ·X+ r) +ₕ (Q ·X+ s) =
let left = (P +ₕ Q)
right = (r +ₕ s)
in if ((isZero A left) and (isZero A right))
then 0ₕ
else left ·X+ right
-ₕ : {n : ℕ} → IteratedHornerForms A n → IteratedHornerForms A n
-ₕ (const x) = const (- x)
-ₕ 0H = 0H
-ₕ (P ·X+ Q) = (-ₕ P) ·X+ (-ₕ Q)
_⋆_ : {n : ℕ} → IteratedHornerForms A n → IteratedHornerForms A (ℕ.suc n)
→ IteratedHornerForms A (ℕ.suc n)
_·ₕ_ : {n : ℕ} → IteratedHornerForms A n → IteratedHornerForms A n
→ IteratedHornerForms A n
r ⋆ 0H = 0H
r ⋆ (P ·X+ Q) =
if (isZero A r)
then 0ₕ
else (r ⋆ P) ·X+ (r ·ₕ Q)
const x ·ₕ const y = const (x · y)
0H ·ₕ Q = 0H
(P ·X+ Q) ·ₕ S =
let
z = (P ·ₕ S)
in if (isZero A z)
then (Q ⋆ S)
else (z ·X+ 0ₕ) +ₕ (Q ⋆ S)
asRawRing : (n : ℕ) → RawRing {ℓ}
RawRing.Carrier (asRawRing n) = IteratedHornerForms A n
RawRing.0r (asRawRing n) = 0ₕ
RawRing.1r (asRawRing n) = 1ₕ
RawRing._+_ (asRawRing n) = _+ₕ_
RawRing._·_ (asRawRing n) = _·ₕ_
RawRing.- (asRawRing n) = -ₕ
Variable : (n : ℕ) (R : RawAlgebra ℤAsRawRing ℓ′) (k : Fin n) → IteratedHornerForms R n
Variable n R k = IteratedHornerOperations.X R n k
Constant : (n : ℕ) (R : RawAlgebra ℤAsRawRing ℓ′) (r : ℤ) → IteratedHornerForms R n
Constant ℕ.zero R r = const r
Constant (ℕ.suc n) R r = IteratedHornerOperations.0ₕ R ·X+ Constant n R r
|
{
"alphanum_fraction": 0.6010838831,
"avg_line_length": 30.7536231884,
"ext": "agda",
"hexsha": "18a36a364d7407f549da703df573d1a574d353af",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "dan-iel-lee/cubical",
"max_forks_repo_path": "Cubical/Algebra/RingSolver/CommRingHornerForms.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "dan-iel-lee/cubical",
"max_issues_repo_path": "Cubical/Algebra/RingSolver/CommRingHornerForms.agda",
"max_line_length": 87,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "dan-iel-lee/cubical",
"max_stars_repo_path": "Cubical/Algebra/RingSolver/CommRingHornerForms.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1791,
"size": 4244
}
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
module cw.cohomology.GridPtdMap {i j k}
{X : Ptd i} {Y : Ptd j} {Z : Ptd k}
(f : X ⊙→ Y) (g : Y ⊙→ Z) where
open import cw.cohomology.GridMap (fst f) (fst g) public
Y/X = ⊙Cofiber f
Z/X = ⊙Cofiber (g ⊙∘ f)
Z/Y = ⊙Cofiber g
Y/X-to-Z/X : Y/X ⊙→ Z/X
Y/X-to-Z/X = B/A-to-C/A , idp
Z/X-to-Z/Y : Z/X ⊙→ Z/Y
Z/X-to-Z/Y = C/A-to-C/B , idp
|
{
"alphanum_fraction": 0.5289855072,
"avg_line_length": 20.7,
"ext": "agda",
"hexsha": "dd50bbf352bd4722b6231be616a0701d9d7d0a24",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2018-12-26T21:31:57.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-12-26T21:31:57.000Z",
"max_forks_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "mikeshulman/HoTT-Agda",
"max_forks_repo_path": "theorems/cw/cohomology/GridPtdMap.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "mikeshulman/HoTT-Agda",
"max_issues_repo_path": "theorems/cw/cohomology/GridPtdMap.agda",
"max_line_length": 58,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "mikeshulman/HoTT-Agda",
"max_stars_repo_path": "theorems/cw/cohomology/GridPtdMap.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 193,
"size": 414
}
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
open import Cubical.Foundations.HLevels
module Cubical.Algebra.Semigroup.Construct.Left {ℓ} (Aˢ : hSet ℓ) where
open import Cubical.Foundations.Prelude
open import Cubical.Algebra.Semigroup
import Cubical.Algebra.Magma.Construct.Left Aˢ as LMagma
open LMagma public hiding (Left-isMagma; LeftMagma)
private
A = ⟨ Aˢ ⟩
isSetA = Aˢ .snd
◂-assoc : Associative _◂_
◂-assoc _ _ _ = refl
Left-isSemigroup : IsSemigroup A _◂_
Left-isSemigroup = record
{ isMagma = LMagma.Left-isMagma
; assoc = ◂-assoc
}
LeftSemigroup : Semigroup ℓ
LeftSemigroup = record { isSemigroup = Left-isSemigroup }
|
{
"alphanum_fraction": 0.7424023155,
"avg_line_length": 23.0333333333,
"ext": "agda",
"hexsha": "bd2170437c18f0a55be098c94c934bd4aa6479f9",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "737f922d925da0cd9a875cb0c97786179f1f4f61",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "bijan2005/univalent-foundations",
"max_forks_repo_path": "Cubical/Algebra/Semigroup/Construct/Left.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "737f922d925da0cd9a875cb0c97786179f1f4f61",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "bijan2005/univalent-foundations",
"max_issues_repo_path": "Cubical/Algebra/Semigroup/Construct/Left.agda",
"max_line_length": 71,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "737f922d925da0cd9a875cb0c97786179f1f4f61",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "bijan2005/univalent-foundations",
"max_stars_repo_path": "Cubical/Algebra/Semigroup/Construct/Left.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 225,
"size": 691
}
|
{-
Base facts about that the ring ℤ is Bézout domain
-}
{-# OPTIONS --safe #-}
module Cubical.Data.Int.Divisibility where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Data.Nat
hiding (+-assoc ; +-comm ; ·-comm)
renaming (_·_ to _·ℕ_; _+_ to _+ℕ_ ; ·-assoc to ·ℕ-assoc)
open import Cubical.Data.Nat.Order
open import Cubical.Data.Nat.Divisibility
using (m∣n→m≤n)
renaming (_∣_ to _∣ℕ_ ; isProp∣ to isProp∣ℕ ; stDivIneq to stDivIneqℕ)
open import Cubical.Data.Nat.Mod
open import Cubical.Data.Int
hiding (_+_ ; _·_ ; _-_ ; -_ ; addEq ; ·Comm ; ·Assoc ; +Comm ; +Assoc)
open import Cubical.Data.Empty as Empty
open import Cubical.Data.Sum
open import Cubical.Data.Sigma
open import Cubical.HITs.PropositionalTruncation as Prop
open import Cubical.Relation.Nullary
open import Cubical.Algebra.CommRing
open import Cubical.Algebra.CommRing.Instances.Int
renaming (ℤ to Ringℤ)
open import Cubical.Algebra.RingSolver.Reflection
private
variable
m n k : ℤ
-- It seems there are bugs when applying ring solver to integers.
-- The following is a work-around.
private
module Helper {ℓ : Level}(𝓡 : CommRing ℓ) where
open CommRingStr (𝓡 .snd)
helper1 : (a b m d r : 𝓡 .fst) → (- a · d + b) · m + a · (d · m + r) ≡ a · r + b · m
helper1 = solve 𝓡
helper2 : (d m r : 𝓡 .fst) → (d · m + r) + (- d) · m ≡ r
helper2 = solve 𝓡
helper3 : (n m d r : 𝓡 .fst) → n ≡ d · m + r → n + (- d) · m ≡ r
helper3 n m d r p = (λ t → p t + (- d) · m) ∙ helper2 d m r
open Helper Ringℤ
open CommRingStr (Ringℤ .snd)
-- The Divisibility Relation
-- Most definitions are the same as in Cubical.Data.Nat.Divisibility
_∣_ : ℤ → ℤ → Type
m ∣ n = ∃[ c ∈ ℤ ] c · m ≡ n
isProp∣ : isProp (m ∣ n)
isProp∣ = squash
-- Untruncated divisiblility relation
_∣'_ : ℤ → ℤ → Type
pos 0 ∣' n = 0 ≡ n
pos (suc m) ∣' n = Σ[ c ∈ ℤ ] c · (pos (suc m)) ≡ n
(negsuc m) ∣' n = Σ[ c ∈ ℤ ] c · (negsuc m) ≡ n
isProp∣' : isProp (m ∣' n)
isProp∣' {m = pos 0} {n = n} = isSetℤ 0 n
isProp∣' {m = pos (suc m)} {n = n} p q =
Σ≡Prop (λ _ → isSetℤ _ _) (·rCancel (pos (suc m)) _ _ (p .snd ∙ sym (q .snd)) (λ r → snotz (injPos r)))
isProp∣' {m = negsuc m} {n = n} p q =
Σ≡Prop (λ _ → isSetℤ _ _) (·rCancel (negsuc m) _ _ (p .snd ∙ sym (q .snd)) (negsucNotpos _ 0))
∣→∣' : (m n : ℤ) → m ∣ n → m ∣' n
∣→∣' (pos 0) n ∣ c , p ∣ = ·Comm 0 c ∙ p
∣→∣' (pos (suc m)) n ∣ p ∣ = p
∣→∣' (negsuc m) n ∣ p ∣ = p
∣→∣' m n (squash p q i) = isProp∣' (∣→∣' _ _ p) (∣→∣' _ _ q) i
∣'→∣ : (m n : ℤ) → m ∣' n → m ∣ n
∣'→∣ (pos 0) n p = ∣ 0 , p ∣
∣'→∣ (pos (suc m)) n p = ∣ p ∣
∣'→∣ (negsuc m) n p = ∣ p ∣
∣≃∣' : (m n : ℤ) → (m ∣ n) ≃ (m ∣' n)
∣≃∣' m n = propBiimpl→Equiv isProp∣ isProp∣' (∣→∣' _ _) (∣'→∣ _ _)
-- Properties of divisibility
∣-left : m ∣ (m · k)
∣-left {k = k} = ∣ k , ·Comm k _ ∣
∣-right : m ∣ (k · m)
∣-right {k = k} = ∣ k , refl ∣
∣-refl : m ≡ n → m ∣ n
∣-refl p = ∣ 1 , p ∣
∣-zeroˡ : 0 ∣ m → 0 ≡ m
∣-zeroˡ = ∣→∣' _ _
∣-zeroʳ : m ∣ 0
∣-zeroʳ = ∣ 0 , refl ∣
∣-+ : k ∣ m → k ∣ n → k ∣ (m + n)
∣-+ =
Prop.map2
λ {(c₁ , p) (c₂ , q) → (c₁ + c₂ , ·DistL+ c₁ c₂ _ ∙ (λ t → p t + q t))}
∣-trans : k ∣ m → m ∣ n → k ∣ n
∣-trans =
Prop.map2
λ {(c₁ , p) (c₂ , q) → (c₂ · c₁ , sym (·Assoc c₂ c₁ _) ∙ cong (c₂ ·_) p ∙ q)}
∣-left· : k ∣ n → k ∣ (n · m)
∣-left· {k = k} {m = m} p = ∣-trans p (∣-left {k = m})
∣-right· : k ∣ m → k ∣ (n · m)
∣-right· {k = k} {n = n} p = ∣-trans p (∣-right {k = n})
-- Natural numbers back and forth (using abs)
∣→∣ℕ : m ∣ n → abs m ∣ℕ abs n
∣→∣ℕ {m = m} = Prop.rec isProp∣ℕ (λ (c , h) → ∣ abs c , sym (abs· c m) ∙ cong abs h ∣)
private
∣ℕ→∣-helper : (m n : ℤ)
→ (c : ℕ)(h : c ·ℕ abs m ≡ abs n)
→ (m ≡ pos (abs m)) ⊎ (m ≡ - pos (abs m))
→ (n ≡ pos (abs n)) ⊎ (n ≡ - pos (abs n))
→ Σ[ d ∈ ℤ ] d · m ≡ n
∣ℕ→∣-helper _ _ c _ (inl _) (inl _) .fst = pos c
∣ℕ→∣-helper m n c h (inl p) (inl q) .snd =
(λ t → pos c · p t)
∙ sym (pos·pos c (abs m))
∙ cong pos h
∙ sym q
∣ℕ→∣-helper _ _ c _ (inl _) (inr _) .fst = - pos c
∣ℕ→∣-helper m n c h (inl p) (inr q) .snd =
(λ t → - pos c · p t)
∙ sym (-DistL· (pos c) (pos (abs m)))
∙ (λ t → - pos·pos c (abs m) (~ t))
∙ cong (-_) (cong pos h)
∙ sym q
∣ℕ→∣-helper _ _ c _ (inr _) (inl _) .fst = - pos c
∣ℕ→∣-helper m n c h (inr p) (inl q) .snd =
(λ t → - pos c · p t)
∙ sym (-DistLR· (pos c) (pos (abs m)))
∙ sym (pos·pos c (abs m))
∙ cong pos h
∙ sym q
∣ℕ→∣-helper _ _ c _ (inr _) (inr _) .fst = pos c
∣ℕ→∣-helper m n c h (inr p) (inr q) .snd =
(λ t → pos c · p t)
∙ sym (-DistR· (pos c) (pos (abs m)))
∙ (λ t → - pos·pos c (abs m) (~ t))
∙ cong (-_) (cong pos h)
∙ sym q
∣ℕ→∣ : abs m ∣ℕ abs n → m ∣ n
∣ℕ→∣ = Prop.rec isProp∣ (λ (c , h) → ∣ ∣ℕ→∣-helper _ _ c h (abs→⊎ _ _ refl) (abs→⊎ _ _ refl) ∣)
¬∣→¬∣ℕ : ¬ m ∣ n → ¬ abs m ∣ℕ abs n
¬∣→¬∣ℕ p q = p (∣ℕ→∣ q)
-- Inequality for strict divisibility
stDivIneq : ¬ m ≡ 0 → ¬ m ∣ n → k ∣ m → k ∣ n → abs k < abs m
stDivIneq p q h h' = stDivIneqℕ (¬x≡0→¬abs≡0 p) (¬∣→¬∣ℕ q) (∣→∣ℕ h) (∣→∣ℕ h')
-- Exact division
divide : m ∣ n → ℤ
divide {m = pos 0} _ = 0
divide {m = pos (suc m)} p = ∣→∣' _ _ p .fst
divide {m = negsuc m} p = ∣→∣' _ _ p .fst
divideEq : (p : m ∣ n) → divide p · m ≡ n
divideEq {m = pos 0} = ∣→∣' _ _
divideEq {m = pos (suc m)} p = ∣→∣' _ _ p .snd
divideEq {m = negsuc m} p = ∣→∣' _ _ p .snd
-- Bézout and Euclidean Domain
record Bézout (m n : ℤ) : Type where
constructor bezout
field
coef₁ : ℤ
coef₂ : ℤ
gcd : ℤ
identity : coef₁ · m + coef₂ · n ≡ gcd
isCD : (gcd ∣ m) × (gcd ∣ n)
open Bézout
Bézout0 : (n : ℤ) → Bézout 0 n
Bézout0 n .coef₁ = 0
Bézout0 n .coef₂ = 1
Bézout0 n .gcd = n
Bézout0 n .identity = +Comm 0 n
Bézout0 n .isCD = ∣-zeroʳ , ∣-refl refl
bézoutReduction : (m d r : ℤ) → Bézout r m → Bézout m (d · m + r)
bézoutReduction m d r b .coef₁ = - b .coef₁ · d + b .coef₂
bézoutReduction m d r b .coef₂ = b .coef₁
bézoutReduction m d r b .gcd = b .gcd
bézoutReduction m d r b .identity = helper1 (b .coef₁) (b .coef₂) m d r ∙ b .identity
bézoutReduction m d r b .isCD .fst = b .isCD .snd
bézoutReduction m d r b .isCD .snd = ∣-+ (∣-right· {n = d} (b .isCD .snd)) (b .isCD .fst)
-- Properties of Bézout identity
module _
(b : Bézout m n) where
private
g = b .gcd
gcdIsGCD : k ∣ m → k ∣ n → k ∣ g
gcdIsGCD {k = k} p q =
subst (k ∣_) (b .identity) (∣-+ (∣-right· {n = b .coef₁} p) (∣-right· {n = b .coef₂} q))
gcd≡0 : g ≡ 0 → (m ≡ 0) × (n ≡ 0)
gcd≡0 p .fst = sym (∣-zeroˡ (subst (λ a → a ∣ _) p (b .isCD .fst)))
gcd≡0 p .snd = sym (∣-zeroˡ (subst (λ a → a ∣ _) p (b .isCD .snd)))
¬m≡0→¬gcd≡0 : ¬ m ≡ 0 → ¬ g ≡ 0
¬m≡0→¬gcd≡0 p q = p (gcd≡0 q .fst)
div₁ div₂ : ℤ
div₁ = divide (b .isCD .fst)
div₂ = divide (b .isCD .snd)
div·-helper : g · (div₁ · n) ≡ g · (div₂ · m)
div·-helper =
·Assoc g div₁ n
∙ (λ i → ·Comm g div₁ i · n)
∙ (λ i → divideEq (b .isCD .fst) i · n)
∙ ·Comm m n
∙ (λ i → divideEq (b .isCD .snd) (~ i) · m)
∙ (λ i → ·Comm div₂ g i · m)
∙ sym (·Assoc g div₂ m)
div·-g≠0 : ¬ g ≡ 0 → div₁ · n ≡ div₂ · m
div·-g≠0 p = ·lCancel _ _ _ div·-helper p
div·-g≡0 : g ≡ 0 → div₁ · n ≡ div₂ · m
div·-g≡0 p =
(λ i → div₁ · gcd≡0 p .snd i)
∙ ·Comm div₁ 0
∙ ·Comm 0 div₂
∙ (λ i → div₂ · gcd≡0 p .fst (~ i))
div·-case : Dec (g ≡ 0) → div₁ · n ≡ div₂ · m
div·-case (yes p) = div·-g≡0 p
div·-case (no ¬p) = div·-g≠0 ¬p
div· : div₁ · n ≡ div₂ · m
div· = div·-case (discreteℤ g 0)
div·- : - div₂ · m + div₁ · n ≡ 0
div·- = (λ i → -DistL· div₂ m (~ i) + div₁ · n)
∙ subst (λ a → - a + div₁ · n ≡ 0) div· (-Cancel' (div₁ · n))
-- Quotient and Remainder
record QuotRem (m n : ℤ) : Type where
constructor quotrem
field
div : ℤ
rem : ℤ
quotEq : n ≡ div · m + rem
normIneq : (rem ≡ 0) ⊎ ((¬ rem ≡ 0) × (abs rem < abs m))
open QuotRem
-- Using remainder to decide divisibility
module _
(m n : ℤ)(qr : QuotRem m n) where
rem≡0→m∣n : qr .rem ≡ 0 → m ∣ n
rem≡0→m∣n p = ∣ qr .div , (λ i → qr .div · m + p (~ i)) ∙ sym (qr .quotEq) ∣
m∣n→rem≡0 : m ∣ n → qr .rem ≡ 0
m∣n→rem≡0 p =
case qr .normIneq
return _ of λ
{ (inl q) → q
; (inr q) →
let ∣+ = ∣-+ p (∣-right {m = m} {k = - qr .div})
m∣r = subst (m ∣_) (helper3 _ _ (qr .div) (qr .rem) (qr .quotEq)) ∣+
m≤r = m∣n→m≤n (¬x≡0→¬abs≡0 (q .fst)) (∣→∣ℕ m∣r)
in Empty.rec (<-asym (q .snd) m≤r) }
m∣n→rem≡0' : (p : m ∣ n) → qr .normIneq ≡ inl (m∣n→rem≡0 p)
m∣n→rem≡0' p =
case (qr .normIneq)
return (λ x → x ≡ inl (m∣n→rem≡0 p)) of λ
{ (inl q) → cong inl (isSet→SquareP (λ i j → isSetℤ) q (m∣n→rem≡0 p) refl refl)
; (inr q) → Empty.rec (q .fst (m∣n→rem≡0 p)) }
rem≢0→m∤n : ¬ qr .rem ≡ 0 → ¬ m ∣ n
rem≢0→m∤n p q = p (m∣n→rem≡0 q)
-- The Euclidean Algorithm
module _
(decEq0 : (n : ℤ) → Dec (n ≡ 0))
(quotRem : (m n : ℤ)(¬z : ¬ m ≡ 0) → QuotRem m n) where
euclidStep : (norm : ℕ)
→ (m n : ℤ)(h : abs m < norm)
→ (b : QuotRem m n)
→ Bézout m n
euclidStep 0 _ _ h _ = Empty.rec (¬-<-zero h)
euclidStep (suc N) m n h (quotrem div rem quotEq (inl p)) =
let q = subst (λ r → n ≡ div · m + r) p quotEq
in bezout 1 0 m refl (∣-refl refl , subst (λ k → m ∣ k) (sym q) (∣-right {k = div}))
euclidStep (suc N) m n h (quotrem div rem quotEq (inr p)) =
let b = euclidStep N rem m (<≤-trans (p .snd) (pred-≤-pred h)) (quotRem _ _ (p .fst))
in subst (λ x → Bézout m x) (sym quotEq) (bézoutReduction _ div _ b)
private
euclid-helper : (m n : ℤ)(dec : Dec (m ≡ 0)) → Bézout m n
euclid-helper m n (yes z) = subst (λ x → Bézout x n) (sym z) (Bézout0 n)
euclid-helper m n (no ¬z) = euclidStep (suc (abs m)) m n ≤-refl (quotRem m n ¬z)
euclid : (m n : ℤ) → Bézout m n
euclid m n = euclid-helper m n (decEq0 _)
-- Euclid algorithm when divisibility holds
euclid∣ : (m n : ℤ) → ¬ m ≡ 0 → m ∣ n → (euclid m n .coef₁ ≡ 1) × (euclid m n .coef₂ ≡ 0)
euclid∣ _ _ = euclid∣-helper _ _ (decEq0 _)
where
euclid∣-helper : (m n : ℤ)(dec : Dec (m ≡ 0)) → ¬ m ≡ 0 → m ∣ n
→ (euclid-helper m n dec .coef₁ ≡ 1) × (euclid-helper m n dec .coef₂ ≡ 0)
euclid∣-helper _ _ (yes z) q = Empty.rec (q z)
euclid∣-helper m n (no ¬z) _ q =
let qr = quotRem m n ¬z
path : qr ≡ quotrem _ _ _ _
path t = record qr { normIneq = m∣n→rem≡0' _ _ qr q t }
in (λ t → euclidStep (suc (abs m)) m n ≤-refl (path t) .coef₁) ,
(λ t → euclidStep (suc (abs m)) m n ≤-refl (path t) .coef₂)
-- The ring ℤ is an Euclidean domain
private
dec-helper : {ℓ ℓ' : Level}{A : Type ℓ}{B : Type ℓ'} → Dec A → B → A ⊎ ((¬ A) × B)
dec-helper (yes p) _ = inl p
dec-helper (no ¬p) b = inr (¬p , b)
quotRemPosPos : (m n : ℕ)(¬z : ¬ pos m ≡ 0) → QuotRem (pos m) (pos n)
quotRemPosPos m n _ .div = pos (quotient n / m)
quotRemPosPos m n _ .rem = pos (remainder n / m)
quotRemPosPos m n _ .quotEq =
(λ t → pos (≡remainder+quotient m n (~ t)))
∙ pos+ (remainder n / m) (m ·ℕ (quotient n / m))
∙ +Comm (pos (remainder n / m)) (pos (m ·ℕ (quotient n / m)))
∙ (λ t → pos·pos m (quotient n / m) t + pos (remainder n / m))
∙ (λ t → ·Comm (pos m) (pos (quotient n / m)) t + pos (remainder n / m))
quotRemPosPos 0 n ¬z .normIneq = Empty.rec (¬z refl)
quotRemPosPos (suc m) n ¬z .normIneq = dec-helper (discreteℤ _ 0) (mod< m n)
quotRemNegPos : (m n : ℕ)(¬z : ¬ - pos m ≡ 0) → QuotRem (- pos m) (pos n)
quotRemNegPos m n ¬z .div = - (quotRemPosPos m n (λ p → ¬z (λ t → - p t)) .div)
quotRemNegPos m n ¬z .rem = quotRemPosPos m n (λ p → ¬z (λ t → - p t)) .rem
quotRemNegPos m n ¬z .quotEq =
quotRemPosPos m n (λ p → ¬z (λ t → - p t)) .quotEq
∙ (λ t → -DistLR· (pos (quotient n / m)) (pos m) t + (pos (remainder n / m)))
quotRemNegPos 0 n ¬z .normIneq = Empty.rec (¬z refl)
quotRemNegPos (suc m) n ¬z .normIneq = quotRemPosPos (suc m) n (λ p → ¬z (λ t → - p t)) .normIneq
private
quotRemPos-helper : (m : ℤ)(k n : ℕ)(¬z : ¬ m ≡ 0) → (m ≡ pos k) ⊎ (m ≡ - pos k) → QuotRem m (pos n)
quotRemPos-helper m k n ¬z (inl p) =
subst (λ l → QuotRem l (pos n)) (sym p) (quotRemPosPos k n (λ r → ¬z (p ∙ r)))
quotRemPos-helper m k n ¬z (inr p) =
subst (λ l → QuotRem l (pos n)) (sym p) (quotRemNegPos k n (λ r → ¬z (p ∙ r)))
quotRemPos : (m : ℤ)(n : ℕ)(¬z : ¬ m ≡ 0) → QuotRem m (pos n)
quotRemPos m n ¬z = quotRemPos-helper m (abs m) n ¬z (abs→⊎ _ _ refl)
private
sum-helper : (m r : ℤ)
→ (r ≡ 0) ⊎ ((¬ r ≡ 0) × (abs r < abs m))
→ (- r ≡ 0) ⊎ ((¬ - r ≡ 0) × (abs (- r) < abs m))
sum-helper m r (inl p) = inl (λ t → - p t)
sum-helper m r (inr p) =
inr ((λ q → p .fst (sym (-Involutive r) ∙ (λ t → - q t)))
, subst (λ k → k < abs m) (sym (abs- r)) (p .snd))
quotRemNeg : (m : ℤ)(n : ℕ)(¬z : ¬ m ≡ 0) → QuotRem m (- pos n)
quotRemNeg m n ¬z .div = - (quotRemPos m n ¬z .div)
quotRemNeg m n ¬z .rem = - (quotRemPos m n ¬z .rem)
quotRemNeg m n ¬z .quotEq =
(λ t → - quotRemPos m n ¬z .quotEq t)
∙ -Dist+ (quotRemPos m n ¬z .div · m) (quotRemPos m n ¬z .rem)
∙ (λ t → -DistL· (quotRemPos m n ¬z .div) m t + - quotRemPos m n ¬z .rem)
quotRemNeg m n ¬z .normIneq = sum-helper m _ (quotRemPos m n ¬z .normIneq)
private
quotRem-helper : (m n : ℤ)(k : ℕ)(¬z : ¬ m ≡ 0) → (n ≡ pos k) ⊎ (n ≡ - pos k) → QuotRem m n
quotRem-helper m n k ¬z (inl p) = subst (λ l → QuotRem m l) (sym p) (quotRemPos m k ¬z)
quotRem-helper m n k ¬z (inr p) = subst (λ l → QuotRem m l) (sym p) (quotRemNeg m k ¬z)
-- The quotient-remainder Theorem and the Bézout identity
quotRem : (m n : ℤ)(¬z : ¬ m ≡ 0) → QuotRem m n
quotRem m n ¬z = quotRem-helper m n (abs n) ¬z (abs→⊎ _ _ refl)
bézout : (m n : ℤ) → Bézout m n
bézout = euclid (λ m → discreteℤ m 0) quotRem
bézout∣ : (m n : ℤ) → ¬ m ≡ 0 → m ∣ n → (bézout m n .coef₁ ≡ 1) × (bézout m n .coef₂ ≡ 0)
bézout∣ = euclid∣ (λ m → discreteℤ m 0) quotRem
-- Divisibility is decidable
dec∣ : (m n : ℤ) → Dec (m ∣ n)
dec∣ m n =
case discreteℤ m 0
return (λ _ → Dec (m ∣ n)) of λ
{ (yes p) →
case discreteℤ n 0
return (λ _ → Dec (m ∣ n)) of λ
{ (yes p) → yes (subst (m ∣_) (sym p) ∣-zeroʳ)
; (no ¬p) → no (λ r → ¬p (sym (∣-zeroˡ (subst (_∣ n) p r)))) }
; (no ¬p) →
let qr = quotRem m n ¬p in
case discreteℤ (qr .rem) 0
return (λ _ → Dec (m ∣ n)) of λ
{ (yes p) → yes (rem≡0→m∣n _ _ qr p)
; (no ¬p) → no (rem≢0→m∤n _ _ qr ¬p) }}
|
{
"alphanum_fraction": 0.5179086044,
"avg_line_length": 32.3866666667,
"ext": "agda",
"hexsha": "075e9f1dd4d7ecb397f9e576e183f5d5e57496aa",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "howsiyu/cubical",
"max_forks_repo_path": "Cubical/Data/Int/Divisibility.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "howsiyu/cubical",
"max_issues_repo_path": "Cubical/Data/Int/Divisibility.agda",
"max_line_length": 105,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "howsiyu/cubical",
"max_stars_repo_path": "Cubical/Data/Int/Divisibility.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 6945,
"size": 14574
}
|
{-# OPTIONS --without-K --safe #-}
module Cats.Category.Constructions.Product where
open import Data.Bool using (Bool ; true ; false ; not)
open import Data.Empty using (⊥)
open import Data.Product using (_,_ ; proj₁ ; proj₂) renaming (_×_ to _×T_)
open import Level
open import Cats.Category.Base
open import Cats.Category.Constructions.Terminal as Terminal using (HasTerminal)
open import Cats.Functor using (Functor)
open import Cats.Util.Conv
import Cats.Category.Constructions.Iso as Iso
import Cats.Category.Constructions.Unique as Unique
Bool-elim : ∀ {a} {A : Bool → Set a} → A true → A false → (i : Bool) → A i
Bool-elim x y true = x
Bool-elim x y false = y
module Build {lo la l≈} (Cat : Category lo la l≈) where
private open module Cat = Category Cat
open Cat.≈-Reasoning
open Iso.Build Cat
open Unique.Build Cat
open Terminal.Build Cat
open _≅_
IsProduct : ∀ {li} {I : Set li} (O : I → Obj) P → (∀ i → P ⇒ O i)
→ Set (lo ⊔ la ⊔ l≈ ⊔ li)
IsProduct O P proj
= ∀ {X} (x : ∀ i → X ⇒ O i) → ∃![ u ] (∀ i → x i ≈ proj i ∘ u)
-- TODO The types of the equalities in IsBinaryProducts are backwards, since
-- we want the RHS to be simpler than the LHS. So, projl ∘ u ≈ xl instead
-- of xl ≈ projl ∘ u.
IsBinaryProduct : ∀ {A B} P → (P ⇒ A) → (P ⇒ B) → Set (lo ⊔ la ⊔ l≈)
IsBinaryProduct {A} {B} P projl projr
= ∀ {X} (xl : X ⇒ A) (xr : X ⇒ B)
→ ∃![ u ] (xl ≈ projl ∘ u ×T xr ≈ projr ∘ u)
IsBinaryProduct→IsProduct : ∀ {A B P} {pl : P ⇒ A} {pr : P ⇒ B}
→ IsBinaryProduct P pl pr
→ IsProduct (Bool-elim A B) P (Bool-elim pl pr)
IsBinaryProduct→IsProduct isBinProd x = record
{ arr = f ⃗
; prop = Bool-elim (proj₁ (∃!′.prop f)) (proj₂ (∃!′.prop f))
; unique = λ eq → ∃!′.unique f (eq true , eq false)
}
where
f = isBinProd (x true) (x false)
record Product {li} {I : Set li} (O : I → Obj) : Set (lo ⊔ la ⊔ l≈ ⊔ li) where
field
prod : Obj
proj : ∀ i → prod ⇒ O i
isProduct : IsProduct O prod proj
open Product using (proj ; isProduct)
instance
HasObj-Product : ∀ {li} {I : Set li} {O : I → Obj}
→ HasObj (Product O) lo la l≈
HasObj-Product = record { Cat = Cat ; _ᴼ = Product.prod }
BinaryProduct : Obj → Obj → Set (lo ⊔ la ⊔ l≈)
BinaryProduct A B = Product (Bool-elim A B)
mkBinaryProduct : ∀ {A B P} (pl : P ⇒ A) (pr : P ⇒ B)
→ IsBinaryProduct P pl pr
→ BinaryProduct A B
mkBinaryProduct {P = P} pl pr isBinProd = record
{ isProduct = IsBinaryProduct→IsProduct isBinProd }
nullaryProduct-Terminal : (P : Product {I = ⊥} (λ())) → IsTerminal (P ᴼ)
nullaryProduct-Terminal P X with isProduct P {X = X} λ()
... | ∃!-intro arr _ unique = ∃!-intro arr _ (λ _ → unique λ())
module _ {li} {I : Set li} {O : I → Obj} (P : Product O) where
factorizer : ∀ {X} → (∀ i → X ⇒ O i) → X ⇒ P ᴼ
factorizer proj = isProduct P proj ⃗
factorizer-unique : ∀ {X} (fact : X ⇒ P ᴼ)
→ {x : ∀ i → X ⇒ O i}
→ (∀ i → x i ≈ proj P i ∘ fact)
→ factorizer x ≈ fact
factorizer-unique fact {x} eq = ∃!′.unique (isProduct P x) eq
factorizer-proj : ∀ {X} {x : ∀ i → X ⇒ O i} {i}
→ proj P i ∘ factorizer x ≈ x i
factorizer-proj {x = x} {i} = ≈.sym (∃!′.prop (isProduct P x) i)
factorizer-resp : ∀ {X} {x y : ∀ i → X ⇒ O i}
→ (∀ i → x i ≈ y i)
→ factorizer x ≈ factorizer y
factorizer-resp {x = x} {y} eq = factorizer-unique (factorizer y)
λ i → ≈.trans (eq _) (≈.sym factorizer-proj)
factorizer-∘ : ∀ {X} {x : ∀ i → X ⇒ O i} {Z} {f : Z ⇒ X}
→ factorizer x ∘ f ≈ factorizer (λ i → x i ∘ f)
factorizer-∘ {x = x} {f = f} = ≈.sym
(factorizer-unique (factorizer x ∘ f)
λ _ → ≈.sym (≈.trans unassoc (∘-resp-l factorizer-proj)))
factorizer-id : factorizer (proj P) ≈ id
factorizer-id = factorizer-unique id λ i → ≈.sym id-r
module _ {li} {I : Set li}
{O : I → Obj} (P : Product O)
{O′ : I → Obj} (P′ : Product O′)
where
times : (∀ i → O i ⇒ O′ i) → P ᴼ ⇒ P′ ᴼ
times x = factorizer P′ (λ i → x i ∘ proj P i)
times-proj : ∀ {x : ∀ i → O i ⇒ O′ i} {i}
→ proj P′ i ∘ times x ≈ x i ∘ proj P i
times-proj = factorizer-proj P′
times-resp : {x y : ∀ i → O i ⇒ O′ i}
→ (∀ i → x i ≈ y i)
→ times x ≈ times y
times-resp {x} {y} eq = factorizer-resp P′ (λ i → ∘-resp-l (eq i))
times-id : ∀ {li} {I : Set li} {O : I → Obj} (P : Product O)
→ times P P (λ _ → id) ≈ id
times-id P = factorizer-unique P id λ _ → ≈.trans id-l (≈.sym id-r)
times-∘ : ∀ {li} {I : Set li}
→ {O O′ O″ : I → Obj}
→ (P : Product O) (P′ : Product O′) (P″ : Product O″)
→ {x : ∀ i → O i ⇒ O′ i} {y : ∀ i → O′ i ⇒ O″ i}
→ times P′ P″ y ∘ times P P′ x ≈ times P P″ (λ i → y i ∘ x i)
times-∘ P P′ P″ {x} {y} =
begin
times P′ P″ y ∘ times P P′ x
≈⟨ factorizer-∘ P″ ⟩
factorizer P″ (λ i → (y i ∘ proj P′ i) ∘ times P P′ x)
≈⟨ factorizer-resp P″ (λ i → assoc) ⟩
factorizer P″ (λ i → y i ∘ proj P′ i ∘ times P P′ x)
≈⟨ factorizer-resp P″ (λ i → ∘-resp-r (times-proj P P′)) ⟩
factorizer P″ (λ i → y i ∘ x i ∘ proj P i)
≈⟨ factorizer-resp P″ (λ i → unassoc) ⟩
times P P″ (λ i → y i ∘ x i)
∎
times-factorizer : ∀ {li} {I : Set li}
→ {O O′ : I → Obj}
→ (P : Product O) (P′ : Product O′)
→ ∀ {X} {x : ∀ i → X ⇒ O i} {y : ∀ i → O i ⇒ O′ i}
→ times P P′ y ∘ factorizer P x ≈ factorizer P′ (λ i → y i ∘ x i)
times-factorizer P P′
= ≈.trans (factorizer-∘ P′)
(factorizer-resp P′ λ i → ≈.trans assoc (∘-resp-r (factorizer-proj P)))
proj-cancel : ∀ {li} {I : Set li} {O : I → Obj} {P proj}
→ IsProduct O P proj
→ ∀ {X} {f g : X ⇒ P}
→ (∀ i → proj i ∘ f ≈ proj i ∘ g)
→ f ≈ g
proj-cancel {proj = proj} prod {f = f} {g} eq with prod (λ i → proj i ∘ g)
... | ∃!-intro u _ u-uniq
= begin
f
≈⟨ ≈.sym (u-uniq (λ i → ≈.sym (eq i))) ⟩
u
≈⟨ u-uniq (λ i → ≈.refl) ⟩
g
∎
Product-resp-≅ : ∀ {li} {I : Set li} {O O′ : I → Obj}
→ (∀ i → O i ≅ O′ i)
→ (P : Product O) (P′ : Product O′)
→ P ᴼ ≅ P′ ᴼ
Product-resp-≅ O≅O′ P P′ = record
{ forth = factorizer P′ (λ i → O≅O′ i .forth ∘ proj P i)
; back = factorizer P (λ i → O≅O′ i .back ∘ proj P′ i)
; back-forth = ≈.trans (factorizer-∘ P)
(factorizer-unique P id λ i →
≈.trans assoc (≈.trans (∘-resp-r (factorizer-proj P′))
(≈.trans unassoc (≈.trans (∘-resp-l (O≅O′ i .back-forth))
(≈.trans id-l (≈.sym id-r))))))
; forth-back = ≈.trans (factorizer-∘ P′)
(factorizer-unique P′ id λ i →
≈.trans assoc (≈.trans (∘-resp-r (factorizer-proj P))
(≈.trans unassoc (≈.trans (∘-resp-l (O≅O′ i .forth-back))
(≈.trans id-l (≈.sym id-r))))))
}
open Build public using
(IsProduct ; IsBinaryProduct ; Product ; BinaryProduct ; HasObj-Product)
record HasProducts {lo la l≈} li (C : Category lo la l≈)
: Set (suc li ⊔ lo ⊔ la ⊔ l≈ )
where
private module Bld = Build C
open Category C
open Iso.Build C
field
Π′ : {I : Set li} (O : I → Obj) → Product C O
module _ {I : Set li} where
Π : ∀ (O : I → Obj) → Obj
Π O = Product.prod (Π′ O)
syntax Π (λ i → O) = Π[ i ] O
proj : ∀ {O : I → Obj} i → Π O ⇒ O i
proj {O} = Bld.Product.proj (Π′ O)
factorizer : ∀ {O : I → Obj} {X} → (∀ i → X ⇒ O i) → X ⇒ Π O
factorizer {O} = Bld.factorizer (Π′ O)
times : ∀ {O O′ : I → Obj} → (∀ i → O i ⇒ O′ i) → Π O ⇒ Π O′
times {O} {O′} = Bld.times (Π′ O) (Π′ O′)
factorizer-proj : ∀ {O : I → Obj} {X} {x : ∀ i → X ⇒ O i} {i}
→ proj i ∘ factorizer x ≈ x i
factorizer-proj {O} = Bld.factorizer-proj (Π′ O)
factorizer-resp : ∀ {O : I → Obj} {X} {x y : ∀ i → X ⇒ O i}
→ (∀ i → x i ≈ y i)
→ factorizer x ≈ factorizer y
factorizer-resp {O} = Bld.factorizer-resp (Π′ O)
factorizer-unique : ∀ {O : I → Obj} {X} {x : ∀ i → X ⇒ O i} {u}
→ (∀ i → x i ≈ proj i ∘ u)
→ factorizer x ≈ u
factorizer-unique {O} eq = Bld.factorizer-unique (Π′ O) _ eq
factorizer-∘ : ∀ {O : I → Obj} {X} {x : ∀ i → X ⇒ O i} {Z} {f : Z ⇒ X}
→ factorizer x ∘ f ≈ factorizer (λ i → x i ∘ f)
factorizer-∘ {O} = Bld.factorizer-∘ (Π′ O)
factorizer-id : ∀ {O} → factorizer {O} proj ≈ id
factorizer-id {O} = Bld.factorizer-id (Π′ O)
times-proj : ∀ {O O′ : I → Obj} {x : ∀ i → O i ⇒ O′ i} {i}
→ proj i ∘ times x ≈ x i ∘ proj i
times-proj {O} {O′} = Bld.times-proj (Π′ O) (Π′ O′)
times-resp : ∀ {O O′ : I → Obj} {x y : ∀ i → O i ⇒ O′ i}
→ (∀ i → x i ≈ y i)
→ times x ≈ times y
times-resp {O} {O′} = Bld.times-resp (Π′ O) (Π′ O′)
times-id : ∀ {O : I → Obj} → times {O} (λ _ → id) ≈ id
times-id {O} = Bld.times-id (Π′ O)
times-∘ : ∀ {O O′ O″ : I → Obj} {x : ∀ i → O i ⇒ O′ i} {y : ∀ i → O′ i ⇒ O″ i}
→ times y ∘ times x ≈ times (λ i → y i ∘ x i)
times-∘ {O} {O′} {O″} = Bld.times-∘ (Π′ O) (Π′ O′) (Π′ O″)
times-factorizer : ∀ {O O′ : I → Obj} {X}
→ {x : ∀ i → X ⇒ O i} {y : ∀ i → O i ⇒ O′ i}
→ times y ∘ factorizer x ≈ factorizer (λ i → y i ∘ x i)
times-factorizer {O} {O′} = Bld.times-factorizer (Π′ O) (Π′ O′)
Π-resp-≅ : ∀ {O O′ : I → Obj}
→ (∀ i → O i ≅ O′ i)
→ Π O ≅ Π O′
Π-resp-≅ {O} {O′} O≅O′ = Bld.Product-resp-≅ O≅O′ (Π′ O) (Π′ O′)
HasProducts→HasTerminal : ∀ {lo la l≈} {C : Category lo la l≈}
→ HasProducts zero C
→ HasTerminal C
HasProducts→HasTerminal {C = C} record { Π′ = Π }
= let P = Π {I = ⊥} λ() in
record
{ ⊤ = Product.prod P
; isTerminal = Build.nullaryProduct-Terminal C P
}
record HasBinaryProducts {lo la l≈} (C : Category lo la l≈)
: Set (lo ⊔ la ⊔ l≈)
where
private module Bld = Build C
open Category C
open Iso.Build C
open ≈-Reasoning
infixr 2 _×_ _×′_ ⟨_×_⟩ ⟨_,_⟩
field
_×′_ : ∀ A B → BinaryProduct C A B
_×_ : Obj → Obj → Obj
A × B = (A ×′ B) ᴼ
projl : ∀ {A B} → A × B ⇒ A
projl {A} {B} = Product.proj (A ×′ B) true
projr : ∀ {A B} → A × B ⇒ B
projr {A} {B} = Product.proj (A ×′ B) false
⟨_,_⟩ : ∀ {A B Z} → Z ⇒ A → Z ⇒ B → Z ⇒ A × B
⟨_,_⟩ {A} {B} f g
= Bld.factorizer (A ×′ B) (Bool-elim f g)
⟨_×_⟩ : ∀ {A B A′ B′} → A ⇒ A′ → B ⇒ B′ → A × B ⇒ A′ × B′
⟨_×_⟩ {A} {B} {A′} {B′} f g
= Bld.times (A ×′ B) (A′ ×′ B′) (Bool-elim f g)
first : ∀ {A A′ B} → A ⇒ A′ → A × B ⇒ A′ × B
first f = ⟨ f × id ⟩
second : ∀ {A B B′} → B ⇒ B′ → A × B ⇒ A × B′
second f = ⟨ id × f ⟩
swap : ∀ {A B} → A × B ⇒ B × A
swap = ⟨ projr , projl ⟩
⟨,⟩-resp : ∀ {A B Z} {f f′ : Z ⇒ A} {g g′ : Z ⇒ B}
→ f ≈ f′
→ g ≈ g′
→ ⟨ f , g ⟩ ≈ ⟨ f′ , g′ ⟩
⟨,⟩-resp {A} {B} f≈f′ g≈g′
= Bld.factorizer-resp (A ×′ B) (Bool-elim f≈f′ g≈g′)
⟨,⟩-projl : ∀ {A B Z} {f : Z ⇒ A} {g : Z ⇒ B} → projl ∘ ⟨ f , g ⟩ ≈ f
⟨,⟩-projl {A} {B} = Bld.factorizer-proj (A ×′ B)
⟨,⟩-projr : ∀ {A B Z} {f : Z ⇒ A} {g : Z ⇒ B} → projr ∘ ⟨ f , g ⟩ ≈ g
⟨,⟩-projr {A} {B} = Bld.factorizer-proj (A ×′ B)
⟨,⟩-unique : ∀ {A B Z} {f : Z ⇒ A} {g : Z ⇒ B} {u}
→ f ≈ projl ∘ u
→ g ≈ projr ∘ u
→ ⟨ f , g ⟩ ≈ u
⟨,⟩-unique {A} {B} eql eqr
= Bld.factorizer-unique (A ×′ B) _ (Bool-elim eql eqr)
⟨,⟩-∘ : ∀ {A B Y Z} {f : Y ⇒ Z} {g : Z ⇒ A} {h : Z ⇒ B}
→ ⟨ g , h ⟩ ∘ f ≈ ⟨ g ∘ f , h ∘ f ⟩
⟨,⟩-∘ {A} {B} {Y} {Z} {f} {g} {h}
= begin
⟨ g , h ⟩ ∘ f
≈⟨ Bld.factorizer-∘ (A ×′ B) ⟩
Bld.factorizer (A ×′ B)
(λ i → Bool-elim {A = λ i → Z ⇒ Bool-elim A B i} g h i ∘ f)
≈⟨ Bld.factorizer-resp (A ×′ B) (Bool-elim ≈.refl ≈.refl) ⟩
⟨ g ∘ f , h ∘ f ⟩
∎
⟨,⟩-id : ∀ {A B} → ⟨ projl , projr ⟩ ≈ id {A × B}
⟨,⟩-id {A} {B} = ⟨,⟩-unique (≈.sym id-r) (≈.sym id-r)
⟨×⟩-resp : ∀ {A A′ B B′} {f f′ : A ⇒ A′} {g g′ : B ⇒ B′}
→ f ≈ f′
→ g ≈ g′
→ ⟨ f × g ⟩ ≈ ⟨ f′ × g′ ⟩
⟨×⟩-resp {A} {A′} {B} {B′} f≈f′ g≈g′
= Bld.times-resp (A ×′ B) (A′ ×′ B′) (Bool-elim f≈f′ g≈g′)
⟨×⟩-projl : ∀ {A A′ B B′} {f : A ⇒ A′} {g : B ⇒ B′}
→ projl ∘ ⟨ f × g ⟩ ≈ f ∘ projl
⟨×⟩-projl {A} {A′} {B} {B′} = Bld.times-proj (A ×′ B) (A′ ×′ B′)
⟨×⟩-projr : ∀ {A A′ B B′} {f : A ⇒ A′} {g : B ⇒ B′}
→ projr ∘ ⟨ f × g ⟩ ≈ g ∘ projr
⟨×⟩-projr {A} {A′} {B} {B′} = Bld.times-proj (A ×′ B) (A′ ×′ B′)
⟨×⟩-id : ∀ {A B} → ⟨ id {A} × id {B} ⟩ ≈ id
⟨×⟩-id {A} {B} = Bld.factorizer-unique (A ×′ B) id
(Bool-elim (≈.trans id-l (≈.sym id-r)) (≈.trans id-l (≈.sym id-r)))
⟨×⟩-∘ : ∀ {A A′ A″ B B′ B″}
→ {f : A′ ⇒ A″} {f′ : A ⇒ A′} {g : B′ ⇒ B″} {g′ : B ⇒ B′}
→ ⟨ f × g ⟩ ∘ ⟨ f′ × g′ ⟩ ≈ ⟨ f ∘ f′ × g ∘ g′ ⟩
⟨×⟩-∘ {A} {A′} {A″} {B} {B′} {B″} {f} {f′} {g} {g′} = ≈.trans
(Bld.times-∘ (A ×′ B) (A′ ×′ B′) (A″ ×′ B″))
(Bld.times-resp (A ×′ B) (A″ ×′ B″) (Bool-elim ≈.refl ≈.refl))
⟨×⟩-⟨,⟩ : ∀ {A B C B′ C′} {f : A ⇒ B} {g : A ⇒ C} {f′ : B ⇒ B′} {g′ : C ⇒ C′}
→ ⟨ f′ × g′ ⟩ ∘ ⟨ f , g ⟩ ≈ ⟨ f′ ∘ f , g′ ∘ g ⟩
⟨×⟩-⟨,⟩ {A} {B} {C} {B′} {C′} = ≈.trans
(Bld.times-factorizer (B ×′ C) (B′ ×′ C′))
(Bld.factorizer-resp (B′ ×′ C′) (Bool-elim ≈.refl ≈.refl))
×-resp-≅ : ∀ {A A′ B B′}
→ A ≅ A′
→ B ≅ B′
→ (A × B) ≅ (A′ × B′)
×-resp-≅ {A} {A′} {B} {B′} A≅A′ B≅B′
= Bld.Product-resp-≅ (Bool-elim A≅A′ B≅B′) (A ×′ B) (A′ ×′ B′)
-- The following is conceptually trivial, but we have to dig quite deep to
-- avoid level-related nonsense.
HasProducts→HasBinaryProducts : ∀ {lp lo la l≈} {C : Category lo la l≈}
→ HasProducts lp C
→ HasBinaryProducts C
HasProducts→HasBinaryProducts {lp} {C = C} record { Π′ = Π }
= record { _×′_ = _×_ }
where
open Category C
open Unique.Build C
open Product using (proj)
open ∃!′ using (arr ; prop ; unique)
_×_ : ∀ A B → Build.BinaryProduct C A B
A × B = record
{ prod = prod′
; proj = proj′
; isProduct = isProduct′
}
where
O : Lift lp Bool → _
O (lift true) = A
O (lift false) = B
prod′ = Product.prod (Π O)
proj′ = Bool-elim (proj (Π O) (lift true)) (proj (Π O) (lift false))
isProduct′ : IsProduct C (Bool-elim A B) prod′ proj′
isProduct′ {X} x = record
{ arr = arr′ ⃗
; prop = Bool-elim (prop arr′ (lift true)) (prop arr′ (lift false))
; unique = λ eq → unique arr′
(λ { (lift true) → eq true ; (lift false) → eq false})
}
where
arr′ = Product.isProduct (Π O)
λ { (lift true) → x true ; (lift false) → x false}
record HasFiniteProducts {lo la l≈} (Cat : Category lo la l≈)
: Set (lo ⊔ la ⊔ l≈)
where
field
{{hasTerminal}} : HasTerminal Cat
{{hasBinaryProducts}} : HasBinaryProducts Cat
open HasTerminal hasTerminal public
open HasBinaryProducts hasBinaryProducts public
module _ {lo la l≈ lo′ la′ l≈′}
{C : Category lo la l≈}
{D : Category lo′ la′ l≈′}
where
open Category C
open Functor
PreservesBinaryProducts : (F : Functor C D) → Set _
PreservesBinaryProducts F
= ∀ {A B A×B} {projl : A×B ⇒ A} {projr : A×B ⇒ B}
→ IsBinaryProduct C A×B projl projr
→ IsBinaryProduct D (fobj F A×B) (fmap F projl) (fmap F projr)
PreservesProducts : ∀ {i} (I : Set i) (F : Functor C D) → Set _
PreservesProducts I F
= ∀ {O : I → Obj} {P} {proj : ∀ i → P ⇒ O i}
→ IsProduct C O P proj
→ IsProduct D (λ i → fobj F (O i)) (fobj F P) (λ i → fmap F (proj i))
|
{
"alphanum_fraction": 0.4769933715,
"avg_line_length": 29.2086466165,
"ext": "agda",
"hexsha": "9ee9f44a71c592666f66ce2f48975e8118b195ee",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-18T15:35:07.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-18T15:35:07.000Z",
"max_forks_repo_head_hexsha": "1ad7b243acb622d46731e9ae7029408db6e561f1",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "JLimperg/cats",
"max_forks_repo_path": "Cats/Category/Constructions/Product.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "1ad7b243acb622d46731e9ae7029408db6e561f1",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "JLimperg/cats",
"max_issues_repo_path": "Cats/Category/Constructions/Product.agda",
"max_line_length": 82,
"max_stars_count": 24,
"max_stars_repo_head_hexsha": "1ad7b243acb622d46731e9ae7029408db6e561f1",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "JLimperg/cats",
"max_stars_repo_path": "Cats/Category/Constructions/Product.agda",
"max_stars_repo_stars_event_max_datetime": "2021-08-06T05:00:46.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-11-03T15:18:57.000Z",
"num_tokens": 6705,
"size": 15539
}
|
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020 Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.Prelude
open import LibraBFT.Lemmas
open import LibraBFT.Abstract.Types
module LibraBFT.Abstract.BFT where
-- This is a utility function to make it easy to provide the bft-assumption
-- for the abstract EpochConfig by by assuming that at most bizF members are byzantine
-- and that authorsN ≥ suc (3 * bizF) and that a list of Members is a quorum if it
-- contains at least authorsN ∸ bizF distinct Members.
|
{
"alphanum_fraction": 0.7679882526,
"avg_line_length": 40.0588235294,
"ext": "agda",
"hexsha": "d7edbe14f1a245462ed9754909c797e7df8f1e7c",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b7dd98dd90d98fbb934ef8cb4f3314940986790d",
"max_forks_repo_licenses": [
"UPL-1.0"
],
"max_forks_repo_name": "lisandrasilva/bft-consensus-agda-1",
"max_forks_repo_path": "LibraBFT/Abstract/BFT.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b7dd98dd90d98fbb934ef8cb4f3314940986790d",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"UPL-1.0"
],
"max_issues_repo_name": "lisandrasilva/bft-consensus-agda-1",
"max_issues_repo_path": "LibraBFT/Abstract/BFT.agda",
"max_line_length": 111,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "b7dd98dd90d98fbb934ef8cb4f3314940986790d",
"max_stars_repo_licenses": [
"UPL-1.0"
],
"max_stars_repo_name": "lisandrasilva/bft-consensus-agda-1",
"max_stars_repo_path": "LibraBFT/Abstract/BFT.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 180,
"size": 681
}
|
module Luau.Syntax.ToString where
open import Luau.Syntax using (Block; Stat; Expr; nil; var; addr; _$_; function⟨_⟩_end; return; function_⟨_⟩_end ;local_←_; _∙_; done; block_is_end)
open import FFI.Data.String using (String; _++_)
open import Luau.Addr.ToString using (addrToString)
open import Luau.Var.ToString using (varToString)
exprToString′ : String → Expr → String
statToString′ : String → Stat → String
blockToString′ : String → Block → String
exprToString′ lb nil =
"nil"
exprToString′ lb (addr a) =
addrToString(a)
exprToString′ lb (var x) =
varToString(x)
exprToString′ lb (M $ N) =
(exprToString′ lb M) ++ "(" ++ (exprToString′ lb N) ++ ")"
exprToString′ lb (function⟨ x ⟩ B end) =
"function(" ++ x ++ ")" ++ lb ++
" " ++ (blockToString′ (lb ++ " ") B) ++ lb ++
"end"
exprToString′ lb (block b is B end) =
"(function " ++ b ++ "()" ++ lb ++
" " ++ (blockToString′ (lb ++ " ") B) ++ lb ++
"end)()"
statToString′ lb (function f ⟨ x ⟩ B end) =
"local function " ++ f ++ "(" ++ x ++ ")" ++ lb ++
" " ++ (blockToString′ (lb ++ " ") B) ++ lb ++
"end"
statToString′ lb (local x ← M) =
"local " ++ x ++ " = " ++ (exprToString′ lb M)
statToString′ lb (return M) =
"return " ++ (exprToString′ lb M)
blockToString′ lb (S ∙ done) = statToString′ lb S
blockToString′ lb (S ∙ B) = statToString′ lb S ++ lb ++ blockToString′ lb B
blockToString′ lb (done) = ""
exprToString : Expr → String
exprToString = exprToString′ "\n"
statToString : Stat → String
statToString = statToString′ "\n"
blockToString : Block → String
blockToString = blockToString′ "\n"
|
{
"alphanum_fraction": 0.6188087774,
"avg_line_length": 31.9,
"ext": "agda",
"hexsha": "afec09352b0e393e61f78596daf9b5dc1a28eb77",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "5187e64f88953f34785ffe58acd0610ee5041f5f",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "FreakingBarbarians/luau",
"max_forks_repo_path": "prototyping/Luau/Syntax/ToString.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "5187e64f88953f34785ffe58acd0610ee5041f5f",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "FreakingBarbarians/luau",
"max_issues_repo_path": "prototyping/Luau/Syntax/ToString.agda",
"max_line_length": 148,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "5187e64f88953f34785ffe58acd0610ee5041f5f",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "FreakingBarbarians/luau",
"max_stars_repo_path": "prototyping/Luau/Syntax/ToString.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-11T21:30:17.000Z",
"max_stars_repo_stars_event_min_datetime": "2022-02-11T21:30:17.000Z",
"num_tokens": 499,
"size": 1595
}
|
-- This module is responsible for adding the missing scope information to the parse tree.
module ScopeParseTree where
open import ParseTree
open import Data.Empty
open import ScopeState
open import Data.List hiding (_++_)
open import Data.Product hiding (map)
open import Data.Fin
open import Data.Nat
open import Data.Sum
open import Data.String
open import Data.Bool
open import AgdaHelperFunctions
scopeSignature : TypeSignature -> ScopeType -> ScopeState TypeSignature
scopeExpr : Expr -> ScopeState Expr
scopeExpr (ident identifier₁) = do
-- first try to find identifier among already declared (simplification for constructor), then assume new declaration (simplification for parameter or out-of-file declaration)
inj₂ r <- try $ fillInIdentifier identifier₁
where _ -> do x <- addIdentifier identifier₁
return $ ident x
return $ ident r
scopeExpr (functionApp e e₁ {b} ) = do
r1 <- scopeExpr e
r2 <- scopeExpr e₁
return $ functionApp r1 r2 {b}
scopeExpr (namedArgument arg {b} {bef} {aft}) = do
x <- scopeSignature arg addVariableToType
return $ namedArgument x {b}{bef}{aft}
scopeExpr x = return x
scopeSignature (typeSignature funcName funcType) scopeT = do
newType <- saveAndReturnToScope $ scopeExpr funcType
addScope scopeT
newId <- addIdentifier funcName
return $ typeSignature newId newType
scopePragma : Pragma -> ScopeState Pragma
scopePragma (builtin concept definition) = do
x <- fillInIdentifier definition
return $ builtin concept x
scopePragma x = return x
scopeParseTree : ParseTree -> ScopeState ParseTree
scopeParseTree (signature signature₁ range₁) = do
x <- scopeSignature signature₁ addFuncToModule
return $ signature x range₁
scopeParseTree (functionDefinition definitionOf params body range₁) = do
newId <- fillInIdentifier definitionOf
x <- saveAndReturnToScope $ do
addScope funcDef
newParams <- mapState scopeExpr params
newBody <- scopeExpr body
return $ functionDefinition newId newParams newBody range₁
return x
scopeParseTree
(dataStructure dataName parameters indexInfo constructors range₁ {comments}) = do
addScope $ moduleDef dataName
newDataName <- addIdentifier dataName
( newParams , newIndex) , newCons <- saveAndReturnToScope $ do
newParams <- mapState (λ x -> scopeSignature x addVariableToType) parameters
newIndex <- scopeExpr indexInfo
newCons <- mapState (λ x -> scopeSignature x addFuncToModule) constructors
return ((newParams , newIndex) , newCons)
r <- mapState addContentReferenceToModuleTop newCons
return $ dataStructure newDataName newParams newIndex newCons range₁ {comments}
scopeParseTree (moduleName moduleName₁ range₁) = do
newMod <- addIdentifier moduleName₁
addScope $ moduleDef moduleName₁
return $ moduleName newMod range₁
scopeParseTree (pragma pragma₁ range₁) = do
x <- scopePragma pragma₁
return $ pragma x range₁
scopeParseTree x = return x
scopeParseTreeList : List ParseTree -> ScopeState (List ParseTree)
scopeParseTreeList program = do
--TODO: fix sloppy workaround
put newEnv
addIdentifier (identifier "Set" (λ _ -> before) 0 0 {true}{[]} {[]})
mapState scopeParseTree program
|
{
"alphanum_fraction": 0.7467811159,
"avg_line_length": 38.8333333333,
"ext": "agda",
"hexsha": "5e57ab1dfa0c39d8f88f8470b98336e7dfb68764",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-01-31T08:40:41.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-01-31T08:40:41.000Z",
"max_forks_repo_head_hexsha": "52d1034aed14c578c9e077fb60c3db1d0791416b",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "omega12345/RefactorAgda",
"max_forks_repo_path": "RefactorAgdaEngine/ScopeParseTree.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "52d1034aed14c578c9e077fb60c3db1d0791416b",
"max_issues_repo_issues_event_max_datetime": "2019-02-05T12:53:36.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-31T08:03:07.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "omega12345/RefactorAgda",
"max_issues_repo_path": "RefactorAgdaEngine/ScopeParseTree.agda",
"max_line_length": 176,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "52d1034aed14c578c9e077fb60c3db1d0791416b",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "omega12345/RefactorAgda",
"max_stars_repo_path": "RefactorAgdaEngine/ScopeParseTree.agda",
"max_stars_repo_stars_event_max_datetime": "2019-05-03T10:03:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-01-31T14:10:18.000Z",
"num_tokens": 805,
"size": 3262
}
|
-- Andreas, 2017-10-17, issue #2807
--
-- Refining with an extended lambda gave internal error.
-- Seemed to be triggered only when giving resulted in an error.
{-# OPTIONS --allow-unsolved-metas #-}
-- {-# OPTIONS -v scope.extendedLambda:60 #-}
-- {-# OPTIONS -v impossible:10 #-}
data ⊥ : Set where
actuallyNotEmpty : ⊥
data D : Set where
c : ⊥ → D
test : D → ⊥
test = {! λ{ (c ()) }!} -- C-c C-r
-- WAS: internal error in ConcreteToAbstract (insertApp)
--
-- Expected:
-- Succeed with unsolved constraints and metas.
|
{
"alphanum_fraction": 0.6440677966,
"avg_line_length": 22.125,
"ext": "agda",
"hexsha": "921edb45906739dc0956aa04a56d6e5d4b52637c",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/interaction/Issue2807.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/interaction/Issue2807.agda",
"max_line_length": 64,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/interaction/Issue2807.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 156,
"size": 531
}
|
{-# OPTIONS --without-K #-}
open import HoTT.Base
open import HoTT.Equivalence
open import HoTT.Identity.Pi
open import HoTT.Identity.Sigma
module HoTT.Exercises.Chapter2.Exercise11 where
private
variable
i j k : Level
A B C D : 𝒰 i
pullback : (A : 𝒰 i) (B : 𝒰 j) → (A → C) → (B → C) → 𝒰 _
pullback A B ac bc = Σ[ a ∶ A ] Σ[ b ∶ B ] (ac a == bc b)
module Square (ab : A → B) (ac : A → C) (bd : B → D) (cd : C → D)
where
IsCommutative = bd ∘ ab ~ cd ∘ ac
module Commutative (comm : IsCommutative)
where
inducedMap : {X : 𝒰 i} → (X → A) → pullback (X → B) (X → C) (bd ∘_) (cd ∘_)
inducedMap xa = ab ∘ xa , ac ∘ xa , funext (comm ∘ xa)
IsPullback : ∀ {i} → 𝒰 _
IsPullback {i} = (X : 𝒰 i) → isequiv (inducedMap {X = X})
open Commutative public
module _ {ac : A → C} {bc : B → C}
where
P = pullback A B ac bc
open Square.Commutative {A = P} pr₁ (pr₁ ∘ pr₂) ac bc (pr₂ ∘ pr₂)
prop : IsPullback {i}
prop X = qinv→isequiv (g , η , ε)
where
f = inducedMap
g : pullback (X → A) (X → B) (ac ∘_) (bc ∘_) → (X → P)
g (h' , k' , p) x = h' x , k' x , happly p x
η : g ∘ f ~ id
η xp = funext λ x → pair⁼ (refl , pair⁼ (refl ,
happly (=Π-β (pr₂ ∘ pr₂ ∘ xp)) x))
ε : f ∘ g ~ id
ε (_ , _ , p) = pair⁼ (refl , pair⁼ (refl , =Π-η p))
|
{
"alphanum_fraction": 0.5294117647,
"avg_line_length": 27.2708333333,
"ext": "agda",
"hexsha": "ab92aad811daab991869221e3098bf6f680cae00",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508",
"max_forks_repo_licenses": [
"0BSD"
],
"max_forks_repo_name": "michaelforney/hott",
"max_forks_repo_path": "HoTT/Exercises/Chapter2/Exercise11.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"0BSD"
],
"max_issues_repo_name": "michaelforney/hott",
"max_issues_repo_path": "HoTT/Exercises/Chapter2/Exercise11.agda",
"max_line_length": 79,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508",
"max_stars_repo_licenses": [
"0BSD"
],
"max_stars_repo_name": "michaelforney/hott",
"max_stars_repo_path": "HoTT/Exercises/Chapter2/Exercise11.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 564,
"size": 1309
}
|
module Cats.Limit where
open import Level
open import Cats.Category.Base
open import Cats.Category.Cones using
(Cone ; Cones ; HasObj-Cone ; HasArrow-⇒ ; cone-iso→obj-iso ; apFunctor)
open import Cats.Functor using (Functor)
open import Cats.Util.Conv
import Cats.Category.Constructions.Terminal as Terminal
import Cats.Category.Constructions.Iso as Iso
module _ {lo la l≈ lo′ la′ l≈′}
{J : Category lo la l≈}
{Z : Category lo′ la′ l≈′}
where
IsLimit : {D : Functor J Z} → Cone D → Set (lo ⊔ la ⊔ lo′ ⊔ la′ ⊔ l≈′)
IsLimit {D} = Terminal.Build.IsTerminal (Cones D)
record Limit (D : Functor J Z) : Set (lo ⊔ la ⊔ lo′ ⊔ la′ ⊔ l≈′) where
field
cone : Cone D
isLimit : IsLimit cone
instance
HasObj-Limit : ∀ D → HasObj (Limit D) _ _ _
HasObj-Limit D = record { Cat = Cones D ; _ᴼ = Limit.cone }
module _ {D : Functor J Z} where
open Iso.Build (Cones D) using (_≅_)
open Iso.Build Z using () renaming (_≅_ to _≅Z_)
open Limit using (isLimit)
unique : (l m : Limit D) → l ᴼ ≅ m ᴼ
unique l m = Terminal.Build.terminal-unique (Cones D) (isLimit l) (isLimit m)
obj-unique : (l m : Limit D) → l ᴼ ᴼ ≅Z m ᴼ ᴼ
obj-unique l m = cone-iso→obj-iso _ (unique l m)
module _ {lo la l≈ lo′ la′ l≈′}
{C : Category lo la l≈}
{D : Category lo′ la′ l≈′}
where
preservesLimits : (lo″ la″ l≈″ : Level) → (F : Functor C D) → Set _
preservesLimits lo″ la″ l≈″ F
= {J : Category lo″ la″ l≈″}
→ {D : Functor J C}
→ {c : Cone D}
→ IsLimit c
→ IsLimit (apFunctor F c)
|
{
"alphanum_fraction": 0.6053639847,
"avg_line_length": 25.2580645161,
"ext": "agda",
"hexsha": "175f925712352af7b8f789cfea88d0e00f9f60b8",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "a3b69911c4c6ec380ddf6a0f4510d3a755734b86",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "alessio-b-zak/cats",
"max_forks_repo_path": "Cats/Limit.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "a3b69911c4c6ec380ddf6a0f4510d3a755734b86",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "alessio-b-zak/cats",
"max_issues_repo_path": "Cats/Limit.agda",
"max_line_length": 81,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "a3b69911c4c6ec380ddf6a0f4510d3a755734b86",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "alessio-b-zak/cats",
"max_stars_repo_path": "Cats/Limit.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 571,
"size": 1566
}
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
module groups.CoefficientExtensionality {i} {A : Type i} where
module _ (dec : has-dec-eq A) where
Word-coef : Word A → (A → ℤ)
Word-coef nil a = 0
Word-coef (inl a' :: w) a with dec a' a
Word-coef (inl a' :: w) a | inl a'=a = succ $ Word-coef w a
Word-coef (inl a' :: w) a | inr a'≠a = Word-coef w a
Word-coef (inr a' :: w) a with dec a' a
Word-coef (inr a' :: w) a | inl a'=a = pred $ Word-coef w a
Word-coef (inr a' :: w) a | inr a'≠a = Word-coef w a
abstract
Word-coef-++ : ∀ w₁ w₂ a → Word-coef (w₁ ++ w₂) a
== Word-coef w₁ a ℤ+ Word-coef w₂ a
Word-coef-++ nil w₂ a = idp
Word-coef-++ (inl a' :: w₁) w₂ a with dec a' a
Word-coef-++ (inl a' :: w₁) w₂ a | inl a'=a =
ap succ (Word-coef-++ w₁ w₂ a)
∙ ! (succ-+ (Word-coef w₁ a) (Word-coef w₂ a))
Word-coef-++ (inl a' :: w₁) w₂ a | inr a'≠a = Word-coef-++ w₁ w₂ a
Word-coef-++ (inr a' :: w₁) w₂ a with dec a' a
Word-coef-++ (inr a' :: w₁) w₂ a | inl a'=a =
ap pred (Word-coef-++ w₁ w₂ a)
∙ ! (pred-+ (Word-coef w₁ a) (Word-coef w₂ a))
Word-coef-++ (inr a' :: w₁) w₂ a | inr a'≠a = Word-coef-++ w₁ w₂ a
Word-coef-flip : ∀ w a → Word-coef (Word-flip w) a == ℤ~ (Word-coef w a)
Word-coef-flip nil a = idp
Word-coef-flip (inl a' :: w) a with dec a' a
Word-coef-flip (inl a' :: w) a | inl a'=a =
ap pred (Word-coef-flip w a) ∙ ! (ℤ~-succ (Word-coef w a))
Word-coef-flip (inl a' :: w) a | inr a'≠a = Word-coef-flip w a
Word-coef-flip (inr a' :: w) a with dec a' a
Word-coef-flip (inr a' :: w) a | inl a'=a =
ap succ (Word-coef-flip w a) ∙ ! (ℤ~-pred (Word-coef w a))
Word-coef-flip (inr a' :: w) a | inr a'≠a = Word-coef-flip w a
private
abstract
FormalSum-coef-rel : {w₁ w₂ : Word A} → FormalSumRel w₁ w₂
→ ∀ a → Word-coef w₁ a == Word-coef w₂ a
FormalSum-coef-rel (fsr-refl p) a = ap (λ w → Word-coef w a) p
FormalSum-coef-rel (fsr-trans fwr₁ fwr₂) a = (FormalSum-coef-rel fwr₁ a) ∙ (FormalSum-coef-rel fwr₂ a)
FormalSum-coef-rel (fsr-sym fsr) a = ! $ FormalSum-coef-rel fsr a
FormalSum-coef-rel (fsr-cons x fwr) a =
Word-coef-++ (x :: nil) _ a
∙ ap (Word-coef (x :: nil) a ℤ+_) (FormalSum-coef-rel fwr a)
∙ ! (Word-coef-++ (x :: nil) _ a)
FormalSum-coef-rel (fsr-swap x y w) a =
Word-coef-++ (x :: y :: nil) _ a
∙ ap (_ℤ+ Word-coef w a)
( Word-coef-++ (x :: nil) (y :: nil) a
∙ ℤ+-comm (Word-coef (x :: nil) a) (Word-coef (y :: nil) a)
∙ ! (Word-coef-++ (y :: nil) (x :: nil) a))
∙ ! (Word-coef-++ (y :: x :: nil) _ a)
FormalSum-coef-rel (fsr-flip x w) a =
Word-coef-++ (x :: flip x :: nil) w a
∙ ap (_ℤ+ Word-coef w a)
( Word-coef-++ (x :: nil) (flip x :: nil) a
∙ ap (Word-coef (x :: nil) a ℤ+_) (Word-coef-flip (x :: nil) a)
∙ ℤ~-inv-r (Word-coef (x :: nil) a) )
∙ ℤ+-unit-l (Word-coef w a)
FormalSum-coef : FormalSum A → (A → ℤ)
FormalSum-coef = FormalSum-rec (→-is-set ℤ-is-set) Word-coef (λ r → λ= $ FormalSum-coef-rel r)
-- Theorem : if coef w a == 0 then FormalSumRel w nil
private
exp : A → ℤ → Word A
exp a (pos 0) = nil
exp a (pos (S n)) = inl a :: exp a (pos n)
exp a (negsucc 0) = inr a :: nil
exp a (negsucc (S n)) = inr a :: exp a (negsucc n)
abstract
exp-succ : ∀ a z → FormalSumRel (inl a :: exp a z) (exp a (succ z))
exp-succ a (pos _) = fsr-refl idp
exp-succ a (negsucc 0) = fsr-flip (inl a) nil
exp-succ a (negsucc (S n)) = fsr-flip (inl a) (exp a (negsucc n))
exp-pred : ∀ a z → FormalSumRel (inr a :: exp a z) (exp a (pred z))
exp-pred a (pos 0) = fsr-refl idp
exp-pred a (pos (S n)) = fsr-flip (inr a) (exp a (pos n))
exp-pred a (negsucc _) = fsr-refl idp
Word-coef-inl-eq : ∀ {a b} (p : b == a) w
→ Word-coef (inl b :: w) a == succ (Word-coef w a)
Word-coef-inl-eq {a} {b} p w with dec b a
Word-coef-inl-eq {a} {b} p w | inl _ = idp
Word-coef-inl-eq {a} {b} p w | inr ¬p = ⊥-rec (¬p p)
Word-coef-inr-eq : ∀ {a b} (p : b == a) w
→ Word-coef (inr b :: w) a == pred (Word-coef w a)
Word-coef-inr-eq {a} {b} p w with dec b a
Word-coef-inr-eq {a} {b} p w | inl _ = idp
Word-coef-inr-eq {a} {b} p w | inr ¬p = ⊥-rec (¬p p)
Word-coef-inl-neq : ∀ {a b} (p : b ≠ a) w
→ Word-coef (inl b :: w) a == Word-coef w a
Word-coef-inl-neq {a} {b} ¬p w with dec b a
Word-coef-inl-neq {a} {b} ¬p w | inl p = ⊥-rec (¬p p)
Word-coef-inl-neq {a} {b} ¬p w | inr _ = idp
Word-coef-inr-neq : ∀ {a b} (p : b ≠ a) w
→ Word-coef (inr b :: w) a == Word-coef w a
Word-coef-inr-neq {a} {b} ¬p w with dec b a
Word-coef-inr-neq {a} {b} ¬p w | inl p = ⊥-rec (¬p p)
Word-coef-inr-neq {a} {b} ¬p w | inr _ = idp
-- TODO maybe there is a better way to prove the final theorem?
-- Here we are collecting all elements [inl a] and [inr a], and recurse on the rest.
-- The [right-shorter] field makes sure that it is terminating.
record CollectSplitIH (a : A) {n : ℕ} (w : Word A) (len : length w == n) : Type i where
field
left-exponent : ℤ
left-captures-all : Word-coef w a == left-exponent
right-list : Word A
right-shorter : length right-list ≤ n
fsr : FormalSumRel w (exp a left-exponent ++ right-list)
abstract
collect-split : ∀ a {n} w (len=n : length w == n) → CollectSplitIH a w len=n
collect-split a nil idp = record {
left-exponent = 0;
left-captures-all = idp;
right-list = nil;
right-shorter = inl idp;
fsr = fsr-refl idp}
collect-split a (inl b :: w) idp with dec b a
... | inl b=a = record {
left-exponent = succ left-exponent;
left-captures-all = Word-coef-inl-eq b=a w ∙ ap succ left-captures-all;
right-list = right-list;
right-shorter = ≤-trans right-shorter (inr ltS);
fsr = fsr-trans (fsr-refl (ap (λ a → inl a :: w) b=a)) $
fsr-trans (fsr-cons (inl a) fsr) $
(FormalSumRel-cong-++-l (exp-succ a left-exponent) right-list)}
where open CollectSplitIH (collect-split a w idp)
... | inr b≠a = record {
left-exponent = left-exponent;
left-captures-all = Word-coef-inl-neq b≠a w ∙ left-captures-all;
right-list = inl b :: right-list;
right-shorter = ≤-ap-S right-shorter;
fsr = fsr-trans (fsr-cons (inl b) fsr) $
fsr-sym (FormalSumRel-swap1 (inl b) (exp a left-exponent) right-list)}
where open CollectSplitIH (collect-split a w idp)
collect-split a (inr b :: w) idp with dec b a
... | inl b=a = record {
left-exponent = pred left-exponent;
left-captures-all = Word-coef-inr-eq b=a w ∙ ap pred left-captures-all;
right-list = right-list;
right-shorter = ≤-trans right-shorter (inr ltS);
fsr = fsr-trans (fsr-refl (ap (λ a → inr a :: w) b=a)) $
fsr-trans (fsr-cons (inr a) fsr) $
(FormalSumRel-cong-++-l (exp-pred a left-exponent) right-list)}
where open CollectSplitIH (collect-split a w idp)
... | inr b≠a = record {
left-exponent = left-exponent;
left-captures-all = Word-coef-inr-neq b≠a w ∙ left-captures-all;
right-list = inr b :: right-list;
right-shorter = ≤-ap-S right-shorter;
fsr = fsr-trans (fsr-cons (inr b) fsr) $
fsr-sym (FormalSumRel-swap1 (inr b) (exp a left-exponent) right-list)}
where open CollectSplitIH (collect-split a w idp)
-- We simulate strong induction by recursing on both [m] and [n≤m].
-- We could develop a general framework for strong induction but I am lazy. -Favonia
zero-coef-is-ident' : ∀ {m n} (n≤m : n ≤ m) (w : Word A) (len : length w == n)
→ (∀ a → Word-coef w a == 0) → FormalSumRel w nil
zero-coef-is-ident' (inr ltS) w len zero-coef
= zero-coef-is-ident' (inl idp) w len zero-coef
zero-coef-is-ident' (inr (ltSR lt)) w len zero-coef
= zero-coef-is-ident' (inr lt) w len zero-coef
zero-coef-is-ident' {m = O} (inl idp) nil _ _ = fsr-refl idp
zero-coef-is-ident' {m = O} (inl idp) (_ :: _) len _ = ⊥-rec $ ℕ-S≠O _ len
zero-coef-is-ident' {m = S m} (inl idp) nil len _ = ⊥-rec $ ℕ-S≠O _ (! len)
zero-coef-is-ident' {m = S m} (inl idp) (inl a :: w) len zero-coef =
fsr-trans whole-is-right (zero-coef-is-ident' right-shorter right-list idp right-zero-coef)
where
open CollectSplitIH (collect-split a w (ℕ-S-is-inj _ _ len))
left-exponent-is-minus-one : left-exponent == -1
left-exponent-is-minus-one = succ-is-inj left-exponent -1 $
ap succ (! left-captures-all) ∙ ! (Word-coef-inl-eq idp w) ∙ zero-coef a
whole-is-right : FormalSumRel (inl a :: w) right-list
whole-is-right =
fsr-trans (fsr-cons (inl a) fsr) $
fsr-trans (fsr-refl (ap (λ e → inl a :: exp a e ++ right-list) left-exponent-is-minus-one)) $
fsr-flip (inl a) right-list
right-zero-coef : ∀ a' → Word-coef right-list a' == 0
right-zero-coef a' = ! (FormalSum-coef-rel whole-is-right a') ∙ zero-coef a'
zero-coef-is-ident' {m = S m} (inl idp) (inr a :: w) len zero-coef =
fsr-trans whole-is-right (zero-coef-is-ident' right-shorter right-list idp right-zero-coef)
where
open CollectSplitIH (collect-split a w (ℕ-S-is-inj _ _ len))
left-exponent-is-one : left-exponent == 1
left-exponent-is-one = pred-is-inj left-exponent 1 $
ap pred (! left-captures-all) ∙ ! (Word-coef-inr-eq idp w) ∙ zero-coef a
whole-is-right : FormalSumRel (inr a :: w) right-list
whole-is-right =
fsr-trans (fsr-cons (inr a) fsr) $
fsr-trans (fsr-refl (ap (λ e → inr a :: exp a e ++ right-list) left-exponent-is-one)) $
fsr-flip (inr a) right-list
right-zero-coef : ∀ a' → Word-coef right-list a' == 0
right-zero-coef a' = ! (FormalSum-coef-rel whole-is-right a') ∙ zero-coef a'
zero-coef-is-ident : ∀ (w : Word A)
→ (∀ a → Word-coef w a == 0)
→ FormalSumRel w nil
zero-coef-is-ident w = zero-coef-is-ident' (inl idp) w idp
abstract
FormalSum-coef-ext' : ∀ w₁ w₂
→ (∀ a → Word-coef w₁ a == Word-coef w₂ a)
→ fs[ w₁ ] == fs[ w₂ ]
FormalSum-coef-ext' w₁ w₂ same-coef = G.inv-is-inj fs[ w₁ ] fs[ w₂ ] $
G.inv-unique-l (G.inv fs[ w₂ ]) fs[ w₁ ] $ quot-rel $
zero-coef-is-ident (Word-flip w₂ ++ w₁)
(λ a → Word-coef-++ (Word-flip w₂) w₁ a
∙ ap2 _ℤ+_ (Word-coef-flip w₂ a) (same-coef a)
∙ ℤ~-inv-l (Word-coef w₂ a))
where module G = FreeAbGroup A
FormalSum-coef-ext : ∀ fs₁ fs₂
→ (∀ a → FormalSum-coef fs₁ a == FormalSum-coef fs₂ a)
→ fs₁ == fs₂
FormalSum-coef-ext = FormalSum-elim
(λ fs₁ → Π-is-set λ fs₂ → →-is-set $ =-preserves-set FormalSum-is-set)
(λ w₁ → FormalSum-elim
(λ fs₂ → →-is-set $ =-preserves-set FormalSum-is-set)
(λ w₂ → FormalSum-coef-ext' w₁ w₂)
(λ _ → prop-has-all-paths-↓ (→-is-prop $ FormalSum-is-set _ _)))
(λ _ → prop-has-all-paths-↓ (Π-is-prop λ _ → →-is-prop $ FormalSum-is-set _ _))
has-finite-support : (A → ℤ) → Type i
has-finite-support f = Σ (FormalSum A) λ fs → ∀ a → f a == FormalSum-coef fs a
module _ {dec : has-dec-eq A} where
abstract
has-finite-support-is-prop : ∀ f → is-prop (has-finite-support dec f)
has-finite-support-is-prop f = all-paths-is-prop
λ{(fs₁ , match₁) (fs₂ , match₂) → pair=
(FormalSum-coef-ext dec fs₁ fs₂ λ a → ! (match₁ a) ∙ match₂ a)
(prop-has-all-paths-↓ $ Π-is-prop λ _ → ℤ-is-set _ _)}
|
{
"alphanum_fraction": 0.544841369,
"avg_line_length": 46.91015625,
"ext": "agda",
"hexsha": "eef123f3f5c19241dd4f401f6b14a3ad4e2a3fec",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2018-12-26T21:31:57.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-12-26T21:31:57.000Z",
"max_forks_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "mikeshulman/HoTT-Agda",
"max_forks_repo_path": "theorems/groups/CoefficientExtensionality.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "mikeshulman/HoTT-Agda",
"max_issues_repo_path": "theorems/groups/CoefficientExtensionality.agda",
"max_line_length": 108,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "mikeshulman/HoTT-Agda",
"max_stars_repo_path": "theorems/groups/CoefficientExtensionality.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 4433,
"size": 12009
}
|
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NConnected
open import lib.types.Bool
open import lib.types.Nat
open import lib.types.TLevel
open import lib.types.Suspension
module lib.types.IteratedSuspension where
⊙Susp^ : ∀ {i} (n : ℕ) → Ptd i → Ptd i
⊙Susp^ O X = X
⊙Susp^ (S n) X = ⊙Susp (⊙Susp^ n X)
abstract
⊙Susp^-conn : ∀ {i} (n : ℕ) {X : Ptd i} {m : ℕ₋₂}
{{_ : is-connected m (de⊙ X)}} → is-connected (⟨ n ⟩₋₂ +2+ m) (de⊙ (⊙Susp^ n X))
⊙Susp^-conn O = ⟨⟩
⊙Susp^-conn (S n) = Susp-conn (⊙Susp^-conn n)
⊙Susp^-conn' : ∀ {i} (n : ℕ) {X : Ptd i}
{{_ : is-connected 0 (de⊙ X)}} → is-connected ⟨ n ⟩ (de⊙ (⊙Susp^ n X))
⊙Susp^-conn' O = ⟨⟩
⊙Susp^-conn' (S n) = Susp-conn (⊙Susp^-conn' n)
⊙Susp^-+ : ∀ {i} (m n : ℕ) {X : Ptd i}
→ ⊙Susp^ m (⊙Susp^ n X) == ⊙Susp^ (m + n) X
⊙Susp^-+ O n = idp
⊙Susp^-+ (S m) n = ap ⊙Susp (⊙Susp^-+ m n)
⊙Susp^-fmap : ∀ {i j} (n : ℕ) {X : Ptd i} {Y : Ptd j}
→ X ⊙→ Y → ⊙Susp^ n X ⊙→ ⊙Susp^ n Y
⊙Susp^-fmap O f = f
⊙Susp^-fmap (S n) f = ⊙Susp-fmap (⊙Susp^-fmap n f)
⊙Susp^-fmap-idf : ∀ {i} (n : ℕ) (X : Ptd i)
→ ⊙Susp^-fmap n (⊙idf X) == ⊙idf (⊙Susp^ n X)
⊙Susp^-fmap-idf O X = idp
⊙Susp^-fmap-idf (S n) X =
ap ⊙Susp-fmap (⊙Susp^-fmap-idf n X) ∙ ⊙Susp-fmap-idf (⊙Susp^ n X)
⊙Susp^-fmap-cst : ∀ {i j} (n : ℕ) {X : Ptd i} {Y : Ptd j}
→ ⊙Susp^-fmap n (⊙cst {X = X} {Y = Y}) == ⊙cst
⊙Susp^-fmap-cst O = idp
⊙Susp^-fmap-cst (S n) = ap ⊙Susp-fmap (⊙Susp^-fmap-cst n)
∙ (⊙Susp-fmap-cst {X = ⊙Susp^ n _})
⊙Susp^-fmap-∘ : ∀ {i j k} (n : ℕ) {X : Ptd i} {Y : Ptd j} {Z : Ptd k}
(g : Y ⊙→ Z) (f : X ⊙→ Y)
→ ⊙Susp^-fmap n (g ⊙∘ f) == ⊙Susp^-fmap n g ⊙∘ ⊙Susp^-fmap n f
⊙Susp^-fmap-∘ O g f = idp
⊙Susp^-fmap-∘ (S n) g f =
ap ⊙Susp-fmap (⊙Susp^-fmap-∘ n g f)
∙ ⊙Susp-fmap-∘ (⊙Susp^-fmap n g) (⊙Susp^-fmap n f)
⊙Susp^-Susp-split-iso : ∀ {i} (n : ℕ) (X : Ptd i)
→ ⊙Susp^ (S n) X ⊙≃ ⊙Susp^ n (⊙Susp X)
⊙Susp^-Susp-split-iso O X = ⊙ide _
⊙Susp^-Susp-split-iso (S n) X = ⊙Susp-emap (⊙Susp^-Susp-split-iso n X)
⊙Sphere : (n : ℕ) → Ptd₀
⊙Sphere n = ⊙Susp^ n ⊙Bool
Sphere : (n : ℕ) → Type₀
Sphere n = de⊙ (⊙Sphere n)
abstract
instance
Sphere-conn : ∀ (n : ℕ) → is-connected ⟨ n ⟩₋₁ (Sphere n)
Sphere-conn 0 = inhab-conn true
Sphere-conn (S n) = Susp-conn (Sphere-conn n)
-- favonia: [S¹] has its own elim rules in Circle.agda.
⊙S⁰ = ⊙Sphere 0
⊙S¹ = ⊙Sphere 1
⊙S² = ⊙Sphere 2
⊙S³ = ⊙Sphere 3
S⁰ = Sphere 0
S¹ = Sphere 1
S² = Sphere 2
S³ = Sphere 3
|
{
"alphanum_fraction": 0.5243264978,
"avg_line_length": 29.6071428571,
"ext": "agda",
"hexsha": "bdaf29bbc039b4ad582aea19f0b8b76f29503ff0",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "timjb/HoTT-Agda",
"max_forks_repo_path": "core/lib/types/IteratedSuspension.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "timjb/HoTT-Agda",
"max_issues_repo_path": "core/lib/types/IteratedSuspension.agda",
"max_line_length": 84,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "timjb/HoTT-Agda",
"max_stars_repo_path": "core/lib/types/IteratedSuspension.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1271,
"size": 2487
}
|
{-
Basic theory about h-levels/n-types:
- Basic properties of isContr, isProp and isSet (definitions are in Prelude)
- Hedberg's theorem can be found in Cubical/Relation/Nullary/DecidableEq
-}
{-# OPTIONS --cubical --safe #-}
module Cubical.Foundations.HLevels where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.FunExtEquiv
open import Cubical.Foundations.GroupoidLaws
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Transport
open import Cubical.Foundations.HAEquiv using (congEquiv)
open import Cubical.Foundations.Equiv using (isoToEquiv; isPropIsEquiv; retEq; invEquiv)
open import Cubical.Foundations.Univalence using (ua; univalence)
open import Cubical.Data.Sigma using (ΣPathP; sigmaPath→pathSigma; pathSigma≡sigmaPath; _Σ≡T_)
open import Cubical.Data.Nat using (ℕ; zero; suc; _+_; +-comm)
private
variable
ℓ ℓ' : Level
A : Type ℓ
B : A → Type ℓ
x y : A
n : ℕ
hProp : Type (ℓ-suc ℓ)
hProp {ℓ} = Σ (Type ℓ) isProp
isOfHLevel : ℕ → Type ℓ → Type ℓ
isOfHLevel 0 A = isContr A
isOfHLevel 1 A = isProp A
isOfHLevel (suc (suc n)) A = (x y : A) → isOfHLevel (suc n) (x ≡ y)
isOfHLevelDep : ℕ → {A : Type ℓ} (B : A → Type ℓ') → Type (ℓ-max ℓ ℓ')
isOfHLevelDep 0 {A = A} B = {a : A} → B a
isOfHLevelDep 1 {A = A} B = {a0 a1 : A} (b0 : B a0) (b1 : B a1) (p : a0 ≡ a1) → PathP (λ i → B (p i)) b0 b1
isOfHLevelDep (suc (suc n)) {A = A} B = {a0 a1 : A} (b0 : B a0) (b1 : B a1) → isOfHLevelDep (suc n) {A = a0 ≡ a1} (λ p → PathP (λ i → B (p i)) b0 b1)
isOfHLevel→isOfHLevelDep : {n : ℕ} → {A : Type ℓ} {B : A → Type ℓ'} (h : (a : A) → isOfHLevel n (B a)) → isOfHLevelDep n {A = A} B
isOfHLevel→isOfHLevelDep {n = 0} {A = A} {B} h {a} = h a .fst
isOfHLevel→isOfHLevelDep {n = 1} {A = A} {B} h = λ b0 b1 p → isProp→PathP h p b0 b1
isOfHLevel→isOfHLevelDep {n = suc (suc n)} {A = A} {B} h {a0} {a1} b0 b1 =
isOfHLevel→isOfHLevelDep {n = suc n}
{B = λ p → PathP (λ i → B (p i)) b0 b1} λ p → helper a1 p b1
where
helper : (a1 : A) (p : a0 ≡ a1) (b1 : B a1) →
isOfHLevel (suc n) (PathP (λ i → B (p i)) b0 b1)
helper a1 p b1 = J
(λ a1 p → ∀ b1 → isOfHLevel (suc n) (PathP (λ i → B (p i)) b0 b1))
(λ _ → h _ _ _) p b1
HLevel : ℕ → Type (ℓ-suc ℓ)
HLevel {ℓ} n = Σ[ A ∈ Type ℓ ] (isOfHLevel n A)
inhProp→isContr : A → isProp A → isContr A
inhProp→isContr x h = x , h x
isPropIsProp : isProp (isProp A)
isPropIsProp f g i a b = isProp→isSet f a b (f a b) (g a b) i
-- A retract of a contractible type is contractible
retractIsContr
: ∀ {B : Type ℓ}
→ (f : A → B) (g : B → A)
→ (h : (x : A) → g (f x) ≡ x)
→ (v : isContr B) → isContr A
retractIsContr f g h (b , p) = (g b , λ x → (cong g (p (f x))) ∙ (h x))
retractIsProp
: {B : Type ℓ}
(f : A → B) (g : B → A)
(h : (x : A) → g (f x) ≡ x)
→ isProp B → isProp A
retractIsProp f g h p x y i =
hcomp
(λ j → λ
{ (i = i0) → h x j
; (i = i1) → h y j})
(g (p (f x) (f y) i))
retractIsOfHLevel
: (n : ℕ) {B : Type ℓ}
(f : A → B) (g : B → A)
(h : (x : A) → g (f x) ≡ x)
→ isOfHLevel n B → isOfHLevel n A
retractIsOfHLevel 0 = retractIsContr
retractIsOfHLevel 1 = retractIsProp
retractIsOfHLevel (suc (suc n)) f g h ofLevel x y =
retractIsOfHLevel (suc n)
(cong f)
(λ q i →
hcomp
(λ j → λ
{ (i = i0) → h x j
; (i = i1) → h y j})
(g (q i)))
(λ p k i →
hcomp
(λ j → λ
{ (i = i0) → h x (j ∨ k)
; (i = i1) → h y (j ∨ k)
; (k = i1) → p i})
(h (p i) k))
(ofLevel (f x) (f y))
isContrSigma
: isContr A
→ ((x : A) → isContr (B x))
→ isContr (Σ[ x ∈ A ] B x)
isContrSigma {A = A} {B = B} (a , p) q =
let h : (x : A) (y : B x) → (q x) .fst ≡ y
h x y = (q x) .snd y
in (( a , q a .fst)
, ( λ x i → p (x .fst) i
, h (p (x .fst) i) (transp (λ j → B (p (x .fst) (i ∨ ~ j))) i (x .snd)) i))
isProp→isPropPathP : (∀ a → isProp (B a))
→ (m : x ≡ y) (g : B x) (h : B y)
→ isProp (PathP (λ i → B (m i)) g h)
isProp→isPropPathP {B = B} {x = x} isPropB m = J P d m where
P : ∀ σc → x ≡ σc → _
P _ m = ∀ g h → isProp (PathP (λ i → B (m i)) g h)
d : P x refl
d = isProp→isSet (isPropB x)
isProp→isContrPathP : (∀ a → isProp (B a))
→ (m : x ≡ y) (g : B x) (h : B y)
→ isContr (PathP (λ i → B (m i)) g h)
isProp→isContrPathP isPropB m g h =
inhProp→isContr (isProp→PathP isPropB m g h) (isProp→isPropPathP isPropB m g h)
isProp→isContr≡ : isProp A → (x y : A) → isContr (x ≡ y)
isProp→isContr≡ isPropA x y = inhProp→isContr (isPropA x y) (isProp→isSet isPropA x y)
isContrPath : isContr A → (x y : A) → isContr (x ≡ y)
isContrPath cA = isProp→isContr≡ (isContr→isProp cA)
-- Π preserves propositionality in the following sense:
propPi : (h : (x : A) → isProp (B x)) → isProp ((x : A) → B x)
propPi h f0 f1 i x = h x (f0 x) (f1 x) i
ΣProp≡
: ((x : A) → isProp (B x)) → {u v : Σ[ a ∈ A ] B a}
→ (p : u .fst ≡ v .fst) → u ≡ v
ΣProp≡ pB {u} {v} p i = (p i) , isProp→PathP pB p (u .snd) (v .snd) i
isPropSigma : isProp A → ((x : A) → isProp (B x)) → isProp (Σ[ x ∈ A ] B x)
isPropSigma pA pB t u = ΣProp≡ pB (pA (t .fst) (u .fst))
hLevelPi
: ∀ n
→ ((x : A) → isOfHLevel n (B x))
→ isOfHLevel n ((x : A) → B x)
hLevelPi 0 h = (λ x → fst (h x)) , λ f i y → snd (h y) (f y) i
hLevelPi {B = B} 1 h f g i x = (h x) (f x) (g x) i
hLevelPi (suc (suc n)) h f g =
subst (isOfHLevel (suc n)) funExtPath (hLevelPi (suc n) λ x → h x (f x) (g x))
isSetPi : ((x : A) → isSet (B x)) → isSet ((x : A) → B x)
isSetPi Bset = hLevelPi 2 (λ a → Bset a)
isSet→isSet' : isSet A → isSet' A
isSet→isSet' {A = A} Aset {x} {y} {z} {w} p q r s
= transport (squeezeSq≡ r p q s) (Aset _ _ p (r ∙∙ q ∙∙ sym s))
isSet'→isSet : isSet' A → isSet A
isSet'→isSet {A = A} Aset' x y p q = Aset' p q refl refl
squeezeCu≡
: ∀{w x y z w' x' y' z' : A}
→ {p : w ≡ y} {q : w ≡ x} {r : y ≡ z} {s : x ≡ z}
→ {p' : w' ≡ y'} {q' : w' ≡ x'} {r' : y' ≡ z'} {s' : x' ≡ z'}
→ {a : w ≡ w'} {b : x ≡ x'} {c : y ≡ y'} {d : z ≡ z'}
→ (ps : Square a p p' c) (qs : Square a q q' b)
→ (rs : Square c r r' d) (ss : Square b s s' d)
→ (f0 : Square p q r s) (f1 : Square p' q' r' s')
→ (f0 ≡ transport⁻ (λ k → Square (ps k) (qs k) (rs k) (ss k)) f1)
≡ Cube ps qs rs ss f0 f1
squeezeCu≡ ps qs rs ss f0 f1 τ
= Cube
(λ j → ps (j ∧ τ))
(λ j → qs (j ∧ τ))
(λ j → rs (j ∧ τ))
(λ j → ss (j ∧ τ))
f0
(toPathP {A = λ k → Square (ps k) (qs k) (rs k) (ss k)}
(transportTransport⁻ (λ k → Square (ps k) (qs k) (rs k) (ss k)) f1) τ)
isGroupoid→isGroupoid' : isGroupoid A → isGroupoid' A
isGroupoid→isGroupoid' Agpd ps qs rs ss f0 f1
= transport
( squeezeCu≡ (λ _ → refl) f0 f1' (λ _ → refl) (λ _ → f0 i0) (λ _ → f1' i1)
∙ transpose≡
∙ squeezeCu≡ ps qs rs ss f0 f1
) (Agpd (ps i0 i0) (ss i0 i0) (f0 i0) (f1' i0) refl rs')
where
Sq = λ k → Square (ps k) (qs k) (rs k) (ss k)
f1' = transport⁻ Sq f1
rs' = transport⁻ (λ k → Square refl (f0 k) (f1' k) refl) (λ _ → f1' i1)
transpose≡
: Cube (λ i _ → ps i0 i) f0 f1' (λ i _ → ss i0 i) refl refl
≡ Cube refl refl refl refl f0 f1'
transpose≡
= ua ((λ cu i j → cu j i)
, λ where
.equiv-proof cu
→ ((λ i j → cu j i) , refl)
, (λ{ (cu' , p) → λ k → (λ j i → p (~ k) i j) , λ τ → p (~ k ∨ τ) }))
isGroupoid'→isGroupoid : isGroupoid' A → isGroupoid A
isGroupoid'→isGroupoid Agpd' w x p q r s
= Agpd' {q = p} {r = q} {q' = p} {r' = q} refl refl refl refl r s
hLevelSuc : (n : ℕ) (A : Type ℓ) → isOfHLevel n A → isOfHLevel (suc n) A
hLevelSuc 0 A = isContr→isProp
hLevelSuc 1 A = isProp→isSet
hLevelSuc (suc (suc n)) A h a b = hLevelSuc (suc n) (a ≡ b) (h a b)
hLevelLift : (m : ℕ) (hA : isOfHLevel n A) → isOfHLevel (m + n) A
hLevelLift zero hA = hA
hLevelLift {A = A} (suc m) hA = hLevelSuc _ A (hLevelLift m hA)
isPropIsOfHLevel : (n : ℕ) (A : Type ℓ) → isProp (isOfHLevel n A)
isPropIsOfHLevel 0 A = isPropIsContr
isPropIsOfHLevel 1 A = isPropIsProp
isPropIsOfHLevel (suc (suc n)) A f g i a b =
isPropIsOfHLevel (suc n) (a ≡ b) (f a b) (g a b) i
isPropIsSet : isProp (isSet A)
isPropIsSet {A = A} = isPropIsOfHLevel 2 A
HLevel≡ : ∀ {A B : Type ℓ} {hA : isOfHLevel n A} {hB : isOfHLevel n B} →
(A ≡ B) ≡ ((A , hA) ≡ (B , hB))
HLevel≡ {n = n} {A = A} {B = B} {hA} {hB} =
isoToPath (iso intro elim intro-elim elim-intro)
where
intro : A ≡ B → (A , hA) ≡ (B , hB)
intro eq = ΣProp≡ (λ A → isPropIsOfHLevel n _) eq
elim : (A , hA) ≡ (B , hB) → A ≡ B
elim = cong fst
intro-elim : ∀ x → intro (elim x) ≡ x
intro-elim eq = cong ΣPathP (ΣProp≡ (λ e →
J (λ B e →
∀ k → (x y : PathP (λ i → isOfHLevel n (e i)) hA k) → x ≡ y)
(λ k → isProp→isSet (isPropIsOfHLevel n _) _ _) e hB) refl)
elim-intro : ∀ x → elim (intro x) ≡ x
elim-intro eq = refl
-- H-level for Σ-types
isOfHLevelΣ : ∀ n → isOfHLevel n A → ((x : A) → isOfHLevel n (B x))
→ isOfHLevel n (Σ A B)
isOfHLevelΣ zero h1 h2 =
let center = (fst h1 , fst (h2 (fst h1))) in
let p : ∀ x → center ≡ x
p = λ x → sym (sigmaPath→pathSigma _ _ (sym (snd h1 (fst x)) , sym (snd (h2 (fst h1)) _)))
in (center , p)
isOfHLevelΣ 1 h1 h2 x y = sigmaPath→pathSigma x y ((h1 _ _) , (h2 _ _ _))
isOfHLevelΣ {B = B} (suc (suc n)) h1 h2 x y =
let h3 : isOfHLevel (suc n) (x Σ≡T y)
h3 = isOfHLevelΣ (suc n) (h1 (fst x) (fst y)) λ p → h2 (p i1)
(subst B p (snd x)) (snd y)
in transport (λ i → isOfHLevel (suc n) (pathSigma≡sigmaPath x y (~ i))) h3
hLevel≃ : ∀ n → {A B : Type ℓ} (hA : isOfHLevel n A) (hB : isOfHLevel n B) → isOfHLevel n (A ≃ B)
hLevel≃ zero {A = A} {B = B} hA hB = A≃B , contr
where
A≃B : A ≃ B
A≃B = isoToEquiv (iso (λ _ → fst hB) (λ _ → fst hA) (snd hB ) (snd hA))
contr : (y : A ≃ B) → A≃B ≡ y
contr y = ΣProp≡ isPropIsEquiv (funExt (λ a → snd hB (fst y a)))
hLevel≃ (suc n) hA hB =
isOfHLevelΣ (suc n) (hLevelPi (suc n) (λ _ → hB))
(λ a → subst (λ n → isOfHLevel n (isEquiv a)) (+-comm n 1) (hLevelLift n (isPropIsEquiv a)))
hLevelRespectEquiv : {A : Type ℓ} {B : Type ℓ'} → (n : ℕ) → A ≃ B → isOfHLevel n A → isOfHLevel n B
hLevelRespectEquiv 0 eq hA =
( fst eq (fst hA)
, λ b → cong (fst eq) (snd hA (eq .snd .equiv-proof b .fst .fst)) ∙ eq .snd .equiv-proof b .fst .snd)
hLevelRespectEquiv 1 eq hA x y i =
hcomp (λ j → λ { (i = i0) → retEq eq x j ; (i = i1) → retEq eq y j })
(cong (eq .fst) (hA (invEquiv eq .fst x) (invEquiv eq .fst y)) i)
hLevelRespectEquiv {A = A} {B = B} (suc (suc n)) eq hA x y =
hLevelRespectEquiv (suc n) (invEquiv (congEquiv (invEquiv eq))) (hA _ _)
hLevel≡ : ∀ n → {A B : Type ℓ} (hA : isOfHLevel n A) (hB : isOfHLevel n B) →
isOfHLevel n (A ≡ B)
hLevel≡ n hA hB = hLevelRespectEquiv n (invEquiv univalence) (hLevel≃ n hA hB)
hLevelHLevel1 : isProp (HLevel {ℓ = ℓ} 0)
hLevelHLevel1 x y = ΣProp≡ (λ _ → isPropIsContr) ((hLevel≡ 0 (x .snd) (y .snd) .fst))
hLevelHLevelSuc : ∀ n → isOfHLevel (suc (suc n)) (HLevel {ℓ = ℓ} (suc n))
hLevelHLevelSuc n x y = subst (λ e → isOfHLevel (suc n) e) HLevel≡ (hLevel≡ (suc n) (snd x) (snd y))
hProp≡HLevel1 : hProp {ℓ} ≡ HLevel {ℓ} 1
hProp≡HLevel1 {ℓ} = isoToPath (iso intro elim intro-elim elim-intro)
where
intro : hProp {ℓ} → HLevel {ℓ} 1
intro h = fst h , snd h
elim : HLevel 1 → hProp
elim h = (fst h) , (snd h)
intro-elim : ∀ h → intro (elim h) ≡ h
intro-elim h = ΣProp≡ (λ _ → isPropIsOfHLevel 1 _) refl
elim-intro : ∀ h → elim (intro h) ≡ h
elim-intro h = ΣProp≡ (λ _ → isPropIsProp) refl
isSetHProp : isSet (hProp {ℓ = ℓ})
isSetHProp = subst (λ X → isOfHLevel 2 X) (sym hProp≡HLevel1) (hLevelHLevelSuc 0)
isContrPartial→isContr : ∀ {ℓ} {A : Type ℓ}
→ (extend : ∀ φ → Partial φ A → A)
→ (∀ u → u ≡ (extend i1 λ { _ → u}))
→ isContr A
isContrPartial→isContr {A = A} extend law
= ex , λ y → law ex ∙ (λ i → Aux.v y i) ∙ sym (law y)
where ex = extend i0 empty
module Aux (y : A) (i : I) where
φ = ~ i ∨ i
u : Partial φ A
u = λ { (i = i0) → ex ; (i = i1) → y }
v = extend φ u
isOfHLevelLift : ∀ {ℓ ℓ'} (n : ℕ) {A : Type ℓ} → isOfHLevel n A → isOfHLevel n (Lift {j = ℓ'} A)
isOfHLevelLift n = retractIsOfHLevel n lower lift λ _ → refl
|
{
"alphanum_fraction": 0.540521214,
"avg_line_length": 36.4811594203,
"ext": "agda",
"hexsha": "c592d46ed874a6842987632ef070e1bb8f1d54d6",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cj-xu/cubical",
"max_forks_repo_path": "Cubical/Foundations/HLevels.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cj-xu/cubical",
"max_issues_repo_path": "Cubical/Foundations/HLevels.agda",
"max_line_length": 150,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cj-xu/cubical",
"max_stars_repo_path": "Cubical/Foundations/HLevels.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 5636,
"size": 12586
}
|
module Type.Core where
open import Context
open import Function
infix 3 _⊢ᵗ_
infixr 6 _⇒ᵏ_ _⇒_
infixl 7 _∙_
-- | A `Kind` is either a star or an arrow.
data Kind : Set where
⋆ : Kind
_⇒ᵏ_ : Kind -> Kind -> Kind
-- | Kind contexts.
Conᵏ : Set
Conᵏ = Con Kind
mutual
-- | Types of kind `⋆`.
Star : Conᵏ -> Set
Star Θ = Θ ⊢ᵗ ⋆
-- | A type is defined in a context and has a kind.
data _⊢ᵗ_ Θ : Kind -> Set where
Var : ∀ {σ} -> (v : σ ∈ Θ) -> Θ ⊢ᵗ σ
Lam_ : ∀ {σ τ} -> (β : Θ ▻ σ ⊢ᵗ τ) -> Θ ⊢ᵗ σ ⇒ᵏ τ
_∙_ : ∀ {σ τ} -> (φ : Θ ⊢ᵗ σ ⇒ᵏ τ) -> (α : Θ ⊢ᵗ σ) -> Θ ⊢ᵗ τ
_⇒_ : (α : Star Θ) -> (β : Star Θ) -> Star Θ
π : ∀ σ -> (β : Star (Θ ▻ σ)) -> Star Θ
μ : ∀ {κ} -> (ψ : Θ ⊢ᵗ (κ ⇒ᵏ ⋆) ⇒ᵏ κ ⇒ᵏ ⋆) -> (α : Θ ⊢ᵗ κ) -> Star Θ
-- | Closed types.
Type⁽⁾ : Kind -> Set
Type⁽⁾ σ = ε ⊢ᵗ σ
-- | Closed types that can be used in any context.
Type⁺ : Kind -> Set
Type⁺ σ = ∀ {Γ} -> Γ ⊢ᵗ σ
Star⁺ : Set
Star⁺ = Type⁺ ⋆
bindᵗ : ∀ {Θ σ τ} -> Θ ⊢ᵗ σ -> Θ ▻ σ ⊢ᵗ τ -> Θ ⊢ᵗ τ
bindᵗ α β = (Lam β) ∙ α
-- | Expand the context that a type is defined in, but do not change anything in the type
-- (including variables).
wkᵗ : ∀ {Θ Ξ σ} -> Ξ ⊢ᵗ σ -> Θ ▻▻ Ξ ⊢ᵗ σ
wkᵗ (Var v) = Var (wkᵛ v)
wkᵗ (Lam β) = Lam (wkᵗ β)
wkᵗ (φ ∙ α) = wkᵗ φ ∙ wkᵗ α
wkᵗ (α ⇒ β) = wkᵗ α ⇒ wkᵗ β
wkᵗ (π σ β) = π σ (wkᵗ β)
wkᵗ (μ ψ α) = μ (wkᵗ ψ) (wkᵗ α)
-- | Lift a closed type to any context.
wk⁺ : ∀ {σ} -> Type⁽⁾ σ -> Type⁺ σ
wk⁺ α = wkᵗ α
-- | Rename a type.
renᵗ : ∀ {Θ Ξ σ} -> Θ ⊆ Ξ -> Θ ⊢ᵗ σ -> Ξ ⊢ᵗ σ
renᵗ ι (Var v) = Var (renᵛ ι v)
renᵗ ι (Lam β) = Lam (renᵗ (keep ι) β)
renᵗ ι (φ ∙ α) = renᵗ ι φ ∙ renᵗ ι α
renᵗ ι (α ⇒ β) = renᵗ ι α ⇒ renᵗ ι β
renᵗ ι (π σ α) = π σ (renᵗ (keep ι) α)
renᵗ ι (μ ψ α) = μ (renᵗ ι ψ) (renᵗ ι α)
-- | Extend the context of a type by another context and increase all variables as appropriate.
shiftᵗⁿ : ∀ {Θ σ} Ξ -> Θ ⊢ᵗ σ -> Θ ▻▻ Ξ ⊢ᵗ σ
shiftᵗⁿ Ξ = renᵗ (extʳ Ξ)
-- | Increase all variables in a type by one.
shiftᵗ : ∀ {Θ σ τ} -> Θ ⊢ᵗ σ -> Θ ▻ τ ⊢ᵗ σ
shiftᵗ = shiftᵗⁿ (ε ▻ _)
unshiftᵗ : ∀ {Θ σ τ} -> Θ ▻ σ ▻ σ ⊢ᵗ τ -> Θ ▻ σ ⊢ᵗ τ
unshiftᵗ = renᵗ dupl
shiftᶜⁿ : ∀ {Θ σ} Ξ -> Con (Θ ⊢ᵗ σ) -> Con (Θ ▻▻ Ξ ⊢ᵗ σ)
shiftᶜⁿ Ξ = mapᶜ (shiftᵗⁿ Ξ)
shiftᶜ : ∀ {Θ σ τ} -> Con (Θ ⊢ᵗ σ) -> Con (Θ ▻ τ ⊢ᵗ σ)
shiftᶜ = mapᶜ shiftᵗ
environmentᵗ : Environment _⊢ᵗ_
environmentᵗ = record
{ varᵈ = Var
; renᵈ = renᵗ
}
module TypeEnv = Environment environmentᵗ
_⊢ᵗᵉ_ = TypeEnv._⊢ᵉ_
module _ where
open TypeEnv
subᵗ : ∀ {Θ Ξ σ} -> Ξ ⊢ᵗᵉ Θ -> Θ ⊢ᵗ σ -> Ξ ⊢ᵗ σ
subᵗ ρ (Var v) = lookupᵉ v ρ
subᵗ ρ (Lam β) = Lam (subᵗ (keepᵉ ρ) β)
subᵗ ρ (φ ∙ α) = subᵗ ρ φ ∙ subᵗ ρ α
subᵗ ρ (α ⇒ β) = subᵗ ρ α ⇒ subᵗ ρ β
subᵗ ρ (π σ β) = π σ (subᵗ (keepᵉ ρ) β)
subᵗ ρ (μ ψ α) = μ (subᵗ ρ ψ) (subᵗ ρ α)
_<_>ᵗ : ∀ {Θ σ τ} -> Θ ▻ σ ⊢ᵗ τ -> Θ ⊢ᵗ σ -> Θ ⊢ᵗ τ
β < α >ᵗ = subᵗ (topᵉ α) β
-- | Right-fold a context with `_⇒ᵏ_ ∘ f`.
--
-- > conToKindBy f (ε ▻ σ₁ ▻ … ▻ σₙ) τ = f σ₁ ⇒ᵏ … ⇒ᵏ f σₙ ⇒ᵏ τ
conToKindBy : ∀ {α} {A : Set α} -> (A -> Kind) -> Con A -> Kind -> Kind
conToKindBy f Θ τ = foldrᶜ (_⇒ᵏ_ ∘ f) τ Θ
-- | Right-fold a context with `_⇒ᵏ_`.
--
-- > conToKind (ε ▻ σ₁ ▻ … ▻ σₙ) τ = σ₁ ⇒ᵏ … ⇒ᵏ σₙ ⇒ᵏ τ
conToKind : Conᵏ -> Kind -> Kind
conToKind = conToKindBy id
-- | Construct an environment with n variables going in reverse order.
--
-- > subVars' = ∅ ▷ (n - 1) ▷ … ▷ 0
--
-- (each variable is denoted by its De Bruijn index).
subVars' : ∀ {Θ Ξ} -> Seq (λ σ -> Ξ ▻▻ Θ ⊢ᵗ σ) Θ
subVars' {ε} = ø
subVars' {Θ ▻ σ} = mapˢ shiftᵗ subVars' ▶ Var vz
-- | Construct an environment with n variables going in reverse order.
--
-- > subVars' = ∅ ▷ (n - 1) ▷ … ▷ 0
--
-- (each variable is denoted by its De Bruijn index).
subVars : ∀ {α} {A : Set α} {Ξ Θ} {f : A -> Kind} -> Seq (λ σ -> Ξ ▻▻ mapᶜ f Θ ⊢ᵗ f σ) Θ
subVars {Θ = ε} = ø
subVars {Θ = Θ ▻ σ} = mapˢ shiftᵗ subVars ▶ Var vz
-- | Apply π` to a type `n` times.
--
-- > πⁿ' (ε ▻ σ₁ ▻ … ▻ σₙ) β = πₙ ∘ … ∘ π₁ $ β
πⁿ' : ∀ {Ξ} Θ -> Star (Ξ ▻▻ Θ) -> Star Ξ
πⁿ' ε β = β
πⁿ' (Θ ▻ σ) β = πⁿ' Θ (π σ β)
-- | Apply `Lam` to a type `n` times.
--
-- > Lamⁿ' (ε ▻ σ₁ ▻ … ▻ σₙ) β = Lamₙ ∘ … ∘ Lam₁ $ β
Lamⁿ' : ∀ {Ξ τ} Θ -> Ξ ▻▻ Θ ⊢ᵗ τ -> Ξ ⊢ᵗ conToKind Θ τ
Lamⁿ' ε β = β
Lamⁿ' (Θ ▻ σ) β = Lamⁿ' Θ (Lam β)
-- | Apply `Lam` to a type `n` times.
--
-- > Lamⁿ' (ε ▻ σ₁ ▻ … ▻ σₙ) β = Lamₙ ∘ … ∘ Lam₁ $ β
Lamⁿ : ∀ {α} {A : Set α} {Ξ τ f} (Θ : Con A) -> Ξ ▻▻ mapᶜ f Θ ⊢ᵗ τ -> Ξ ⊢ᵗ conToKindBy f Θ τ
Lamⁿ ε β = β
Lamⁿ (Θ ▻ σ) β = Lamⁿ Θ (Lam β)
-- | Apply a type function to an environment.
--
-- > applyᵗⁿ _ ψ (∅ ▷ α₁ ▷ … ▷ αₙ) = ψ α₁ … αₙ
applyᵗⁿ
: ∀ {α} {A : Set α} {Ξ f τ}
-> (Θ : Con A)
-> Ξ ⊢ᵗ foldrᶜ (_⇒ᵏ_ ∘ f) τ Θ
-> Seq (λ σ -> Ξ ⊢ᵗ f σ) Θ
-> Ξ ⊢ᵗ τ
applyᵗⁿ _ ψ ø = ψ
applyᵗⁿ _ ψ (ρ ▶ α) = applyᵗⁿ _ ψ ρ ∙ α
instᵗⁿ
: ∀ {α} {A : Set α} {Θ Ξ σ} {f : Con A -> Kind}
-> Seq (λ τ -> Θ ⊢ᵗ f τ) Ξ -> Θ ▻▻ mapᶜ f Ξ ⊢ᵗ σ -> Θ ⊢ᵗ σ
instᵗⁿ ø β = β
instᵗⁿ {Ξ = Ξ ▻ _} (ρ ▶ α) β = instᵗⁿ ρ (bindᵗ (shiftᵗⁿ (mapᶜ _ Ξ) α) β)
instᵗⁿ' : ∀ {Θ Ξ σ} -> Seq (Θ ⊢ᵗ_) Ξ -> Θ ▻▻ Ξ ⊢ᵗ σ -> Θ ⊢ᵗ σ
instᵗⁿ' ø β = β
instᵗⁿ' {Ξ = Ξ ▻ _} (ρ ▶ α) β = instᵗⁿ' ρ (bindᵗ (shiftᵗⁿ Ξ α) β)
conToTypeBy : ∀ {Θ Ξ} -> (Star Θ -> Star Ξ) -> Con (Star Θ) -> Star Ξ -> Star Ξ
conToTypeBy f Δ β = foldrᶜ (_⇒_ ∘ f) β Δ
|
{
"alphanum_fraction": 0.4992360581,
"avg_line_length": 28,
"ext": "agda",
"hexsha": "46cfd6f9e60f2b5a3220996ddff3d4498a7d7d90",
"lang": "Agda",
"max_forks_count": 399,
"max_forks_repo_forks_event_max_datetime": "2022-03-31T11:18:25.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-10-05T09:36:10.000Z",
"max_forks_repo_head_hexsha": "f7d34336cd3d65f62b0da084a16f741dc9156413",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "AriFordsham/plutus",
"max_forks_repo_path": "papers/unraveling-recursion/code/src/Type/Core.agda",
"max_issues_count": 2493,
"max_issues_repo_head_hexsha": "f7d34336cd3d65f62b0da084a16f741dc9156413",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T15:31:31.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-09-28T19:28:17.000Z",
"max_issues_repo_licenses": [
"Apache-2.0"
],
"max_issues_repo_name": "AriFordsham/plutus",
"max_issues_repo_path": "papers/unraveling-recursion/code/src/Type/Core.agda",
"max_line_length": 95,
"max_stars_count": 1299,
"max_stars_repo_head_hexsha": "f7d34336cd3d65f62b0da084a16f741dc9156413",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "AriFordsham/plutus",
"max_stars_repo_path": "papers/unraveling-recursion/code/src/Type/Core.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-28T01:10:02.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-10-02T13:41:39.000Z",
"num_tokens": 3099,
"size": 5236
}
|
module Adjunctions where
open import Library
open import Categories
open import Functors
open Cat
open Fun
record Adj {a b c d}(C : Cat {a}{b})(D : Cat {c}{d}) : Set (a ⊔ b ⊔ c ⊔ d)
where
constructor adjunction
field L : Fun C D
R : Fun D C
left : {X : Obj C}{Y : Obj D} →
Hom D (OMap L X) Y → Hom C X (OMap R Y)
right : {X : Obj C}{Y : Obj D} →
Hom C X (OMap R Y) → Hom D (OMap L X) Y
lawa : {X : Obj C}{Y : Obj D}(f : Hom D (OMap L X) Y) →
right (left f) ≅ f
lawb : {X : Obj C}{Y : Obj D}(f : Hom C X (OMap R Y)) →
left (right f) ≅ f
natleft : {X X' : Obj C}{Y Y' : Obj D}
(f : Hom C X' X)(g : Hom D Y Y')
(h : Hom D (OMap L X) Y) →
comp C (HMap R g) (comp C (left h) f)
≅
left (comp D g (comp D h (HMap L f)))
natright : {X X' : Obj C}{Y Y' : Obj D}
(f : Hom C X' X)(g : Hom D Y Y')
(h : Hom C X (OMap R Y)) →
right (comp C (HMap R g) (comp C h f))
≅
comp D g (comp D (right h) (HMap L f))
|
{
"alphanum_fraction": 0.390513834,
"avg_line_length": 36.1428571429,
"ext": "agda",
"hexsha": "3b010400be8aca1a90510163d675f5cbb010dc66",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-11-04T21:33:13.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-11-04T21:33:13.000Z",
"max_forks_repo_head_hexsha": "74707d3538bf494f4bd30263d2f5515a84733865",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "jmchapman/Relative-Monads",
"max_forks_repo_path": "Adjunctions.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "74707d3538bf494f4bd30263d2f5515a84733865",
"max_issues_repo_issues_event_max_datetime": "2019-05-29T09:50:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-13T13:12:33.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "jmchapman/Relative-Monads",
"max_issues_repo_path": "Adjunctions.agda",
"max_line_length": 74,
"max_stars_count": 21,
"max_stars_repo_head_hexsha": "74707d3538bf494f4bd30263d2f5515a84733865",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "jmchapman/Relative-Monads",
"max_stars_repo_path": "Adjunctions.agda",
"max_stars_repo_stars_event_max_datetime": "2021-02-13T18:02:18.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-07-30T01:25:12.000Z",
"num_tokens": 426,
"size": 1265
}
|
------------------------------------------------------------------------
-- A combined definition of strong and weak bisimilarity and
-- expansion, along with various properties
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
module Delay-monad.Sized.Bisimilarity where
open import Equality.Propositional as E using (_≡_)
open import Logical-equivalence using (_⇔_)
open import Prelude
open import Prelude.Size
open import Function-universe E.equality-with-J hiding (_∘_; Kind)
open import Delay-monad.Sized
open import Delay-monad.Bisimilarity.Kind
------------------------------------------------------------------------
-- The code below is defined for a fixed type family A
module _ {a} {A : Size → Type a} where
----------------------------------------------------------------------
-- The relations
mutual
-- A combined definition of all three relations. The definition
-- uses mixed induction and coinduction.
--
-- Note that this type is not defined in the same way as Delay.
-- One might argue that the now constructor should have the
-- following type, using a /sized/ identity type Id:
--
-- now : ∀ {x y} →
-- Id (A ∞) i x y →
-- [ i ] now x ∼ now y
infix 4 [_]_⟨_⟩_ [_]_⟨_⟩′_
data [_]_⟨_⟩_ (i : Size) :
Delay A ∞ → Kind → Delay A ∞ → Type a where
now : ∀ {k x} → [ i ] now x ⟨ k ⟩ now x
later : ∀ {k x₁ x₂} →
[ i ] force x₁ ⟨ k ⟩′ force x₂ →
[ i ] later x₁ ⟨ k ⟩ later x₂
laterˡ : ∀ {k x₁ x₂} →
[ i ] force x₁ ⟨ other k ⟩ x₂ →
[ i ] later x₁ ⟨ other k ⟩ x₂
laterʳ : ∀ {x₁ x₂} →
[ i ] x₁ ⟨ other weak ⟩ force x₂ →
[ i ] x₁ ⟨ other weak ⟩ later x₂
record [_]_⟨_⟩′_ (i : Size)
(x₁ : Delay A ∞) (k : Kind) (x₂ : Delay A ∞) :
Type a where
coinductive
field
force : {j : Size< i} → [ j ] x₁ ⟨ k ⟩ x₂
open [_]_⟨_⟩′_ public
-- Strong bisimilarity.
infix 4 [_]_∼_ [_]_∼′_ _∼_ _∼′_
[_]_∼_ : Size → Delay A ∞ → Delay A ∞ → Type a
[_]_∼_ = [_]_⟨ strong ⟩_
[_]_∼′_ : Size → Delay A ∞ → Delay A ∞ → Type a
[_]_∼′_ = [_]_⟨ strong ⟩′_
_∼_ : Delay A ∞ → Delay A ∞ → Type a
_∼_ = [ ∞ ]_∼_
_∼′_ : Delay A ∞ → Delay A ∞ → Type a
_∼′_ = [ ∞ ]_∼′_
-- Expansion.
infix 4 [_]_≳_ [_]_≳′_ _≳_ _≳′_
[_]_≳_ : Size → Delay A ∞ → Delay A ∞ → Type a
[_]_≳_ = [_]_⟨ other expansion ⟩_
[_]_≳′_ : Size → Delay A ∞ → Delay A ∞ → Type a
[_]_≳′_ = [_]_⟨ other expansion ⟩′_
_≳_ : Delay A ∞ → Delay A ∞ → Type a
_≳_ = [ ∞ ]_≳_
_≳′_ : Delay A ∞ → Delay A ∞ → Type a
_≳′_ = [ ∞ ]_≳′_
-- The converse of expansion.
infix 4 [_]_≲_ [_]_≲′_ _≲_ _≲′_
[_]_≲_ : Size → Delay A ∞ → Delay A ∞ → Type a
[_]_≲_ i = flip [ i ]_⟨ other expansion ⟩_
[_]_≲′_ : Size → Delay A ∞ → Delay A ∞ → Type a
[_]_≲′_ i = flip [ i ]_⟨ other expansion ⟩′_
_≲_ : Delay A ∞ → Delay A ∞ → Type a
_≲_ = [ ∞ ]_≲_
_≲′_ : Delay A ∞ → Delay A ∞ → Type a
_≲′_ = [ ∞ ]_≲′_
-- Weak bisimilarity.
infix 4 [_]_≈_ [_]_≈′_ _≈_ _≈′_
[_]_≈_ : Size → Delay A ∞ → Delay A ∞ → Type a
[_]_≈_ = [_]_⟨ other weak ⟩_
[_]_≈′_ : Size → Delay A ∞ → Delay A ∞ → Type a
[_]_≈′_ = [_]_⟨ other weak ⟩′_
_≈_ : Delay A ∞ → Delay A ∞ → Type a
_≈_ = [ ∞ ]_≈_
_≈′_ : Delay A ∞ → Delay A ∞ → Type a
_≈′_ = [ ∞ ]_≈′_
----------------------------------------------------------------------
-- Conversions
-- Strong bisimilarity is contained in the other relations (and
-- itself).
∼→ : ∀ {k i x y} → [ i ] x ∼ y → [ i ] x ⟨ k ⟩ y
∼→ now = now
∼→ (later p) = later λ { .force → ∼→ (force p) }
-- Expansion is contained in weak bisimilarity (and expansion).
≳→ : ∀ {k i x y} → [ i ] x ≳ y → [ i ] x ⟨ other k ⟩ y
≳→ now = now
≳→ (later p) = later λ { .force → ≳→ (force p) }
≳→ (laterˡ p) = laterˡ (≳→ p)
-- In some cases weak bisimilarity is contained in expansion (and
-- itself).
≈→-now : ∀ {k i x y} → [ i ] x ≈ now y → [ i ] x ⟨ other k ⟩ now y
≈→-now now = now
≈→-now (laterˡ p) = laterˡ (≈→-now p)
-- In some cases all three relations are contained in strong
-- bisimilarity.
→∼-neverˡ : ∀ {k i x} → [ i ] never ⟨ k ⟩ x → [ i ] never ∼ x
→∼-neverˡ (later p) = later λ { .force → →∼-neverˡ (force p) }
→∼-neverˡ (laterˡ p) = →∼-neverˡ p
→∼-neverˡ (laterʳ p) = later λ { .force → →∼-neverˡ p }
→∼-neverʳ : ∀ {k i x} → [ i ] x ⟨ k ⟩ never → [ i ] x ∼ never
→∼-neverʳ (later p) = later λ { .force → →∼-neverʳ (force p) }
→∼-neverʳ (laterˡ p) = later λ { .force → →∼-neverʳ p }
→∼-neverʳ (laterʳ p) = →∼-neverʳ p
----------------------------------------------------------------------
-- Removing later constructors
-- Later constructors can sometimes be removed.
drop-laterʳ :
∀ {k i} {j : Size< i} {x y} →
[ i ] x ⟨ other k ⟩ y →
[ j ] x ⟨ other k ⟩ drop-later y
drop-laterʳ now = now
drop-laterʳ (later p) = laterˡ (force p)
drop-laterʳ (laterʳ p) = p
drop-laterʳ (laterˡ p) = laterˡ (drop-laterʳ p)
drop-laterˡ :
∀ {i} {j : Size< i} {x y} →
[ i ] x ≈ y →
[ j ] drop-later x ≈ y
drop-laterˡ now = now
drop-laterˡ (later p) = laterʳ (force p)
drop-laterˡ (laterʳ p) = laterʳ (drop-laterˡ p)
drop-laterˡ (laterˡ p) = p
drop-laterˡʳ :
∀ {k i} {j : Size< i} {x y} →
[ i ] x ⟨ k ⟩ y →
[ j ] drop-later x ⟨ k ⟩ drop-later y
drop-laterˡʳ now = now
drop-laterˡʳ (later p) = force p
drop-laterˡʳ (laterʳ p) = drop-laterˡ p
drop-laterˡʳ (laterˡ p) = drop-laterʳ p
-- Special cases of the functions above.
laterʳ⁻¹ : ∀ {k i} {j : Size< i} {x y} →
[ i ] x ⟨ other k ⟩ later y →
[ j ] x ⟨ other k ⟩ force y
laterʳ⁻¹ = drop-laterʳ
laterˡ⁻¹ : ∀ {i} {j : Size< i} {x y} →
[ i ] later x ≈ y →
[ j ] force x ≈ y
laterˡ⁻¹ = drop-laterˡ
later⁻¹ : ∀ {k i} {j : Size< i} {x y} →
[ i ] later x ⟨ k ⟩ later y →
[ j ] force x ⟨ k ⟩ force y
later⁻¹ = drop-laterˡʳ
-- The following size-preserving variant of laterʳ⁻¹ and laterˡ⁻¹
-- can be defined.
--
-- Several other variants cannot be defined if ∀ i → A i is
-- inhabited, see Delay-monad.Bisimilarity.Sized.Negative.
laterˡʳ⁻¹ :
∀ {k i x y} →
[ i ] later x ⟨ other k ⟩ force y →
[ i ] force x ⟨ other k ⟩ later y →
[ i ] force x ⟨ other k ⟩ force y
laterˡʳ⁻¹ {k} {i} p q = laterˡʳ⁻¹′ p q E.refl E.refl
where
laterˡʳ⁻¹″ :
∀ {x′ y′ x y} →
({j : Size< i} → [ j ] x′ ⟨ other k ⟩ force y) →
({j : Size< i} → [ j ] force x ⟨ other k ⟩ y′) →
x′ ≡ later x → y′ ≡ later y →
[ i ] later x ⟨ other k ⟩ later y
laterˡʳ⁻¹″ p q E.refl E.refl = later λ { .force → laterˡʳ⁻¹ p q }
laterˡʳ⁻¹′ :
∀ {x′ y′ x y} →
[ i ] later x ⟨ other k ⟩ y′ →
[ i ] x′ ⟨ other k ⟩ later y →
force x ≡ x′ → force y ≡ y′ →
[ i ] x′ ⟨ other k ⟩ y′
laterˡʳ⁻¹′ (later p) (later q) ≡x′ ≡y′ = laterˡʳ⁻¹″ (force p) (force q) ≡x′ ≡y′
laterˡʳ⁻¹′ (laterʳ p) (later q) ≡x′ ≡y′ = laterˡʳ⁻¹″ (λ { {_} → laterˡ⁻¹ p }) (force q) ≡x′ ≡y′
laterˡʳ⁻¹′ (later p) (laterˡ q) ≡x′ ≡y′ = laterˡʳ⁻¹″ (force p) (λ { {_} → laterʳ⁻¹ q }) ≡x′ ≡y′
laterˡʳ⁻¹′ (laterʳ p) (laterˡ q) ≡x′ ≡y′ = laterˡʳ⁻¹″ (λ { {_} → laterˡ⁻¹ p }) (λ { {_} → laterʳ⁻¹ q }) ≡x′ ≡y′
laterˡʳ⁻¹′ (laterˡ p) _ E.refl E.refl = p
laterˡʳ⁻¹′ _ (laterʳ q) E.refl ≡y′ = E.subst ([ i ] _ ⟨ _ ⟩_) ≡y′ q
----------------------------------------------------------------------
-- Reflexivity, symmetry/antisymmetry, transitivity
-- All three relations are reflexive.
reflexive : ∀ {k i} x → [ i ] x ⟨ k ⟩ x
reflexive (now _) = now
reflexive (later x) = later λ { .force → reflexive (force x) }
-- Strong and weak bisimilarity are symmetric.
symmetric :
∀ {k i x y} {¬≳ : if k ≟-Kind other expansion then ⊥ else ⊤} →
[ i ] x ⟨ k ⟩ y → [ i ] y ⟨ k ⟩ x
symmetric now = now
symmetric (laterˡ {k = weak} p) = laterʳ (symmetric p)
symmetric (laterʳ p) = laterˡ (symmetric p)
symmetric {¬≳ = ¬≳} (later p) =
later λ { .force → symmetric {¬≳ = ¬≳} (force p) }
symmetric {¬≳ = ()} (laterˡ {k = expansion} _)
-- Some special cases of symmetry hold for expansion.
symmetric-neverˡ : ∀ {i x} → [ i ] never ≳ x → [ i ] x ≳ never
symmetric-neverˡ = ∼→ ∘ symmetric ∘ →∼-neverˡ
symmetric-neverʳ : ∀ {i x} → [ i ] x ≳ never → [ i ] never ≳ x
symmetric-neverʳ = ∼→ ∘ symmetric ∘ →∼-neverʳ
-- The expansion relation is antisymmetric (up to weak
-- bisimilarity).
antisymmetric-≳ : ∀ {i x y} → [ i ] x ≳ y → [ i ] y ≳ x → [ i ] x ≈ y
antisymmetric-≳ p _ = ≳→ p
-- Several more or less size-preserving variants of transitivity.
--
-- Many size-preserving variants cannot be defined if ∀ i → A i is
-- inhabited, see Delay-monad.Sized.Bisimilarity.Negative.
transitive-∼ʳ :
∀ {k i x y z}
{¬≈ : if k ≟-Kind other weak then ⊥ else ⊤} →
[ i ] x ⟨ k ⟩ y → [ i ] y ∼ z → [ i ] x ⟨ k ⟩ z
transitive-∼ʳ now now = now
transitive-∼ʳ {¬≈ = ¬≈} (laterˡ p) q = laterˡ
(transitive-∼ʳ {¬≈ = ¬≈} p q)
transitive-∼ʳ {¬≈ = ()} (laterʳ _) _
transitive-∼ʳ {¬≈ = ¬≈} (later p) (later q) =
later λ { .force → transitive-∼ʳ {¬≈ = ¬≈} (force p) (force q) }
transitive-∼ˡ :
∀ {k i x y z} →
x ∼ y → [ i ] y ⟨ k ⟩ z → [ i ] x ⟨ k ⟩ z
transitive-∼ˡ now now = now
transitive-∼ˡ (later p) (later q) = later λ { .force →
transitive-∼ˡ (force p) (force q) }
transitive-∼ˡ (later p) (laterˡ q) = laterˡ (transitive-∼ˡ (force p) q)
transitive-∼ˡ p (laterʳ q) = laterʳ (transitive-∼ˡ p q)
transitive-∞∼ʳ :
∀ {k i x y z} →
[ i ] x ⟨ k ⟩ y → y ∼ z → [ i ] x ⟨ k ⟩ z
transitive-∞∼ʳ now now = now
transitive-∞∼ʳ (later p) (later q) = later λ { .force →
transitive-∞∼ʳ (force p) (force q) }
transitive-∞∼ʳ (laterˡ p) q = laterˡ (transitive-∞∼ʳ p q)
transitive-∞∼ʳ (laterʳ p) (later q) = laterʳ (transitive-∞∼ʳ p (force q))
transitive-≳ˡ :
∀ {k i x y z} →
x ≳ y → [ i ] y ⟨ other k ⟩ z → [ i ] x ⟨ other k ⟩ z
transitive-≳ˡ now now = now
transitive-≳ˡ (later p) (later q) = later λ { .force →
transitive-≳ˡ (force p) (force q) }
transitive-≳ˡ (later p) (laterˡ q) = laterˡ (transitive-≳ˡ (force p) q)
transitive-≳ˡ (laterˡ p) q = laterˡ (transitive-≳ˡ p q)
transitive-≳ˡ p (laterʳ q) = laterʳ (transitive-≳ˡ p q)
transitive-≈≲ :
∀ {i x y z} →
[ i ] x ≈ y → y ≲ z → [ i ] x ≈ z
transitive-≈≲ p q = symmetric (transitive-≳ˡ q (symmetric p))
transitive-≈-now :
∀ {i x′ y z} →
let x = now x′ in
[ i ] x ≈ y → y ≈ z → [ i ] x ≈ z
transitive-≈-now now now = now
transitive-≈-now (laterʳ p) q = transitive-≈-now p (laterˡ⁻¹ q)
transitive-≈-now p (laterʳ q) = laterʳ (transitive-≈-now p q)
mutual
transitive-≈-later :
∀ {i x′ y z} →
let x = later x′ in
x ≈ y → y ≈ z → [ i ] x ≈ z
transitive-≈-later p (later q) = later λ { .force →
transitive-≈ (later⁻¹ p) (force q) }
transitive-≈-later p (laterʳ q) = laterʳ (transitive-≈-later p q)
transitive-≈-later p (laterˡ q) = transitive-≈ (laterʳ⁻¹ p) q
transitive-≈-later (laterˡ p) q = laterˡ (transitive-≈ p q)
transitive-≈ : ∀ {i x y z} → x ≈ y → y ≈ z → [ i ] x ≈ z
transitive-≈ {x = now x} p q = transitive-≈-now p q
transitive-≈ {x = later x} p q = transitive-≈-later p q
-- Equational reasoning combinators.
infix -1 _∎ finally finally-≳ finally-≈
infixr -2 step-∼ˡ step-∼∼ step-≳∼ step-≈∼ step-?∼ step-≳ˡ step-≈
_≳⟨⟩_ step-≡ˡ _∼⟨⟩_
_∎ : ∀ {k i} x → [ i ] x ⟨ k ⟩ x
_∎ = reflexive
finally : ∀ {k i} x y →
[ i ] x ⟨ k ⟩ y → [ i ] x ⟨ k ⟩ y
finally _ _ x?y = x?y
syntax finally x y x≈y = x ?⟨ x≈y ⟩∎ y ∎
finally-≳ : ∀ {i} x y →
[ i ] x ≳ y → [ i ] x ≳ y
finally-≳ _ _ x≳y = x≳y
syntax finally-≳ x y x≳y = x ≳⟨ x≳y ⟩∎ y ∎
finally-≈ : ∀ {i} x y →
[ i ] x ≈ y → [ i ] x ≈ y
finally-≈ _ _ x≈y = x≈y
syntax finally-≈ x y x≈y = x ≈⟨ x≈y ⟩∎ y ∎
step-∼ˡ : ∀ {k i} x {y z} →
[ i ] y ⟨ k ⟩ z → x ∼ y → [ i ] x ⟨ k ⟩ z
step-∼ˡ _ y⟨⟩z x∼y = transitive-∼ˡ x∼y y⟨⟩z
syntax step-∼ˡ x y⟨⟩z x∼y = x ∼⟨ x∼y ⟩ y⟨⟩z
step-∼∼ : ∀ {i} x {y z} →
[ i ] y ∼ z → [ i ] x ∼ y → [ i ] x ∼ z
step-∼∼ _ y∼z x∼y = transitive-∼ʳ x∼y y∼z
syntax step-∼∼ x y∼z x∼y = x ∼⟨ x∼y ⟩∼ y∼z
step-≳∼ : ∀ {i} x {y z} →
[ i ] y ∼ z → [ i ] x ≳ y → [ i ] x ≳ z
step-≳∼ _ y∼z x≳y = transitive-∼ʳ x≳y y∼z
syntax step-≳∼ x y∼z x≳y = x ≳⟨ x≳y ⟩∼ y∼z
step-≈∼ : ∀ {k i} x {y z} →
y ∼ z → [ i ] x ⟨ k ⟩ y → [ i ] x ⟨ k ⟩ z
step-≈∼ _ y∼z x≈y = transitive-∞∼ʳ x≈y y∼z
syntax step-≈∼ x y∼z x≈y = x ≈⟨ x≈y ⟩∼ y∼z
step-?∼ : ∀ {k i} x {y z} →
y ∼ z → [ i ] x ⟨ k ⟩ y → [ i ] x ⟨ k ⟩ z
step-?∼ _ y∼z x?y = transitive-∞∼ʳ x?y y∼z
syntax step-?∼ x y∼z x?y = x ?⟨ x?y ⟩∼ y∼z
step-≳ˡ : ∀ {k i} x {y z} →
[ i ] y ⟨ other k ⟩ z → x ≳ y →
[ i ] x ⟨ other k ⟩ z
step-≳ˡ _ y≳≈z x≳y = transitive-≳ˡ x≳y y≳≈z
syntax step-≳ˡ x y≳≈z x≳y = x ≳⟨ x≳y ⟩ y≳≈z
step-≈ : ∀ {i} x {y z} →
y ≈ z → x ≈ y → [ i ] x ≈ z
step-≈ _ y≈z x≈y = transitive-≈ x≈y y≈z
syntax step-≈ x y≈z x≈y = x ≈⟨ x≈y ⟩ y≈z
_≳⟨⟩_ : ∀ {k i} x {y} →
[ i ] drop-later x ⟨ other k ⟩ y → [ i ] x ⟨ other k ⟩ y
now _ ≳⟨⟩ p = p
later _ ≳⟨⟩ p = laterˡ p
step-≡ˡ : ∀ {k i} x {y z} →
[ i ] y ⟨ k ⟩ z → x ≡ y → [ i ] x ⟨ k ⟩ z
step-≡ˡ _ y⟨⟩z E.refl = y⟨⟩z
syntax step-≡ˡ x y⟨⟩z x≡y = x ≡⟨ x≡y ⟩ y⟨⟩z
_∼⟨⟩_ : ∀ {k i} x {y} →
[ i ] x ⟨ k ⟩ y → [ i ] x ⟨ k ⟩ y
_ ∼⟨⟩ x≈y = x≈y
----------------------------------------------------------------------
-- Some results related to negation
-- The computation never is not related to now x.
never≉now : ∀ {k i x} → ¬ [ i ] never ⟨ k ⟩ now x
never≉now (laterˡ p) = never≉now p
-- The computation now x is not related to never.
now≉never : ∀ {k i x} → ¬ [ i ] now x ⟨ k ⟩ never
now≉never (laterʳ p) = now≉never p
-- If A ∞ is uninhabited, then the three relations defined above are
-- trivial.
uninhabited→trivial : ∀ {k i} → ¬ A ∞ → ∀ x y → [ i ] x ⟨ k ⟩ y
uninhabited→trivial ¬A (now x) _ = ⊥-elim (¬A x)
uninhabited→trivial ¬A (later x) (now y) = ⊥-elim (¬A y)
uninhabited→trivial ¬A (later x) (later y) =
later λ { .force → uninhabited→trivial ¬A (force x) (force y) }
-- Expansion and weak bisimilarity are not pointwise propositional.
¬-≳≈-propositional :
∀ {k} → ¬ (∀ {x y} → E.Is-proposition ([ ∞ ] x ⟨ other k ⟩ y))
¬-≳≈-propositional {k} =
(∀ {x y} → E.Is-proposition ([ ∞ ] x ⟨ other k ⟩ y)) ↝⟨ (λ prop → prop {x = never} {y = never}) ⟩
E.Is-proposition ([ ∞ ] never ⟨ other k ⟩ never) ↝⟨ (λ irr → irr _ _) ⟩
proof₁ ≡ proof₂ ↝⟨ (λ ()) ⟩□
⊥₀ □
where
proof₁ : ∀ {i} → [ i ] never ⟨ other k ⟩ never
proof₁ = later λ { .force → proof₁ }
proof₂ : ∀ {i} → [ i ] never ⟨ other k ⟩ never
proof₂ = laterˡ proof₁
------------------------------------------------------------------------
-- A statement of extensionality for strong bisimilarity
-- A statement of extensionality: strongly bisimilar computations are
-- equal.
Extensionality : (ℓ : Level) → Type (lsuc ℓ)
Extensionality a =
{A : Size → Type a} {x y : Delay A ∞} → x ∼ y → x ≡ y
|
{
"alphanum_fraction": 0.4645029167,
"avg_line_length": 32.8857142857,
"ext": "agda",
"hexsha": "1c3fd1a8ceed5b3964db37a029e0905358c9373a",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "495f9996673d0f1f34ce202902daaa6c39f8925e",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/delay-monad",
"max_forks_repo_path": "src/Delay-monad/Sized/Bisimilarity.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "495f9996673d0f1f34ce202902daaa6c39f8925e",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/delay-monad",
"max_issues_repo_path": "src/Delay-monad/Sized/Bisimilarity.agda",
"max_line_length": 121,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "495f9996673d0f1f34ce202902daaa6c39f8925e",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/delay-monad",
"max_stars_repo_path": "src/Delay-monad/Sized/Bisimilarity.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 6892,
"size": 16114
}
|
{-# OPTIONS --without-K --safe #-}
module Categories.Diagram.Cocone.Properties where
open import Level
open import Categories.Category
open import Categories.Functor
open import Categories.Functor.Properties
open import Categories.NaturalTransformation
open import Categories.Diagram.Cone.Properties
open import Categories.Diagram.Duality
import Categories.Diagram.Cocone as Coc
import Categories.Morphism.Reasoning as MR
private
variable
o ℓ e : Level
C D J J′ : Category o ℓ e
module _ {F : Functor J C} (G : Functor C D) where
private
module C = Category C
module D = Category D
module F = Functor F
module G = Functor G
module CF = Coc F
GF = G ∘F F
module CGF = Coc GF
F-map-Coconeˡ : CF.Cocone → CGF.Cocone
F-map-Coconeˡ K = record
{ coapex = record
{ ψ = λ X → G.F₁ (ψ X)
; commute = λ f → [ G ]-resp-∘ (commute f)
}
}
where open CF.Cocone K
F-map-Cocone⇒ˡ : ∀ {K K′} (f : CF.Cocone⇒ K K′) → CGF.Cocone⇒ (F-map-Coconeˡ K) (F-map-Coconeˡ K′)
F-map-Cocone⇒ˡ f = record
{ arr = G.F₁ arr
; commute = [ G ]-resp-∘ commute
}
where open CF.Cocone⇒ f
module _ {F : Functor J C} (G : Functor J′ J) where
private
module C = Category C
module J′ = Category J′
module F = Functor F
module G = Functor G
module CF = Coc F
FG = F ∘F G
module CFG = Coc FG
F-map-Coconeʳ : CF.Cocone → CFG.Cocone
F-map-Coconeʳ K = coCone⇒Cocone C (F-map-Coneʳ G.op (Cocone⇒coCone C K))
F-map-Cocone⇒ʳ : ∀ {K K′} (f : CF.Cocone⇒ K K′) → CFG.Cocone⇒ (F-map-Coconeʳ K) (F-map-Coconeʳ K′)
F-map-Cocone⇒ʳ f = coCone⇒⇒Cocone⇒ C (F-map-Cone⇒ʳ G.op (Cocone⇒⇒coCone⇒ C f))
module _ {F G : Functor J C} (α : NaturalTransformation F G) where
private
module α = NaturalTransformation α
module CF = Coc F
module CG = Coc G
nat-map-Cocone : CG.Cocone → CF.Cocone
nat-map-Cocone K = coCone⇒Cocone C (nat-map-Cone α.op (Cocone⇒coCone C K))
nat-map-Cocone⇒ : ∀ {K K′} (f : CG.Cocone⇒ K K′) → CF.Cocone⇒ (nat-map-Cocone K) (nat-map-Cocone K′)
nat-map-Cocone⇒ f = coCone⇒⇒Cocone⇒ C (nat-map-Cone⇒ α.op (Cocone⇒⇒coCone⇒ C f))
|
{
"alphanum_fraction": 0.6324274528,
"avg_line_length": 28.9466666667,
"ext": "agda",
"hexsha": "dba9f470867f9e49c2196f72369d85367a8628e4",
"lang": "Agda",
"max_forks_count": 64,
"max_forks_repo_forks_event_max_datetime": "2022-03-14T02:00:59.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-06-02T16:58:15.000Z",
"max_forks_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Code-distancing/agda-categories",
"max_forks_repo_path": "src/Categories/Diagram/Cocone/Properties.agda",
"max_issues_count": 236,
"max_issues_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_issues_repo_issues_event_max_datetime": "2022-03-28T14:31:43.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-06-01T14:53:54.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Code-distancing/agda-categories",
"max_issues_repo_path": "src/Categories/Diagram/Cocone/Properties.agda",
"max_line_length": 102,
"max_stars_count": 279,
"max_stars_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Trebor-Huang/agda-categories",
"max_stars_repo_path": "src/Categories/Diagram/Cocone/Properties.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-22T00:40:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-06-01T14:36:40.000Z",
"num_tokens": 822,
"size": 2171
}
|
-- Andreas, 2014-10-23
-- We want to split on hidden variables.
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
f : {n : ℕ} → Set₁
f = Set
where
g : {n : ℕ} → Set → Set
g _ = {!.n!}
|
{
"alphanum_fraction": 0.5079365079,
"avg_line_length": 13.5,
"ext": "agda",
"hexsha": "41f00278ef825c96a4b919b93261746c897a8baf",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "redfish64/autonomic-agda",
"max_forks_repo_path": "test/interaction/Issue1325a.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "redfish64/autonomic-agda",
"max_issues_repo_path": "test/interaction/Issue1325a.agda",
"max_line_length": 40,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "redfish64/autonomic-agda",
"max_stars_repo_path": "test/interaction/Issue1325a.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 80,
"size": 189
}
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Coinductive "natural" numbers
------------------------------------------------------------------------
module Data.Conat where
open import Coinduction
open import Data.Nat using (ℕ; zero; suc)
open import Relation.Binary
------------------------------------------------------------------------
-- The type
data Coℕ : Set where
zero : Coℕ
suc : (n : ∞ Coℕ) → Coℕ
------------------------------------------------------------------------
-- Some operations
fromℕ : ℕ → Coℕ
fromℕ zero = zero
fromℕ (suc n) = suc (♯ fromℕ n)
∞ℕ : Coℕ
∞ℕ = suc (♯ ∞ℕ)
infixl 6 _+_
_+_ : Coℕ → Coℕ → Coℕ
zero + n = n
suc m + n = suc (♯ (♭ m + n))
------------------------------------------------------------------------
-- Equality
data _≈_ : Coℕ → Coℕ → Set where
zero : zero ≈ zero
suc : ∀ {m n} (m≈n : ∞ (♭ m ≈ ♭ n)) → suc m ≈ suc n
setoid : Setoid _ _
setoid = record
{ Carrier = Coℕ
; _≈_ = _≈_
; isEquivalence = record
{ refl = refl
; sym = sym
; trans = trans
}
}
where
refl : Reflexive _≈_
refl {zero} = zero
refl {suc n} = suc (♯ refl)
sym : Symmetric _≈_
sym zero = zero
sym (suc m≈n) = suc (♯ sym (♭ m≈n))
trans : Transitive _≈_
trans zero zero = zero
trans (suc m≈n) (suc n≈k) = suc (♯ trans (♭ m≈n) (♭ n≈k))
|
{
"alphanum_fraction": 0.3937716263,
"avg_line_length": 22.2307692308,
"ext": "agda",
"hexsha": "185e892390ce8b46d5a343286bffdfc5cc843fdf",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "9d4c43b1609d3f085636376fdca73093481ab882",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "qwe2/try-agda",
"max_forks_repo_path": "agda-stdlib-0.9/src/Data/Conat.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "9d4c43b1609d3f085636376fdca73093481ab882",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Apache-2.0"
],
"max_issues_repo_name": "qwe2/try-agda",
"max_issues_repo_path": "agda-stdlib-0.9/src/Data/Conat.agda",
"max_line_length": 72,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "9d4c43b1609d3f085636376fdca73093481ab882",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "qwe2/try-agda",
"max_stars_repo_path": "agda-stdlib-0.9/src/Data/Conat.agda",
"max_stars_repo_stars_event_max_datetime": "2016-10-20T15:52:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-10-20T15:52:05.000Z",
"num_tokens": 468,
"size": 1445
}
|
-- A DSL example in the language Agda: "polynomial types"
module TypeDSL where
open import Data.Nat using (ℕ;_+_;_*_)
data E : Set where
Zero : E
One : E
Add : (x : E) -> (y : E) -> E
Mul : (x : E) -> (y : E) -> E
two : E
two = Add One One
four : E
four = Mul two two
-- First semantics: compute the natural number "value" of the expression
card : E -> ℕ
card Zero = 0
card One = 1
card (Add x y) = card x + card y
card (Mul x y) = card x * card y
data Empty : Set where
data Unit : Set where unit : Unit
data Either (a : Set) (b : Set) : Set where
Left : a -> Either a b
Right : b -> Either a b
data Both (a : Set) (b : Set) : Set where
_,_ : a -> b -> Both a b
-- Second semantics: compute the corresponding finite type
typ : E -> Set
typ Zero = Empty
typ One = Unit
typ (Add x y) = Either (typ x) (typ y) -- disjoint union type = sum type
typ (Mul x y) = Both (typ x) (typ y) -- cartesian product type = pair type
Bool : Set
Bool = typ two
false : Bool
false = Left unit
true : Bool
true = Right unit
BothBoolBool : Set
BothBoolBool = typ four
ex1 : BothBoolBool
ex1 = ( false , true )
open import Data.Vec as V
variable
a b : Set
m n : ℕ
enumAdd : Vec a m -> Vec b n -> Vec (Either a b) (m + n)
enumAdd as bs = V.map Left as ++ V.map Right bs
enumMul : Vec a m -> Vec b n -> Vec (Both a b) (m * n)
enumMul as bs = concat (V.map (\ a -> V.map (\ b -> (a , b)) bs) as)
-- Third semantics: enumerate all the values in a vector
enumerate : (t : E) -> Vec (typ t) (card t)
enumerate Zero = []
enumerate One = [ unit ]
enumerate (Add x y) = enumAdd (enumerate x) (enumerate y)
enumerate (Mul x y) = enumMul (enumerate x) (enumerate y)
test2 : Vec (typ two) (card two) -- Vec Bool 2
test2 = enumerate two
-- false ∷ true ∷ []
test4 : Vec (typ four) (card four) -- Vec BothBoolBool 4
test4 = enumerate four
{-
(false , false) ∷
(false , true) ∷
(true , false) ∷
(true , true) ∷ []
-}
-- Exercise: add a constructor for function types
|
{
"alphanum_fraction": 0.6149974836,
"avg_line_length": 23.1046511628,
"ext": "agda",
"hexsha": "4787ff189c69f1dced0db0a5d9886a52813a2a04",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "ce764c9bbff5a726d5cf1699a433d9921a1d6a60",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "nicolabotta/DSLsofMath",
"max_forks_repo_path": "L/01/agda/TypeDSL.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "ce764c9bbff5a726d5cf1699a433d9921a1d6a60",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "nicolabotta/DSLsofMath",
"max_issues_repo_path": "L/01/agda/TypeDSL.agda",
"max_line_length": 78,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "ce764c9bbff5a726d5cf1699a433d9921a1d6a60",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "nicolabotta/DSLsofMath",
"max_stars_repo_path": "L/01/agda/TypeDSL.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-24T21:27:31.000Z",
"max_stars_repo_stars_event_min_datetime": "2022-02-24T21:27:31.000Z",
"num_tokens": 662,
"size": 1987
}
|
module IsLiteralFormula where
open import OscarPrelude
open import PredicateName
open import Term
open import Formula
open import HasNegation
data IsLiteralFormula : Formula → Set
where
atomic : (𝑃 : PredicateName) → (τs : Terms) → IsLiteralFormula $ 𝑃[ 𝑃 ♭ τs ]
logical : (𝑃 : PredicateName) → (τs : Terms) → IsLiteralFormula ∘ ~ $ 𝑃[ 𝑃 ♭ τs ]
eqIsLiteralFormula : ∀ {φ} → (lf₁ lf₂ : IsLiteralFormula φ) → lf₁ ≡ lf₂
eqIsLiteralFormula (atomic _ _) (atomic _ _) = refl
eqIsLiteralFormula (logical _ _) (logical _ _) = refl
instance EqIsLiteralFormula : ∀ {φ} → Eq (IsLiteralFormula φ)
Eq._==_ EqIsLiteralFormula lf₁ lf₂ = yes $ eqIsLiteralFormula lf₁ lf₂
|
{
"alphanum_fraction": 0.7233082707,
"avg_line_length": 31.6666666667,
"ext": "agda",
"hexsha": "dc9f89657b1f8dfad1923912f3cb0cd0efe31749",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_forks_repo_licenses": [
"RSA-MD"
],
"max_forks_repo_name": "m0davis/oscar",
"max_forks_repo_path": "archive/agda-1/IsLiteralFormula.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_issues_repo_issues_event_max_datetime": "2019-05-11T23:33:04.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-04-29T00:35:04.000Z",
"max_issues_repo_licenses": [
"RSA-MD"
],
"max_issues_repo_name": "m0davis/oscar",
"max_issues_repo_path": "archive/agda-1/IsLiteralFormula.agda",
"max_line_length": 83,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_stars_repo_licenses": [
"RSA-MD"
],
"max_stars_repo_name": "m0davis/oscar",
"max_stars_repo_path": "archive/agda-1/IsLiteralFormula.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 217,
"size": 665
}
|
open import Agda.Primitive
postulate
X : Set
Id : Set → Set
module Generic1HIT (S : Set) where
module RecType k (C : Set k) (Necc : Set) where
postulate P : Set
module Flattening k (F : Set → Set) (C : Set k) (Necc : Set) where
-- order f before C matters!
module W = Generic1HIT (F X) -- use of F matters, application of F matters
module M = W.RecType k C X -- k matters
module S¹RecType i (A : Set i) where
module FlatteningS¹ = Flattening i Id A X -- i matters here
module HopfJunior = S¹RecType _ Set -- meta variable matters
|
{
"alphanum_fraction": 0.665480427,
"avg_line_length": 26.7619047619,
"ext": "agda",
"hexsha": "04ef333d30e179f6c0c7ee80169fcb0ca39b49e1",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Succeed/Issue2150.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Succeed/Issue2150.agda",
"max_line_length": 77,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Succeed/Issue2150.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 186,
"size": 562
}
|
data Nat : Set where
zero : Nat -- Comment which gets eaten
suc : Nat -> Nat
{-# BUILTIN NATURAL
Nat #-}
f : Nat -> Nat
f a = 3
g : Nat -> Nat
g a = 4
--TODO found first bug
function : Nat -> (Nat -> Nat) -> Nat
function a f = f a
apply : Nat
apply = function 2 g
|
{
"alphanum_fraction": 0.5833333333,
"avg_line_length": 12.5454545455,
"ext": "agda",
"hexsha": "2a3e172dc82c0652323cb01de6b7a3803961ae11",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-01-31T08:40:41.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-01-31T08:40:41.000Z",
"max_forks_repo_head_hexsha": "52d1034aed14c578c9e077fb60c3db1d0791416b",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "omega12345/RefactorAgda",
"max_forks_repo_path": "RefactorAgdaEngine/Test/Tests/input/Test2.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "52d1034aed14c578c9e077fb60c3db1d0791416b",
"max_issues_repo_issues_event_max_datetime": "2019-02-05T12:53:36.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-31T08:03:07.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "omega12345/RefactorAgda",
"max_issues_repo_path": "RefactorAgdaEngine/Test/Tests/input/Test2.agda",
"max_line_length": 40,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "52d1034aed14c578c9e077fb60c3db1d0791416b",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "omega12345/RefactorAgda",
"max_stars_repo_path": "RefactorAgdaEngine/Test/Tests/input/Test2.agda",
"max_stars_repo_stars_event_max_datetime": "2019-05-03T10:03:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-01-31T14:10:18.000Z",
"num_tokens": 93,
"size": 276
}
|
open import Web.Semantic.DL.ABox using ( ABox )
open import Web.Semantic.DL.Signature using ( Signature )
open import Web.Semantic.DL.TBox using ( TBox )
module Web.Semantic.DL.KB where
infixr 4 _,_
data KB (Σ : Signature) (X : Set) : Set where
_,_ : (T : TBox Σ) → (A : ABox Σ X) → KB Σ X
tbox : ∀ {Σ X} → KB Σ X → TBox Σ
tbox (T , A) = T
abox : ∀ {Σ X} → KB Σ X → ABox Σ X
abox (T , A) = A
|
{
"alphanum_fraction": 0.6140350877,
"avg_line_length": 23.4705882353,
"ext": "agda",
"hexsha": "17998e95fd7d5382517d2e00dc0f7ecb1eca26b2",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:40:03.000Z",
"max_forks_repo_forks_event_min_datetime": "2017-12-03T14:52:09.000Z",
"max_forks_repo_head_hexsha": "8ddbe83965a616bff6fc7a237191fa261fa78bab",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "agda/agda-web-semantic",
"max_forks_repo_path": "src/Web/Semantic/DL/KB.agda",
"max_issues_count": 4,
"max_issues_repo_head_hexsha": "8ddbe83965a616bff6fc7a237191fa261fa78bab",
"max_issues_repo_issues_event_max_datetime": "2021-01-04T20:57:19.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-11-14T02:32:28.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "agda/agda-web-semantic",
"max_issues_repo_path": "src/Web/Semantic/DL/KB.agda",
"max_line_length": 57,
"max_stars_count": 9,
"max_stars_repo_head_hexsha": "8ddbe83965a616bff6fc7a237191fa261fa78bab",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "agda/agda-web-semantic",
"max_stars_repo_path": "src/Web/Semantic/DL/KB.agda",
"max_stars_repo_stars_event_max_datetime": "2020-03-14T14:21:08.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-13T17:46:41.000Z",
"num_tokens": 166,
"size": 399
}
|
-- Andreas, 2022-03-28, issue #5856, reported by Szumi Xie.
-- Patterns in path-lambdas were simply ignored, but should be illegal.
{-# OPTIONS --cubical #-}
open import Agda.Builtin.Cubical.Path
postulate
A E : Set
a : A
data C : Set where
c : E → C
p : a ≡ a
p = λ (c e) → e
-- WAS: panic about unbound identifier e.
-- Expected error:
-- Patterns are not allowed in Path-lambdas
-- when checking that the expression λ .patternInTele0 @ (c e) → e has type a ≡ a
|
{
"alphanum_fraction": 0.6666666667,
"avg_line_length": 20.7391304348,
"ext": "agda",
"hexsha": "dd3b3d13e1d1899e1d47869e75392ce25db201aa",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "KDr2/agda",
"max_forks_repo_path": "test/Fail/Issue5856b.agda",
"max_issues_count": 6,
"max_issues_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_issues_repo_issues_event_max_datetime": "2021-11-24T08:31:10.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-10-18T08:12:24.000Z",
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "KDr2/agda",
"max_issues_repo_path": "test/Fail/Issue5856b.agda",
"max_line_length": 81,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "KDr2/agda",
"max_stars_repo_path": "test/Fail/Issue5856b.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 152,
"size": 477
}
|
module Issue1245AmbiguousParse where
postulate
A : Set
*_* : A → A
_*_ : A → A → A
module M (_ : A) where
module N (a : A) = M * a * a * a *
|
{
"alphanum_fraction": 0.5466666667,
"avg_line_length": 13.6363636364,
"ext": "agda",
"hexsha": "ca7022a4240a170d673d301c48590cf233acddf4",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Fail/Issue1245AmbiguousParse.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Fail/Issue1245AmbiguousParse.agda",
"max_line_length": 36,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Fail/Issue1245AmbiguousParse.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 59,
"size": 150
}
|
------------------------------------------------------------------------
-- Safe modules that use --erased-cubical
------------------------------------------------------------------------
{-# OPTIONS --safe --erased-cubical #-}
module README.Safe.Cubical.Erased where
-- Paths, extensionality and univalence.
import Equality.Path
-- Isomorphisms and equalities relating an arbitrary "equality with J"
-- to path equality, along with proofs of extensionality and
-- univalence for the "equality with J".
import Equality.Path.Isomorphisms
-- The cubical identity type.
import Equality.Id
-- Propositional equality, with some extra bells and whistles
-- definable in Cubical Agda.
import Equality.Propositional.Cubical
-- Some tactics aimed at making equational reasoning proofs more
-- readable for path equality.
import Tactic.By.Path
-- Some tactics aimed at making equational reasoning proofs more
-- readable for the cubical identity type.
import Tactic.By.Id
-- Some theory of Erased, developed using Cubical Agda.
import Erased.Cubical
-- Some theory of equivalences with erased "proofs", defined in terms
-- of partly erased contractible fibres, developed using Cubical Agda.
import Equivalence.Erased.Contractible-preimages.Cubical
-- Some theory of equivalences with erased "proofs", developed using
-- Cubical Agda.
import Equivalence.Erased.Cubical
-- A sequential colimit for which everything except for the "base
-- case" is erased.
import Colimit.Sequential.Very-erased
-- The sequential colimit HIT with an erased higher constructor.
import Colimit.Sequential.Erased
-- Sequential colimits.
import Colimit.Sequential
-- The one-step truncation HIT with an erased higher constructor.
import H-level.Truncation.Propositional.One-step.Erased
-- The one-step truncation.
import H-level.Truncation.Propositional.One-step
-- A non-recursive variant of H-level.Truncation.Propositional.Erased.
import H-level.Truncation.Propositional.Non-recursive.Erased
-- A variant of the propositional truncation operator with an erased
-- truncation constructor.
import H-level.Truncation.Propositional.Erased
-- Propositional truncation.
import H-level.Truncation.Propositional
-- A definition of the propositional truncation operator that does not
-- use recursive higher inductive types.
import H-level.Truncation.Propositional.Non-recursive
-- Some properties that hold for Erased do not hold for every
-- accessible modality.
import Erased.Counterexamples.Cubical
-- The "interval".
import Interval
-- Suspensions.
import Suspension
-- Spheres.
import Sphere
-- Pushouts, defined using a HIT.
import Pushout
-- Localisation.
import Localisation
-- Truncation, defined as a HIT.
import H-level.Truncation
-- Homotopy groups of pointed types.
import Pointed-type.Homotopy-group
-- Connectedness for pointed types.
import Pointed-type.Connected
-- A variant of set quotients with erased higher constructors.
import Quotient.Erased.Basics
-- Quotients (set-quotients), defined using a higher inductive type.
import Quotient
-- Two variants of the set quotients from Quotient.
import Quotient.Set-truncated-if-propositional
import Quotient.Higher-constructors-if-propositional
-- A variant of set quotients with erased higher constructors.
import Quotient.Erased
-- Cyclic groups.
import Group.Cyclic
-- Integers, defined using a quotient type.
import Integer.Quotient
-- The Eilenberg-MacLane space K(G, 1).
import Eilenberg-MacLane-space
-- Coherently constant functions.
import Coherently-constant
-- The "circle".
import Circle
-- The circle with an erased higher constructor.
import Circle.Erased
-- The torus, defined as a HIT.
import Torus
-- The figure of eight.
import Figure-of-eight
-- A variant of Nat.Wrapper.Cubical, defined using --erased-cubical.
import Nat.Wrapper.Cubical.Erased
-- A variant of the development in "Internalizing Representation
-- Independence with Univalence" (by Angiuli, Cavallo, Mörtberg and
-- Zeuner) with support for erasure.
import Structure-identity-principle.Erased
-- Truncated queues: any two queues representing the same sequence are
-- equal, and things are set up so that at compile-time (but not at
-- run-time) some queue operations compute in roughly the same way as
-- the corresponding list operations.
import Queue.Truncated
-- Queue instances for the queues in Queue.Truncated.
import Queue.Truncated.Instances
-- Quotiented queues: any two queues representing the same sequence
-- are equal.
import Queue.Quotiented
-- Queue instances for the queues in Queue.Quotiented.
import Queue.Quotiented.Instances
|
{
"alphanum_fraction": 0.7581755594,
"avg_line_length": 22.5631067961,
"ext": "agda",
"hexsha": "9ce94b7caaa0ed9dc1c706d8706133bcc38604b4",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/equality",
"max_forks_repo_path": "README/Safe/Cubical/Erased.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/equality",
"max_issues_repo_path": "README/Safe/Cubical/Erased.agda",
"max_line_length": 72,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/equality",
"max_stars_repo_path": "README/Safe/Cubical/Erased.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-02T17:18:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-05-21T22:58:50.000Z",
"num_tokens": 1058,
"size": 4648
}
|
------------------------------------------------------------------------------
-- Translation of projection-like functions
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
-- 2012-04-03: More information about what is a projection-like in the
-- patch:
--
-- Mon Apr 2 02:41:41 COT 2012 Andreas Abel <[email protected]>
-- * Type signatures and comments explaining what is considered projection-like.
-- 2012-02-23: The function P is not considered a projection-like
-- function after the patch:
--
-- Tue Feb 21 11:41:08 COT 2012 Nils Anders Danielsson <[email protected]>
-- * The positivity checker (and more) is now only run once per mutual block.
-- 2011-09-23: From the Agda mailing list
-- Subject: Compiler internals for projection functions
-- There is some additional information about this issue.
-- 2011-09-19: Maybe the information in the issue 465 (Missing
-- patterns in funClauses) is useful.
------------------------------------------------------------------------------
module ProjectionLikeFunction where
open import Common.FOL
postulate
N : D → Set
-- See Issue #81.
P : D → Set
P i = i ≡ i
{-# ATP definition P #-}
foo : ∀ {n} → N n → n ≡ n
foo {n} Nn = bar
where
postulate bar : P n
{-# ATP prove bar #-}
|
{
"alphanum_fraction": 0.5608108108,
"avg_line_length": 30.8333333333,
"ext": "agda",
"hexsha": "2a9ffb933d0f477895ea25cbd975bb0fe61442f8",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2016-08-03T03:54:55.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-05-10T23:06:19.000Z",
"max_forks_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/apia",
"max_forks_repo_path": "test/Succeed/fol-theorems/ProjectionLikeFunction.agda",
"max_issues_count": 121,
"max_issues_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_issues_repo_issues_event_max_datetime": "2018-04-22T06:01:44.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-25T13:22:12.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/apia",
"max_issues_repo_path": "test/Succeed/fol-theorems/ProjectionLikeFunction.agda",
"max_line_length": 92,
"max_stars_count": 10,
"max_stars_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/apia",
"max_stars_repo_path": "test/Succeed/fol-theorems/ProjectionLikeFunction.agda",
"max_stars_repo_stars_event_max_datetime": "2019-12-03T13:44:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:54:16.000Z",
"num_tokens": 348,
"size": 1480
}
|
module _ where
open import Common.Prelude
open import Lib.Vec
_∘_ : ∀ {a b c} {A : Set a} {B : A → Set b} {C : ∀ x → B x → Set c}
(f : ∀ {x} (y : B x) → C x y) (g : ∀ x → B x) → ∀ x → C x (g x)
(f ∘ g) x = f (g x)
sum : ∀ {n} → Vec Nat n → Nat
sum (x ∷ xs) = x + sum xs
sum [] = 0
foldl : ∀ {A}{B : Nat → Set} → (∀ {n} → B n → A → B (suc n)) → B 0 → ∀ {n} → Vec A n → B n
foldl {B = B} f z (x ∷ xs) = foldl {B = λ n → B (suc n)} f (f z x) xs
foldl f z [] = z
reverse : ∀ {A n} → Vec A n → Vec A n
reverse = foldl {B = Vec _} (λ xs x → x ∷ xs) []
downFrom : ∀ n → Vec Nat n
downFrom zero = []
downFrom (suc n) = n ∷ downFrom n
main : IO Unit
main = printNat (sum (reverse (downFrom 6000)))
|
{
"alphanum_fraction": 0.4759206799,
"avg_line_length": 25.2142857143,
"ext": "agda",
"hexsha": "2136d8dd0e32c7114cdd4a6e382c6af60e8a9dfe",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "redfish64/autonomic-agda",
"max_forks_repo_path": "test/Compiler/simple/VecReverse.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "redfish64/autonomic-agda",
"max_issues_repo_path": "test/Compiler/simple/VecReverse.agda",
"max_line_length": 90,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "redfish64/autonomic-agda",
"max_stars_repo_path": "test/Compiler/simple/VecReverse.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 317,
"size": 706
}
|
{-# OPTIONS --safe #-}
module Cubical.Algebra.NatSolver.Examples where
open import Cubical.Foundations.Prelude
open import Cubical.Data.FinData
open import Cubical.Data.Nat
open import Cubical.Data.Vec.Base
open import Cubical.Algebra.NatSolver.NatExpression
open import Cubical.Algebra.NatSolver.HornerForms
open import Cubical.Algebra.NatSolver.Solver
open import Cubical.Algebra.NatSolver.Reflection
private
variable
ℓ : Level
module ReflectionSolving where
_ : (x y : ℕ) → (x + y) · (x + y) ≡ x · x + 2 · x · y + y · y
_ = solve
{-
If you want to use the solver in some more complex situation,
you have to declare a helper variable (`useSolver` below) that
is a term of a dependent function type as above:
-}
module _ (SomeType : Type ℓ-zero) where
complexSolverApplication :
(someStuff : SomeType) → (x y : ℕ) → (moreStuff : SomeType)
→ x + y ≡ y + x
complexSolverApplication someStuff x y moreStuff = useSolver x y
where useSolver : (x y : ℕ) → x + y ≡ y + x
useSolver = solve
module SolvingExplained where
open EqualityToNormalform renaming (solve to natSolve)
open IteratedHornerOperations hiding (X)
ℕ[X₀,X₁] = IteratedHornerForms 2
X₀ : ℕ[X₀,X₁]
X₀ = Variable 2 (Fin.zero)
X₁ : ℕ[X₀,X₁]
X₁ = Variable 2 (suc Fin.zero)
Two : ℕ[X₀,X₁]
Two = Constant 2 2
_ : eval X₀ (1 ∷ 0 ∷ []) ≡ 1
_ = refl
_ : eval X₁ (0 ∷ 1 ∷ []) ≡ 1
_ = refl
X : Expr 3
X = ∣ Fin.zero
Y : Expr 3
Y = ∣ (suc Fin.zero)
Z : Expr 3
Z = ∣ (suc (suc Fin.zero))
{-
'normalize' maps an expression to its Horner Normalform.
Two expressions evaluating to the same ring element
have the same Horner Normal form.
This means equality of the represented ring elements
can be checked by agda's unification (so refl is a proof)
-}
_ : normalize ((K 2) ·' X) ≡
normalize (X +' X)
_ = refl
_ : normalize ((K 2) ·' X) ≡ normalize (X +' X)
_ = refl
_ : normalize (((K 2) ·' X) ·' Y) ≡ normalize (Y ·' (X +' X))
_ = refl
_ : normalize (Z ·' (((K 2) ·' X) ·' Y)) ≡ normalize (Z ·' (Y ·' (X +' X)))
_ = refl
{-
The solver needs to produce an equality between
actual ring elements. So we need a proof that
those actual ring elements are equal to a normal form:
-}
_ : (x y z : ℕ) →
eval (normalize ((K 2) ·' X ·' Y)) (x ∷ y ∷ z ∷ [])
≡ 2 · x · y
_ = λ x y z → isEqualToNormalform ((K 2) ·' X ·' Y) (x ∷ y ∷ z ∷ [])
{-
Now two of these proofs can be plugged together
to solve an equation:
-}
open Eval
_ : (x y z : ℕ) → 3 + x + y · y ≡ y · y + x + 1 + 2
_ = let
lhs = (K 3) +' X +' (Y ·' Y)
rhs = Y ·' Y +' X +' (K 1) +' (K 2)
in (λ x y z →
⟦ lhs ⟧ (x ∷ y ∷ z ∷ [])
≡⟨ sym (isEqualToNormalform lhs (x ∷ y ∷ z ∷ [])) ⟩
eval (normalize lhs) (x ∷ y ∷ z ∷ [])
≡⟨ refl ⟩
eval (normalize rhs) (x ∷ y ∷ z ∷ [])
≡⟨ isEqualToNormalform rhs (x ∷ y ∷ z ∷ []) ⟩
⟦ rhs ⟧ (x ∷ y ∷ z ∷ []) ∎)
{-
Parts of that can be automated easily:
-}
_ : (x y z : ℕ) → (x + y) · (x + y) ≡ x · x + 2 · x · y + y · y
_ = λ x y z → let
lhs = (X +' Y) ·' (X +' Y)
rhs = X ·' X +' (K 2) ·' X ·' Y +' Y ·' Y
in natSolve lhs rhs (x ∷ y ∷ z ∷ []) refl
{-
A bigger example
-}
_ : (x y z : ℕ) → (x + y) · (x + y) · (x + y) · (x + y)
≡ x · x · x · x + 4 · x · x · x · y + 6 · x · x · y · y
+ 4 · x · y · y · y + y · y · y · y
_ = λ x y z → let
lhs = (X +' Y) ·' (X +' Y) ·' (X +' Y) ·' (X +' Y)
rhs = X ·' X ·' X ·' X
+' (K 4) ·' X ·' X ·' X ·' Y
+' (K 6) ·' X ·' X ·' Y ·' Y
+' (K 4) ·' X ·' Y ·' Y ·' Y
+' Y ·' Y ·' Y ·' Y
in natSolve lhs rhs (x ∷ y ∷ z ∷ []) refl
{-
this one cannot work so far:
_ : (x y z : ℕ) → (x + y) · (x - y) ≡ (x · x - (y · y))
_ = λ x y z → let
lhs = (X +' Y) ·' (X +' (-' Y))
rhs = (X ·' X) +' (-' (Y ·' Y))
in natSolve lhs rhs (x ∷ y ∷ z ∷ []) {!!}
-}
|
{
"alphanum_fraction": 0.479811098,
"avg_line_length": 28.6148648649,
"ext": "agda",
"hexsha": "f177de40487a7f69838d96fd88ea012f1eff04aa",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "58f2d0dd07e51f8aa5b348a522691097b6695d1c",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Seanpm2001-web/cubical",
"max_forks_repo_path": "Cubical/Algebra/NatSolver/Examples.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "58f2d0dd07e51f8aa5b348a522691097b6695d1c",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Seanpm2001-web/cubical",
"max_issues_repo_path": "Cubical/Algebra/NatSolver/Examples.agda",
"max_line_length": 77,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "9acdecfa6437ec455568be4e5ff04849cc2bc13b",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "FernandoLarrain/cubical",
"max_stars_repo_path": "Cubical/Algebra/NatSolver/Examples.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-05T00:28:39.000Z",
"max_stars_repo_stars_event_min_datetime": "2022-03-05T00:28:39.000Z",
"num_tokens": 1566,
"size": 4235
}
|
module Tuples where
open import Haskell.Prelude
swap : a × b → b × a
swap (a , b) = b , a
{-# COMPILE AGDA2HS swap #-}
unit2unit : ⊤ → Tuple []
unit2unit tt = []
{-# COMPILE AGDA2HS unit2unit #-}
|
{
"alphanum_fraction": 0.6089108911,
"avg_line_length": 13.4666666667,
"ext": "agda",
"hexsha": "0a70371962ff28eaf00b403e53d8229599949e9f",
"lang": "Agda",
"max_forks_count": 18,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:42:52.000Z",
"max_forks_repo_forks_event_min_datetime": "2020-10-21T22:19:09.000Z",
"max_forks_repo_head_hexsha": "160478a51bc78b0fdab07b968464420439f9fed6",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "seanpm2001/agda2hs",
"max_forks_repo_path": "test/Tuples.agda",
"max_issues_count": 63,
"max_issues_repo_head_hexsha": "160478a51bc78b0fdab07b968464420439f9fed6",
"max_issues_repo_issues_event_max_datetime": "2022-02-25T15:47:30.000Z",
"max_issues_repo_issues_event_min_datetime": "2020-10-22T05:19:27.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "seanpm2001/agda2hs",
"max_issues_repo_path": "test/Tuples.agda",
"max_line_length": 33,
"max_stars_count": 55,
"max_stars_repo_head_hexsha": "8c8f24a079ed9677dbe6893cf786e7ed52dfe8b6",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "dxts/agda2hs",
"max_stars_repo_path": "test/Tuples.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-26T21:57:56.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-10-20T13:36:25.000Z",
"num_tokens": 68,
"size": 202
}
|
-- Andreas, 2016-12-29, issue #2366
-- With clauses need to be printed in fresh environment,
-- as they DON'T shadow the pattern variables of the parent clause.
-- (These are not even in scope)
-- {-# OPTIONS -v error.checkclause:60 #-}
open import Agda.Builtin.List
test : {A : Set} → List A → List A
test (x ∷ y ∷ ys) with []
test (x ∷ xs) | q = []
test _ = []
-- ERROR WAS:
-- With clause pattern xs is not an instance of its parent pattern y ∷ ys
-- when checking that the clause
-- test (x ∷ y ∷ ys) with []
-- test (x₁ ∷ xs) | q = []
-- has type {A : Set} → List A → List A
-- NOTE THE x₁!
-- Expected error:
-- With clause pattern xs is not an instance of its parent pattern y ∷ ys
-- when checking that the clause
-- test (x ∷ y ∷ ys) with []
-- test (x ∷ xs) | q = []
-- has type {A : Set} → List A → List A
|
{
"alphanum_fraction": 0.6192214112,
"avg_line_length": 28.3448275862,
"ext": "agda",
"hexsha": "0030be87b044bdd913b9e3611389fa36091e6cc8",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "pthariensflame/agda",
"max_forks_repo_path": "test/Fail/Issue2366.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "pthariensflame/agda",
"max_issues_repo_path": "test/Fail/Issue2366.agda",
"max_line_length": 73,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "pthariensflame/agda",
"max_stars_repo_path": "test/Fail/Issue2366.agda",
"max_stars_repo_stars_event_max_datetime": "2015-12-07T20:14:00.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-03-28T14:51:03.000Z",
"num_tokens": 256,
"size": 822
}
|
open import Agda.Builtin.Equality
open import Agda.Builtin.Nat
foo : Nat → (Nat → Nat) → Nat
foo zero f = f zero
foo (suc n) f = foo n λ n → f (suc n)
fsuc : (Nat → Nat) → Nat → Nat
fsuc f n = f (suc n)
foo' : Nat → (Nat → Nat) → Nat
foo' zero f = f zero
foo' (suc n) f = foo' n (fsuc f)
foo'' : Nat → (Nat → Nat) → Nat
foo'' zero f = f zero
foo'' (suc n) f = foo'' n λ { n → f (suc n) }
test : foo 50000 (λ n → n) ≡ 50000
test = refl
test' : foo' 50000 (λ n → n) ≡ 50000
test' = refl
test'' : foo'' 50000 (λ n → n) ≡ 50000
test'' = refl
|
{
"alphanum_fraction": 0.5459459459,
"avg_line_length": 19.8214285714,
"ext": "agda",
"hexsha": "167ec9ae41a6cb029b9db7944a86f39b87aadf56",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Succeed/Issue2255.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Succeed/Issue2255.agda",
"max_line_length": 45,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Succeed/Issue2255.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 238,
"size": 555
}
|
-- Andreas, 2013-02-27 issue reported by Nisse
-- {-# OPTIONS -v tc.polarity:100 -v tc.pos:100 #-}
module Issue802 where
data I : Set where
i : I
mutual
data P : I → Set where
p : (x : I) → Q x x → P x
Q : I → I → Set
Q i = P
-- Polarity of Q should be mixed for both arguments.
f : (x y : I) → Q x y → P y
f i _ q = q
data R (x : I) : P x → Set where
r : (q : Q x x) → R _ (f x _ q) → R x (p x q)
-- Agda should solve the two meta variables in the type of r.
|
{
"alphanum_fraction": 0.5569358178,
"avg_line_length": 20.125,
"ext": "agda",
"hexsha": "bd27f80cc8686ea63730f8d715a529b920deb413",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue802.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue802.agda",
"max_line_length": 61,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue802.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 185,
"size": 483
}
|
module BHeap.Heap {A : Set}(_≤_ : A → A → Set) where
open import BHeap _≤_
open import Bound.Lower A
open import Bound.Lower.Order _≤_
open import BTree.Heap _≤_
lemma-bheap-heap : {b : Bound}(h : BHeap b) → Heap (forget h)
lemma-bheap-heap lf = leaf
lemma-bheap-heap (nd {x = x} _ lf lf) = single x
lemma-bheap-heap (nd _ (nd (lexy x≤y) l r) lf) = left x≤y (lemma-bheap-heap (nd (lexy x≤y) l r))
lemma-bheap-heap (nd _ lf (nd (lexy x≤y) l r)) = right x≤y (lemma-bheap-heap (nd (lexy x≤y) l r))
lemma-bheap-heap (nd _ (nd (lexy x≤y) l r) (nd (lexy x≤y') l' r')) = both x≤y x≤y' (lemma-bheap-heap (nd (lexy x≤y) l r)) (lemma-bheap-heap (nd (lexy x≤y') l' r'))
|
{
"alphanum_fraction": 0.6299093656,
"avg_line_length": 47.2857142857,
"ext": "agda",
"hexsha": "a05534c90196e8da324eacb0a1ea129d141c846d",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "bgbianchi/sorting",
"max_forks_repo_path": "agda/BHeap/Heap.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "bgbianchi/sorting",
"max_issues_repo_path": "agda/BHeap/Heap.agda",
"max_line_length": 163,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "bgbianchi/sorting",
"max_stars_repo_path": "agda/BHeap/Heap.agda",
"max_stars_repo_stars_event_max_datetime": "2021-08-24T22:11:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-05-21T12:50:35.000Z",
"num_tokens": 291,
"size": 662
}
|
-- Andreas, 2013-09-17 catches a bug in constraint solving
-- with meta-variables applied to underapplied record constructors
-- {-# OPTIONS --show-implicit -v tc.meta.assign:50 -v tc.conv.elim:30 #-}
module Issue889 where
record Monad (M : Set → Set) : Set₁ where
field
return : ∀ {A} → A → M A
_>>=_ : ∀ {A} {B : M A → Set} (m : M A) →
((x : A) → M (B (return x))) → M (B m)
record Σ (A : Set) (B : A → Set) : Set where
constructor _,_
field
proj₁ : A
proj₂ : B proj₁
_×_ : (A B : Set) → Set
A × B = Σ A λ _ → B
State : Set → Set → Set
State S X = S → X × S
-- Here is the underapplied record constructor
-- (made underapplied by eta-contraction, resp.).
state-return : ∀ {S X} → X → State S X
state-return x = _,_ x -- λ s → x , s
-- When giving the @_>>=_@ function to the record goal we get:
--
-- An internal error has occurred. Please report this as a bug.
-- Location of the error: src/full/Agda/TypeChecking/Conversion.hs:524
state-monad : ∀ {S} → Monad (State S)
state-monad {S} = record { return = state-return; _>>=_ = {!_>>=_!} }
where
postulate
_>>=_ : ∀ {A} {B : State S A → Set} (m : State S A) →
((x : A) → State S (B (state-return x))) → State S (B m)
-- Bug arises when checking
-- _B (state-return x) = B (state-return x)
-- _B (_,_ x) = B (_,_ x)
-- then Agda does something special for record constructors
-- [Miller unification in the presence of records]
-- (now only done for FULLY APPLIED record constructors!)
-- and produces some garbage solution for _B.
------------------------------------------------------------------------
-- Note that if we define the product type using data instead of
-- record then it works:
data _×′_ (A B : Set) : Set where
_,_ : A → B → A ×′ B
State′ : Set → Set → Set
State′ S X = S → X ×′ S
state-return′ : ∀ {S X} → X → State′ S X
state-return′ x = λ s → x , s
state-monad′ : ∀ {S} → Monad (State′ S)
state-monad′ {S} = record { return = state-return′; _>>=_ = _>>=_ }
where
postulate
_>>=_ : ∀ {A} {B : State′ S A → Set} (m : State′ S A) →
((x : A) → State′ S (B (state-return′ x))) → State′ S (B m)
|
{
"alphanum_fraction": 0.5662037037,
"avg_line_length": 32.2388059701,
"ext": "agda",
"hexsha": "b4a0570aad1588caa992f606f222db637a129dc4",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/interaction/Issue889.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/interaction/Issue889.agda",
"max_line_length": 74,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/interaction/Issue889.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 704,
"size": 2160
}
|
open import AEff
open import EffectAnnotations
open import Renamings
open import Types hiding (``)
open import Relation.Binary.PropositionalEquality hiding ([_])
module Substitutions where
-- SET OF SUBSTITUTIONS BETWEEN CONTEXTS
Sub : Ctx → Ctx → Set
Sub Γ Γ' = {X : VType} → X ∈ Γ → Γ' ⊢V⦂ X
-- IDENTITY AND EXTENSION SUBSTITUTIONS
id-subst : {Γ : Ctx} → Sub Γ Γ
id-subst x = ` x
_[_]s : {Γ Γ' : Ctx} {X : VType} → Sub Γ Γ' → Γ' ⊢V⦂ X → Sub (Γ ∷ X) Γ'
(s [ V ]s) Hd = V
(s [ V ]s) (Tl x) = s x
-- LIFTING SUBSTITUTIONS
lift : {Γ Γ' : Ctx} {X : VType} → Sub Γ Γ' → Sub (Γ ∷ X) (Γ' ∷ X)
lift s Hd = ` Hd
lift s (Tl x) = V-rename Tl (s x)
-- ACTION OF SUBSTITUTION ON WELL-TYPED VALUES AND COMPUTATIONS
mutual
infix 40 _[_]v
infix 40 _[_]m
_[_]v : {Γ Γ' : Ctx} → {X : VType} → Γ ⊢V⦂ X → Sub Γ Γ' → Γ' ⊢V⦂ X
(` x) [ s ]v =
s x
(`` c) [ s ]v =
`` c
(ƛ M) [ s ]v =
ƛ (M [ lift s ]m)
⟨ V ⟩ [ s ]v =
⟨ V [ s ]v ⟩
_[_]m : {Γ Γ' : Ctx} → {C : CType} → Γ ⊢M⦂ C → Sub Γ Γ' → Γ' ⊢M⦂ C
(return V) [ s ]m =
return (V [ s ]v)
(let= M `in N) [ s ]m =
let= (M [ s ]m) `in (N [ lift s ]m)
(letrec M `in N) [ s ]m =
letrec M [ lift (lift s) ]m `in (N [ lift s ]m)
(V · W) [ s ]m =
(V [ s ]v) · (W [ s ]v)
(↑ op p V M) [ s ]m =
↑ op p (V [ s ]v) (M [ s ]m)
(↓ op V M) [ s ]m =
↓ op (V [ s ]v) (M [ s ]m)
(promise op ∣ p ↦ M `in N) [ s ]m =
promise op ∣ p ↦ (M [ lift s ]m) `in (N [ lift s ]m)
(await V until M) [ s ]m =
await (V [ s ]v) until (M [ lift s ]m)
(coerce p q M) [ s ]m =
coerce p q (M [ s ]m)
-- ACTION OF SUBSTITUTION ON WELL-TYPED TERMS
infix 40 _[_]p
_[_]p : {Γ Γ' : Ctx} {o : O} {PP : PType o} → Γ ⊢P⦂ PP → Sub Γ Γ' → Γ' ⊢P⦂ PP
(run M) [ s ]p =
run (M [ s ]m)
(P ∥ Q) [ s ]p =
(P [ s ]p) ∥ (Q [ s ]p)
(↑ op p V P) [ s ]p =
↑ op p (V [ s ]v) (P [ s ]p)
(↓ op V P) [ s ]p =
↓ op (V [ s ]v) (P [ s ]p)
|
{
"alphanum_fraction": 0.4680962343,
"avg_line_length": 22.7619047619,
"ext": "agda",
"hexsha": "6427665c6d832413e1dfca80d44c2c0c693576bc",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "71ebed9f90a3eb37ae6cd209457bae23a4d122d1",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "danelahman/aeff-agda",
"max_forks_repo_path": "Substitutions.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "71ebed9f90a3eb37ae6cd209457bae23a4d122d1",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "danelahman/aeff-agda",
"max_issues_repo_path": "Substitutions.agda",
"max_line_length": 77,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "71ebed9f90a3eb37ae6cd209457bae23a4d122d1",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "danelahman/aeff-agda",
"max_stars_repo_path": "Substitutions.agda",
"max_stars_repo_stars_event_max_datetime": "2021-03-22T22:48:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-07-17T00:15:00.000Z",
"num_tokens": 906,
"size": 1912
}
|
------------------------------------------------------------------------------
-- Problem with a simplified version of the combinators for preorder
-- reasoning
------------------------------------------------------------------------------
{-# OPTIONS --allow-unsolved-metas #-}
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module FOT.Common.FOL.Relation.Binary.PreorderReasoning.ImplicitArgumentsProblem
where
-- Nils suggested a possible problem with the relation
-- R : {A : Set} → A → A → Set
-- R _ _ = ⊤
-- and a version of the combinators for preorder reasoning without use
-- the wrapper data type. This example shows that Nils was right.
------------------------------------------------------------------------------
record ⊤ : Set where
constructor tt
R : {A : Set} → A → A → Set
R _ _ = ⊤
R-refl : {A : Set}{x : A} → R x x
R-refl = tt
R-trans : {A : Set}{x y z : A} → R x y → R y z → R x z
R-trans _ _ = tt
data ℕ : Set where
zero : ℕ
succ : ℕ → ℕ
module Thesis where
-- From Ulf's thesis (p. 112).
infix 7 _≃_
infix 6 chain>_
infixl 5 _===_by_
infix 4 _qed
data _≃_ {A : Set}(x y : A) : Set where
prf : R x y → x ≃ y
chain>_ : {A : Set}(x : A) → x ≃ x
chain> x = prf (R-refl {x = x})
_===_by_ : {A : Set}{x y : A} → x ≃ y → (z : A) → R y z → x ≃ z
_===_by_ {x = x} {y} (prf p) z q = prf (R-trans {x = x} {y} {z} p q)
_qed : {A : Set}{x y : A} → x ≃ y → R x y
prf p qed = p
-- Example (no problem with implicit arguments).
test : (x y : ℕ) → R x y
test x y =
chain> x
=== y by tt
qed
module SL where
-- Adapted from the Agda standard library 0.8.1 (see
-- Relation/Binary/PreorderReasoning.agda).
infix 7 _≃_
infix 4 begin_
infixr 5 _≡⟨_⟩_
infix 6 _∎
data _≃_ {A : Set}(x y : A) : Set where
prf : R x y → x ≃ y
begin_ : {A : Set}{x y : A} → x ≃ y → R x y
begin_ {x = x} (prf Rxy) = R-refl {x = x}
_≡⟨_⟩_ : {A : Set}(x : A){y z : A} → R x y → y ≃ z → x ≃ z
_≡⟨_⟩_ x {y} {z} Rxy (prf Ryz) = prf (R-trans {x = x} {y} {z} Rxy Ryz)
_∎ : {A : Set}(x : A) → x ≃ x
_∎ x = prf (R-refl {x = x})
-- Example (no problem with implicit arguments).
test : (x y : ℕ) → R x y
test x y =
begin
x ≡⟨ tt ⟩
y
∎
module NonWrapper where
-- A set of combinators without request a wrapper data type (Mu,
-- S.-C., Ko, H.-S. and Jansson, P. (2009)).
infixr 5 _≡⟨_⟩_
infix 6 _∎
_≡⟨_⟩_ : {A : Set}(x : A){y z : A} → R x y → R y z → R x z
_≡⟨_⟩_ x {y} {z} x≡y y≡z = R-trans {x = x} {y} {z} x≡y y≡z
_∎ : {A : Set}(x : A) → R x x
_∎ x = R-refl {x = x}
-- Example.
test : (x y : ℕ) → R x y
test x y = x ≡⟨ tt ⟩
y ∎
------------------------------------------------------------------------------
-- References
--
-- Mu, S.-C., Ko, H.-S. and Jansson, P. (2009). Algebra of programming
-- in Agda: Dependent types for relational program derivation. Journal
-- of Functional Programming 19.5, pp. 545–579.
|
{
"alphanum_fraction": 0.4773901809,
"avg_line_length": 25.5867768595,
"ext": "agda",
"hexsha": "84aef8f47e4e5fb39fd8a0e1b02c9b055396a582",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z",
"max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/fotc",
"max_forks_repo_path": "notes/FOT/Common/FOL/Relation/Binary/PreorderReasoning/ImplicitArgumentsProblem.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/fotc",
"max_issues_repo_path": "notes/FOT/Common/FOL/Relation/Binary/PreorderReasoning/ImplicitArgumentsProblem.agda",
"max_line_length": 80,
"max_stars_count": 11,
"max_stars_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/fotc",
"max_stars_repo_path": "notes/FOT/Common/FOL/Relation/Binary/PreorderReasoning/ImplicitArgumentsProblem.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-12T16:09:54.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:53:42.000Z",
"num_tokens": 1140,
"size": 3096
}
|
{- wip, coming to realise that the instance of IsSetoid defined in Data.Equality.properties is over-eager (defining _≡_ for all (A : Set (a : Level)), _≡̇_ for ∀ (x : A : Set (a : Level)) → (B : A → Set (b : Level)) x -}
-- add samples of stuff from unification (AList, etc.)
module Oscar.Data5 where
record ⊤ : Set where
constructor tt
Const_ : ∀ {a} {A : Set a} {b} {B : Set b} → B → A → B
Const_ x _ = x
infixr 20 _∷_
-- List
data ⟦_⟧ {a} (A : Set a) : Set a where
∅ : ⟦ A ⟧
_∷_ : A → ⟦ A ⟧ → ⟦ A ⟧
-- Nat
⟦⟧ = ⟦ ⊤ ⟧
infix 21 ¡_
pattern ¡_ ⟦A⟧ = tt ∷ ⟦A⟧
--¡ : ⟦⟧ → ⟦⟧
--¡ ⟦A⟧ = tt ∷ ⟦A⟧
-- Fin (with a payload)
data ⟦_⟧[_] {a} (A : ⟦⟧ → Set a) : ⟦⟧ → Set a where
∅ : ∀ {n} → ⟦ A ⟧[ ¡ n ]
_∷_ : ∀ {n} → A n → ⟦ A ⟧[ n ] → ⟦ A ⟧[ ¡ n ]
⟦⟧[_] = ⟦ Const ⊤ ⟧[_]
-- Vec (with an (optional) index)
data ⟦_⟧[_₀] {a} (A : ⟦⟧ → Set a) : ⟦⟧ → Set a where
∅ : ⟦ A ⟧[ ∅ ₀]
_∷_ : ∀ {n} → A n → ⟦ A ⟧[ n ₀] → ⟦ A ⟧[ ¡ n ₀]
⟦⟧[_₀] = ⟦ Const ⊤ ⟧[_₀]
-- m ≤ n, counting down from n-1 to m
data ⟦_⟧[_≤_↓] {a} (A : ⟦⟧ → Set a) (m : ⟦⟧) : ⟦⟧ → Set a where
∅ : ⟦ A ⟧[ m ≤ m ↓]
_∷_ : ∀ {n} → A n → ⟦ A ⟧[ m ≤ n ↓] → ⟦ A ⟧[ m ≤ ¡ n ↓]
⟦⟧[_≤_↓] = ⟦ Const ⊤ ⟧[_≤_↓]
-- m ≤ n, counting up from m to n-1
data ⟦_⟧[↑_≤_] {a} (A : ⟦⟧ → Set a) (m : ⟦⟧) : ⟦⟧ → Set a where
∅ : ⟦ A ⟧[↑ m ≤ m ]
_∷_ : ∀ {n} → A m → ⟦ A ⟧[↑ ¡ m ≤ n ] → ⟦ A ⟧[↑ m ≤ n ]
⟦⟧[↑_≤_] = ⟦ Const ⊤ ⟧[↑_≤_]
-- Inj (almost)
data ⟦_⟧[↓_≤_↓] {a} (A : ⟦⟧ → ⟦⟧ → Set a) : ⟦⟧ → ⟦⟧ → Set a where
∅ : ∀ {n} → ⟦ A ⟧[↓ ∅ ≤ n ↓]
_∷_ : ∀ {m n} → A m n → ⟦ A ⟧[↓ m ≤ n ↓] → ⟦ A ⟧[↓ ¡ m ≤ ¡ n ↓]
⟦⟧[↓_≤_↓] = ⟦ Const Const ⊤ ⟧[↓_≤_↓]
⟦_⟧[_⇒_]∞ : ∀ {a} (A : ⟦⟧ → Set a) → ⟦⟧ → ⟦⟧ → Set a
⟦ A ⟧[ m ⇒ n ]∞ = A m → A n
open import Oscar.Category.Semigroupoid
open import Oscar.Category.Category
open import Oscar.Category.Morphism
open import Oscar.Category.Setoid
--open import Oscar.Data.Equality
--open import Oscar.Data.Equality.properties
open import Oscar.Function
module _ {𝔬 𝔪 𝔮} (G : Semigroupoid 𝔬 𝔪 𝔮) where
open Semigroupoid G
{-
_≋̇_ : ∀ {a} {A : ⋆ → Set a} {m n : ⋆} → (A m → A n) → (A m → A n) → Set 𝔮
_≋̇_ {A = A} {m = m} m→n₁ m→n₂ = {!∀ (am : A m) → m→n₁ am ≋ m→n₂ am!}
cat2 : ∀ {a} (A : ⋆ → Set a) → Category {!!} {!!} {!!}
Semigroupoid.⋆ (Category.semigroupoid (cat2 A)) = ⋆
Setoid.⋆ ((Semigroupoid.𝔐 (Category.semigroupoid (cat2 A)) Morphism.⇒ m) n) = A m → A n
IsSetoid._≋_ (Setoid.isSetoid ((Semigroupoid.𝔐 (Category.semigroupoid (cat2 A)) Morphism.⇒ m) n)) = _≡̇_
IsSetoid.isEquivalence (Setoid.isSetoid ((Semigroupoid.𝔐 (Category.semigroupoid (cat2 A)) Morphism.⇒ m) n)) = it
Semigroupoid._∙_ (Category.semigroupoid (cat2 A)) g f = g ∘ f
Semigroupoid.isSemigroupoid (Category.semigroupoid (cat2 A)) = it
Category.ε (cat2 A) = id
Category.isCategory (cat2 A) = it
-}
cat2G : ∀ {a} (A : ⋆ → Set a) → ∀ ℓ ⦃ _ : ∀ {n : ⋆} → IsSetoid (A n) ℓ ⦄ → Category {!!} {!!} {!!}
Semigroupoid.⋆ (Category.semigroupoid (cat2G A ℓ)) = ⋆
Setoid.⋆ ((Semigroupoid.𝔐 (Category.semigroupoid (cat2G A ℓ)) Morphism.⇒ m) n) = A m → A n
IsSetoid._≋_ (Setoid.isSetoid ((Semigroupoid.𝔐 (Category.semigroupoid (cat2G A ℓ)) Morphism.⇒ m) n)) m↦n₁ m↦n₂ = ∀ (am : A m) → m↦n₁ am ≋ m↦n₂ am
-- ∀ (am : A m) → m↦n₁ am ≋ m↦n₂ am
{-
_≋̇_ : ∀ {a} {A : ⋆ → Set a} {m n : ⋆} → (A m → A n) → (A m → A n) → Set 𝔮
_≋̇_ {A = A} {m = m} m→n₁ m→n₂ = {!∀ (am : A m) → m→n₁ am ≋ m→n₂ am!}
-}
IsSetoid.isEquivalence (Setoid.isSetoid ((Semigroupoid.𝔐 (Category.semigroupoid (cat2G A ℓ)) Morphism.⇒ m) n)) = {!it!}
Semigroupoid._∙_ (Category.semigroupoid (cat2G A ℓ)) g f = g ∘ f
Semigroupoid.isSemigroupoid (Category.semigroupoid (cat2G A ℓ)) = {!it!}
Category.ε (cat2G A ℓ) = id
Category.isCategory (cat2G A ℓ) = {!it!}
infix 21 ‼_
pattern ‼_ ⟦A⟧ = tt ∷ ⟦A⟧ -- tricky, works for all above _∷_ constructors only because it is defined afterwards, won't work for any later-defined constructors
open import Agda.Primitive
open import Oscar.Data.Product
open import Oscar.Function
postulate
ℓ : Level
Term : ⟦⟧ → Set ℓ
Step : ⟦⟧ → Set ℓ
Fin = ⟦⟧[_]
Inj = ⟦ Const Fin ⟧[↓_≤_↓]
Terms = λ N n → ⟦ Const (Term n) ⟧[ N ₀]
AList = ⟦ (λ n → Term n × Fin (¡ n)) ⟧[_≤_↓]
Fx : ∀ {a} {A : Set a} → A → A → ∀ {b₁} (B₁ : A → Set b₁) → ∀ {b₂} (B₂ : A → Set b₂) → Set (b₁ ⊔ b₂)
Fx m n B₁ B₂ = B₁ m → B₂ n
Fx₁ : ∀ {a} {A : Set a} → A → ∀ {b₁} (B₁ : A → Set b₁) → ∀ {b₂} (B₂ : A → Set b₂) → Set (b₁ ⊔ b₂)
Fx₁ n B₁ B₂ = Fx n n B₁ B₂
ListStep = λ n → ⟦ Step n ⟧
Rel : ∀ {a} {A : Set a} {b₁} (B₁ : A → Set b₁) {b₂} (B₂ : A → Set b₂) {c₁} (C₁ : A → Set c₁) {c₂} (C₂ : A → Set c₂) → Set (a ⊔ b₁ ⊔ b₂ ⊔ c₁ ⊔ c₂)
Rel B₁ B₂ C₁ C₂ = ∀ {m n} → Fx m n B₁ B₂ → Fx m n C₁ C₂
Morph : ∀ {a} {A : Set a} {b₁} {b₂} (B : (A → Set b₁) × (A → Set b₂)) {c₁} {c₂} (C₂ : (A → Set c₁) × (A → Set c₂)) → Set (a ⊔ b₁ ⊔ b₂ ⊔ c₁ ⊔ c₂)
Morph (B₁ , B₂) (C₁ , C₂) = ∀ {m n} → Fx m n B₁ B₂ → Fx m n C₁ C₂
-- functor mappings
postulate
_◃_ : Morph (Fin , Term) (Term , Term)
_◃s_ : ∀ N → Morph (Fin , Term) (Terms N , Terms N)
sub : ∀ {m n} → AList m n → Fx m n Fin Term
fmapS : Morph (Term , Term) (Step , Step)
_◃S_ : Morph (Fin , Term) (ListStep , ListStep)
-- ?
postulate
_⊹_ : ∀ {n} → ⟦ Step n ⟧ → Fx₁ n Term Term
testNat : ⟦⟧
testNat = ¡ ∅
testListNat : ⟦ ⟦⟧ ⟧
testListNat = ¡ ∅ ∷ ‼ ∅ ∷ ‼ ‼ ∅ ∷ ∅ ∷ ¡ ¡ ¡ ∅ ∷ ∅
testFin : ⟦⟧[ ¡ ¡ ∅ ]
testFin = ‼ ∅
test≤↓ : ⟦⟧[ ‼ ‼ ‼ ∅ ≤ ‼ ‼ ‼ ‼ ‼ ∅ ↓]
test≤↓ = ‼ ‼ ∅
⓪ ⑴ ⑵ ⑶ : ⟦⟧
⓪ = ∅
⑴ = ‼ ∅
⑵ = ‼ ⑴
⑶ = ‼ ⑵
testInj : Inj ⑵ ⑶
testInj = ‼ ∅ ∷ ∅ ∷ ∅
|
{
"alphanum_fraction": 0.5027402265,
"avg_line_length": 31.28,
"ext": "agda",
"hexsha": "c2545d039caa9d4ec945bf63066f469c0b568c0b",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_forks_repo_licenses": [
"RSA-MD"
],
"max_forks_repo_name": "m0davis/oscar",
"max_forks_repo_path": "archive/agda-2/Oscar/Data5.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_issues_repo_issues_event_max_datetime": "2019-05-11T23:33:04.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-04-29T00:35:04.000Z",
"max_issues_repo_licenses": [
"RSA-MD"
],
"max_issues_repo_name": "m0davis/oscar",
"max_issues_repo_path": "archive/agda-2/Oscar/Data5.agda",
"max_line_length": 220,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_stars_repo_licenses": [
"RSA-MD"
],
"max_stars_repo_name": "m0davis/oscar",
"max_stars_repo_path": "archive/agda-2/Oscar/Data5.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2829,
"size": 5474
}
|
module ProjectionLikeAndMatching where
data Unit : Set where
* : Unit
data Box A : Set where
[_] : A → Box A
-- Unbox should not be considered projection-like since it's matching on more than
-- the eliminatee.
unbox : ∀ {A} → Box A → Unit → A
unbox [ x ] * = x
postulate
Thm : {A : Set} → A → Set
prf : {A : Set}(x : A) → Thm x
-- If unbox was projection-like we would end up with
-- [_] (apply x) (elim unbox) (apply u) : A
-- and we wouldn't be able to reconstruct the parameter
-- argument to [_].
lem : ∀ {A} (x : A) u → Thm (unbox [ x ] u)
lem x u = prf (unbox [ x ] u)
|
{
"alphanum_fraction": 0.6108291032,
"avg_line_length": 24.625,
"ext": "agda",
"hexsha": "481e6eea60ee108dee60aaa1f7d45f011b94f8c8",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "masondesu/agda",
"max_forks_repo_path": "test/succeed/ProjectionLikeAndMatching.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "masondesu/agda",
"max_issues_repo_path": "test/succeed/ProjectionLikeAndMatching.agda",
"max_line_length": 82,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "redfish64/autonomic-agda",
"max_stars_repo_path": "test/Succeed/ProjectionLikeAndMatching.agda",
"max_stars_repo_stars_event_max_datetime": "2015-12-07T20:14:00.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-03-28T14:51:03.000Z",
"num_tokens": 202,
"size": 591
}
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Induced preorders
------------------------------------------------------------------------
open import Relation.Binary
module Relation.Binary.InducedPreorders
{s₁ s₂}
(S : Setoid s₁ s₂) -- The underlying equality.
where
open import Function
open import Data.Product
open Setoid S
-- Every respectful unary relation induces a preorder. (No claim is
-- made that this preorder is unique.)
InducedPreorder₁ : ∀ {p} (P : Carrier → Set p) →
P Respects _≈_ → Preorder _ _ _
InducedPreorder₁ P resp = record
{ _≈_ = _≈_
; _∼_ = λ c₁ c₂ → P c₁ → P c₂
; isPreorder = record
{ isEquivalence = isEquivalence
; reflexive = resp
; trans = flip _∘′_
}
}
-- Every respectful binary relation induces a preorder. (No claim is
-- made that this preorder is unique.)
InducedPreorder₂ : ∀ {a r} {A : Set a} →
(_R_ : A → Carrier → Set r) →
(∀ {x} → _R_ x Respects _≈_) → Preorder _ _ _
InducedPreorder₂ _R_ resp = record
{ _≈_ = _≈_
; _∼_ = λ c₁ c₂ → ∀ {a} → a R c₁ → a R c₂
; isPreorder = record
{ isEquivalence = isEquivalence
; reflexive = λ c₁≈c₂ → resp c₁≈c₂
; trans = λ c₁∼c₂ c₂∼c₃ → c₂∼c₃ ∘ c₁∼c₂
}
}
|
{
"alphanum_fraction": 0.5129682997,
"avg_line_length": 28.3265306122,
"ext": "agda",
"hexsha": "53d343b2d6602e0493bbe84a40a78f4fe9e36374",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "9d4c43b1609d3f085636376fdca73093481ab882",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "qwe2/try-agda",
"max_forks_repo_path": "agda-stdlib-0.9/src/Relation/Binary/InducedPreorders.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "9d4c43b1609d3f085636376fdca73093481ab882",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Apache-2.0"
],
"max_issues_repo_name": "qwe2/try-agda",
"max_issues_repo_path": "agda-stdlib-0.9/src/Relation/Binary/InducedPreorders.agda",
"max_line_length": 72,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "9d4c43b1609d3f085636376fdca73093481ab882",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "qwe2/try-agda",
"max_stars_repo_path": "agda-stdlib-0.9/src/Relation/Binary/InducedPreorders.agda",
"max_stars_repo_stars_event_max_datetime": "2016-10-20T15:52:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-10-20T15:52:05.000Z",
"num_tokens": 425,
"size": 1388
}
|
{-# OPTIONS --without-K --safe #-}
module Cats.Category.Setoids.Facts.Terminal where
open import Level
open import Relation.Binary using (Setoid)
open import Cats.Category
open import Cats.Category.Setoids using (Setoids)
import Data.Unit as Unit
⊤ : ∀ {l l′} → Setoid l l′
⊤ = record
{ Carrier = Lift _ Unit.⊤
; _≈_ = λ _ _ → Lift _ Unit.⊤
}
instance
hasTerminal : ∀ {l l≈} → HasTerminal (Setoids l l≈)
hasTerminal = record { ⊤ = ⊤ }
|
{
"alphanum_fraction": 0.6615044248,
"avg_line_length": 19.652173913,
"ext": "agda",
"hexsha": "9f9f5f0f201c65342a02f6fdff6e150c0368e249",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-18T15:35:07.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-18T15:35:07.000Z",
"max_forks_repo_head_hexsha": "1ad7b243acb622d46731e9ae7029408db6e561f1",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "JLimperg/cats",
"max_forks_repo_path": "Cats/Category/Setoids/Facts/Terminal.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "1ad7b243acb622d46731e9ae7029408db6e561f1",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "JLimperg/cats",
"max_issues_repo_path": "Cats/Category/Setoids/Facts/Terminal.agda",
"max_line_length": 53,
"max_stars_count": 24,
"max_stars_repo_head_hexsha": "1ad7b243acb622d46731e9ae7029408db6e561f1",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "JLimperg/cats",
"max_stars_repo_path": "Cats/Category/Setoids/Facts/Terminal.agda",
"max_stars_repo_stars_event_max_datetime": "2021-08-06T05:00:46.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-11-03T15:18:57.000Z",
"num_tokens": 146,
"size": 452
}
|
module Data.QuadTree.Implementation.SafeFunctions where
open import Haskell.Prelude renaming (zero to Z; suc to S)
open import Data.Lens.Lens
open import Data.Logic
open import Data.QuadTree.Implementation.PropDepthRelation
open import Data.QuadTree.Implementation.Definition
open import Data.QuadTree.Implementation.ValidTypes
open import Data.QuadTree.Implementation.QuadrantLenses
open import Data.QuadTree.Implementation.DataLenses
{-# FOREIGN AGDA2HS
{-# LANGUAGE Safe #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE Rank2Types #-}
import Data.Nat
import Data.Lens.Lens
import Data.Logic
import Data.QuadTree.Implementation.Definition
import Data.QuadTree.Implementation.ValidTypes
import Data.QuadTree.Implementation.QuadrantLenses
import Data.QuadTree.Implementation.DataLenses
#-}
---- Safe functions
makeTreeSafe : {t : Set} {{eqT : Eq t}} -> (size : Nat × Nat) -> (v : t) -> VQuadTree t {maxDepth $ Wrapper size (Leaf v)}
makeTreeSafe (w , h) v = CVQuadTree (Wrapper (w , h) (Leaf v)) {andCombine (zeroLteAny (log2up $ max w h)) IsTrue.itsTrue} {eqReflexivity (maxDepth $ Wrapper (w , h) (Leaf v))}
{-# COMPILE AGDA2HS makeTreeSafe #-}
getLocationSafe : {t : Set} {{eqT : Eq t}}
-> (loc : Nat × Nat) -> (dep : Nat)
-> (qt : VQuadTree t {dep})
-> {.(IsTrue (isInsideQuadTree loc (qtFromSafe qt)))}
-> t
getLocationSafe index dep vqt {inside} = view (atLocation index dep {insideQTtoInsidePow index vqt inside}) vqt
{-# COMPILE AGDA2HS getLocationSafe #-}
setLocationSafe : {t : Set} {{eqT : Eq t}}
-> (loc : Nat × Nat) -> (dep : Nat)
-> t -> (qt : VQuadTree t {dep})
-> {.(IsTrue (isInsideQuadTree loc (qtFromSafe qt)))}
-> VQuadTree t {dep}
setLocationSafe index dep v vqt {inside} = set (atLocation index dep {insideQTtoInsidePow index vqt inside}) v vqt
{-# COMPILE AGDA2HS setLocationSafe #-}
mapLocationSafe : {t : Set} {{eqT : Eq t}}
-> (loc : Nat × Nat) -> (dep : Nat)
-> (t -> t) -> (qt : VQuadTree t {dep})
-> {.(IsTrue (isInsideQuadTree loc (qtFromSafe qt)))}
-> VQuadTree t {dep}
mapLocationSafe index dep f vqt {inside} = over (atLocation index dep {insideQTtoInsidePow index vqt inside}) f vqt
{-# COMPILE AGDA2HS mapLocationSafe #-}
|
{
"alphanum_fraction": 0.7068493151,
"avg_line_length": 40.5555555556,
"ext": "agda",
"hexsha": "d67d72c26800ef95e6f61d246b5d8ae348c6aed3",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "4959a3c9cd8563a1726e0e968e6a179008cd4d9f",
"max_forks_repo_licenses": [
"Unlicense"
],
"max_forks_repo_name": "JonathanBrouwer/research-project",
"max_forks_repo_path": "src/Data/QuadTree/Implementation/SafeFunctions.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "4959a3c9cd8563a1726e0e968e6a179008cd4d9f",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Unlicense"
],
"max_issues_repo_name": "JonathanBrouwer/research-project",
"max_issues_repo_path": "src/Data/QuadTree/Implementation/SafeFunctions.agda",
"max_line_length": 176,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "4959a3c9cd8563a1726e0e968e6a179008cd4d9f",
"max_stars_repo_licenses": [
"Unlicense"
],
"max_stars_repo_name": "JonathanBrouwer/research-project",
"max_stars_repo_path": "src/Data/QuadTree/Implementation/SafeFunctions.agda",
"max_stars_repo_stars_event_max_datetime": "2021-05-25T09:10:20.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-05-25T09:10:20.000Z",
"num_tokens": 649,
"size": 2190
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.