hexsha
stringlengths 40
40
| size
int64 3
1.05M
| ext
stringclasses 163
values | lang
stringclasses 53
values | max_stars_repo_path
stringlengths 3
945
| max_stars_repo_name
stringlengths 4
112
| max_stars_repo_head_hexsha
stringlengths 40
78
| max_stars_repo_licenses
listlengths 1
10
| max_stars_count
float64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 3
945
| max_issues_repo_name
stringlengths 4
113
| max_issues_repo_head_hexsha
stringlengths 40
78
| max_issues_repo_licenses
listlengths 1
10
| max_issues_count
float64 1
116k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 3
945
| max_forks_repo_name
stringlengths 4
113
| max_forks_repo_head_hexsha
stringlengths 40
78
| max_forks_repo_licenses
listlengths 1
10
| max_forks_count
float64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 3
1.05M
| avg_line_length
float64 1
966k
| max_line_length
int64 1
977k
| alphanum_fraction
float64 0
1
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1b2717a0cd495bb54e938dde224b9054a6f125a0
| 1,579
|
agda
|
Agda
|
bool.agda
|
rfindler/ial
|
f3f0261904577e930bd7646934f756679a6cbba6
|
[
"MIT"
] | 29
|
2019-02-06T13:09:31.000Z
|
2022-03-04T15:05:12.000Z
|
bool.agda
|
rfindler/ial
|
f3f0261904577e930bd7646934f756679a6cbba6
|
[
"MIT"
] | 8
|
2018-07-09T22:53:38.000Z
|
2022-03-22T03:43:34.000Z
|
bool.agda
|
rfindler/ial
|
f3f0261904577e930bd7646934f756679a6cbba6
|
[
"MIT"
] | 17
|
2018-12-03T22:38:15.000Z
|
2021-11-28T20:13:21.000Z
|
module bool where
open import level
----------------------------------------------------------------------
-- datatypes
----------------------------------------------------------------------
data 𝔹 : Set where
tt : 𝔹
ff : 𝔹
-- this is an alias for Mac users who cannot see blackboard b.
bool : Set
bool = 𝔹
{-# BUILTIN BOOL 𝔹 #-}
{-# BUILTIN TRUE tt #-}
{-# BUILTIN FALSE ff #-}
----------------------------------------------------------------------
-- syntax
----------------------------------------------------------------------
infix 7 ~_
infix 6 _xor_ _nand_
infixr 6 _&&_
infixr 5 _||_
infix 4 if_then_else_ if*_then_else_
infixr 4 _imp_
infix 4 _iff_
----------------------------------------------------------------------
-- operations
----------------------------------------------------------------------
-- not
~_ : 𝔹 → 𝔹
~ tt = ff
~ ff = tt
_iff_ : 𝔹 → 𝔹 → 𝔹
tt iff tt = tt
tt iff ff = ff
ff iff tt = ff
ff iff ff = tt
-- and
_&&_ : 𝔹 → 𝔹 → 𝔹
tt && b = b
ff && b = ff
-- or
_||_ : 𝔹 → 𝔹 → 𝔹
tt || b = tt
ff || b = b
if_then_else_ : ∀ {ℓ} {A : Set ℓ} → 𝔹 → A → A → A
if tt then y else z = y
if ff then y else z = z
if*_then_else_ : ∀ {ℓ} {A B : Set ℓ} → (b : 𝔹) → A → B → if b then A else B
if* tt then a else b = a
if* ff then a else b = b
_xor_ : 𝔹 → 𝔹 → 𝔹
tt xor ff = tt
ff xor tt = tt
tt xor tt = ff
ff xor ff = ff
-- implication
_imp_ : 𝔹 → 𝔹 → 𝔹
tt imp b2 = b2
ff imp b2 = tt
-- also called the Sheffer stroke
_nand_ : 𝔹 → 𝔹 → 𝔹
tt nand tt = ff
tt nand ff = tt
ff nand tt = tt
ff nand ff = tt
_nor_ : 𝔹 → 𝔹 → 𝔹
x nor y = ~ (x || y)
| 18.360465
| 75
| 0.412286
|
fd843779b3a31507c9ec0f429c2e052aa48ca580
| 1,466
|
agda
|
Agda
|
theorems/groups/KernelCstImageCst.agda
|
mikeshulman/HoTT-Agda
|
e7d663b63d89f380ab772ecb8d51c38c26952dbb
|
[
"MIT"
] | null | null | null |
theorems/groups/KernelCstImageCst.agda
|
mikeshulman/HoTT-Agda
|
e7d663b63d89f380ab772ecb8d51c38c26952dbb
|
[
"MIT"
] | null | null | null |
theorems/groups/KernelCstImageCst.agda
|
mikeshulman/HoTT-Agda
|
e7d663b63d89f380ab772ecb8d51c38c26952dbb
|
[
"MIT"
] | 1
|
2018-12-26T21:31:57.000Z
|
2018-12-26T21:31:57.000Z
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
module groups.KernelCstImageCst {i j k}
(G : Group i) (H : Group j) (K : Group k)
(H-ab : is-abelian H) where
private
module H = Group H
open import groups.KernelImage {G = G} {H = H} {K = K} cst-hom cst-hom H-ab
Ker-cst-quot-Im-cst : Ker/Im ≃ᴳ H
Ker-cst-quot-Im-cst = ≃-to-≃ᴳ (equiv to from to-from from-to) to-pres-comp where
to : Ker/Im.El → H.El
to = SetQuot-rec H.El-level to' to-rel where
to' : Ker.El (cst-hom {G = H} {H = K}) → H.El
to' ker = fst ker
abstract
to-rel : ∀ {h₁ h₂} → ker/im-rel' h₁ h₂ → h₁ == h₂
to-rel {h₁} {h₂} = Trunc-rec (H.El-level _ _)
λ{(_ , 0=h₁h₂⁻¹) → H.zero-diff-same h₁ h₂ (! 0=h₁h₂⁻¹)}
from : H.El → Ker/Im.El
from h = q[ h , idp ]
abstract
to-from : ∀ h → to (from h) == h
to-from h = idp
from-to : ∀ k/i → from (to k/i) == k/i
from-to = SetQuot-elim (λ _ → =-preserves-set SetQuot-level)
(λ _ → ap q[_] $ ker-El=-out idp)
(λ _ → prop-has-all-paths-↓ (SetQuot-level _ _))
to-pres-comp : preserves-comp Ker/Im.comp H.comp to
to-pres-comp = SetQuot-elim
(λ _ → Π-is-set λ _ → =-preserves-set H.El-level)
(λ _ → SetQuot-elim
(λ _ → =-preserves-set H.El-level)
(λ _ → idp)
(λ _ → prop-has-all-paths-↓ (H.El-level _ _)))
(λ _ → prop-has-all-paths-↓ (Π-is-prop λ _ → H.El-level _ _))
| 31.869565
| 82
| 0.53206
|
529c9916e5ad91a5199f00777a7f049a673bc2ee
| 197
|
agda
|
Agda
|
test/Fail/Erased-cubical-Import/Cubical.agda
|
cagix/agda
|
cc026a6a97a3e517bb94bafa9d49233b067c7559
|
[
"BSD-2-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Fail/Erased-cubical-Import/Cubical.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Fail/Erased-cubical-Import/Cubical.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
{-# OPTIONS --cubical #-}
module Erased-cubical-Import.Cubical where
open import Agda.Builtin.Cubical.Path
data ∥_∥ (A : Set) : Set where
∣_∣ : A → ∥ A ∥
trivial : (x y : ∥ A ∥) → x ≡ y
| 19.7
| 42
| 0.583756
|
1462aac597a19b1ef12a067b992b6bd095a06539
| 456
|
agda
|
Agda
|
stdlib-exts/Data/Maybe/Instance.agda
|
WhatisRT/meta-cedille
|
62fa6f36e4555360d94041113749bbb6d291691c
|
[
"MIT"
] | 35
|
2019-06-13T07:44:50.000Z
|
2021-10-12T22:59:10.000Z
|
stdlib-exts/Data/Maybe/Instance.agda
|
WhatisRT/meta-cedille
|
62fa6f36e4555360d94041113749bbb6d291691c
|
[
"MIT"
] | 10
|
2019-06-13T17:44:43.000Z
|
2020-04-25T15:29:17.000Z
|
stdlib-exts/Data/Maybe/Instance.agda
|
WhatisRT/meta-cedille
|
62fa6f36e4555360d94041113749bbb6d291691c
|
[
"MIT"
] | 2
|
2019-06-27T23:12:48.000Z
|
2021-10-20T10:46:20.000Z
|
module Data.Maybe.Instance where
open import Class.Equality
open import Class.Monad
open import Data.Maybe
open import Data.Maybe.Properties
instance
Maybe-Monad : ∀ {a} -> Monad (Maybe {a})
Maybe-Monad = record { _>>=_ = λ x f → maybe f nothing x ; return = just }
Maybe-Eq : ∀ {A} {{_ : Eq A}} → Eq (Maybe A)
Maybe-Eq ⦃ record { _≟_ = _≟_ } ⦄ = record { _≟_ = ≡-dec _≟_ }
Maybe-EqB : ∀ {A} {{_ : Eq A}} → EqB (Maybe A)
Maybe-EqB = Eq→EqB
| 26.823529
| 76
| 0.611842
|
fdf8c689b57f4d8f0022bfe03508b7a220fcaae4
| 3,886
|
agda
|
Agda
|
old/Spaces/Flattening.agda
|
danbornside/HoTT-Agda
|
1695a7f3dc60177457855ae846bbd86fcd96983e
|
[
"MIT"
] | 294
|
2015-01-09T16:23:23.000Z
|
2022-03-20T13:54:45.000Z
|
old/Spaces/Flattening.agda
|
danbornside/HoTT-Agda
|
1695a7f3dc60177457855ae846bbd86fcd96983e
|
[
"MIT"
] | 31
|
2015-03-05T20:09:00.000Z
|
2021-10-03T19:15:25.000Z
|
old/Spaces/Flattening.agda
|
danbornside/HoTT-Agda
|
1695a7f3dc60177457855ae846bbd86fcd96983e
|
[
"MIT"
] | 50
|
2015-01-10T01:48:08.000Z
|
2022-02-14T03:03:25.000Z
|
{-# OPTIONS --without-K #-}
open import BaseOver
module Spaces.Flattening {i j k}
(A : Set i) (B : Set j) (f g : B → A)
(C : A → Set k) (D : (b : B) → C (f b) ≃ C (g b)) where
open import Spaces.FlatteningTypes A B f g C D
-- The family of paths used in the definition of [flatten]
paths-flatten : (b : B) → (cct (f b) == cct (g b) [ (λ w → (P w → Wt)) ↓ pp b ])
paths-flatten b =
↓-app→cst-in (λ q → ppt b _ ∘' ap (cct (g b)) (↓-pp-out q))
flatten-curried : (w : W) → (P w → Wt)
flatten-curried = W-rec _ cct paths-flatten
flatten : Σ W P → Wt
flatten (w , x) = flatten-curried w x
unflatten : Wt → Σ W P
unflatten = Wt-rec-nondep _ (λ a c → (cc a , c))
(λ b d → Σ-eq (pp b) (↓-pp-in refl))
--
flatten-unflatten : (w : Wt) → flatten (unflatten w) ≡ w
flatten-unflatten =
Wt-rec _
(λ _ _ → refl)
(λ b d → ↓-◯=id-in unflatten flatten
(ap flatten (ap unflatten (ppt b d))
≡⟨ Wt-rec-nondep-β _ (λ a c → (cc a , c)) (λ b d → Σ-eq (pp b) (↓-pp-in refl)) b d |in-ctx ap flatten ⟩
ap flatten (Σ-eq (pp b) (↓-pp-in refl))
≡⟨ split-ap2 flatten (pp b) (↓-pp-in refl) ⟩
↓-app→cst-out (apd flatten-curried (pp b)) (↓-pp-in refl)
≡⟨ W-rec-β _ cct paths-flatten b |in-ctx (λ u → ↓-app→cst-out u (↓-pp-in refl)) ⟩
↓-app→cst-out (paths-flatten b) (↓-pp-in refl)
≡⟨ refl ⟩
↓-app→cst-out (↓-app→cst-in
(λ q → ppt b _ ∘' ap (cct (g b)) (↓-pp-out q))) (↓-pp-in refl)
≡⟨ ↓-app→cst-β (λ q → ppt b _ ∘' ap (cct (g b)) (↓-pp-out q)) (↓-pp-in refl) ⟩
ppt b d ∘' ap (cct (g b)) (↓-pp-out (↓-pp-in refl))
≡⟨ ↓-pp-β refl |in-ctx (λ u → ppt b d ∘' ap (cct (g b)) u) ⟩
ppt b d ∎))
unflatten-flatten-curried : (w : W) (x : P w)
→ unflatten (flatten-curried w x) ≡ (w , x)
unflatten-flatten-curried =
W-rec _ (λ a x → refl)
(λ b → ↓-Π-in
(λ q → ↓-◯=id-in flatten unflatten
(ap unflatten (ap flatten (Σ-eq (pp b) q))
≡⟨ split-ap2 flatten (pp b) q |in-ctx ap unflatten ⟩
ap unflatten (↓-app→cst-out (apd flatten-curried (pp b)) q)
≡⟨ W-rec-β _ cct paths-flatten b |in-ctx (λ u → ap unflatten (↓-app→cst-out u q)) ⟩
ap unflatten (↓-app→cst-out (paths-flatten b) q)
≡⟨ refl ⟩
ap unflatten (↓-app→cst-out (↓-app→cst-in (λ qq → ppt b _ ∘' ap (cct (g b)) (↓-pp-out qq))) q)
≡⟨ ↓-app→cst-β (λ qq → ppt b _ ∘' ap (cct (g b)) (↓-pp-out qq)) q |in-ctx ap unflatten ⟩
ap unflatten (ppt b _ ∘' ap (cct (g b)) (↓-pp-out q))
≡⟨ ap-∘' unflatten (ppt b _) (ap (cct (g b)) (↓-pp-out q)) ⟩
ap unflatten (ppt b _) ∘' ap unflatten (ap (cct (g b)) (↓-pp-out q))
≡⟨ Wt-rec-nondep-β _ (λ a c → (cc a , c)) (λ b d → Σ-eq (pp b) (↓-pp-in refl)) b _ |in-ctx (λ u → u ∘' ap unflatten (ap (cct (g b)) (↓-pp-out q))) ⟩
Σ-eq (pp b) (↓-pp-in refl) ∘' ap unflatten (ap (cct (g b)) (↓-pp-out q))
≡⟨ compose-ap unflatten (cct (g b)) (↓-pp-out q) |in-ctx (λ u → (Σ-eq (pp b) (↓-pp-in refl) ∘' u)) ⟩
Σ-eq (pp b) (↓-pp-in refl) ∘' ap (unflatten ◯ cct (g b)) (↓-pp-out q)
≡⟨ refl ⟩
Σ-eq (pp b) (↓-pp-in refl) ∘' ap (λ x → (cc (g b), x)) (↓-pp-out q)
≡⟨ ap-cst,id P (↓-pp-out q) |in-ctx (λ u → Σ-eq (pp b) (↓-pp-in refl) ∘' u) ⟩
Σ-eq (pp b) (↓-pp-in refl) ∘' Σ-eq refl (↓-pp-out q)
≡⟨ Σ-∘' (↓-pp-in refl) (↓-pp-out q) ⟩
Σ-eq (pp b) (↓-pp-in refl ∘'dep ↓-pp-out q)
≡⟨ to-transp-weird q (pp-path _ _) |in-ctx Σ-eq (pp b) ⟩
Σ-eq (pp b) q ∎)))
unflatten-flatten : (wx : Σ W P) → unflatten (flatten wx) ≡ wx
unflatten-flatten (w , x) = unflatten-flatten-curried w x
eqv : Σ W P ≃ Wt
eqv = (flatten , iso-is-eq flatten unflatten flatten-unflatten unflatten-flatten)
| 46.819277
| 165
| 0.488677
|
3710a14308a178ebc035875ba78680ea62df93c3
| 2,706
|
agda
|
Agda
|
test/asset/agda-stdlib-1.0/Data/List/Membership/Propositional/Properties/Core.agda
|
omega12345/agda-mode
|
0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71
|
[
"MIT"
] | null | null | null |
test/asset/agda-stdlib-1.0/Data/List/Membership/Propositional/Properties/Core.agda
|
omega12345/agda-mode
|
0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71
|
[
"MIT"
] | null | null | null |
test/asset/agda-stdlib-1.0/Data/List/Membership/Propositional/Properties/Core.agda
|
omega12345/agda-mode
|
0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71
|
[
"MIT"
] | null | null | null |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Core properties related to propositional list membership.
--
-- This file is needed to break the cyclic dependency with the proof
-- `Any-cong` in `Data.Any.Properties` which relies on `Any↔` in this
-- file.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Membership.Propositional.Properties.Core where
open import Function using (flip; id; _∘_)
open import Function.Inverse using (_↔_; inverse)
open import Data.List.Base using (List)
open import Data.List.Relation.Unary.Any as Any using (Any; here; there)
open import Data.List.Membership.Propositional
open import Data.Product as Prod
using (_,_; proj₁; proj₂; uncurry′; ∃; _×_)
open import Relation.Binary.PropositionalEquality as P
using (_≡_; refl)
open import Relation.Unary using (_⊆_)
-- Lemmas relating map and find.
map∘find : ∀ {a p} {A : Set a} {P : A → Set p} {xs}
(p : Any P xs) → let p′ = find p in
{f : _≡_ (proj₁ p′) ⊆ P} →
f refl ≡ proj₂ (proj₂ p′) →
Any.map f (proj₁ (proj₂ p′)) ≡ p
map∘find (here p) hyp = P.cong here hyp
map∘find (there p) hyp = P.cong there (map∘find p hyp)
find∘map : ∀ {a p q} {A : Set a} {P : A → Set p} {Q : A → Set q}
{xs : List A} (p : Any P xs) (f : P ⊆ Q) →
find (Any.map f p) ≡ Prod.map id (Prod.map id f) (find p)
find∘map (here p) f = refl
find∘map (there p) f rewrite find∘map p f = refl
-- find satisfies a simple equality when the predicate is a
-- propositional equality.
find-∈ : ∀ {a} {A : Set a} {x : A} {xs : List A} (x∈xs : x ∈ xs) →
find x∈xs ≡ (x , x∈xs , refl)
find-∈ (here refl) = refl
find-∈ (there x∈xs) rewrite find-∈ x∈xs = refl
-- find and lose are inverses (more or less).
lose∘find : ∀ {a p} {A : Set a} {P : A → Set p} {xs : List A}
(p : Any P xs) →
uncurry′ lose (proj₂ (find p)) ≡ p
lose∘find p = map∘find p P.refl
find∘lose : ∀ {a p} {A : Set a} (P : A → Set p) {x xs}
(x∈xs : x ∈ xs) (pp : P x) →
find {P = P} (lose x∈xs pp) ≡ (x , x∈xs , pp)
find∘lose P x∈xs p
rewrite find∘map x∈xs (flip (P.subst P) p)
| find-∈ x∈xs
= refl
-- Any can be expressed using _∈_
∃∈-Any : ∀ {a p} {A : Set a} {P : A → Set p} {xs} →
(∃ λ x → x ∈ xs × P x) → Any P xs
∃∈-Any = uncurry′ lose ∘ proj₂
Any↔ : ∀ {a p} {A : Set a} {P : A → Set p} {xs} →
(∃ λ x → x ∈ xs × P x) ↔ Any P xs
Any↔ = inverse ∃∈-Any find from∘to lose∘find
where
from∘to : ∀ v → find (∃∈-Any v) ≡ v
from∘to p = find∘lose _ (proj₁ (proj₂ p)) (proj₂ (proj₂ p))
| 35.142857
| 72
| 0.54139
|
34c94ecb491eab526bfa7148318d2e5fe3a05e9d
| 826
|
agda
|
Agda
|
test/Succeed/Issue1231.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Succeed/Issue1231.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Succeed/Issue1231.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
data Nat : Set where
zero : Nat
data _≡_ {A : Set} (x : A) : A → Set where
refl : x ≡ x
subst : ∀ {A : Set} (P : A → Set) {x y} → x ≡ y → P x → P y
subst P refl px = px
postulate
Eq : Set → Set
mkEq : {A : Set} (x y : A) → x ≡ y
_==_ : {A : Set} {{_ : Eq A}} (x y : A) → x ≡ y
A : Set
B : A → Set
C : ∀ x → B x → Set
case_of_ : ∀ {a b} {A : Set a} {B : Set b} → A → (A → B) → B
case x of f = f x
id : ∀ {a} (A : Set a) → A → A
id A x = x
eqTriple : {{_ : ∀ {x} {y : B x} → Eq (C x y)}}
(a : A) (b : B a) (c : C a b)
(a₁ : A) (b₁ : B a₁) (c : C a₁ b₁) → Nat
eqTriple a b c a₁ b₁ c₁ =
subst (λ a₂ → ∀ (b₂ : B a₂) (c₂ : _) → Nat) (mkEq a a₁)
(λ b₂ c₂ → subst (λ b₃ → ∀ c₃ → Nat) (mkEq b b₂)
(λ c₃ → case c == c₃ of λ eq → zero) c₂)
b₁ c₁
| 24.294118
| 67
| 0.401937
|
37aa1d6f7549fcf271f01ce198900bdde405c6e2
| 314
|
agda
|
Agda
|
test/Fail/Issue2897.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Fail/Issue2897.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Fail/Issue2897.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
module _ where
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
data ⊥ : Set where
T : Nat → Set
T zero = ⊥
T (suc n) = Nat
module M (n : Nat) where
foo : n ≡ 0 → T n → Nat
foo refl t = 0
module M' where
bar : ⊥
bar = t
bad : ⊥
bad = M'.bar
loop : ⊥
loop = M.bad 0
| 12.076923
| 33
| 0.55414
|
0de98dc12e6875a7679ac29a9adbfface5aa72ba
| 463
|
agda
|
Agda
|
Cats/Category/Sets/Facts/Terminal.agda
|
JLimperg/cats
|
1ad7b243acb622d46731e9ae7029408db6e561f1
|
[
"MIT"
] | 24
|
2017-11-03T15:18:57.000Z
|
2021-08-06T05:00:46.000Z
|
Cats/Category/Sets/Facts/Terminal.agda
|
JLimperg/cats
|
1ad7b243acb622d46731e9ae7029408db6e561f1
|
[
"MIT"
] | null | null | null |
Cats/Category/Sets/Facts/Terminal.agda
|
JLimperg/cats
|
1ad7b243acb622d46731e9ae7029408db6e561f1
|
[
"MIT"
] | 1
|
2019-03-18T15:35:07.000Z
|
2019-03-18T15:35:07.000Z
|
{-# OPTIONS --without-K --safe #-}
module Cats.Category.Sets.Facts.Terminal where
open import Data.Unit using (⊤)
open import Level using (Lift ; lift ; lower)
open import Relation.Binary.PropositionalEquality using (_≡_ ; refl)
open import Cats.Category
open import Cats.Category.Sets using (Sets)
instance
hasTerminal : ∀ {l} → HasTerminal (Sets l)
hasTerminal = record
{ ⊤ = Lift _ ⊤
; isTerminal = λ X → record { unique = λ _ _ → refl }
}
| 25.722222
| 68
| 0.684665
|
145993a70aaf357d8ef92333493fa50a5a247178
| 93
|
agda
|
Agda
|
test/Fail/AmbiguousModule.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Fail/AmbiguousModule.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Fail/AmbiguousModule.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
module AmbiguousModule where
module A where
module B where
module A where
open B
open A
| 9.3
| 28
| 0.774194
|
033ab393102d71e087c33df99983c8b493e5606d
| 613
|
agda
|
Agda
|
examples/outdated-and-incorrect/fileIO/Base.agda
|
asr/agda-kanso
|
aa10ae6a29dc79964fe9dec2de07b9df28b61ed5
|
[
"MIT"
] | 1
|
2019-11-27T07:26:06.000Z
|
2019-11-27T07:26:06.000Z
|
examples/outdated-and-incorrect/fileIO/Base.agda
|
np/agda-git-experiment
|
20596e9dd9867166a64470dd24ea68925ff380ce
|
[
"MIT"
] | null | null | null |
examples/outdated-and-incorrect/fileIO/Base.agda
|
np/agda-git-experiment
|
20596e9dd9867166a64470dd24ea68925ff380ce
|
[
"MIT"
] | null | null | null |
module Base where
postulate String : Set
Char : Set
{-# BUILTIN STRING String #-}
{-# BUILTIN CHAR Char #-}
data Unit : Set where
unit : Unit
{-# COMPILED_DATA Unit () #-}
data Bool : Set where
true : Bool
false : Bool
data False : Set where
record True : Set where
IsTrue : Bool -> Set
IsTrue true = True
IsTrue false = False
{-# COMPILED_DATA Bool True False #-}
infixr 40 _::_
data List (A : Set) : Set where
[] : List A
_::_ : A -> List A -> List A
{-# COMPILED_DATA List [] (:) #-}
data _×_ (A B : Set) : Set where
_,_ : A -> B -> A × B
{-# COMPILED_DATA _×_ (,) #-}
| 16.567568
| 37
| 0.582382
|
36584a266ef40c8b672b3d1bdbdb767813b17176
| 457
|
agda
|
Agda
|
test/fail/SizedTypesFunctionFromSuccSize.agda
|
asr/agda-kanso
|
aa10ae6a29dc79964fe9dec2de07b9df28b61ed5
|
[
"MIT"
] | 1
|
2018-10-10T17:08:44.000Z
|
2018-10-10T17:08:44.000Z
|
test/fail/SizedTypesFunctionFromSuccSize.agda
|
np/agda-git-experiment
|
20596e9dd9867166a64470dd24ea68925ff380ce
|
[
"MIT"
] | null | null | null |
test/fail/SizedTypesFunctionFromSuccSize.agda
|
np/agda-git-experiment
|
20596e9dd9867166a64470dd24ea68925ff380ce
|
[
"MIT"
] | 1
|
2022-03-12T11:35:18.000Z
|
2022-03-12T11:35:18.000Z
|
{-# OPTIONS --sized-types --injective-type-constructors #-}
module SizedTypesFunctionFromSuccSize where
postulate
Size : Set
_^ : Size -> Size
∞ : Size
{-# BUILTIN SIZE Size #-}
{-# BUILTIN SIZESUC _^ #-}
{-# BUILTIN SIZEINF ∞ #-}
data Nat : {size : Size} -> Set where
zero : {size : Size} -> Nat {size ^}
suc : {size : Size} -> Nat {size} -> Nat {size ^}
bad : {i : Size} -> Nat {i ^} -> Set
bad (zero) = bad zero
bad (suc x) = Nat
| 20.772727
| 59
| 0.573304
|
14170963b9eaba7c8374cfbea6570062b6ebe204
| 1,639
|
agda
|
Agda
|
examples/examplesPaperJFP/SpaceShipSimpleVar.agda
|
agda/ooAgda
|
7cc45e0148a4a508d20ed67e791544c30fecd795
|
[
"MIT"
] | 23
|
2016-06-19T12:57:55.000Z
|
2020-10-12T23:15:25.000Z
|
examples/examplesPaperJFP/SpaceShipSimpleVar.agda
|
agda/ooAgda
|
7cc45e0148a4a508d20ed67e791544c30fecd795
|
[
"MIT"
] | null | null | null |
examples/examplesPaperJFP/SpaceShipSimpleVar.agda
|
agda/ooAgda
|
7cc45e0148a4a508d20ed67e791544c30fecd795
|
[
"MIT"
] | 2
|
2018-09-01T15:02:37.000Z
|
2022-03-12T11:41:00.000Z
|
module examplesPaperJFP.SpaceShipSimpleVar where
open import SizedIO.Base
open import StateSizedIO.GUI.BaseStateDependent
open import Data.Bool.Base
open import Data.List.Base
open import Data.Integer
open import Data.Product hiding (map)
open import SizedIO.Object
open import SizedIO.IOObject
open import NativeIO
open import StateSizedIO.GUI.WxBindingsFFI
open import StateSizedIO.GUI.VariableList
open import StateSizedIO.GUI.WxGraphicsLib
open import StateSized.GUI.BitMaps
VarType = ℤ
varInit : VarType
varInit = (+ 150)
onPaint : ∀{i} → VarType → DC → Rect → IO GuiLev1Interface i VarType
onPaint z dc rect = exec (drawBitmap dc ship (z , (+ 150)) true) λ _ →
return z
moveSpaceShip : ∀{i} → Frame → VarType → IO GuiLev1Interface i VarType
moveSpaceShip fra z = return (z + (+ 20))
callRepaint : ∀{i} → Frame → VarType → IO GuiLev1Interface i VarType
callRepaint fra z = exec (repaint fra) λ _ → return z
buttonHandler : ∀{i} → Frame → List (VarType → IO GuiLev1Interface i VarType)
buttonHandler fra = moveSpaceShip fra ∷ [ callRepaint fra ]
program : ∀{i} → IOˢ GuiLev2Interface i (λ _ → Unit) []
program = execˢ (level1C makeFrame) λ fra →
execˢ (level1C (makeButton fra)) λ bt →
execˢ (level1C (addButton fra bt)) λ _ →
execˢ (createVar varInit) λ _ →
execˢ (setButtonHandler bt (moveSpaceShip fra
∷ [ callRepaint fra ])) λ _ →
execˢ (setOnPaint fra [ onPaint ])
returnˢ
main : NativeIO Unit
main = start (translateLev2 program)
| 29.8
| 78
| 0.663819
|
3406296e9336917a6b842a20046009cdc1661fdc
| 365
|
agda
|
Agda
|
test/Succeed/Issue1115.agda
|
favonia/agda
|
8d433b967567c08afe15d04a5cb63b6f6d8884ee
|
[
"BSD-2-Clause"
] | null | null | null |
test/Succeed/Issue1115.agda
|
favonia/agda
|
8d433b967567c08afe15d04a5cb63b6f6d8884ee
|
[
"BSD-2-Clause"
] | 6
|
2021-10-18T08:12:24.000Z
|
2021-11-24T08:31:10.000Z
|
test/Succeed/Issue1115.agda
|
antoinevanmuylder/agda
|
bd59d5b07ffe02a43b28d186d95e1747aac5bc8c
|
[
"BSD-2-Clause"
] | null | null | null |
{-# OPTIONS --cubical-compatible #-}
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
data Fin : Nat → Set where
zero : {n : Nat} → Fin (suc n)
suc : {n : Nat} (i : Fin n) → Fin (suc n)
-- From Data.Fin.Properties in the standard library (2016-12-30).
suc-injective : ∀ {o} {m n : Fin o} → Fin.suc m ≡ suc n → m ≡ n
suc-injective refl = refl
| 26.071429
| 65
| 0.630137
|
3fe8da1abe7a99a34d1d710a6540f7dd531116d1
| 2,980
|
agda
|
Agda
|
SOAS/Families/Build.agda
|
k4rtik/agda-soas
|
b224d31e20cfd010b7c924ce940f3c2f417777e3
|
[
"MIT"
] | null | null | null |
SOAS/Families/Build.agda
|
k4rtik/agda-soas
|
b224d31e20cfd010b7c924ce940f3c2f417777e3
|
[
"MIT"
] | null | null | null |
SOAS/Families/Build.agda
|
k4rtik/agda-soas
|
b224d31e20cfd010b7c924ce940f3c2f417777e3
|
[
"MIT"
] | null | null | null |
-- Operators for combining and building families
module SOAS.Families.Build {T : Set} where
open import SOAS.Common
open import SOAS.Context
open import SOAS.Sorting {T}
open import SOAS.Families.Core {T}
-- | Metavariable contexts
-- Inductive construction of context- and type-indexed sets
data MCtx : Set where
⁅⁆ : MCtx
⁅_⊩ₙ_⁆_ : (Π : Ctx {T}) → (τ : T) → MCtx → MCtx
infixr 7 ⁅_⊩ₙ_⁆_
-- Pattern synonym for parameterless elements and final elements
infixr 10 ⁅_⁆̣ ⁅_⊩ₙ_⁆̣
infixr 7 ⁅_⁆_ ⁅_⊩_⁆_ ⁅_·_⊩_⁆_ ⁅_⊩_⁆̣ ⁅_·_⊩_⁆̣ _⁅_⊩ₙ_⁆
pattern ⁅_⁆̣ α = ⁅ ∅ ⊩ₙ α ⁆ ⁅⁆
pattern ⁅_⊩ₙ_⁆̣ Π α = ⁅ Π ⊩ₙ α ⁆ ⁅⁆
pattern ⁅_⁆_ τ 𝔐 = ⁅ ∅ ⊩ₙ τ ⁆ 𝔐
pattern ⁅_⊩_⁆_ τ α 𝔐 = ⁅ ⌊ τ ⌋ ⊩ₙ α ⁆ 𝔐
pattern ⁅_·_⊩_⁆_ τ₁ τ₂ α 𝔐 = ⁅ ⌊ τ₁ ∙ τ₂ ⌋ ⊩ₙ α ⁆ 𝔐
pattern ⁅_⊩_⁆̣ τ α = ⁅ ⌊ τ ⌋ ⊩ₙ α ⁆ ⁅⁆
pattern ⁅_·_⊩_⁆̣ τ₁ τ₂ α = ⁅ ⌊ τ₁ ∙ τ₂ ⌋ ⊩ₙ α ⁆ ⁅⁆
-- Add type-context pair to the end of the metavariable context
_⁅_⊩ₙ_⁆ : MCtx → Ctx {T} → T → MCtx
⁅⁆ ⁅ Γ ⊩ₙ α ⁆ = ⁅ Γ ⊩ₙ α ⁆̣
(⁅ Π ⊩ₙ τ ⁆ 𝔐) ⁅ Γ ⊩ₙ α ⁆ = ⁅ Π ⊩ₙ τ ⁆ (𝔐 ⁅ Γ ⊩ₙ α ⁆)
private
variable
Γ Δ Θ Π : Ctx
α β γ τ : T
𝔐 : MCtx
-- Membership of metavariable contexts
data _⊩_∈_ : Ctx → T → MCtx → Set where
↓ : Π ⊩ τ ∈ (⁅ Π ⊩ₙ τ ⁆ 𝔐)
↑_ : Π ⊩ τ ∈ 𝔐 → Π ⊩ τ ∈ (⁅ Γ ⊩ₙ α ⁆ 𝔐)
infixr 220 ↑_
-- Metavariable context can be interpreted as a family via the membership
∥_∥ : MCtx → Familyₛ
∥ 𝔐 ∥ α Γ = Γ ⊩ α ∈ 𝔐
infixr 60 ∥_∥
_▷_ : MCtx → (Familyₛ → Familyₛ) → Familyₛ
𝔐 ▷ 𝒳 = 𝒳 ∥ 𝔐 ∥
infix 4 _▷_
-- Generalised sums and pattern matching
data +₂ (A B : Set) : Set where
_₁ : A → +₂ A B
_₂ : B → +₂ A B
data +₃ (A B C : Set) : Set where
_₁ : A → +₃ A B C
_₂ : B → +₃ A B C
_₃ : C → +₃ A B C
data +₄ (A B C D : Set) : Set where
_₁ : A → +₄ A B C D
_₂ : B → +₄ A B C D
_₃ : C → +₄ A B C D
_₄ : D → +₄ A B C D
infixr 60 _₁
infixr 60 _₂
infixr 60 _₃
infixr 60 _₄
₂| : {A B : Set}{X : Set} → (A → X) → (B → X) → (+₂ A B → X)
₂| f g (a ₁) = f a
₂| f g (b ₂) = g b
₃| : {A B C : Set}{X : Set} → (A → X) → (B → X) → (C → X) → (+₃ A B C → X)
₃| f g h (a ₁) = f a
₃| f g h (b ₂) = g b
₃| f g h (c ₃) = h c
₄| : {A B C D : Set}{X : Set} → (A → X) → (B → X) → (C → X) → (D → X) → (+₄ A B C D → X)
₄| f g h e (a ₁) = f a
₄| f g h e (b ₂) = g b
₄| f g h e (c ₃) = h c
₄| f g h e (d ₄) = e d
pattern _ₛ 𝔪 = 𝔪 ₁
pattern _ₘ 𝔪 = 𝔪 ₂
infixr 60 _ₛ
infixr 60 _ₘ
-- Empty and unit families
data Ø : Familyₛ where
data _⊪_ (Γ : Ctx)(α : T) : Familyₛ where
● : (Γ ⊪ α) α Γ
⊪_ : T → Familyₛ
⊪ α = ∅ ⊪ α
infix 20 _⊪_
infix 20 ⊪_
-- Sum of families
infix 10 _⊹_
infix 10 _⊹_⊹_
infix 10 _⊹_⊹_⊹_
_⊹_ : Familyₛ → Familyₛ → Familyₛ
(𝒳 ⊹ 𝒴) α Γ = +₂ (𝒳 α Γ) (𝒴 α Γ)
_⊹₁_ : {𝒳₁ 𝒳₂ 𝒴₁ 𝒴₂ : Familyₛ} → (𝒳₁ ⇾̣ 𝒳₂) → (𝒴₁ ⇾̣ 𝒴₂)
→ (𝒳₁ ⊹ 𝒴₁) ⇾̣ (𝒳₂ ⊹ 𝒴₂)
(f ⊹₁ g) (x ₁) = (f x) ₁
(f ⊹₁ g) (y ₂) = (g y) ₂
_⊹_⊹_ : Familyₛ → Familyₛ → Familyₛ → Familyₛ
(𝒳 ⊹ 𝒴 ⊹ 𝒵) α Γ = +₃ (𝒳 α Γ) (𝒴 α Γ) (𝒵 α Γ)
_⊹_⊹_⊹_ : Familyₛ → Familyₛ → Familyₛ → Familyₛ → Familyₛ
(𝒳 ⊹ 𝒴 ⊹ 𝒵 ⊹ 𝒲) α Γ = +₄ (𝒳 α Γ) (𝒴 α Γ) (𝒵 α Γ) (𝒲 α Γ)
| 22.575758
| 88
| 0.508725
|
3fb837cf23c0bc7bf7e37cf48d1152a487aa51bc
| 37,421
|
agda
|
Agda
|
src/agda/FRP/JS/Model.agda
|
agda/agda-frp-js
|
c7ccaca624cb1fa1c982d8a8310c313fb9a7fa72
|
[
"MIT",
"BSD-3-Clause"
] | 63
|
2015-04-20T21:47:00.000Z
|
2022-02-28T09:46:14.000Z
|
src/agda/FRP/JS/Model.agda
|
agda/agda-frp-js
|
c7ccaca624cb1fa1c982d8a8310c313fb9a7fa72
|
[
"MIT",
"BSD-3-Clause"
] | null | null | null |
src/agda/FRP/JS/Model.agda
|
agda/agda-frp-js
|
c7ccaca624cb1fa1c982d8a8310c313fb9a7fa72
|
[
"MIT",
"BSD-3-Clause"
] | 7
|
2016-11-07T21:50:58.000Z
|
2022-03-12T11:39:38.000Z
|
open import FRP.JS.Level using ( Level ; _⊔_ ) renaming ( zero to o ; suc to ↑ )
open import FRP.JS.Time using ( Time ; _≤_ ; _<_ )
open import FRP.JS.Bool using ( Bool ; true ; false ; not ; _≟_ )
open import FRP.JS.True using ( True ; tt )
module FRP.JS.Model where
-- This model is essentially System F-omega with a kind time
-- together with a type for the partial order on time,
-- and expressions for reflexivity and transitivity.
-- We prove parametricity, and then show that parametricity implies causality.
-- Note that this is a "deep" notion of causality, not the "shallow"
-- causality usually used in FRP. The pragmatic upshot of this is that
-- there is only one time model: nested signals are in the same time
-- model, not a simulated time model. This fits with the JS implementation,
-- which uses wall clock time for all signals.
-- Propositional equality
data _≡_ {α} {A : Set α} (a : A) : A → Set α where
refl : a ≡ a
sym : ∀ {α} {A : Set α} {a b : A} → (a ≡ b) → (b ≡ a)
sym refl = refl
trans : ∀ {α} {A : Set α} {a b c : A} → (a ≡ b) → (b ≡ c) → (a ≡ c)
trans refl refl = refl
cong : ∀ {α β} {A : Set α} {B : Set β} (f : A → B) {a₁ a₂ : A} →
(a₁ ≡ a₂) → (f a₁ ≡ f a₂)
cong f refl = refl
apply : ∀ {α β} {A : Set α} {B : Set β} {F G : A → B} → (F ≡ G) →
∀ {a b} → (a ≡ b) → (F a ≡ G b)
apply refl refl = refl
cast : ∀ {α} {A B : Set α} → (A ≡ B) → A → B
cast refl a = a
cast² : ∀ {α} {A B : Set α} {ℜ ℑ : A → B → Set α} → (ℜ ≡ ℑ) → ∀ {a b} → ℜ a b → ℑ a b
cast² refl aℜb = aℜb
irrel : ∀ b → (b₁ b₂ : True b) → (b₁ ≡ b₂)
irrel true tt tt = refl
irrel false () ()
-- Postulates (including dependent extensionality)
data _≤?_ (t u : Time) : Set where
leq : True (t ≤ u) → (t ≤? u)
geq : True (u ≤ t) → (t ≤? u)
postulate
≤-refl : ∀ t → True (t ≤ t)
≤-trans : ∀ t u v → True (t ≤ u) → True (u ≤ v) → True (t ≤ v)
≤-asym : ∀ t u → True (t ≤ u) → True (u ≤ t) → (t ≡ u)
≤-total : ∀ t u → (t ≤? u)
dext : ∀ {α β} {A : Set α} {B : A → Set β} {F G : ∀ a → B a} → (∀ a → F a ≡ G a) → (F ≡ G)
ext : ∀ {α β} {A : Set α} {B : Set β} {F G : A → B} →
(∀ a → F a ≡ G a) → (F ≡ G)
ext = dext
iext : ∀ {α β} {A : Set α} {B : A → Set β} {F G : ∀ {a} → B a} →
(∀ a → F {a} ≡ G {a}) → ((λ {a} → F {a}) ≡ (λ {a} → G {a}))
iext F≈G = cong (λ X {a} → X a) (dext F≈G)
-- Finite products
record ⊤ {α} : Set α where
constructor tt
open ⊤ public
record Σ {α β} (A : Set α) (B : A → Set β) : Set (α ⊔ β) where
constructor _,_
field
proj₁ : A
proj₂ : B proj₁
open Σ public
_×_ : ∀ {α β} → Set α → Set β → Set (α ⊔ β)
A × B = Σ A (λ a → B)
_ײ_ : ∀ {α β} {A C : Set α} {B D : Set β} →
(A → C → Set α) → (B → D → Set β) → ((A × B) → (C × D) → Set (α ⊔ β))
(ℜ ײ ℑ) (a , b) (c , d) = (ℜ a c × ℑ b d)
_→²_ : ∀ {α β} {A C : Set α} {B D : Set β} →
(A → C → Set α) → (B → D → Set β) → ((A → B) → (C → D) → Set (α ⊔ β))
(ℜ →² ℑ) f g = ∀ {a b} → ℜ a b → ℑ (f a) (g b)
-- Case on booleans
data Case (c : Bool) : Set where
_,_ : ∀ b → True (b ≟ c) → Case c
switch : ∀ b → Case b
switch true = (true , tt)
switch false = (false , tt)
-- Reactive sets
RSet : ∀ α → Set (↑ α)
RSet α = Time → Set α
-- Equalitional reasoning
infix 4 _IsRelatedTo_
infix 2 _∎
infixr 2 _≡⟨_⟩_
infix 1 begin_
data _IsRelatedTo_ {α} {A : Set α} (a b : A) : Set α where
relTo : (a≡b : a ≡ b) → a IsRelatedTo b
begin_ : ∀ {α} {A : Set α} {a b : A} → a IsRelatedTo b → a ≡ b
begin relTo a≡b = a≡b
_≡⟨_⟩_ : ∀ {α} {A : Set α} a {b c : A} → a ≡ b → b IsRelatedTo c → a IsRelatedTo c
_ ≡⟨ a≡b ⟩ relTo b≡c = relTo (trans a≡b b≡c)
_∎ : ∀ {α} {A : Set α} (a : A) → a IsRelatedTo a
_∎ _ = relTo refl
-- Kinds
data Kind : Set where
time : Kind
set : Level → Kind
_⇒_ : Kind → Kind → Kind
level : Kind → Level
level time = o
level (set α) = ↑ α
level (K ⇒ L) = level K ⊔ level L
K⟦_⟧ : ∀ K → Set (level K)
K⟦ time ⟧ = Time
K⟦ set α ⟧ = Set α
K⟦ K ⇒ L ⟧ = K⟦ K ⟧ → K⟦ L ⟧
_∋_↔_ : ∀ K → K⟦ K ⟧ → K⟦ K ⟧ → Set (level K)
time ∋ t ↔ u = (t ≡ u)
set α ∋ A ↔ B = A → B → Set α
(K ⇒ L) ∋ F ↔ G = ∀ {A B} → (K ∋ A ↔ B) → (L ∋ F A ↔ G B)
-- ≡ can be used as a structural equivalence on relations.
struct : ∀ K {A B C D} → (A ≡ B) → (K ∋ B ↔ D) → (C ≡ D) → (K ∋ A ↔ C)
struct K refl ℜ refl = ℜ
struct-ext : ∀ K L {A B} {F G H I : K⟦ K ⇒ L ⟧}
(F≈G : ∀ A → F A ≡ G A) (ℜ : (K ⇒ L) ∋ G ↔ I) (H≈I : ∀ B → H B ≡ I B) (ℑ : K ∋ A ↔ B) →
struct L (F≈G A) (ℜ ℑ) (H≈I B) ≡ struct (K ⇒ L) (ext F≈G) ℜ (ext H≈I) ℑ
struct-ext K L {A} {B} F≈G ℜ H≈I ℑ
with ext F≈G | ext H≈I | F≈G A | H≈I B
... | refl | refl | refl | refl = refl
struct-apply : ∀ K L {F G H I A B C D} →
(F≡G : F ≡ G) (ℜ : (K ⇒ L) ∋ G ↔ I) (H≡I : H ≡ I) →
(A≡B : A ≡ B) (ℑ : K ∋ B ↔ D) (C≡D : C ≡ D) →
struct (K ⇒ L) F≡G ℜ H≡I (struct K A≡B ℑ C≡D)
≡ struct L (apply F≡G A≡B) (ℜ ℑ) (apply H≡I C≡D)
struct-apply K L refl ℜ refl refl ℑ refl = refl
struct-cast : ∀ {α A B C D} (ℜ : set α ∋ B ↔ D) (A≡B : A ≡ B) (C≡D : C ≡ D) {a c} →
struct (set α) A≡B ℜ C≡D a c → ℜ (cast A≡B a) (cast C≡D c)
struct-cast ℜ refl refl aℜc = aℜc
struct-sym : ∀ K {A B C D ℑ ℜ} → (A≡B : A ≡ B) → (C≡D : C ≡ D) →
(ℑ ≡ struct K A≡B ℜ C≡D) →
(ℜ ≡ struct K (sym A≡B) ℑ (sym C≡D))
struct-sym K refl refl refl = refl
struct-trans : ∀ K {A B C D E F}
(A≡B : A ≡ B) (B≡C : B ≡ C) (ℜ : K ∋ C ↔ F) (E≡F : E ≡ F) (D≡E : D ≡ E) →
struct K A≡B (struct K B≡C ℜ E≡F) D≡E ≡
struct K (trans A≡B B≡C) ℜ (trans D≡E E≡F)
struct-trans K refl refl ℜ refl refl = refl
-- Type contexts
infixr 4 _∷_
data Kinds : Set where
[] : Kinds
_∷_ : Kind → Kinds → Kinds
levels : Kinds → Level
levels [] = o
levels (K ∷ Σ) = level K ⊔ levels Σ
Σ⟦_⟧ : ∀ Σ → Set (levels Σ)
Σ⟦ [] ⟧ = ⊤
Σ⟦ K ∷ Σ ⟧ = K⟦ K ⟧ × Σ⟦ Σ ⟧
_∋_↔*_ : ∀ Σ → Σ⟦ Σ ⟧ → Σ⟦ Σ ⟧ → Set (levels Σ)
[] ∋ tt ↔* tt = ⊤
(K ∷ Σ) ∋ (A , As) ↔* (B , Bs) = (K ∋ A ↔ B) × (Σ ∋ As ↔* Bs)
-- Inclusion order on type contexts.
-- Credited by Randy Pollack to Geuvers and Nederhof, JAR 1991.
-- http://thread.gmane.org/gmane.comp.lang.agda/3259/focus=3267
data _⊑_ : Kinds → Kinds → Set where
id : ∀ {Σ} → Σ ⊑ Σ
keep : ∀ K {Σ Υ} → (Σ ⊑ Υ) → ((K ∷ Σ) ⊑ (K ∷ Υ))
skip : ∀ K {Σ Υ} → (Σ ⊑ Υ) → (Σ ⊑ (K ∷ Υ))
⊑⟦_⟧ : ∀ {Σ Υ} → (Σ ⊑ Υ) → Σ⟦ Υ ⟧ → Σ⟦ Σ ⟧
⊑⟦ id ⟧ As = As
⊑⟦ keep K Σ⊑Υ ⟧ (A , As) = (A , ⊑⟦ Σ⊑Υ ⟧ As)
⊑⟦ skip K Σ⊑Υ ⟧ (A , As) = ⊑⟦ Σ⊑Υ ⟧ As
⊑⟦_⟧² : ∀ {Σ Υ} → (Σ⊑Υ : Σ ⊑ Υ) → ∀ {As Bs} → (Υ ∋ As ↔* Bs) → (Σ ∋ ⊑⟦ Σ⊑Υ ⟧ As ↔* ⊑⟦ Σ⊑Υ ⟧ Bs)
⊑⟦ id ⟧² ℜs = ℜs
⊑⟦ keep K Σ⊑Υ ⟧² (ℜ , ℜs) = (ℜ , ⊑⟦ Σ⊑Υ ⟧² ℜs)
⊑⟦ skip K Σ⊑Υ ⟧² (ℜ , ℜs) = ⊑⟦ Σ⊑Υ ⟧² ℜs
-- Concatenation of type contexts
_++_ : Kinds → Kinds → Kinds
[] ++ Υ = Υ
(K ∷ Σ) ++ Υ = K ∷ (Σ ++ Υ)
_∋_++_∋_ : ∀ Σ → Σ⟦ Σ ⟧ → ∀ Υ → Σ⟦ Υ ⟧ → Σ⟦ Σ ++ Υ ⟧
[] ∋ tt ++ Υ ∋ Bs = Bs
(K ∷ Σ) ∋ (A , As) ++ Υ ∋ Bs = (A , (Σ ∋ As ++ Υ ∋ Bs))
_∋_++²_∋_ : ∀ Σ {As Bs} → (Σ ∋ As ↔* Bs) → ∀ Υ {Cs Ds} → (Υ ∋ Cs ↔* Ds) →
((Σ ++ Υ) ∋ (Σ ∋ As ++ Υ ∋ Cs) ↔* (Σ ∋ Bs ++ Υ ∋ Ds))
[] ∋ tt ++² Υ ∋ ℑs = ℑs
(K ∷ Σ) ∋ (ℜ , ℜs) ++² Υ ∋ ℑs = (ℜ , (Σ ∋ ℜs ++² Υ ∋ ℑs))
-- Type variables
data TVar (K : Kind) : Kinds → Set where
zero : ∀ {Σ} → TVar K (K ∷ Σ)
suc : ∀ {L Σ} → TVar K Σ → TVar K (L ∷ Σ)
τ⟦_⟧ : ∀ {Σ K} (τ : TVar K Σ) → Σ⟦ Σ ⟧ → K⟦ K ⟧
τ⟦ zero ⟧ (A , As) = A
τ⟦ suc τ ⟧ (A , As) = τ⟦ τ ⟧ As
τ⟦_⟧² : ∀ {Σ K} (τ : TVar K Σ) {As Bs} → (Σ ∋ As ↔* Bs) → (K ∋ τ⟦ τ ⟧ As ↔ τ⟦ τ ⟧ Bs)
τ⟦ zero ⟧² (ℜ , ℜs) = ℜ
τ⟦ suc τ ⟧² (ℜ , ℜs) = τ⟦ τ ⟧² ℜs
-- Type constants
data TConst : Kind → Set where
prod fun : ∀ {α β} → TConst (set α ⇒ (set β ⇒ set (α ⊔ β)))
leq : TConst (time ⇒ (time ⇒ set o))
univ : ∀ K {α} → TConst ((K ⇒ set α) ⇒ set (level K ⊔ α))
C⟦_⟧ : ∀ {K} → (TConst K) → K⟦ K ⟧
C⟦ prod ⟧ = λ A B → (A × B)
C⟦ fun ⟧ = λ A B → (A → B)
C⟦ leq ⟧ = λ t u → True (t ≤ u)
C⟦ univ K ⟧ = λ F → ∀ A → F A
C⟦_⟧² : ∀ {K} (C : TConst K) → (K ∋ C⟦ C ⟧ ↔ C⟦ C ⟧)
C⟦ prod ⟧² = λ ℜ ℑ → (ℜ ײ ℑ)
C⟦ fun ⟧² = λ ℜ ℑ → (ℜ →² ℑ)
C⟦ leq ⟧² = λ _ _ _ _ → ⊤
C⟦ univ K ⟧² = λ ℜ f g → ∀ {a b} ℑ → ℜ ℑ (f a) (g b)
-- Types
data Typ (Σ : Kinds) : Kind → Set where
const : ∀ {K} → TConst K → Typ Σ K
abs : ∀ K {L} → Typ (K ∷ Σ) L → Typ Σ (K ⇒ L)
app : ∀ {K L} → Typ Σ (K ⇒ L) → Typ Σ K → Typ Σ L
var : ∀ {K} → TVar K Σ → Typ Σ K
tlevel : ∀ {Σ α} → Typ Σ (set α) → Level
tlevel {Σ} {α} T = α
T⟦_⟧ : ∀ {Σ K} (T : Typ Σ K) → Σ⟦ Σ ⟧ → K⟦ K ⟧
T⟦ const C ⟧ As = C⟦ C ⟧
T⟦ abs K T ⟧ As = λ A → T⟦ T ⟧ (A , As)
T⟦ app T U ⟧ As = T⟦ T ⟧ As (T⟦ U ⟧ As)
T⟦ var τ ⟧ As = τ⟦ τ ⟧ As
T⟦_⟧² : ∀ {Σ K} (T : Typ Σ K) {As Bs} → (Σ ∋ As ↔* Bs) → (K ∋ T⟦ T ⟧ As ↔ T⟦ T ⟧ Bs)
T⟦ const C ⟧² ℜs = C⟦ C ⟧²
T⟦ abs K T ⟧² ℜs = λ ℜ → T⟦ T ⟧² (ℜ , ℜs)
T⟦ app T U ⟧² ℜs = T⟦ T ⟧² ℜs (T⟦ U ⟧² ℜs)
T⟦ var τ ⟧² ℜs = τ⟦ τ ⟧² ℜs
-- Type shorthands
app₂ : ∀ {Σ K L M} → Typ Σ (K ⇒ (L ⇒ M)) → Typ Σ K → Typ Σ L → Typ Σ M
app₂ T U V = app (app T U) V
capp : ∀ {Σ K L} → TConst (K ⇒ L) → Typ Σ K → Typ Σ L
capp C = app (const C)
capp₂ : ∀ {Σ K L M} → TConst (K ⇒ (L ⇒ M)) → Typ Σ K → Typ Σ L → Typ Σ M
capp₂ C = app₂ (const C)
_⊗_ : ∀ {Σ α β} → Typ Σ (set α) → Typ Σ (set β) → Typ Σ (set (α ⊔ β))
_⊗_ = capp₂ prod
_⊸_ : ∀ {Σ α β} → Typ Σ (set α) → Typ Σ (set β) → Typ Σ (set (α ⊔ β))
_⊸_ = capp₂ fun
_≼_ : ∀ {Σ} → Typ Σ time → Typ Σ time → Typ Σ (set o)
_≼_ = capp₂ leq
Π : ∀ {Σ α} K → Typ (K ∷ Σ) (set α) → Typ Σ (set (level K ⊔ α))
Π K T = capp (univ K) (abs K T)
tvar₀ : ∀ {Σ K} → Typ (K ∷ Σ) K
tvar₀ = var zero
tvar₁ : ∀ {Σ K L} → Typ (L ∷ K ∷ Σ) K
tvar₁ = var (suc zero)
tvar₂ : ∀ {Σ K L M} → Typ (M ∷ L ∷ K ∷ Σ) K
tvar₂ = var (suc (suc zero))
tvar₃ : ∀ {Σ K L M N} → Typ (N ∷ M ∷ L ∷ K ∷ Σ) K
tvar₃ = var (suc (suc (suc zero)))
rset : Level → Kind
rset α = time ⇒ set α
rset₀ : Kind
rset₀ = rset o
prodʳ : ∀ {Σ α β} → Typ Σ (rset α ⇒ (rset β ⇒ rset (α ⊔ β)))
prodʳ {Σ} {α} {β} = abs (rset α) (abs (rset β) (abs time (app tvar₂ tvar₀ ⊗ app tvar₁ tvar₀)))
_⊗ʳ_ : ∀ {Σ α β} → Typ Σ (rset α) → Typ Σ (rset β) → Typ Σ (rset (α ⊔ β))
_⊗ʳ_ = app₂ prodʳ
funʳ : ∀ {Σ α β} → Typ Σ (rset α ⇒ (rset β ⇒ rset (α ⊔ β)))
funʳ {Σ} {α} {β} = abs (rset α) (abs (rset β) (abs time (app tvar₂ tvar₀ ⊸ app tvar₁ tvar₀)))
_⊸ʳ_ : ∀ {Σ α β} → Typ Σ (rset α) → Typ Σ (rset β) → Typ Σ (rset (α ⊔ β))
_⊸ʳ_ = app₂ funʳ
always : ∀ {Σ α} → Typ Σ (set α ⇒ rset α)
always {Σ} {α} = abs (set α) (abs time tvar₁)
interval : ∀ {Σ α} → Typ Σ (rset α ⇒ (time ⇒ (time ⇒ set α)))
interval {Σ} {α} = abs (rset α) (abs time (abs time (Π time
((tvar₂ ≼ tvar₀) ⊸ ((tvar₀ ≼ tvar₁) ⊸ app tvar₃ tvar₀)))))
_[_,_] : ∀ {Σ α} → Typ Σ (rset α) → Typ Σ time → Typ Σ time → Typ Σ (set α)
T [ t , u ] = app (app (app interval T) t) u
constreq : ∀ {Σ α β} → Typ Σ (rset α ⇒ (rset β ⇒ rset (α ⊔ β)))
constreq {Σ} {α} {β} = abs (rset α) (abs (rset β) (abs time (Π time
((tvar₁ ≼ tvar₀) ⊸ ((tvar₃ [ tvar₁ , tvar₀ ]) ⊸ app tvar₂ tvar₀)))))
_⊵_ : ∀ {Σ α β} → Typ Σ (rset α) → Typ Σ (rset β) → Typ Σ (rset (α ⊔ β))
T ⊵ U = app₂ constreq T U
-- Contexts
data Typs (Σ : Kinds) : Set where
[] : Typs Σ
_∷_ : ∀ {α} → (Typ Σ (set α)) → Typs Σ → Typs Σ
tlevels : ∀ {Σ} → Typs Σ → Level
tlevels [] = o
tlevels (T ∷ Γ) = tlevel T ⊔ tlevels Γ
Γ⟦_⟧ : ∀ {Σ} (Γ : Typs Σ) → Σ⟦ Σ ⟧ → Set (tlevels Γ)
Γ⟦ [] ⟧ As = ⊤
Γ⟦ T ∷ Γ ⟧ As = T⟦ T ⟧ As × Γ⟦ Γ ⟧ As
Γ⟦_⟧² : ∀ {Σ} (Γ : Typs Σ) {As Bs} (ℜs : Σ ∋ As ↔* Bs) → (Γ⟦ Γ ⟧ As → Γ⟦ Γ ⟧ Bs → Set (tlevels Γ))
Γ⟦ [] ⟧² ℜs tt tt = ⊤
Γ⟦ T ∷ Γ ⟧² ℜs (a , as) (b , bs) = T⟦ T ⟧² ℜs a b × Γ⟦ Γ ⟧² ℜs as bs
-- Weakening of type variables
τweaken : ∀ {Σ Υ K} → (Σ ⊑ Υ) → TVar K Σ → TVar K Υ
τweaken id x = x
τweaken (keep K Σ⊑Υ) zero = zero
τweaken (keep K Σ⊑Υ) (suc x) = suc (τweaken Σ⊑Υ x)
τweaken (skip K Σ⊑Υ) x = suc (τweaken Σ⊑Υ x)
τweaken⟦_⟧ : ∀ {Σ Υ K} (τ : TVar K Σ) (Σ⊑Υ : Σ ⊑ Υ) (As : Σ⟦ Υ ⟧) →
τ⟦ τ ⟧ (⊑⟦ Σ⊑Υ ⟧ As) ≡ τ⟦ τweaken Σ⊑Υ τ ⟧ As
τweaken⟦ τ ⟧ id As = refl
τweaken⟦ zero ⟧ (keep K Σ⊑Υ) (A , As) = refl
τweaken⟦ suc τ ⟧ (keep K Σ⊑Υ) (A , As) = τweaken⟦ τ ⟧ Σ⊑Υ As
τweaken⟦ τ ⟧ (skip K Σ⊑Υ) (A , As) = τweaken⟦ τ ⟧ Σ⊑Υ As
τweaken⟦_⟧² : ∀ {Σ Υ K} (τ : TVar K Σ) (Σ⊑Υ : Σ ⊑ Υ) {As Bs} (ℜs : Υ ∋ As ↔* Bs) →
τ⟦ τ ⟧² (⊑⟦ Σ⊑Υ ⟧² ℜs) ≡
struct K (τweaken⟦ τ ⟧ Σ⊑Υ As) (τ⟦ τweaken Σ⊑Υ τ ⟧² ℜs) (τweaken⟦ τ ⟧ Σ⊑Υ Bs)
τweaken⟦ τ ⟧² id ℜs = refl
τweaken⟦ zero ⟧² (keep K Σ⊑Υ) (ℜ , ℜs) = refl
τweaken⟦ suc τ ⟧² (keep K Σ⊑Υ) (ℜ , ℜs) = τweaken⟦ τ ⟧² Σ⊑Υ ℜs
τweaken⟦ τ ⟧² (skip K Σ⊑Υ) (ℜ , ℜs) = τweaken⟦ τ ⟧² Σ⊑Υ ℜs
-- Weakening of types
weaken : ∀ {Σ Υ K} → (Σ ⊑ Υ) → Typ Σ K → Typ Υ K
weaken Σ⊑Υ (const C) = const C
weaken Σ⊑Υ (abs K T) = abs K (weaken (keep K Σ⊑Υ) T)
weaken Σ⊑Υ (app T U) = app (weaken Σ⊑Υ T) (weaken Σ⊑Υ U)
weaken Σ⊑Υ (var τ) = var (τweaken Σ⊑Υ τ)
weaken⟦_⟧ : ∀ {Σ Υ K} (T : Typ Σ K) (Σ⊑Υ : Σ ⊑ Υ) (As : Σ⟦ Υ ⟧) →
T⟦ T ⟧ (⊑⟦ Σ⊑Υ ⟧ As) ≡ T⟦ weaken Σ⊑Υ T ⟧ As
weaken⟦ const C ⟧ Σ⊑Υ As = refl
weaken⟦ abs K T ⟧ Σ⊑Υ As = ext (λ A → weaken⟦ T ⟧ (keep K Σ⊑Υ) (A , As))
weaken⟦ app T U ⟧ Σ⊑Υ As = apply (weaken⟦ T ⟧ Σ⊑Υ As) (weaken⟦ U ⟧ Σ⊑Υ As)
weaken⟦ var τ ⟧ Σ⊑Υ As = τweaken⟦ τ ⟧ Σ⊑Υ As
weaken⟦_⟧² : ∀ {Σ Υ K} (T : Typ Σ K) (Σ⊑Υ : Σ ⊑ Υ) {As Bs} (ℜs : Υ ∋ As ↔* Bs) →
T⟦ T ⟧² (⊑⟦ Σ⊑Υ ⟧² ℜs) ≡ struct K (weaken⟦ T ⟧ Σ⊑Υ As) (T⟦ weaken Σ⊑Υ T ⟧² ℜs) (weaken⟦ T ⟧ Σ⊑Υ Bs)
weaken⟦ const C ⟧² Σ⊑Υ ℜs = refl
weaken⟦ abs K {L} T ⟧² Σ⊑Υ {As} {Bs} ℜs =
iext (λ A → iext (λ B → ext (λ ℜ → begin
T⟦ abs K T ⟧² (⊑⟦ Σ⊑Υ ⟧² ℜs) ℜ
≡⟨ weaken⟦ T ⟧² (keep K Σ⊑Υ) (ℜ , ℜs) ⟩
struct L
(weaken⟦ T ⟧ (keep K Σ⊑Υ) (A , As))
(T⟦ weaken (keep K Σ⊑Υ) T ⟧² (ℜ , ℜs))
(weaken⟦ T ⟧ (keep K Σ⊑Υ) (B , Bs))
≡⟨ struct-ext K L
(λ A → weaken⟦ T ⟧ (keep K Σ⊑Υ) (A , As))
(λ ℜ → T⟦ weaken (keep K Σ⊑Υ) T ⟧² (ℜ , ℜs))
(λ B → weaken⟦ T ⟧ (keep K Σ⊑Υ) (B , Bs)) ℜ ⟩
struct (K ⇒ L)
(weaken⟦ abs K T ⟧ Σ⊑Υ As)
(T⟦ weaken Σ⊑Υ (abs K T) ⟧² ℜs)
(weaken⟦ abs K T ⟧ Σ⊑Υ Bs) ℜ
∎)))
weaken⟦ app {K} {L} T U ⟧² Σ⊑Υ {As} {Bs} ℜs =
begin
T⟦ app T U ⟧² (⊑⟦ Σ⊑Υ ⟧² ℜs)
≡⟨ cong (T⟦ T ⟧² (⊑⟦ Σ⊑Υ ⟧² ℜs)) (weaken⟦ U ⟧² Σ⊑Υ ℜs) ⟩
T⟦ T ⟧² (⊑⟦ Σ⊑Υ ⟧² ℜs)
(struct K (weaken⟦ U ⟧ Σ⊑Υ As) (T⟦ weaken Σ⊑Υ U ⟧² ℜs) (weaken⟦ U ⟧ Σ⊑Υ Bs))
≡⟨ cong (λ X → X (struct K (weaken⟦ U ⟧ Σ⊑Υ As) (T⟦ weaken Σ⊑Υ U ⟧² ℜs) (weaken⟦ U ⟧ Σ⊑Υ Bs)))
(weaken⟦ T ⟧² Σ⊑Υ ℜs) ⟩
(struct (K ⇒ L) (weaken⟦ T ⟧ Σ⊑Υ As) (T⟦ weaken Σ⊑Υ T ⟧² ℜs) (weaken⟦ T ⟧ Σ⊑Υ Bs))
(struct K (weaken⟦ U ⟧ Σ⊑Υ As) (T⟦ weaken Σ⊑Υ U ⟧² ℜs) (weaken⟦ U ⟧ Σ⊑Υ Bs))
≡⟨ struct-apply K L
(weaken⟦ T ⟧ Σ⊑Υ As) (T⟦ weaken Σ⊑Υ T ⟧² ℜs) (weaken⟦ T ⟧ Σ⊑Υ Bs)
(weaken⟦ U ⟧ Σ⊑Υ As) (T⟦ weaken Σ⊑Υ U ⟧² ℜs) (weaken⟦ U ⟧ Σ⊑Υ Bs) ⟩
struct L
(weaken⟦ app T U ⟧ Σ⊑Υ As)
(T⟦ weaken Σ⊑Υ (app T U) ⟧² ℜs)
(weaken⟦ app T U ⟧ Σ⊑Υ Bs)
∎
weaken⟦ var τ ⟧² Σ⊑Υ ℜs = τweaken⟦ τ ⟧² Σ⊑Υ ℜs
-- Weakening on type contexts
weakens : ∀ {Σ Υ} → (Σ ⊑ Υ) → Typs Σ → Typs Υ
weakens Σ⊑Υ [] = []
weakens Σ⊑Υ (T ∷ Γ) = weaken Σ⊑Υ T ∷ weakens Σ⊑Υ Γ
weakens⟦_⟧ : ∀ {Σ Υ} (Γ : Typs Σ) (Σ⊑Υ : Σ ⊑ Υ) (As : Σ⟦ Υ ⟧) →
Γ⟦ Γ ⟧ (⊑⟦ Σ⊑Υ ⟧ As) → Γ⟦ weakens Σ⊑Υ Γ ⟧ As
weakens⟦ [] ⟧ Σ⊑Υ As tt = tt
weakens⟦ T ∷ Γ ⟧ Σ⊑Υ As (B , Bs) = (cast (weaken⟦ T ⟧ Σ⊑Υ As) B , weakens⟦ Γ ⟧ Σ⊑Υ As Bs)
weakens⟦_⟧² : ∀ {Σ Υ} (Γ : Typs Σ) (Σ⊑Υ : Σ ⊑ Υ) {As Bs} (ℜs : Υ ∋ As ↔* Bs) {as bs} →
Γ⟦ Γ ⟧² (⊑⟦ Σ⊑Υ ⟧² ℜs) as bs →
Γ⟦ weakens Σ⊑Υ Γ ⟧² ℜs (weakens⟦ Γ ⟧ Σ⊑Υ As as) (weakens⟦ Γ ⟧ Σ⊑Υ Bs bs)
weakens⟦ [] ⟧² Σ⊑Υ ℜs tt
= tt
weakens⟦ T ∷ Γ ⟧² Σ⊑Υ ℜs (aℜb , asℜbs)
= ( struct-cast (T⟦ weaken Σ⊑Υ T ⟧² ℜs)
(weaken⟦ T ⟧ Σ⊑Υ _) (weaken⟦ T ⟧ Σ⊑Υ _) (cast² (weaken⟦ T ⟧² Σ⊑Υ ℜs) aℜb)
, weakens⟦ Γ ⟧² Σ⊑Υ ℜs asℜbs)
-- Susbtitution on type variables under a context
τsubstn+ : ∀ Σ {Υ K L} → TVar K (Σ ++ (L ∷ Υ)) → Typ Υ L → Typ (Σ ++ Υ) K
τsubstn+ [] zero U = U
τsubstn+ [] (suc τ) U = var τ
τsubstn+ (K ∷ Σ) zero U = var zero
τsubstn+ (K ∷ Σ) (suc τ) U = weaken (skip K id) (τsubstn+ Σ τ U)
τsubstn+_⟦_⟧⟦_⟧ : ∀ Σ {Υ K L} (τ : TVar K (Σ ++ (L ∷ Υ))) (U : Typ Υ L)
(As : Σ⟦ Σ ⟧) (Bs : Σ⟦ Υ ⟧) →
τ⟦ τ ⟧ (Σ ∋ As ++ (L ∷ Υ) ∋ (T⟦ U ⟧ Bs , Bs)) ≡
T⟦ τsubstn+ Σ τ U ⟧ (Σ ∋ As ++ Υ ∋ Bs)
τsubstn+ [] ⟦ zero ⟧⟦ U ⟧ tt Bs = refl
τsubstn+ [] ⟦ suc τ ⟧⟦ U ⟧ tt Bs = refl
τsubstn+ (K ∷ Σ) ⟦ zero ⟧⟦ U ⟧ (A , As) Bs = refl
τsubstn+ (K ∷ Σ) ⟦ suc τ ⟧⟦ U ⟧ (A , As) Bs = trans
(τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧ As Bs)
(weaken⟦ τsubstn+ Σ τ U ⟧ (skip K id) (A , (Σ ∋ As ++ _ ∋ Bs)))
τsubstn+_⟦_⟧⟦_⟧² : ∀ Σ {Υ L K} (τ : TVar K (Σ ++ (L ∷ Υ))) (U : Typ Υ L) {As Bs Cs Ds}
(ℜs : Σ ∋ As ↔* Bs) → (ℑs : Υ ∋ Cs ↔* Ds) →
τ⟦ τ ⟧² (Σ ∋ ℜs ++² (L ∷ Υ) ∋ (T⟦ U ⟧² ℑs , ℑs)) ≡
struct K
(τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧ As Cs)
(T⟦ τsubstn+ Σ τ U ⟧² (Σ ∋ ℜs ++² Υ ∋ ℑs) )
(τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧ Bs Ds)
τsubstn+ [] ⟦ zero ⟧⟦ U ⟧² tt ℑs = refl
τsubstn+ [] ⟦ suc τ ⟧⟦ U ⟧² tt ℑs = refl
τsubstn+ (J ∷ Σ) ⟦ zero ⟧⟦ U ⟧² (ℜ , ℜs) ℑs = refl
τsubstn+_⟦_⟧⟦_⟧² (J ∷ Σ) {Υ} {L} {K} (suc τ) U {A , As} {B , Bs} {Cs} {Ds} (ℜ , ℜs) ℑs =
begin
τ⟦ τ ⟧² (Σ ∋ ℜs ++² (L ∷ Υ) ∋ (T⟦ U ⟧² ℑs , ℑs))
≡⟨ τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧² ℜs ℑs ⟩
struct K
(τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧ As Cs)
(T⟦ τsubstn+ Σ τ U ⟧² (Σ ∋ ℜs ++² Υ ∋ ℑs))
(τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧ Bs Ds)
≡⟨ cong (λ X → struct K (τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧ As Cs) X (τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧ Bs Ds))
(weaken⟦ τsubstn+ Σ τ U ⟧² (skip J id) (ℜ , (Σ ∋ ℜs ++² Υ ∋ ℑs))) ⟩
struct K
(τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧ As Cs)
(struct K
(weaken⟦ τsubstn+ Σ τ U ⟧ (skip J id) (A , (Σ ∋ As ++ Υ ∋ Cs)))
(T⟦ weaken (skip J id) (τsubstn+ Σ τ U) ⟧² (ℜ , (Σ ∋ ℜs ++² Υ ∋ ℑs)))
(weaken⟦ τsubstn+ Σ τ U ⟧ (skip J id) (B , (Σ ∋ Bs ++ Υ ∋ Ds))))
(τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧ Bs Ds)
≡⟨ struct-trans K
(τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧ As Cs)
(weaken⟦ τsubstn+ Σ τ U ⟧ (skip J id) (A , (Σ ∋ As ++ Υ ∋ Cs)))
(T⟦ weaken (skip J id) (τsubstn+ Σ τ U) ⟧² (ℜ , (Σ ∋ ℜs ++² Υ ∋ ℑs)))
(weaken⟦ τsubstn+ Σ τ U ⟧ (skip J id) (B , (Σ ∋ Bs ++ Υ ∋ Ds)))
(τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧ Bs Ds) ⟩
struct K
(τsubstn+ (J ∷ Σ) ⟦ suc τ ⟧⟦ U ⟧ (A , As) Cs)
(T⟦ τsubstn+ (J ∷ Σ) (suc τ) U ⟧² (ℜ , (Σ ∋ ℜs ++² Υ ∋ ℑs)) )
(τsubstn+ (J ∷ Σ) ⟦ suc τ ⟧⟦ U ⟧ (B , Bs) Ds)
∎
-- Substitution on types under a context
substn+ : ∀ Σ {Υ K L} → Typ (Σ ++ (L ∷ Υ)) K → Typ Υ L → Typ (Σ ++ Υ) K
substn+ Σ (const C) U = const C
substn+ Σ (abs K T) U = abs K (substn+ (K ∷ Σ) T U)
substn+ Σ (app S T) U = app (substn+ Σ S U) (substn+ Σ T U)
substn+ Σ (var τ) U = τsubstn+ Σ τ U
substn+_⟦_⟧⟦_⟧ : ∀ Σ {Υ K L} (T : Typ (Σ ++ (L ∷ Υ)) K) (U : Typ Υ L)
(As : Σ⟦ Σ ⟧) (Bs : Σ⟦ Υ ⟧) →
T⟦ T ⟧ (Σ ∋ As ++ (L ∷ Υ) ∋ (T⟦ U ⟧ Bs , Bs)) ≡
T⟦ substn+ Σ T U ⟧ (Σ ∋ As ++ Υ ∋ Bs)
substn+ Σ ⟦ const C ⟧⟦ U ⟧ As Bs = refl
substn+ Σ ⟦ abs K T ⟧⟦ U ⟧ As Bs = ext (λ A → substn+ K ∷ Σ ⟦ T ⟧⟦ U ⟧ (A , As) Bs)
substn+ Σ ⟦ app S T ⟧⟦ U ⟧ As Bs = apply (substn+ Σ ⟦ S ⟧⟦ U ⟧ As Bs) (substn+ Σ ⟦ T ⟧⟦ U ⟧ As Bs)
substn+ Σ ⟦ var τ ⟧⟦ U ⟧ As Bs = τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧ As Bs
substn+_⟦_⟧⟦_⟧² : ∀ Σ {Υ L K} (T : Typ (Σ ++ (L ∷ Υ)) K) (U : Typ Υ L) {As Bs Cs Ds}
(ℜs : Σ ∋ As ↔* Bs) → (ℑs : Υ ∋ Cs ↔* Ds) →
T⟦ T ⟧² (Σ ∋ ℜs ++² (L ∷ Υ) ∋ (T⟦ U ⟧² ℑs , ℑs)) ≡
struct K
(substn+ Σ ⟦ T ⟧⟦ U ⟧ As Cs)
(T⟦ substn+ Σ T U ⟧² (Σ ∋ ℜs ++² Υ ∋ ℑs) )
(substn+ Σ ⟦ T ⟧⟦ U ⟧ Bs Ds)
substn+ Σ ⟦ const C ⟧⟦ U ⟧² ℜs ℑs = refl
substn+_⟦_⟧⟦_⟧² Σ {Υ} {L} (abs J {K} T) U {As} {Bs} {Cs} {Ds} ℜs ℑs =
iext (λ A → iext (λ B → ext (λ ℜ → begin
T⟦ abs J T ⟧² (Σ ∋ ℜs ++² (L ∷ Υ) ∋ (T⟦ U ⟧² ℑs , ℑs)) ℜ
≡⟨ substn+ (J ∷ Σ) ⟦ T ⟧⟦ U ⟧² (ℜ , ℜs) ℑs ⟩
struct K
(substn+ J ∷ Σ ⟦ T ⟧⟦ U ⟧ (A , As) Cs)
(T⟦ substn+ (J ∷ Σ) T U ⟧² ((J ∷ Σ) ∋ (ℜ , ℜs) ++² Υ ∋ ℑs))
(substn+ J ∷ Σ ⟦ T ⟧⟦ U ⟧ (B , Bs) Ds)
≡⟨ struct-ext J K
(λ A → substn+ J ∷ Σ ⟦ T ⟧⟦ U ⟧ (A , As) Cs)
(λ ℜ → T⟦ substn+ (J ∷ Σ) T U ⟧² ((J ∷ Σ) ∋ ℜ , ℜs ++² Υ ∋ ℑs))
(λ B → substn+ J ∷ Σ ⟦ T ⟧⟦ U ⟧ (B , Bs) Ds) ℜ ⟩
struct (J ⇒ K)
(substn+ Σ ⟦ abs J T ⟧⟦ U ⟧ As Cs)
(T⟦ substn+ Σ (abs J T) U ⟧² (Σ ∋ ℜs ++² Υ ∋ ℑs))
(substn+ Σ ⟦ abs J T ⟧⟦ U ⟧ Bs Ds) ℜ
∎)))
substn+_⟦_⟧⟦_⟧² Σ {Υ} {L} (app {J} {K} S T) U {As} {Bs} {Cs} {Ds} ℜs ℑs =
begin
T⟦ app S T ⟧² (Σ ∋ ℜs ++² L ∷ Υ ∋ (T⟦ U ⟧² ℑs , ℑs))
≡⟨ cong (T⟦ S ⟧² (Σ ∋ ℜs ++² L ∷ Υ ∋ (T⟦ U ⟧² ℑs , ℑs))) (substn+ Σ ⟦ T ⟧⟦ U ⟧² ℜs ℑs) ⟩
T⟦ S ⟧² (Σ ∋ ℜs ++² L ∷ Υ ∋ (T⟦ U ⟧² ℑs , ℑs))
(struct J
(substn+ Σ ⟦ T ⟧⟦ U ⟧ As Cs)
(T⟦ substn+ Σ T U ⟧² (Σ ∋ ℜs ++² Υ ∋ ℑs))
(substn+ Σ ⟦ T ⟧⟦ U ⟧ Bs Ds))
≡⟨ cong (λ X → X (struct J
(substn+ Σ ⟦ T ⟧⟦ U ⟧ As Cs)
(T⟦ substn+ Σ T U ⟧² (Σ ∋ ℜs ++² Υ ∋ ℑs))
(substn+ Σ ⟦ T ⟧⟦ U ⟧ Bs Ds)))
(substn+ Σ ⟦ S ⟧⟦ U ⟧² ℜs ℑs) ⟩
struct (J ⇒ K)
(substn+ Σ ⟦ S ⟧⟦ U ⟧ As Cs)
(T⟦ substn+ Σ S U ⟧² (Σ ∋ ℜs ++² Υ ∋ ℑs))
(substn+ Σ ⟦ S ⟧⟦ U ⟧ Bs Ds)
(struct J
(substn+ Σ ⟦ T ⟧⟦ U ⟧ As Cs)
(T⟦ substn+ Σ T U ⟧² (Σ ∋ ℜs ++² Υ ∋ ℑs))
(substn+ Σ ⟦ T ⟧⟦ U ⟧ Bs Ds))
≡⟨ struct-apply J K
(substn+ Σ ⟦ S ⟧⟦ U ⟧ As Cs)
(T⟦ substn+ Σ S U ⟧² (Σ ∋ ℜs ++² Υ ∋ ℑs))
(substn+ Σ ⟦ S ⟧⟦ U ⟧ Bs Ds)
(substn+ Σ ⟦ T ⟧⟦ U ⟧ As Cs)
(T⟦ substn+ Σ T U ⟧² (Σ ∋ ℜs ++² Υ ∋ ℑs))
(substn+ Σ ⟦ T ⟧⟦ U ⟧ Bs Ds) ⟩
struct K
(substn+ Σ ⟦ app S T ⟧⟦ U ⟧ As Cs)
(T⟦ substn+ Σ (app S T) U ⟧² (Σ ∋ ℜs ++² Υ ∋ ℑs))
(substn+ Σ ⟦ app S T ⟧⟦ U ⟧ Bs Ds)
∎
substn+ Σ ⟦ var τ ⟧⟦ U ⟧² ℜs ℑs = τsubstn+ Σ ⟦ τ ⟧⟦ U ⟧² ℜs ℑs
-- Substitution on types
substn : ∀ {Σ K L} → Typ (L ∷ Σ) K → Typ Σ L → Typ Σ K
substn = substn+ []
substn⟦_⟧⟦_⟧ : ∀ {Σ K L} (T : Typ (L ∷ Σ) K) (U : Typ Σ L) (As : Σ⟦ Σ ⟧)→
T⟦ T ⟧ (T⟦ U ⟧ As , As) ≡ T⟦ substn T U ⟧ As
substn⟦ T ⟧⟦ U ⟧ = substn+ [] ⟦ T ⟧⟦ U ⟧ tt
substn⟦_⟧⟦_⟧² : ∀ {Σ K L} (T : Typ (L ∷ Σ) K) (U : Typ Σ L) {As Bs} (ℜs : Σ ∋ As ↔* Bs) →
T⟦ T ⟧² (T⟦ U ⟧² ℜs , ℜs) ≡
struct K (substn⟦ T ⟧⟦ U ⟧ As) (T⟦ substn T U ⟧² ℜs) (substn⟦ T ⟧⟦ U ⟧ Bs)
substn⟦ T ⟧⟦ U ⟧² = substn+ [] ⟦ T ⟧⟦ U ⟧² tt
-- Eta-beta equivalence on types
data _∋_≣_ {Σ} : ∀ K → Typ Σ K → Typ Σ K → Set where
abs : ∀ K {L T U} → (L ∋ T ≣ U) → ((K ⇒ L) ∋ abs K T ≣ abs K U)
app : ∀ {K L F G T U} → ((K ⇒ L) ∋ F ≣ G) → (K ∋ T ≣ U) → (L ∋ app F T ≣ app G U)
beta : ∀ {K L} T U → (L ∋ app (abs K T) U ≣ substn T U)
eta : ∀ {K L} T → ((K ⇒ L) ∋ T ≣ abs K (app (weaken (skip K id) T) tvar₀))
≣-refl : ∀ {K T} → (K ∋ T ≣ T)
≣-sym : ∀ {K T U} → (K ∋ T ≣ U) → (K ∋ U ≣ T)
≣-trans : ∀ {K T U V} → (K ∋ T ≣ U) → (K ∋ U ≣ V) → (K ∋ T ≣ V)
≣⟦_⟧ : ∀ {Σ K} {T U : Typ Σ K} → (K ∋ T ≣ U) → ∀ As → T⟦ T ⟧ As ≡ T⟦ U ⟧ As
≣⟦ abs K T≣U ⟧ As = ext (λ A → ≣⟦ T≣U ⟧ (A , As))
≣⟦ app F≣G T≣U ⟧ As = apply (≣⟦ F≣G ⟧ As) (≣⟦ T≣U ⟧ As)
≣⟦ beta T U ⟧ As = substn⟦ T ⟧⟦ U ⟧ As
≣⟦ eta {K} T ⟧ As = ext (λ A → apply (weaken⟦ T ⟧ (skip K id) (A , As)) refl)
≣⟦ ≣-refl ⟧ As = refl
≣⟦ ≣-sym T≣U ⟧ As = sym (≣⟦ T≣U ⟧ As)
≣⟦ ≣-trans T≣U U≣V ⟧ As = trans (≣⟦ T≣U ⟧ As) (≣⟦ U≣V ⟧ As)
≣⟦_⟧² : ∀ {Σ K} {T U : Typ Σ K} (T≣U : K ∋ T ≣ U) {As Bs} (ℜs : Σ ∋ As ↔* Bs) →
T⟦ T ⟧² ℜs ≡ struct K (≣⟦ T≣U ⟧ As) (T⟦ U ⟧² ℜs) (≣⟦ T≣U ⟧ Bs)
≣⟦ abs K {L} {T} {U} T≣U ⟧² {As} {Bs} ℜs =
iext (λ A → iext (λ B → ext (λ ℜ → begin
T⟦ T ⟧² (ℜ , ℜs)
≡⟨ ≣⟦ T≣U ⟧² (ℜ , ℜs) ⟩
struct L (≣⟦ T≣U ⟧ (A , As)) (T⟦ U ⟧² (ℜ , ℜs)) (≣⟦ T≣U ⟧ (B , Bs))
≡⟨ struct-ext K L (λ A → ≣⟦ T≣U ⟧ (A , As)) (λ ℜ' → T⟦ U ⟧² (ℜ' , ℜs)) (λ B → ≣⟦ T≣U ⟧ (B , Bs)) ℜ ⟩
struct (K ⇒ L) (≣⟦ abs K T≣U ⟧ As) (T⟦ abs K U ⟧² ℜs) (≣⟦ abs K T≣U ⟧ Bs) ℜ
∎)))
≣⟦ app {K} {L} {F} {G} {T} {U} F≣G T≣U ⟧² {As} {Bs} ℜs =
begin
T⟦ app F T ⟧² ℜs
≡⟨ cong (T⟦ F ⟧² ℜs) (≣⟦ T≣U ⟧² ℜs) ⟩
T⟦ F ⟧² ℜs (struct K (≣⟦ T≣U ⟧ As) (T⟦ U ⟧² ℜs) (≣⟦ T≣U ⟧ Bs))
≡⟨ cong (λ X → X (struct K (≣⟦ T≣U ⟧ As) (T⟦ U ⟧² ℜs) (≣⟦ T≣U ⟧ Bs)))
(≣⟦ F≣G ⟧² ℜs) ⟩
struct (K ⇒ L) (≣⟦ F≣G ⟧ As) (T⟦ G ⟧² ℜs) (≣⟦ F≣G ⟧ Bs)
(struct K (≣⟦ T≣U ⟧ As) (T⟦ U ⟧² ℜs) (≣⟦ T≣U ⟧ Bs))
≡⟨ struct-apply K L
(≣⟦ F≣G ⟧ As) (T⟦ G ⟧² ℜs) (≣⟦ F≣G ⟧ Bs)
(≣⟦ T≣U ⟧ As) (T⟦ U ⟧² ℜs) (≣⟦ T≣U ⟧ Bs) ⟩
struct L (≣⟦ app F≣G T≣U ⟧ As) (T⟦ app G U ⟧² ℜs) (≣⟦ app F≣G T≣U ⟧ Bs)
∎
≣⟦ beta T U ⟧² ℜs = substn⟦ T ⟧⟦ U ⟧² ℜs
≣⟦ eta {K} {L} T ⟧² {As} {Bs} ℜs = iext (λ A → iext (λ B → ext (λ ℜ →
begin
T⟦ T ⟧² ℜs ℜ
≡⟨ cong (λ X → X ℜ) (weaken⟦ T ⟧² (skip K id) (ℜ , ℜs)) ⟩
struct (K ⇒ L)
(weaken⟦ T ⟧ (skip K id) (A , As))
(T⟦ weaken (skip K id) T ⟧² (ℜ , ℜs))
(weaken⟦ T ⟧ (skip K id) (B , Bs)) ℜ
≡⟨ struct-apply K L
(weaken⟦ T ⟧ (skip K id) (A , As))
(T⟦ weaken (skip K id) T ⟧² (ℜ , ℜs))
(weaken⟦ T ⟧ (skip K id) (B , Bs)) refl ℜ refl ⟩
struct L
(apply (weaken⟦ T ⟧ (skip K id) (A , As)) refl)
(T⟦ weaken (skip K id) T ⟧² (ℜ , ℜs) ℜ)
(apply (weaken⟦ T ⟧ (skip K id) (B , Bs)) refl)
≡⟨ struct-ext K L
(λ A → apply (weaken⟦ T ⟧ (skip K id) (A , As)) refl)
(λ ℜ → T⟦ weaken (skip K id) T ⟧² (ℜ , ℜs) ℜ)
(λ B → apply (weaken⟦ T ⟧ (skip K id) (B , Bs)) refl) ℜ ⟩
struct (K ⇒ L)
(≣⟦ eta T ⟧ As)
(T⟦ abs K (app (weaken (skip K id) T) (var zero)) ⟧² ℜs)
(≣⟦ eta T ⟧ Bs) ℜ
∎)))
≣⟦ ≣-refl ⟧² ℜs = refl
≣⟦ ≣-sym {K} {T} {U} T≣U ⟧² {As} {Bs} ℜs =
struct-sym K (≣⟦ T≣U ⟧ As) (≣⟦ T≣U ⟧ Bs) (≣⟦ T≣U ⟧² ℜs)
≣⟦ ≣-trans {K} {T} {U} {V} T≣U U≣V ⟧² {As} {Bs} ℜs =
begin
T⟦ T ⟧² ℜs
≡⟨ ≣⟦ T≣U ⟧² ℜs ⟩
struct K (≣⟦ T≣U ⟧ As) (T⟦ U ⟧² ℜs) (≣⟦ T≣U ⟧ Bs)
≡⟨ cong (λ X → struct K (≣⟦ T≣U ⟧ As) X (≣⟦ T≣U ⟧ Bs)) (≣⟦ U≣V ⟧² ℜs) ⟩
struct K (≣⟦ T≣U ⟧ As) (struct K (≣⟦ U≣V ⟧ As) (T⟦ V ⟧² ℜs) (≣⟦ U≣V ⟧ Bs)) (≣⟦ T≣U ⟧ Bs)
≡⟨ struct-trans K (≣⟦ T≣U ⟧ As) (≣⟦ U≣V ⟧ As) (T⟦ V ⟧² ℜs) (≣⟦ U≣V ⟧ Bs) (≣⟦ T≣U ⟧ Bs) ⟩
struct K (≣⟦ ≣-trans T≣U U≣V ⟧ As) (T⟦ V ⟧² ℜs) (≣⟦ ≣-trans T≣U U≣V ⟧ Bs)
∎
-- Variables
data Var {Σ : Kinds} {α} (T : Typ Σ (set α)) : Typs Σ → Set where
zero : ∀ {Γ} → Var T (T ∷ Γ)
suc : ∀ {β Γ} {U : Typ Σ (set β)} → Var T Γ → Var T (U ∷ Γ)
x⟦_⟧ : ∀ {Σ} {Γ : Typs Σ} {α} {T : Typ Σ (set α)} →
Var T Γ → (As : Σ⟦ Σ ⟧) → (as : Γ⟦ Γ ⟧ As) → (T⟦ T ⟧ As)
x⟦ zero ⟧ As (a , as) = a
x⟦ suc x ⟧ As (a , as) = x⟦ x ⟧ As as
x⟦_⟧² : ∀ {Σ} {Γ : Typs Σ} {α} {T : Typ Σ (set α)} (x : Var T Γ) →
∀ {As Bs} (ℜs : Σ ∋ As ↔* Bs) {as bs} →
(Γ⟦ Γ ⟧² ℜs as bs) → (T⟦ T ⟧² ℜs (x⟦ x ⟧ As as) (x⟦ x ⟧ Bs bs))
x⟦ zero ⟧² ℜs (aℜb , asℜbs) = aℜb
x⟦ suc x ⟧² ℜs (aℜb , asℜbs) = x⟦ x ⟧² ℜs asℜbs
-- Constants
data Const {Σ : Kinds} : ∀ {α} → Typ Σ (set α) → Set where
pair : ∀ {α β} → Const (Π (set α) (Π (set β) (tvar₁ ⊸ (tvar₀ ⊸ (tvar₁ ⊗ tvar₀)))))
fst : ∀ {α β} → Const (Π (set α) (Π (set β) ((tvar₁ ⊗ tvar₀) ⊸ tvar₁)))
snd : ∀ {α β} → Const (Π (set α) (Π (set β) ((tvar₁ ⊗ tvar₀) ⊸ tvar₀)))
≼-refl : Const (Π time (tvar₀ ≼ tvar₀))
≼-trans : Const (Π time (Π time (Π time ((tvar₂ ≼ tvar₁) ⊸ ((tvar₁ ≼ tvar₀) ⊸ (tvar₂ ≼ tvar₀))))))
≼-antisym : ∀ {α} → Const (Π (rset α) (Π time (Π time ((tvar₁ ≼ tvar₀) ⊸ ((tvar₀ ≼ tvar₁) ⊸ (app tvar₂ tvar₁ ⊸ app tvar₂ tvar₀))))))
≼-case : ∀ {α} → Const (Π (set α) (Π time (Π time (((tvar₁ ≼ tvar₀) ⊸ tvar₂) ⊸ (((tvar₀ ≼ tvar₁) ⊸ tvar₂) ⊸ tvar₂)))))
≤-antisym : ∀ {α} (A : RSet α) t u → True (t ≤ u) → True (u ≤ t) → A t → A u
≤-antisym A t u t≤u u≤t a with ≤-asym t u t≤u u≤t
≤-antisym A t .t _ _ a | refl = a
≤-case′ : ∀ {α} {A : Set α} {t u} → (t ≤? u) → (True (t ≤ u) → A) → (True (u ≤ t) → A) → A
≤-case′ (leq t≤u) f g = f t≤u
≤-case′ (geq u≤t) f g = g u≤t
≤-case : ∀ {α} (A : Set α) t u → (True (t ≤ u) → A) → (True (u ≤ t) → A) → A
≤-case A t u = ≤-case′ (≤-total t u)
c⟦_⟧ : ∀ {Σ} {α} {T : Typ Σ (set α)} →
Const T → (As : Σ⟦ Σ ⟧) → (T⟦ T ⟧ As)
c⟦ pair ⟧ As = λ A B a b → (a , b)
c⟦ fst ⟧ As = λ A B → proj₁
c⟦ snd ⟧ As = λ A B → proj₂
c⟦ ≼-refl ⟧ As = ≤-refl
c⟦ ≼-trans ⟧ As = ≤-trans
c⟦ ≼-antisym ⟧ As = ≤-antisym
c⟦ ≼-case ⟧ As = ≤-case
c⟦_⟧² : ∀ {Σ} {α} {T : Typ Σ (set α)} (c : Const T) →
∀ {As Bs} (ℜs : Σ ∋ As ↔* Bs) →
(T⟦ T ⟧² ℜs (c⟦ c ⟧ As) (c⟦ c ⟧ Bs))
c⟦ pair ⟧² ℜs = λ ℜ ℑ aℜb cℑd → (aℜb , cℑd)
c⟦ fst ⟧² ℜs = λ ℜ ℑ → proj₁
c⟦ snd ⟧² ℜs = λ ℜ ℑ → proj₂
c⟦ ≼-refl ⟧² ℜs = _
c⟦ ≼-trans ⟧² ℜs = _
c⟦ ≼-antisym {α} ⟧² ℜs = lemma where
lemma : ∀ {α} {A B : RSet α} (ℜ : rset α ∋ A ↔ B) →
{t u : Time} → (t≡u : t ≡ u) → {v w : Time} → (v≡w : v ≡ w) →
{t≤v : True (t ≤ v)} {u≤w : True (u ≤ w)} → ⊤ →
{v≤t : True (v ≤ t)} {w≤u : True (w ≤ u)} → ⊤ →
{a : A t} {b : B u} → ℜ t≡u a b →
ℜ v≡w (≤-antisym A t v t≤v v≤t a) (≤-antisym B u w u≤w w≤u b)
lemma ℜ {t} refl {v} refl {t≤v} {u≤w} tt {v≤t} {w≤u} tt aℜb
with irrel (t ≤ v) t≤v u≤w | irrel (v ≤ t) v≤t w≤u
lemma ℜ {t} refl {v} refl {t≤v} tt {v≤t} tt aℜb
| refl | refl with ≤-asym t v t≤v v≤t
lemma ℜ refl refl tt tt aℜb
| refl | refl | refl = aℜb
c⟦ ≼-case {α} ⟧² ℜs = lemma where
lemma : ∀ {α} {A B : Set α} (ℜ : set α ∋ A ↔ B) →
∀ {t u : Time} → (t≡u : t ≡ u) → ∀ {v w : Time} → (v≡w : v ≡ w) →
∀ {f g} → (∀ {t≤v} {u≤w} → ⊤ → ℜ (f t≤v) (g u≤w)) →
∀ {h i} → (∀ {v≤t} {w≤u} → ⊤ → ℜ (h v≤t) (i w≤u)) →
ℜ (≤-case A t v f h) (≤-case B u w g i)
lemma ℜ {t} refl {v} refl {f} {g} fℜg {h} {i} hℜi = lemma′ (≤-total t v) where
lemma′ : ∀ t≤?v → ℜ (≤-case′ t≤?v f h) (≤-case′ t≤?v g i)
lemma′ (leq t≤v) = fℜg {t≤v} {t≤v} tt
lemma′ (geq v≤t) = hℜi {v≤t} {v≤t} tt
-- Expressions
data Exp {Σ : Kinds} (Γ : Typs Σ) : ∀ {α} → Typ Σ (set α) → Set where
const : ∀ {α} {T : Typ Σ (set α)} → Const T → Exp Γ T
abs : ∀ {α β} (T : Typ Σ (set α)) {U : Typ Σ (set β)} (M : Exp (T ∷ Γ) U) → Exp Γ (T ⊸ U)
app : ∀ {α β} {T : Typ Σ (set α)} {U : Typ Σ (set β)} (M : Exp Γ (T ⊸ U)) (N : Exp Γ T) → Exp Γ U
var : ∀ {α} {T : Typ Σ (set α)} → Var T Γ → Exp Γ T
tabs : ∀ K {α} {T : Typ (K ∷ Σ) (set α)} (M : Exp (weakens (skip K id) Γ) T) → Exp Γ (Π K T)
tapp : ∀ {K α} {T : Typ (K ∷ Σ) (set α)} → Exp Γ (Π K T) → ∀ U → Exp Γ (substn T U)
eq : ∀ {α T U} → (set α ∋ T ≣ U) → (Exp Γ T) → (Exp Γ U)
ctxt : ∀ {Σ Γ α T} → Exp {Σ} Γ {α} T → Typs Σ
ctxt {Σ} {Γ} M = Γ
M⟦_⟧ : ∀ {Σ} {Γ : Typs Σ} {α} {T : Typ Σ (set α)} →
Exp Γ T → (As : Σ⟦ Σ ⟧) → (as : Γ⟦ Γ ⟧ As) → (T⟦ T ⟧ As)
M⟦ const c ⟧ As as = c⟦ c ⟧ As
M⟦ abs T M ⟧ As as = λ a → M⟦ M ⟧ As (a , as)
M⟦ app M N ⟧ As as = M⟦ M ⟧ As as (M⟦ N ⟧ As as)
M⟦ var x ⟧ As as = x⟦ x ⟧ As as
M⟦ tabs K M ⟧ As as = λ A →
M⟦ M ⟧ (A , As) (weakens⟦ ctxt (tabs K M) ⟧ (skip K id) (A , As) as)
M⟦ tapp {T = T} M U ⟧ As as =
cast (substn⟦ T ⟧⟦ U ⟧ As) (M⟦ M ⟧ As as (T⟦ U ⟧ As))
M⟦ eq T≣U M ⟧ As as = cast (≣⟦ T≣U ⟧ As) (M⟦ M ⟧ As as)
M⟦_⟧² : ∀ {Σ} {Γ : Typs Σ} {α} {T : Typ Σ (set α)} (M : Exp Γ T) →
∀ {As Bs} (ℜs : Σ ∋ As ↔* Bs) {as bs} →
(Γ⟦ Γ ⟧² ℜs as bs) → (T⟦ T ⟧² ℜs (M⟦ M ⟧ As as) (M⟦ M ⟧ Bs bs))
M⟦ const c ⟧² ℜs asℜbs = c⟦ c ⟧² ℜs
M⟦ abs T M ⟧² ℜs asℜbs = λ aℜb → M⟦ M ⟧² ℜs (aℜb , asℜbs)
M⟦ app M N ⟧² ℜs asℜbs = M⟦ M ⟧² ℜs asℜbs (M⟦ N ⟧² ℜs asℜbs)
M⟦ var x ⟧² ℜs asℜbs = x⟦ x ⟧² ℜs asℜbs
M⟦ tabs K M ⟧² ℜs asℜbs = λ ℜ →
M⟦ M ⟧² (ℜ , ℜs) (weakens⟦ ctxt (tabs K M) ⟧² (skip K id) (ℜ , ℜs) asℜbs)
M⟦ tapp {T = T} M U ⟧² ℜs asℜbs =
struct-cast (T⟦ substn T U ⟧² ℜs) (substn⟦ T ⟧⟦ U ⟧ _) (substn⟦ T ⟧⟦ U ⟧ _)
(cast² (substn⟦ T ⟧⟦ U ⟧² ℜs) (M⟦ M ⟧² ℜs asℜbs (T⟦ U ⟧² ℜs)))
M⟦ eq {α} {T} {U} T≣U M ⟧² {As} {Bs} ℜs asℜbs =
struct-cast (T⟦ U ⟧² ℜs) (≣⟦ T≣U ⟧ As) (≣⟦ T≣U ⟧ Bs) (cast² (≣⟦ T≣U ⟧² ℜs) (M⟦ M ⟧² ℜs asℜbs))
-- Types with a chosen free world variable
_∷ʳ_ : Kinds → Kind → Kinds
[] ∷ʳ K = K ∷ []
(T ∷ Σ) ∷ʳ K = T ∷ (Σ ∷ʳ K)
TVar+ : Kind → Kinds → Set
TVar+ K Σ = TVar K (Σ ∷ʳ rset₀)
Typ+ : Kinds → Kind → Set
Typ+ Σ = Typ (Σ ∷ʳ rset₀)
wvar : ∀ Σ → TVar+ rset₀ Σ
wvar [] = zero
wvar (K ∷ Σ) = suc (wvar Σ)
world : ∀ {Σ} → Typ+ Σ rset₀
world {Σ} = var (wvar Σ)
World : Time → Set
World t = ⊤
taut : ∀ {Σ α} → Typ+ Σ (rset α ⇒ set α)
taut {Σ} {α} = abs (rset α) (Π time
(app (world {time ∷ rset α ∷ Σ}) tvar₀ ⊸ app tvar₁ tvar₀))
-- Surface types
data STyp : Kind → Set where
⟨_⟩ : ∀ {α} → STyp (set α) → STyp (rset α)
[_] : ∀ {α} → STyp (rset α) → STyp (set α)
_⊠_ _↦_ : ∀ {α β} → STyp (set α) → STyp (set β) → STyp (set (α ⊔ β))
_∧_ _⇒_ : ∀ {α β} → STyp (rset α) → STyp (rset β) → STyp (rset (α ⊔ β))
□ : ∀ {α} → STyp (rset α) → STyp (rset α)
⟪_⟫ : ∀ {K} → STyp K → Typ+ [] K
⟪ ⟨ T ⟩ ⟫ = app always ⟪ T ⟫
⟪ [ T ] ⟫ = app (taut {[]}) ⟪ T ⟫
⟪ T ⊠ U ⟫ = ⟪ T ⟫ ⊗ ⟪ U ⟫
⟪ T ↦ U ⟫ = ⟪ T ⟫ ⊸ ⟪ U ⟫
⟪ T ∧ U ⟫ = ⟪ T ⟫ ⊗ʳ ⟪ U ⟫
⟪ T ⇒ U ⟫ = ⟪ T ⟫ ⊸ʳ ⟪ U ⟫
⟪ □ T ⟫ = tvar₀ ⊵ ⟪ T ⟫
T⟪_⟫ : ∀ {K} → STyp K → K⟦ K ⟧
T⟪ T ⟫ = T⟦ ⟪ T ⟫ ⟧ (World , tt)
-- Signals of T are iso to □ T
Signal : ∀ {α} → RSet α → RSet α
Signal A s = ∀ t → True (s ≤ t) → A t
sig : ∀ {α} (T : STyp (rset α)) s →
T⟪ □ T ⟫ s → Signal T⟪ T ⟫ s
sig T s σ t s≤t = σ t s≤t _
sig⁻¹ : ∀ {α} (T : STyp (rset α)) s →
Signal T⟪ T ⟫ s → T⟪ □ T ⟫ s
sig⁻¹ T s σ t s≤t _ = σ t s≤t
sig-iso : ∀ {α} (T : STyp (rset α)) s σ →
(sig T s (sig⁻¹ T s σ) ≡ σ)
sig-iso T s σ = refl
sig-iso⁻¹ : ∀ {α} (T : STyp (rset α)) s σ →
(sig⁻¹ T s (sig T s σ) ≡ σ)
sig-iso⁻¹ T s σ = refl
-- Signal functions from T to U are iso to □ T ⇒ □ U
SF : ∀ {α β} → RSet α → RSet β → RSet (α ⊔ β)
SF A B s = Signal A s → Signal B s
sf : ∀ {α β} (T : STyp (rset α)) (U : STyp (rset β)) s →
T⟪ □ T ⇒ □ U ⟫ s → SF T⟪ T ⟫ T⟪ U ⟫ s
sf T U s f σ = sig U s (f (sig⁻¹ T s σ))
sf⁻¹ : ∀ {α β} (T : STyp (rset α)) (U : STyp (rset β)) s →
SF T⟪ T ⟫ T⟪ U ⟫ s → T⟪ □ T ⇒ □ U ⟫ s
sf⁻¹ T U s f σ = sig⁻¹ U s (f (sig T s σ))
sf-iso : ∀ {α β} (T : STyp (rset α)) (U : STyp (rset β)) s f →
(sf T U s (sf⁻¹ T U s f) ≡ f)
sf-iso T U s f = refl
sf-iso⁻¹ : ∀ {α β} (T : STyp (rset α)) (U : STyp (rset β)) s f →
(sf⁻¹ T U s (sf T U s f) ≡ f)
sf-iso⁻¹ T U s f = refl
-- Causality
mutual
_at_⊨_≈[_]_ : ∀ {α} (T : STyp (rset α)) s → T⟪ T ⟫ s → Time → T⟪ T ⟫ s → Set α
⟨ T ⟩ at s ⊨ a ≈[ u ] b = T ⊨ a ≈[ u ] b
(T ∧ U) at s ⊨ (a , b) ≈[ u ] (c , d) = (T at s ⊨ a ≈[ u ] c) × (U at s ⊨ b ≈[ u ] d)
(T ⇒ U) at s ⊨ f ≈[ u ] g = ∀ a b → (T at s ⊨ a ≈[ u ] b) → (U at s ⊨ f a ≈[ u ] g b)
□ T at s ⊨ σ ≈[ u ] τ = (∀ t s≤t → True (t ≤ u) → (T at t ⊨ σ t s≤t _ ≈[ u ] τ t s≤t _))
_⊨_≈[_]_ : ∀ {α} → (T : STyp (set α)) → T⟪ T ⟫ → Time → T⟪ T ⟫ → Set α
[ T ] ⊨ σ ≈[ u ] τ = ∀ s → True (s ≤ u) → (T at s ⊨ σ s _ ≈[ u ] τ s _)
(T ⊠ U) ⊨ (a , b) ≈[ u ] (c , d) = (T ⊨ a ≈[ u ] c) × (U ⊨ b ≈[ u ] d)
(T ↦ U) ⊨ f ≈[ u ] g = ∀ a b → (T ⊨ a ≈[ u ] b) → (U ⊨ f a ≈[ u ] g b)
Causal : ∀ {α β} (T : STyp (set α)) (U : STyp (set β)) → T⟪ T ↦ U ⟫ → Set (α ⊔ β)
Causal T U f = ∀ u σ τ →
(T ⊨ σ ≈[ u ] τ) → (U ⊨ f σ ≈[ u ] f τ)
-- Parametricity implies causality
ℜ[_] : Time → (rset o ∋ World ↔ World)
ℜ[ u ] {t} s≡t tt tt = True (t ≤ u)
mutual
ℜ-impl-≈_at : ∀ {α} (T : STyp (rset α)) s u → True (s ≤ u) → ∀ a b →
(T⟦ ⟪ T ⟫ ⟧² (ℜ[ u ] , tt) refl a b) → (T at s ⊨ a ≈[ u ] b)
ℜ-impl-≈ ⟨ T ⟩ at s u s≤u a b aℜb
= ℜ-impl-≈ T u a b aℜb
ℜ-impl-≈ (T ∧ U) at s u s≤u (a , b) (c , d) (aℜc , bℜd)
= (ℜ-impl-≈ T at s u s≤u a c aℜc , ℜ-impl-≈ U at s u s≤u b d bℜd)
ℜ-impl-≈ (T ⇒ U) at s u s≤u f g fℜg
= λ a b a≈b → ℜ-impl-≈ U at s u s≤u (f a) (g b) (fℜg (≈-impl-ℜ T at s u s≤u a b a≈b))
ℜ-impl-≈_at (□ T) s u s≤u σ τ σℜτ = λ t s≤t t≤u →
ℜ-impl-≈ T at t u t≤u (σ t s≤t _) (τ t s≤t _)
(σℜτ refl tt (λ {r} _ _ {r≤t} _ → ≤-trans r t u r≤t t≤u))
≈-impl-ℜ_at : ∀ {α} (T : STyp (rset α)) s u → True (s ≤ u) → ∀ a b →
(T at s ⊨ a ≈[ u ] b) → (T⟦ ⟪ T ⟫ ⟧² (ℜ[ u ] , tt) refl a b)
≈-impl-ℜ ⟨ T ⟩ at s u s≤u a b a≈b
= ≈-impl-ℜ T u a b a≈b
≈-impl-ℜ (T ∧ U) at s u s≤u (a , b) (c , d) (a≈c , b≈d)
= (≈-impl-ℜ T at s u s≤u a c a≈c , ≈-impl-ℜ U at s u s≤u b d b≈d)
≈-impl-ℜ (T ⇒ U) at s u s≤u f g f≈g
= λ {a} {b} aℜb → ≈-impl-ℜ U at s u s≤u (f a) (g b) (f≈g a b (ℜ-impl-≈ T at s u s≤u a b aℜb))
≈-impl-ℜ (□ T) at s u s≤u σ τ σ≈τ = lemma where
lemma : T⟦ ⟪ □ T ⟫ ⟧² (ℜ[ u ] , tt) {s} refl σ τ
lemma {t} refl {s≤t} {s≤t′} tt kℜk′ with irrel (s ≤ t) s≤t s≤t′
lemma {t} refl {s≤t} tt kℜk′ | refl
= ≈-impl-ℜ T at t u t≤u (σ t s≤t _) (τ t s≤t _) (σ≈τ t s≤t t≤u) where
t≤u = kℜk′ {t} refl {s≤t} {s≤t} tt {≤-refl t} {≤-refl t} tt
ℜ-impl-≈ : ∀ {α} (T : STyp (set α)) (u : Time) (a b : T⟪ T ⟫) →
(T⟦ ⟪ T ⟫ ⟧² (ℜ[ u ] , tt) a b) → (T ⊨ a ≈[ u ] b)
ℜ-impl-≈ (T ⊠ U) u (a , b) (c , d) (aℜc , bℜd)
= (ℜ-impl-≈ T u a c aℜc , ℜ-impl-≈ U u b d bℜd)
ℜ-impl-≈ (T ↦ U) u f g fℜg
= λ a b a≈b → ℜ-impl-≈ U u (f a) (g b) (fℜg (≈-impl-ℜ T u a b a≈b))
ℜ-impl-≈ [ T ] u σ τ σℜτ
= λ s s≤u → ℜ-impl-≈ T at s u s≤u (σ s _) (τ s _) (σℜτ refl s≤u)
≈-impl-ℜ : ∀ {α} (T : STyp (set α)) (u : Time) (a b : T⟪ T ⟫) →
(T ⊨ a ≈[ u ] b) → (T⟦ ⟪ T ⟫ ⟧² (ℜ[ u ] , tt) a b)
≈-impl-ℜ (T ⊠ U) u (a , b) (c , d) (a≈c , b≈d)
= (≈-impl-ℜ T u a c a≈c , ≈-impl-ℜ U u b d b≈d)
≈-impl-ℜ (T ↦ U) u f g f≈g
= λ {a} {b} aℜb → ≈-impl-ℜ U u (f a) (g b) (f≈g a b (ℜ-impl-≈ T u a b aℜb))
≈-impl-ℜ [ T ] u σ τ σ≈τ = lemma where
lemma : T⟦ ⟪ [ T ] ⟫ ⟧² (ℜ[ u ] , tt) σ τ
lemma {s} refl s≤u = ≈-impl-ℜ T at s u s≤u (σ s _) (τ s _) (σ≈τ s s≤u)
-- Every F-omega function is causal
causality : ∀ {α β} (T : STyp (set α)) (U : STyp (set β)) (M : Exp [] ⟪ T ↦ U ⟫) →
Causal T U (M⟦ M ⟧ (World , tt) tt)
causality T U M u
= ℜ-impl-≈ (T ↦ U) u
(M⟦ M ⟧ (World , tt) tt)
(M⟦ M ⟧ (World , tt) tt)
(M⟦ M ⟧² (ℜ[ u ] , _) tt)
| 37.160874
| 134
| 0.436359
|
38a1878175f00ef820335c837ec4e5664ee4b579
| 129
|
agda
|
Agda
|
thesisExamples/VecFlip.agda
|
JoeyEremondi/lambda-pi-constraint
|
64a1b4c6632153d75cba540f7c91f40b49375e2f
|
[
"BSD-3-Clause"
] | 16
|
2017-03-16T11:14:56.000Z
|
2021-02-05T20:21:46.000Z
|
thesisExamples/VecFlip.agda
|
JoeyEremondi/lambda-pi-constraint
|
64a1b4c6632153d75cba540f7c91f40b49375e2f
|
[
"BSD-3-Clause"
] | null | null | null |
thesisExamples/VecFlip.agda
|
JoeyEremondi/lambda-pi-constraint
|
64a1b4c6632153d75cba540f7c91f40b49375e2f
|
[
"BSD-3-Clause"
] | null | null | null |
module VecFlip where
open import AgdaPrelude
goodNil : Vec Nat Zero
goodNil = Nil Nat
badNil : Vec Zero Nat
badNil = Nil Nat
| 11.727273
| 23
| 0.751938
|
fdbb77ecd12a49b7635e67c6a865c42578a19d8d
| 224
|
agda
|
Agda
|
Cubical/HITs/Truncation/FromNegOne.agda
|
kiana-S/univalent-foundations
|
8bdb0766260489f9c89a14f4c0f2ad26e5190dec
|
[
"MIT"
] | null | null | null |
Cubical/HITs/Truncation/FromNegOne.agda
|
kiana-S/univalent-foundations
|
8bdb0766260489f9c89a14f4c0f2ad26e5190dec
|
[
"MIT"
] | null | null | null |
Cubical/HITs/Truncation/FromNegOne.agda
|
kiana-S/univalent-foundations
|
8bdb0766260489f9c89a14f4c0f2ad26e5190dec
|
[
"MIT"
] | 1
|
2021-11-22T02:02:01.000Z
|
2021-11-22T02:02:01.000Z
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Truncation.FromNegOne where
open import Cubical.HITs.Truncation.FromNegOne.Base public
open import Cubical.HITs.Truncation.FromNegOne.Properties public
| 37.333333
| 64
| 0.808036
|
0d747b5131c75c3eca915e7a2af279f01e110c72
| 727
|
agda
|
Agda
|
src/Data/List/First/Membership.agda
|
metaborg/mj.agda
|
0c096fea1716d714db0ff204ef2a9450b7a816df
|
[
"Apache-2.0"
] | 10
|
2017-11-17T17:10:36.000Z
|
2021-09-24T08:02:33.000Z
|
src/Data/List/First/Membership.agda
|
metaborg/mj.agda
|
0c096fea1716d714db0ff204ef2a9450b7a816df
|
[
"Apache-2.0"
] | 1
|
2019-01-13T13:03:47.000Z
|
2020-10-14T13:41:58.000Z
|
src/Data/List/First/Membership.agda
|
metaborg/mj.agda
|
0c096fea1716d714db0ff204ef2a9450b7a816df
|
[
"Apache-2.0"
] | 1
|
2021-12-28T17:38:05.000Z
|
2021-12-28T17:38:05.000Z
|
module Data.List.First.Membership {ℓ}{A : Set ℓ} where
open import Data.Product
open import Data.List
open import Data.List.Relation.Unary.Any
open import Data.List.First hiding (find)
open import Relation.Nullary
open import Relation.Binary
open import Relation.Binary.PropositionalEquality
open import Level
open import Function
open import Data.Empty
_∈_ : A → List A → Set _
x ∈ l = first x ∈ l ⇒ (_≡_ x)
¬x∈[] : ∀ {x} → ¬ x ∈ []
¬x∈[] ()
find : Decidable (_≡_ {A = A}) → ∀ x l → Dec (x ∈ l)
find _≟_ x [] = no (λ ())
find _≟_ x (y ∷ l) with x ≟ y
... | yes refl = yes (here refl)
... | no neq with find _≟_ x l
... | yes p = yes (there y neq p)
... | no ¬p = no (λ{ (here eq) → neq eq ; (there _ _ p) → ¬p p})
| 26.925926
| 67
| 0.616231
|
36c1d9b06a6a7d2253e14b457079a820e9ace836
| 514
|
agda
|
Agda
|
Groups/Subgroups/Normal/Definition.agda
|
Smaug123/agdaproofs
|
0f4230011039092f58f673abcad8fb0652e6b562
|
[
"MIT"
] | 4
|
2019-08-08T12:44:19.000Z
|
2022-01-28T06:04:15.000Z
|
Groups/Subgroups/Normal/Definition.agda
|
Smaug123/agdaproofs
|
0f4230011039092f58f673abcad8fb0652e6b562
|
[
"MIT"
] | 14
|
2019-01-06T21:11:59.000Z
|
2020-04-11T11:03:39.000Z
|
Groups/Subgroups/Normal/Definition.agda
|
Smaug123/agdaproofs
|
0f4230011039092f58f673abcad8fb0652e6b562
|
[
"MIT"
] | 1
|
2021-11-29T13:23:07.000Z
|
2021-11-29T13:23:07.000Z
|
{-# OPTIONS --safe --warning=error --without-K #-}
open import Groups.Definition
open import Setoids.Setoids
open import Groups.Subgroups.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
module Groups.Subgroups.Normal.Definition {a b : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ : A → A → A} (G : Group S _+_) where
normalSubgroup : {c : _} {pred : A → Set c} (sub : Subgroup G pred) → Set (a ⊔ c)
normalSubgroup {pred = pred} sub = {g k : A} → pred k → pred (g + (k + Group.inverse G g))
| 39.538462
| 128
| 0.64786
|
381fe55c5b86ab7a6682d80b7209c68494ba7961
| 193
|
agda
|
Agda
|
test/Fail/Issue1084.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Fail/Issue1084.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Fail/Issue1084.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
-- Andreas, 2014-12-03 Issue reported by Fabien Renaud
postulate A : Set
f : A → A
g : A → A
f x = g x
ok : A → A
ok x = x
g x = f x
-- Only `f` and `g` should be colored red, not `ok`.
| 11.352941
| 54
| 0.564767
|
a1e938754620801e2a3177af4f29d5b93adc61cc
| 2,326
|
agda
|
Agda
|
Cubical/Algebra/RingSolver/CommRingExamples.agda
|
maxdore/cubical
|
ef62b84397396d48135d73ba7400b71c721ddc94
|
[
"MIT"
] | null | null | null |
Cubical/Algebra/RingSolver/CommRingExamples.agda
|
maxdore/cubical
|
ef62b84397396d48135d73ba7400b71c721ddc94
|
[
"MIT"
] | null | null | null |
Cubical/Algebra/RingSolver/CommRingExamples.agda
|
maxdore/cubical
|
ef62b84397396d48135d73ba7400b71c721ddc94
|
[
"MIT"
] | 1
|
2021-03-12T20:08:45.000Z
|
2021-03-12T20:08:45.000Z
|
{-# OPTIONS --safe #-}
module Cubical.Algebra.RingSolver.CommRingExamples where
open import Cubical.Foundations.Prelude
open import Cubical.Data.FinData
open import Cubical.Data.Nat using (ℕ)
open import Cubical.Data.Vec.Base
open import Cubical.Algebra.CommRing
open import Cubical.Algebra.RingSolver.NatAsAlmostRing
open import Cubical.Algebra.RingSolver.RawAlgebra renaming (⟨_⟩ to ⟨_⟩ᵣ)
open import Cubical.Algebra.RingSolver.CommRingSolver
private
variable
ℓ : Level
module MultivariateSolving (R : CommRing ℓ) where
-- In scope for debuggin:
-- In scope for solver use:
open CommRingStr (snd R)
AsAlgebra = CommRing→RawℤAlgebra R
X : ℤExpr R 3
X = ∣ Fin.zero
Y : ℤExpr R 3
Y = ∣ (suc Fin.zero)
Z : ℤExpr R 3
Z = ∣ (suc (suc Fin.zero))
_ : (x y z : (fst R)) → x · y · z ≡ z · y · x
_ = λ x y z →
let
lhs = X ·' Y ·' Z
rhs = Z ·' Y ·' X
in solve R lhs rhs (x ∷ y ∷ z ∷ []) refl
_ : (x y z : (fst R)) → x · (y + z) ≡ z · x + y · x
_ = λ x y z →
let
lhs = X ·' (Y +' Z)
rhs = Z ·' X +' Y ·' X
in solve R lhs rhs (x ∷ y ∷ z ∷ []) refl
_ : (x y z : (fst R)) → x · (y - z) ≡ (- z) · x + y · x
_ = λ x y z →
let
lhs = X ·' (Y +' (-' Z))
rhs = (-' Z) ·' X +' (Y ·' X)
in solve R lhs rhs (x ∷ y ∷ z ∷ []) refl
{-
A bigger example, copied from 'Example.agda'
-}
_ : (x y z : (fst R)) → (x + y) · (x + y) · (x + y) · (x + y)
≡ x · x · x · x + (scalar R 4) · x · x · x · y + (scalar R 6) · x · x · y · y
+ (scalar R 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 solve R lhs rhs (x ∷ y ∷ z ∷ []) refl
_ : (x y z : (fst R)) → (x + y) · (x - y) ≡ (x · x - y · y)
_ = λ x y z →
let
lhs = (X +' Y) ·' (X +' (-' Y))
rhs = (X ·' X) +' (-' (Y ·' Y))
in solve R lhs rhs (x ∷ y ∷ z ∷ []) refl
| 29.075
| 93
| 0.414445
|
141e6baaf47f1d29d10b75ae32c0e7713ca3f192
| 8,581
|
agda
|
Agda
|
choices/minlist-is-correct.agda
|
mihanus/curry-agda
|
b7cfdda11cdadeba882b6b72d75448acd8b0a294
|
[
"BSD-3-Clause"
] | null | null | null |
choices/minlist-is-correct.agda
|
mihanus/curry-agda
|
b7cfdda11cdadeba882b6b72d75448acd8b0a294
|
[
"BSD-3-Clause"
] | null | null | null |
choices/minlist-is-correct.agda
|
mihanus/curry-agda
|
b7cfdda11cdadeba882b6b72d75448acd8b0a294
|
[
"BSD-3-Clause"
] | null | null | null |
-- Proof: if we non-deterministically select an element
-- which is less-than-or-equal than all other elements,
-- such a result is the minimum of the list.
-- This holds for any non-deterministically selected element.
-- Basically, this is the translation of the Curry rule:
--
-- min-nd xs@(_++[x]++_) | all (x<=) xs = x
--
open import bool
module minlist-is-correct
(Choice : Set)
(choose : Choice → 𝔹)
(lchoice : Choice → Choice)
(rchoice : Choice → Choice)
where
open import eq
open import bool-thms
open import bool-thms2
open import nat
open import nat-thms
open import list
open import maybe
open import inspect
----------------------------------------------------------------------
-- Some auxiliaries:
-- We define our own less-or-equal since the standard definition with
-- if-then-else produces too many branches:
_<=_ : ℕ → ℕ → 𝔹
0 <= y = tt
(suc x) <= 0 = ff
(suc x) <= (suc y) = x <= y
-- Some properties about less-or-equal:
<=-refl : ∀ (x : ℕ) → x <= x ≡ tt
<=-refl 0 = refl
<=-refl (suc x) = <=-refl x
<=-trans : ∀ (x y z : ℕ) → x <= y ≡ tt → y <= z ≡ tt → x <= z ≡ tt
<=-trans zero y z p1 p2 = refl
<=-trans (suc x) zero z p1 p2 = 𝔹-contra p1
<=-trans (suc x) (suc y) zero p1 p2 = 𝔹-contra p2
<=-trans (suc x) (suc y) (suc z) p1 p2 = <=-trans x y z p1 p2
<=-< : ∀ (x y : ℕ) → x <= y ≡ ff → y < x ≡ tt
<=-< zero x ()
<=-< (suc x) zero p = refl
<=-< (suc x) (suc y) p = <=-< x y p
<-<= : ∀ (x y : ℕ) → x < y ≡ tt → y <= x ≡ ff
<-<= x zero p rewrite <-0 x = 𝔹-contra p
<-<= zero (suc y) p = refl
<-<= (suc x) (suc y) p = <-<= x y p
<-<=-ff : ∀ (x y : ℕ) → x < y ≡ ff → y <= x ≡ tt
<-<=-ff zero zero p = refl
<-<=-ff zero (suc y) p = 𝔹-contra (sym p)
<-<=-ff (suc x) zero p = refl
<-<=-ff (suc x) (suc y) p = <-<=-ff x y p
<-<=-trans : ∀ (x y z : ℕ) → x < y ≡ tt → y <= z ≡ tt → x < z ≡ tt
<-<=-trans zero zero z p1 p2 = 𝔹-contra p1
<-<=-trans zero (suc y) zero p1 p2 = 𝔹-contra p2
<-<=-trans zero (suc y) (suc z) p1 p2 = refl
<-<=-trans (suc x) zero z p1 p2 = 𝔹-contra p1
<-<=-trans (suc x) (suc y) zero p1 p2 = 𝔹-contra p2
<-<=-trans (suc x) (suc y) (suc z) p1 p2 = <-<=-trans x y z p1 p2
----------------------------------------------------------------------
-- More lemmas about ordering relations:
leq-if : ∀ (x y z : ℕ)
→ y <= x && y <= z ≡ (if x <= z then y <= x else y <= z)
leq-if x y z with inspect (y <= x)
leq-if x y z | it tt p1 with inspect (x <= z)
... | it tt p2 rewrite p1 | p2 | <=-trans y x z p1 p2 = refl
... | it ff p2 rewrite p1 | p2 = refl
leq-if x y z | it ff p1 with inspect (x <= z)
... | it tt p2 rewrite p1 | p2 = refl
... | it ff p2 rewrite p1 | p2
| <-<= z y (<-trans {z} {x} {y} (<=-< x z p2) (<=-< y x p1)) = refl
le-if : ∀ (x y z : ℕ)
→ y < x && y < z ≡ (if x <= z then y < x else y < z)
le-if x y z with inspect (y < x)
le-if x y z | it tt p1 with inspect (x <= z)
... | it tt p2 rewrite p1 | p2 | <-<=-trans y x z p1 p2 = refl
... | it ff p2 rewrite p1 | p2 = refl
le-if x y z | it ff p1 with inspect (x <= z)
... | it tt p2 rewrite p1 | p2 = refl
... | it ff p2 rewrite p1 | p2
| <-asym {z} {y} (<-<=-trans z x y (<=-< x z p2) (<-<=-ff y x p1))
= refl
----------------------------------------------------------------------
-- A lemma relating equality and orderings:
=ℕ-not-le : ∀ (m n : ℕ) → m =ℕ n ≡ ~ (m < n) && m <= n
=ℕ-not-le zero zero = refl
=ℕ-not-le zero (suc m) = refl
=ℕ-not-le (suc n) zero = refl
=ℕ-not-le (suc n) (suc m) = =ℕ-not-le n m
----------------------------------------------------------------------
-- This is the translation of the Curry program:
-- Check whether all elements of a list satisfy a given predicate:
all : {A : Set} → (A → 𝔹) → 𝕃 A → 𝔹
all _ [] = tt
all p (x :: xs) = p x && all p xs
-- Deterministic min-d:
min-d : (l : 𝕃 ℕ) → is-empty l ≡ ff → ℕ
min-d [] ()
min-d (x :: []) _ = x
min-d (x :: y :: xs) _ =
--if x <= min-d (y :: xs) refl then x else min-d (y :: xs) refl
let z = min-d (y :: xs) refl
in if x <= z then x else z
-- Select some element from a list:
select : {A : Set} → Choice → 𝕃 A -> maybe A
select _ [] = nothing
select ch (x :: xs) = if choose ch then just x
else select (lchoice ch) xs
-- Select elements with a property from a list:
select-with : {A : Set} → Choice → (A → 𝔹) → 𝕃 A → maybe A
select-with _ p [] = nothing
select-with ch p (x :: xs) =
if choose ch then (if p x then just x else nothing)
else select-with (lchoice ch) p xs
{-
-- more or less original definition:
min-nd : Choice → 𝕃 ℕ -> maybe ℕ
min-nd ch xs = (select ch xs) ≫=maybe
(λ y → if all (_<=_ y) xs then just y else nothing)
-}
min-nd : Choice → (xs : 𝕃 ℕ) → maybe ℕ
min-nd ch xs = select-with ch (λ x → all (_<=_ x) xs) xs
----------------------------------------------------------------------
-- Proof of the correctness of the operation select-with:
select-with-correct : ∀ {A : Set}
→ (ch : Choice) (p : A → 𝔹) (xs : 𝕃 A) (z : A)
→ select-with ch p xs ≡ just z → p z ≡ tt
select-with-correct ch p [] z ()
select-with-correct ch p (x :: xs) z u with choose ch
select-with-correct ch p (x :: xs) z u | tt with inspect (p x)
select-with-correct ch p (x :: xs) z u | tt | it tt v rewrite v | u | down-≡ u
= v
select-with-correct ch p (x :: xs) z u | tt | it ff v rewrite v with u
select-with-correct ch p (x :: xs) z u | tt | it ff v | ()
select-with-correct ch p (x :: xs) z u | ff =
select-with-correct (lchoice ch) p xs z u
----------------------------------------------------------------------
-- First step: if y smaller than all elements, y is smaller than the minimum:
all-leq-min : ∀ (y x : ℕ) (xs : 𝕃 ℕ)
→ all (_<=_ y) (x :: xs) ≡ y <= min-d (x :: xs) refl
all-leq-min y x [] = &&-tt (y <= x)
all-leq-min y x (z :: zs)
rewrite all-leq-min y z zs
| ite-arg (_<=_ y) (x <= min-d (z :: zs) refl) x (min-d (z :: zs) refl)
= leq-if x y (min-d (z :: zs) refl)
-- Now we can prove:
-- if min-nd selects an element, it is smaller or equal than the minimum:
min-nd-select-min-d : ∀ (ch : Choice) (x : ℕ) (xs : 𝕃 ℕ) (z : ℕ)
→ min-nd ch (x :: xs) ≡ just z → z <= min-d (x :: xs) refl ≡ tt
min-nd-select-min-d ch x xs z u
rewrite sym (all-leq-min z x xs)
| select-with-correct ch (λ y → all (_<=_ y) (x :: xs)) (x :: xs) z u
= refl
----------------------------------------------------------------------
-- Next step: if y smaller than all elements, y is smaller than the minimum:
all-less-min : ∀ (y x : ℕ) (xs : 𝕃 ℕ)
→ all (_<_ y) (x :: xs) ≡ y < min-d (x :: xs) refl
all-less-min y x [] rewrite &&-tt (y < x) = refl
all-less-min y x (z :: zs)
rewrite all-less-min y z zs
| ite-arg (_<_ y) (x <= min-d (z :: zs) refl) x (min-d (z :: zs) refl)
= le-if x y (min-d (z :: zs) refl)
-- Next want to prove that the element selected by min-nd cannot be smaller
-- than the minimum.
-- For this purpose, we prove an auxiliary lemma:
-- If an element is selected from a list, it cannot be smaller than all elements
select-with-all<-ff : ∀ (ch : Choice) (p : ℕ → 𝔹) (xs : 𝕃 ℕ) (z : ℕ)
→ select-with ch p xs ≡ just z → all (_<_ z) xs ≡ ff
select-with-all<-ff ch _ [] z ()
select-with-all<-ff ch p (x :: xs) z u with (choose ch)
select-with-all<-ff ch p (x :: xs) z u | tt with (p x)
select-with-all<-ff ch p (x :: xs) z u | tt | tt rewrite down-≡ u | <-irrefl z
= refl
select-with-all<-ff ch p (x :: xs) z () | tt | ff
select-with-all<-ff ch p (x :: xs) z u | ff
rewrite select-with-all<-ff (lchoice ch) p xs z u | &&-ff (z < x) = refl
-- Now we can prove: if min-nd selects an element, it cannot be smaller
-- than all other elements:
min-nd-select-all<-ff : ∀ (ch : Choice) (xs : 𝕃 ℕ) (z : ℕ)
→ min-nd ch xs ≡ just z → all (_<_ z) xs ≡ ff
min-nd-select-all<-ff ch xs z u
rewrite select-with-all<-ff ch (λ y → all (_<=_ y) xs) xs z u = refl
----------------------------------------------------------------------
-- This is the main theorem:
min-nd-theorem : ∀ (ch : Choice) (x : ℕ) (xs : 𝕃 ℕ) (z : ℕ)
→ min-nd ch (x :: xs) ≡ just z → z =ℕ min-d (x :: xs) refl ≡ tt
min-nd-theorem ch x xs z u
rewrite
=ℕ-not-le z (min-d (x :: xs) refl) -- split equality into no less and leq
| min-nd-select-min-d ch x xs z u -- min-nd selects leq min. elements
| sym (all-less-min z x xs) -- less-than min. elements satisfy all<
| min-nd-select-all<-ff ch (x :: xs) z u -- min-nd can't select any all< element
= refl
----------------------------------------------------------------------
| 36.514894
| 81
| 0.510547
|
43916dee6efd1a96f427c2be5da7adc097783aa7
| 1,385
|
agda
|
Agda
|
src/data/lib/prim/Agda/Builtin/Cubical/Id.agda
|
cagix/agda
|
cc026a6a97a3e517bb94bafa9d49233b067c7559
|
[
"BSD-2-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
src/data/lib/prim/Agda/Builtin/Cubical/Id.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
src/data/lib/prim/Agda/Builtin/Cubical/Id.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
{-# OPTIONS --erased-cubical --safe --no-sized-types --no-guardedness #-}
module Agda.Builtin.Cubical.Id where
open import Agda.Primitive.Cubical
open import Agda.Builtin.Cubical.Path
open import Agda.Builtin.Cubical.Sub renaming (primSubOut to ouc; Sub to _[_↦_])
{-# BUILTIN ID Id #-}
{-# BUILTIN REFLID reflId #-}
private
module ConId where
primitive
primConId : ∀ {ℓ} {A : Set ℓ} {x y : A} → I → x ≡ y → Id x y
open ConId public renaming (primConId to conid)
-- Id x y is treated as a pair of I and x ≡ y, using "i" for the
-- first component and "p" for the second.
{-# COMPILE JS conid =
_ => _ => _ => _ => i => p => { return { "i" : i, "p" : p } }
#-}
primitive
primDepIMin : _
primIdFace : ∀ {ℓ} {A : Set ℓ} {x y : A} → Id x y → I
primIdPath : ∀ {ℓ} {A : Set ℓ} {x y : A} → Id x y → x ≡ y
primitive
primIdJ : ∀ {ℓ ℓ'} {A : Set ℓ} {x : A} (P : ∀ y → Id x y → Set ℓ') →
P x (conid i1 (λ i → x)) → ∀ {y} (p : Id x y) → P y p
primitive
primIdElim : ∀ {a c} {A : Set a} {x : A}
(C : (y : A) → Id x y → Set c) →
((φ : I) (y : A [ φ ↦ (λ _ → x) ])
(w : (x ≡ ouc y) [ φ ↦ (λ { (φ = i1) → \ _ → x}) ]) →
C (ouc y) (conid φ (ouc w))) →
{y : A} (p : Id x y) → C y p
| 32.97619
| 82
| 0.462816
|
34352758cb73b4581ec6e5d13f2e43e40dc42f7e
| 65
|
agda
|
Agda
|
test/interaction/Issue1268.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/interaction/Issue1268.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/interaction/Issue1268.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
postulate
A : Set
F : { x : A } → Set
G : ⦃ x : A ⦄ → Set
| 10.833333
| 21
| 0.384615
|
1bd5c6fbe17d7c67815144391ada6ddebe100832
| 308
|
agda
|
Agda
|
notes/talks/Types07/Bad.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
notes/talks/Types07/Bad.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
notes/talks/Types07/Bad.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
module Bad where
data Bool : Set where
false : Bool
true : Bool
data Nat : Set where
zero : Nat
suc : Nat -> Nat
F : Bool -> Set
F false = Bool
F true = Nat
cast : {x : Bool} -> F x -> F x
cast a = a
not : Bool -> Bool
not true = false
not false = true
oops : Bool
oops = not (cast zero)
| 11.846154
| 31
| 0.587662
|
35fc7b6a4452d10c27aade1fed0583ccd6ee502d
| 3,588
|
agda
|
Agda
|
Cubical/Categories/Category/Properties.agda
|
hyleIndex/cubical
|
ce5c2820ecb2e0fd8dce74fb0247856cdbf034c4
|
[
"MIT"
] | 301
|
2018-10-17T18:00:24.000Z
|
2022-03-24T02:10:47.000Z
|
Cubical/Categories/Category/Properties.agda
|
hyleIndex/cubical
|
ce5c2820ecb2e0fd8dce74fb0247856cdbf034c4
|
[
"MIT"
] | 584
|
2018-10-15T09:49:02.000Z
|
2022-03-30T12:09:17.000Z
|
Cubical/Categories/Category/Properties.agda
|
hyleIndex/cubical
|
ce5c2820ecb2e0fd8dce74fb0247856cdbf034c4
|
[
"MIT"
] | 134
|
2018-11-16T06:11:03.000Z
|
2022-03-23T16:22:13.000Z
|
{-# OPTIONS --safe #-}
module Cubical.Categories.Category.Properties where
open import Cubical.Core.Glue
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Categories.Category.Base hiding (isSetHom)
open Precategory
private
variable
ℓ ℓ' : Level
module _ {C : Precategory ℓ ℓ'} ⦃ isC : isCategory C ⦄ where
open isCategory isC
-- isSet where your allowed to compare paths where one side is only
-- equal up to path. Is there a generalization of this?
isSetHomP1 : ∀ {x y : C .ob} {n : C [ x , y ]}
→ isOfHLevelDep 1 (λ m → m ≡ n)
isSetHomP1 {x = x} {y} {n} = isOfHLevel→isOfHLevelDep 1 (λ m → isSetHom m n)
-- isSet where the arrows can be between non-definitionally equal obs
isSetHomP2l : ∀ {y : C .ob}
→ isOfHLevelDep 2 (λ x → C [ x , y ])
isSetHomP2l = isOfHLevel→isOfHLevelDep 2 (λ a → isSetHom {x = a})
isSetHomP2r : ∀ {x : C .ob}
→ isOfHLevelDep 2 (λ y → C [ x , y ])
isSetHomP2r = isOfHLevel→isOfHLevelDep 2 (λ a → isSetHom {y = a})
-- opposite of opposite is definitionally equal to itself
involutiveOp : ∀ {C : Precategory ℓ ℓ'} → (C ^op) ^op ≡ C
involutiveOp = refl
module _ {C : Precategory ℓ ℓ'} where
-- Other useful operations on categories
-- whisker the parallel morphisms g and g' with f
lPrecatWhisker : {x y z : C .ob} (f : C [ x , y ]) (g g' : C [ y , z ]) (p : g ≡ g') → f ⋆⟨ C ⟩ g ≡ f ⋆⟨ C ⟩ g'
lPrecatWhisker f _ _ p = cong (_⋆_ C f) p
rPrecatWhisker : {x y z : C .ob} (f f' : C [ x , y ]) (g : C [ y , z ]) (p : f ≡ f') → f ⋆⟨ C ⟩ g ≡ f' ⋆⟨ C ⟩ g
rPrecatWhisker _ _ g p = cong (λ v → v ⋆⟨ C ⟩ g) p
-- working with equal objects
idP : ∀ {x x'} {p : x ≡ x'} → C [ x , x' ]
idP {x = x} {x'} {p} = subst (λ v → C [ x , v ]) p (C .id x)
-- heterogeneous seq
seqP : ∀ {x y y' z} {p : y ≡ y'}
→ (f : C [ x , y ]) (g : C [ y' , z ])
→ C [ x , z ]
seqP {x = x} {_} {_} {z} {p} f g = f ⋆⟨ C ⟩ (subst (λ a → C [ a , z ]) (sym p) g)
-- also heterogeneous seq, but substituting on the left
seqP' : ∀ {x y y' z} {p : y ≡ y'}
→ (f : C [ x , y ]) (g : C [ y' , z ])
→ C [ x , z ]
seqP' {x = x} {_} {_} {z} {p} f g = subst (λ a → C [ x , a ]) p f ⋆⟨ C ⟩ g
-- show that they're equal
seqP≡seqP' : ∀ {x y y' z} {p : y ≡ y'}
→ (f : C [ x , y ]) (g : C [ y' , z ])
→ seqP {p = p} f g ≡ seqP' {p = p} f g
seqP≡seqP' {x = x} {z = z} {p = p} f g i =
(toPathP {A = λ i' → C [ x , p i' ]} {f} refl i)
⋆⟨ C ⟩
(toPathP {A = λ i' → C [ p (~ i') , z ]} {x = g} (sym refl) (~ i))
-- seqP is equal to normal seq when y ≡ y'
seqP≡seq : ∀ {x y z}
→ (f : C [ x , y ]) (g : C [ y , z ])
→ seqP {p = refl} f g ≡ f ⋆⟨ C ⟩ g
seqP≡seq {y = y} {z} f g i = f ⋆⟨ C ⟩ toPathP {A = λ _ → C [ y , z ]} {x = g} refl (~ i)
-- whiskering with heterogenous seq -- (maybe should let z be heterogeneous too)
lPrecatWhiskerP : {x y z y' : C .ob} {p : y ≡ y'}
→ (f : C [ x , y ]) (g : C [ y , z ]) (g' : C [ y' , z ])
→ (r : PathP (λ i → C [ p i , z ]) g g')
→ f ⋆⟨ C ⟩ g ≡ seqP {p = p} f g'
lPrecatWhiskerP f g g' r = cong (λ v → f ⋆⟨ C ⟩ v) (sym (fromPathP (symP r)))
rPrecatWhiskerP : {x y' y z : C .ob} {p : y' ≡ y}
→ (f' : C [ x , y' ]) (f : C [ x , y ]) (g : C [ y , z ])
→ (r : PathP (λ i → C [ x , p i ]) f' f)
→ f ⋆⟨ C ⟩ g ≡ seqP' {p = p} f' g
rPrecatWhiskerP f' f g r = cong (λ v → v ⋆⟨ C ⟩ g) (sym (fromPathP r))
| 38.170213
| 113
| 0.479933
|
212fc7ba5ed41946e952dedb5d481c8ffcd09c81
| 1,709
|
agda
|
Agda
|
Cubical/Algebra/CommRing/Instances/MultivariatePoly.agda
|
guilhermehas/cubical
|
ce3120d3f8d692847b2744162bcd7a01f0b687eb
|
[
"MIT"
] | 1
|
2021-10-31T17:32:49.000Z
|
2021-10-31T17:32:49.000Z
|
Cubical/Algebra/CommRing/Instances/MultivariatePoly.agda
|
guilhermehas/cubical
|
ce3120d3f8d692847b2744162bcd7a01f0b687eb
|
[
"MIT"
] | null | null | null |
Cubical/Algebra/CommRing/Instances/MultivariatePoly.agda
|
guilhermehas/cubical
|
ce3120d3f8d692847b2744162bcd7a01f0b687eb
|
[
"MIT"
] | null | null | null |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.CommRing.Instances.MultivariatePoly where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat renaming(_+_ to _+n_; _·_ to _·n_)
open import Cubical.Algebra.Ring
open import Cubical.Algebra.CommRing
open import Cubical.Algebra.CommRing.Instances.Int
open import Cubical.Algebra.Polynomials.Multivariate.Base
open import Cubical.Algebra.Polynomials.Multivariate.Properties
private variable
ℓ : Level
-----------------------------------------------------------------------------
-- General Nth polynome
module _
(A : CommRing ℓ)
(n : ℕ)
where
open CommRingStr
open RingTheory (CommRing→Ring A)
open Nth-Poly-structure A n
PolyCommRing : CommRing ℓ
fst PolyCommRing = Poly A n
0r (snd PolyCommRing) = 0P
1r (snd PolyCommRing) = 1P
_+_ (snd PolyCommRing) = _poly+_
_·_ (snd PolyCommRing) = _poly*_
- snd PolyCommRing = polyInv
isCommRing (snd PolyCommRing) = makeIsCommRing
trunc
poly+Assoc
poly+IdR
poly+InvR
poly+Comm
poly*Assoc
poly*IdR
poly*DistR
poly*Comm
-----------------------------------------------------------------------------
-- Notation and syntax in the case 1,2,3 and ℤ
module _
(Ar@(A , Astr) : CommRing ℓ)
(n : ℕ)
where
A[X1,···,Xn] : CommRing ℓ
A[X1,···,Xn] = PolyCommRing Ar n
A[x1,···,xn] : Type ℓ
A[x1,···,xn] = fst (A[X1,···,Xn])
| 27.564516
| 77
| 0.523113
|
d1a25151390d3a00c19fa6f1864a3cb89837f60b
| 2,001
|
agda
|
Agda
|
bench/stlc_small.agda
|
int-index/smalltt
|
6a87f295148bd753d2519d50c2e1011b64c859ff
|
[
"MIT"
] | 377
|
2017-11-26T16:57:16.000Z
|
2022-03-19T21:31:01.000Z
|
bench/stlc_small.agda
|
int-index/smalltt
|
6a87f295148bd753d2519d50c2e1011b64c859ff
|
[
"MIT"
] | 3
|
2020-03-16T09:14:57.000Z
|
2022-02-28T21:51:10.000Z
|
bench/stlc_small.agda
|
int-index/smalltt
|
6a87f295148bd753d2519d50c2e1011b64c859ff
|
[
"MIT"
] | 19
|
2018-12-05T21:11:34.000Z
|
2022-03-03T19:46:54.000Z
|
{-# OPTIONS --type-in-type #-}
Ty% : Set; Ty%
= (Ty : Set)
(ι : Ty)
(arr : Ty → Ty → Ty)
→ Ty
ι% : Ty%; ι% = λ _ ι% _ → ι%
arr% : Ty% → Ty% → Ty%; arr% = λ A B Ty% ι% arr% → arr% (A Ty% ι% arr%) (B Ty% ι% arr%)
Con% : Set;Con%
= (Con% : Set)
(nil : Con%)
(snoc : Con% → Ty% → Con%)
→ Con%
nil% : Con%;nil%
= λ Con% nil% snoc → nil%
snoc% : Con% → Ty% → Con%;snoc%
= λ Γ A Con% nil% snoc% → snoc% (Γ Con% nil% snoc%) A
Var% : Con% → Ty% → Set;Var%
= λ Γ A →
(Var% : Con% → Ty% → Set)
(vz : (Γ : _)(A : _) → Var% (snoc% Γ A) A)
(vs : (Γ : _)(B A : _) → Var% Γ A → Var% (snoc% Γ B) A)
→ Var% Γ A
vz% : ∀{Γ A} → Var% (snoc% Γ A) A;vz%
= λ Var% vz% vs → vz% _ _
vs% : ∀{Γ B A} → Var% Γ A → Var% (snoc% Γ B) A;vs%
= λ x Var% vz% vs% → vs% _ _ _ (x Var% vz% vs%)
Tm% : Con% → Ty% → Set;Tm%
= λ Γ A →
(Tm% : Con% → Ty% → Set)
(var : (Γ : _) (A : _) → Var% Γ A → Tm% Γ A)
(lam : (Γ : _) (A B : _) → Tm% (snoc% Γ A) B → Tm% Γ (arr% A B))
(app : (Γ : _) (A B : _) → Tm% Γ (arr% A B) → Tm% Γ A → Tm% Γ B)
→ Tm% Γ A
var% : ∀{Γ A} → Var% Γ A → Tm% Γ A;var%
= λ x Tm% var% lam app → var% _ _ x
lam% : ∀{Γ A B} → Tm% (snoc% Γ A) B → Tm% Γ (arr% A B);lam%
= λ t Tm% var% lam% app → lam% _ _ _ (t Tm% var% lam% app)
app% : ∀{Γ A B} → Tm% Γ (arr% A B) → Tm% Γ A → Tm% Γ B;app%
= λ t u Tm% var% lam% app% →
app% _ _ _ (t Tm% var% lam% app%) (u Tm% var% lam% app%)
v0% : ∀{Γ A} → Tm% (snoc% Γ A) A;v0%
= var% vz%
v1% : ∀{Γ A B} → Tm% (snoc% (snoc% Γ A) B) A;v1%
= var% (vs% vz%)
v2% : ∀{Γ A B C} → Tm% (snoc% (snoc% (snoc% Γ A) B) C) A;v2%
= var% (vs% (vs% vz%))
v3% : ∀{Γ A B C D} → Tm% (snoc% (snoc% (snoc% (snoc% Γ A) B) C) D) A;v3%
= var% (vs% (vs% (vs% vz%)))
v4% : ∀{Γ A B C D E} → Tm% (snoc% (snoc% (snoc% (snoc% (snoc% Γ A) B) C) D) E) A;v4%
= var% (vs% (vs% (vs% (vs% vz%))))
test% : ∀{Γ A} → Tm% Γ (arr% (arr% A A) (arr% A A));test%
= lam% (lam% (app% v1% (app% v1% (app% v1% (app% v1% (app% v1% (app% v1% v0%)))))))
| 27.791667
| 87
| 0.418291
|
11d754ee4f534be835c5952396cf5cb7f52862af
| 2,863
|
agda
|
Agda
|
Cubical/Categories/Abelian/Base.agda
|
guilhermehas/cubical
|
ce3120d3f8d692847b2744162bcd7a01f0b687eb
|
[
"MIT"
] | 1
|
2021-10-31T17:32:49.000Z
|
2021-10-31T17:32:49.000Z
|
Cubical/Categories/Abelian/Base.agda
|
guilhermehas/cubical
|
ce3120d3f8d692847b2744162bcd7a01f0b687eb
|
[
"MIT"
] | null | null | null |
Cubical/Categories/Abelian/Base.agda
|
guilhermehas/cubical
|
ce3120d3f8d692847b2744162bcd7a01f0b687eb
|
[
"MIT"
] | null | null | null |
-- (Pre)abelian categories
{-# OPTIONS --safe #-}
module Cubical.Categories.Abelian.Base where
open import Cubical.Categories.Additive.Base
open import Cubical.Categories.Category.Base
open import Cubical.Categories.Morphism
open import Cubical.Data.Sigma.Base
open import Cubical.Foundations.Prelude
private
variable
ℓ ℓ' : Level
-- (Co)kernels
module _ (C : PreaddCategory ℓ ℓ') where
open PreaddCategory C
module _ {x y : ob} (f : Hom[ x , y ]) where
-- Kernels
record IsKernel {k : ob} (ker : Hom[ k , x ]) : Type (ℓ-max ℓ ℓ') where
field
ker⋆f : ker ⋆ f ≡ 0h
univ : ∀ (w : ob) (t : Hom[ w , x ])
→ (t ⋆ f ≡ 0h) → ∃![ u ∈ Hom[ w , k ] ] (u ⋆ ker ≡ t)
record Kernel : Type (ℓ-max ℓ ℓ') where
constructor kernel
field
k : ob
ker : Hom[ k , x ]
isKer : IsKernel ker
open IsKernel isKer public
-- Cokernels
record IsCokernel {c : ob} (coker : Hom[ y , c ]) : Type (ℓ-max ℓ ℓ') where
field
f⋆coker : f ⋆ coker ≡ 0h
univ : ∀ (w : ob) (t : Hom[ y , w ])
→ (f ⋆ t ≡ 0h) → ∃![ u ∈ Hom[ c , w ] ] (coker ⋆ u ≡ t)
record Cokernel : Type (ℓ-max ℓ ℓ') where
field
c : ob
coker : Hom[ y , c ]
isCoker : IsCokernel coker
open IsCokernel isCoker public
-- Preabelian categories
record PreAbCategoryStr (C : AdditiveCategory ℓ ℓ') : Type (ℓ-max ℓ ℓ') where
open AdditiveCategory C
field
hasKernels : {x y : ob} → (f : Hom[ x , y ]) → Kernel preaddcat f
hasCokernels : {x y : ob} → (f : Hom[ x , y ]) → Cokernel preaddcat f
-- Convenient ker/coker functions
ker = λ {x y} (f : Hom[ x , y ]) → hasKernels f .Kernel.ker
coker = λ {x y} (f : Hom[ x , y ]) → hasCokernels f .Cokernel.coker
record PreAbCategory (ℓ ℓ' : Level) : Type (ℓ-suc (ℓ-max ℓ ℓ')) where
field
additive : AdditiveCategory ℓ ℓ'
preAbStr : PreAbCategoryStr additive
open AdditiveCategory additive public
open PreAbCategoryStr preAbStr public
-- Abelian categories
record AbelianCategoryStr (C : PreAbCategory ℓ ℓ') : Type (ℓ-max ℓ ℓ') where
open PreAbCategory C
private
_=ker_ : ∀ {k x y} → Hom[ k , x ] → Hom[ x , y ] → Type (ℓ-max ℓ ℓ')
m =ker f = IsKernel preaddcat f m
_=coker_ : ∀ {c x y} → Hom[ y , c ] → Hom[ x , y ] → Type (ℓ-max ℓ ℓ')
e =coker f = IsCokernel preaddcat f e
field
monNormal : {x y : ob} → (m : Hom[ x , y ]) → isMonic cat m
→ Σ[ z ∈ ob ] Σ[ f ∈ Hom[ y , z ] ] (m =ker f)
epiNormal : {x y : ob} → (e : Hom[ x , y ]) → isEpic cat e
→ Σ[ w ∈ ob ] Σ[ f ∈ Hom[ w , x ] ] (e =coker f)
record AbelianCategory (ℓ ℓ' : Level): Type (ℓ-suc (ℓ-max ℓ ℓ')) where
field
preAb : PreAbCategory ℓ ℓ'
abelianStr : AbelianCategoryStr preAb
open PreAbCategory preAb public
open AbelianCategoryStr abelianStr public
| 27.796117
| 79
| 0.581558
|
2e70023b4d2c004729020925b67c27a5a650f0be
| 834
|
agda
|
Agda
|
test/Succeed/FlexRemoval.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Succeed/FlexRemoval.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Succeed/FlexRemoval.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
{-
In order to solve the metavariables in this example
we need to solve a constraint of the form
_1 := unit₂ (_2 y)
With the flex removal feature the occurs check will
spot the bad variable 'y' in the instantiation and
remove it by instantiating
_2 := λ y → _3
for a fresh metavariable _3. The instantiation of _1
can then proceed.
-}
module FlexRemoval where
record Unit : Set where
data Unit₂ : Set where
unit₂ : Unit → Unit₂
mutual
data D : Set where
c₁ : D
c₂ : (x : Unit₂) → (Unit → D₂ x) → D
D₂ : Unit₂ → Set
D₂ (unit₂ x) = D
foo : D
foo = c₂ _ (λ y → c₁)
{- 2011-04-05 Andreas
This test case and the explanation is no longer up to date.
What happens is
_2 y : Unit
is solved by eta-expansion
_2 = λ y -> record {}
and then
_1 = unit₂ (record {})
is in solved form.
-}
| 15.163636
| 59
| 0.653477
|
37eefff48ba9ecdb585729f87c807d4401703eec
| 2,880
|
agda
|
Agda
|
LibraBFT/Impl/Consensus/ChainedBFT/EventProcessor.agda
|
lisandrasilva/bft-consensus-agda-1
|
b7dd98dd90d98fbb934ef8cb4f3314940986790d
|
[
"UPL-1.0"
] | null | null | null |
LibraBFT/Impl/Consensus/ChainedBFT/EventProcessor.agda
|
lisandrasilva/bft-consensus-agda-1
|
b7dd98dd90d98fbb934ef8cb4f3314940986790d
|
[
"UPL-1.0"
] | null | null | null |
LibraBFT/Impl/Consensus/ChainedBFT/EventProcessor.agda
|
lisandrasilva/bft-consensus-agda-1
|
b7dd98dd90d98fbb934ef8cb4f3314940986790d
|
[
"UPL-1.0"
] | null | null | null |
{- 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.Base.ByteString
open import LibraBFT.Base.PKCS
open import LibraBFT.Impl.Consensus.Types
open import LibraBFT.Impl.Util.Crypto
open import LibraBFT.Impl.Util.Util
open import LibraBFT.Hash
open import Optics.All
open RWST-do
-- This is a minimal/fake example handler that obeys the VotesOnce rule, enabling us to start
-- exploring how we express the algorithm and prove properties about it. It simply sends a vote for
-- 1 + its LatestVotedRound, and increments its LatestVotedRound. It is called EventProcessor for
-- historical reasons, because this what a previous version of LibraBFT called its main handler;
-- this will be updated when we move towards modeling a more recent implementation.
module LibraBFT.Impl.Consensus.ChainedBFT.EventProcessor
(hash : BitString → Hash)
(hash-cr : ∀{x y} → hash x ≡ hash y → Collision hash x y ⊎ x ≡ y)
where
processCommitM : LedgerInfoWithSignatures → LBFT (List ExecutedBlock)
processCommitM finalityProof = pure []
fakeAuthor : Author
fakeAuthor = 0
fakeBlockInfo : EpochId → Round → ProposalMsg → BlockInfo
fakeBlockInfo eid rnd pm = mkBlockInfo eid rnd (pm ^∙ pmProposal ∙ bId)
fakeLedgerInfo : BlockInfo → ProposalMsg → LedgerInfo
fakeLedgerInfo bi pm = mkLedgerInfo bi (pm ^∙ pmProposal ∙ bId)
postulate
fakeSK : SK
fakeSig : Signature
processProposalMsg : Instant → ProposalMsg → LBFT Unit
processProposalMsg inst pm = do
st ← get
let 𝓔 = α-EC ((₋epEC st) , (₋epEC-correct st))
ix = EpochConfig.epochId 𝓔
ep = ₋epEC st
epw = ₋epWithEC st
epc = ₋epEC-correct st
bt = epw ^∙ (lBlockTree 𝓔)
nr = suc ((₋epEC st) ^∙ epLastVotedRound)
uv = mkVote (mkVoteData (fakeBlockInfo ix nr pm) (fakeBlockInfo ix 0 pm))
fakeAuthor
(fakeLedgerInfo (fakeBlockInfo ix nr pm) pm)
fakeSig
(₋bSignature (₋pmProposal pm))
sv = record uv { ₋vSignature = sign ⦃ sig-Vote ⦄ uv fakeSK}
si = mkSyncInfo (₋btHighestQuorumCert bt) (₋btHighestCommitCert bt)
ep' = ep [ epLastVotedRound := nr ]
epc2 = EventProcessorEC-correct-≡ (₋epEC st) ep' refl epc
st' = record st { ₋epEC = ep'
; ₋epEC-correct = epc2
; ₋epWithEC = subst EventProcessorWithEC (α-EC-≡ ep ep' refl refl epc) epw
}
put st'
tell1 (SendVote (mkVoteMsg sv si) (fakeAuthor ∷ []))
pure unit
processVote : Instant → VoteMsg → LBFT Unit
processVote now msg = pure unit
| 39.452055
| 111
| 0.667014
|
5e6f310438245bc5887aac29443b899b6c0f040e
| 5,474
|
agda
|
Agda
|
setoid-cats/Category/Diagram.agda
|
heades/AUGL
|
b33c6a59d664aed46cac8ef77d34313e148fecc2
|
[
"MIT"
] | null | null | null |
setoid-cats/Category/Diagram.agda
|
heades/AUGL
|
b33c6a59d664aed46cac8ef77d34313e148fecc2
|
[
"MIT"
] | null | null | null |
setoid-cats/Category/Diagram.agda
|
heades/AUGL
|
b33c6a59d664aed46cac8ef77d34313e148fecc2
|
[
"MIT"
] | null | null | null |
module Category.Diagram where
open import Level renaming (suc to lsuc)
open import Equality.Eq
open import Setoid.Total
open import Category.Category
open import Category.Funct
open import Category.Preorder
-- Diagrams are functors from an index category J to a category ℂ. We
-- think of J as the scheme of the diagram in ℂ.
record Diagram {l₁ l₂ : Level} (J : Cat {l₁}) (ℂ : Cat {l₂}) : Set (l₁ ⊔ l₂) where
field
diag : Functor J ℂ
-- A commutative diagram is a diagram from a preorder to a category ℂ.
-- The preorder axiom garauntees that any diagram must commute because
-- there is only one composition. Mixing this with the fact that
-- functors preserve composition implies that there can only be one
-- composition in ℂ. This definition goes against the references --
-- nLab and Awedoy's book -- that comm. diagrams must be functors from
-- posets. In fact we can prove that a PO is enough. See the next
-- module.
record Comm-Diagram {l₁ l₂ : Level} (J : PO {l₁}) (ℂ : Cat {l₂}) : Set (l₁ ⊔ l₂) where
field
diag : Diagram (po-cat J) ℂ
open Comm-Diagram
-- The underlying functor of a diagram.
UFunc : {l l' : Level}{J : PO {l}}{ℂ : Cat {l'}} → Comm-Diagram J ℂ → Functor (po-cat J) ℂ
UFunc D = Diagram.diag (diag D)
-- This module shows that comm. squares can be modeled by POs.
module Commutative-Squares where
open 4PO
record Comm-Square'
{l : Level}
(ℂ : Cat {l})
(om : 4Obj → Obj ℂ)
(g : el (Hom ℂ (om i₁) (om i₂)))
(h : el (Hom ℂ (om i₂) (om i₄)))
(j : el (Hom ℂ (om i₁) (om i₃)))
(k : el (Hom ℂ (om i₃) (om i₄))) : Set l where
field
Sq : {a b : 4Obj {l}} → SetoidFun (4Hom a b) (Hom ℂ (om a) (om b))
sq-max₁ : ⟨ Hom ℂ (om i₁) (om i₂) ⟩[ appT Sq f₁ ≡ g ]
sq-max₂ : ⟨ Hom ℂ (om i₁) (om i₃) ⟩[ appT Sq f₂ ≡ j ]
sq-max₃ : ⟨ Hom ℂ (om i₂) (om i₄) ⟩[ appT Sq f₃ ≡ h ]
sq-max₄ : ⟨ Hom ℂ (om i₃) (om i₄) ⟩[ appT Sq f₄ ≡ k ]
sq-funct-id : {i : 4Obj} → ⟨ Hom ℂ (om i) (om i) ⟩[ appT Sq (4Id {_}{i}) ≡ id ℂ ]
sq-funct-comp : ∀{i j k : 4Obj {l}}{a : el (4Hom i j)}{b : el (4Hom j k)}
→ ⟨ Hom ℂ (om i) (om k) ⟩[ appT Sq (a ○[ 4Comp {l}{i}{j}{k} ] b) ≡ (appT Sq a) ○[ comp ℂ ] (appT Sq b) ]
open Comm-Square'
-- A default function from the objects of the 4PO to the objects of
-- a square in ℂ.
sq-default-om : {l : Level}{ℂ : Cat {l}}
→ Obj ℂ
→ Obj ℂ
→ Obj ℂ
→ Obj ℂ
→ (4Obj {l} → Obj ℂ)
sq-default-om A B D C i₁ = A
sq-default-om A B D C i₂ = B
sq-default-om A B D C i₃ = D
sq-default-om A B D C i₄ = C
-- Commutative squares in ℂ.
Comm-Square : {l : Level}{ℂ : Cat {l}}
→ (A B D C : Obj ℂ)
→ (g : el (Hom ℂ A B))
→ (h : el (Hom ℂ B C))
→ (j : el (Hom ℂ A D))
→ (k : el (Hom ℂ D C))
→ Set l
Comm-Square {_} {ℂ} A B D C g h j k = Comm-Square' ℂ (sq-default-om {_} {ℂ} A B D C) g h j k
-- Commutative squares are functors.
Comm-Square-is-Functor : ∀{l}{ℂ : Cat {l}}{A B D C}
→ {g : el (Hom ℂ A B)}
→ {h : el (Hom ℂ B C)}
→ {j : el (Hom ℂ A D)}
→ {k : el (Hom ℂ D C)}
→ Comm-Square {_} {ℂ} A B D C g h j k
→ Functor {l} 4cat ℂ
Comm-Square-is-Functor {_} {ℂ} {A} {B} {D} {C} {g} {h} {j} {k} sq =
record { omap = sq-default-om {_}{ℂ} A B D C;
fmap = λ {A₁} {B₁} → Sq sq {A₁} {B₁};
idPF = sq-funct-id sq;
compPF = λ {A₁} {B₁} {C₁} {f} {g₁} → sq-funct-comp sq {A₁}{B₁}{C₁}{f}{g₁} }
-- The former now implies that we have a commutative diagram.
Comm-Square-is-Comm-Diagram : ∀{l}{ℂ : Cat {l}}{A B D C}
→ {g : el (Hom ℂ A B)}
→ {h : el (Hom ℂ B C)}
→ {j : el (Hom ℂ A D)}
→ {k : el (Hom ℂ D C)}
→ Comm-Square {_} {ℂ} A B D C g h j k
→ Comm-Diagram {l}{l} 4po ℂ
Comm-Square-is-Comm-Diagram {l}{ℂ}{g}{h}{j}{k} sq =
record { diag = record { diag = Comm-Square-is-Functor sq } }
-- If we have a commutative square, then it commutes in ℂ.
Comm-Square-Commutes : ∀{l}{ℂ : Cat {l}}{A B D C}
→ {g : el (Hom ℂ A B)}
→ {h : el (Hom ℂ B C)}
→ {j : el (Hom ℂ A D)}
→ {k : el (Hom ℂ D C)}
→ Comm-Square {_} {ℂ} A B D C g h j k
→ ⟨ Hom ℂ A C ⟩[ g ○[ comp ℂ ] h ≡ j ○[ comp ℂ ] k ]
Comm-Square-Commutes {l}{ℂ}{A}{B}{D}{C}{g}{h}{j}{k} sq with sq-funct-comp sq {i₁}{i₂}{i₄}{f₁}{f₃} | sq-funct-comp sq {i₁}{i₃}{i₄}{f₂}{f₄}
... | sq-eq₁ | sq-eq₂ with transPf (parEqPf (eqRpf (Hom ℂ A C))) (symPf (parEqPf (eqRpf (Hom ℂ A C))) sq-eq₁) sq-eq₂
... | sq-eq₃ with eq-comp-all {_}{ℂ}{A}{B}{C}{g}
{appT {_}{_}{4Hom i₁ i₂} {Hom ℂ A B} (Sq sq {i₁}{i₂}) f₁}
{h}
{appT (Sq sq {i₂}{i₄}) f₃}
(symPf (parEqPf (eqRpf (Hom ℂ A B))) (sq-max₁ sq))
(symPf (parEqPf (eqRpf (Hom ℂ B C))) (sq-max₃ sq))
... | sq-eq₄ with eq-comp-all {_}{ℂ}{A}{D}{C}
{appT {_}{_}{4Hom i₁ i₃} {Hom ℂ A D} (Sq sq {i₁}{i₃}) f₂}
{j}
{appT (Sq sq {i₃}{i₄}) f₄}
{k}
(sq-max₂ sq)
(sq-max₄ sq)
... | sq-eq₅ with transPf (parEqPf (eqRpf (Hom ℂ A C))) sq-eq₄ sq-eq₃
... | sq-eq₆ = transPf (parEqPf (eqRpf (Hom ℂ A C))) sq-eq₆ sq-eq₅
| 40.548148
| 139
| 0.504202
|
4e326e7794ecc5a14305ba5e2d8645644608004f
| 483
|
agda
|
Agda
|
test/interaction/SplitResult.agda
|
pthariensflame/agda
|
222c4c64b2ccf8e0fc2498492731c15e8fef32d4
|
[
"BSD-3-Clause"
] | 3
|
2015-03-28T14:51:03.000Z
|
2015-12-07T20:14:00.000Z
|
test/interaction/SplitResult.agda
|
Blaisorblade/Agda
|
802a28aa8374f15fe9d011ceb80317fdb1ec0949
|
[
"BSD-3-Clause"
] | null | null | null |
test/interaction/SplitResult.agda
|
Blaisorblade/Agda
|
802a28aa8374f15fe9d011ceb80317fdb1ec0949
|
[
"BSD-3-Clause"
] | 1
|
2019-03-05T20:02:38.000Z
|
2019-03-05T20:02:38.000Z
|
{-# OPTIONS --copatterns #-}
module SplitResult where
open import Common.Product
test : {A B : Set} (a : A) (b : B) → A × B
test a b = {!!}
-- expected:
-- proj₁ (test a b) = {!!}
-- proj₂ (test a b) = {!!}
testFun : {A B : Set} (a : A) (b : B) → A × B
testFun = {!!}
-- expected:
-- testFun a b = {!!}
record FunRec A : Set where
field funField : A → A
open FunRec
testFunRec : ∀{A} → FunRec A
testFunRec = {!!}
-- expected (since 2016-05-03):
-- funField testFunRec = {!!}
| 18.576923
| 45
| 0.554865
|
37e146bd5d034d98724688884a262d9ccb95400a
| 2,899
|
agda
|
Agda
|
theorems/cw/cohomology/grid/CofiberSplit.agda
|
AntoineAllioux/HoTT-Agda
|
1037d82edcf29b620677a311dcfd4fc2ade2faa6
|
[
"MIT"
] | 294
|
2015-01-09T16:23:23.000Z
|
2022-03-20T13:54:45.000Z
|
theorems/cw/cohomology/grid/CofiberSplit.agda
|
AntoineAllioux/HoTT-Agda
|
1037d82edcf29b620677a311dcfd4fc2ade2faa6
|
[
"MIT"
] | 31
|
2015-03-05T20:09:00.000Z
|
2021-10-03T19:15:25.000Z
|
theorems/cw/cohomology/grid/CofiberSplit.agda
|
AntoineAllioux/HoTT-Agda
|
1037d82edcf29b620677a311dcfd4fc2ade2faa6
|
[
"MIT"
] | 50
|
2015-01-10T01:48:08.000Z
|
2022-02-14T03:03:25.000Z
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.PushoutSplit
module cw.cohomology.grid.CofiberSplit {i j k}
{A : Type i} {B : Type j} {C : Type k}
(f : A → B) (g : B → C) where
{-
A -------> B -----------> C
| | _/|
| | _/ |
| | __.D_ |
v v .--' | `-.v
1 ------> B/A ------|-> C/A
| | |
| v |
| __.E_ |
v .--' `-.v
1 ---------> C/B
-}
open import cw.cohomology.grid.Map f g
private
B-to-B/A : B → B/A
B-to-B/A = cfcod' f
D-span : Span
D-span = span B/A C B B-to-B/A g
D : Type (lmax i (lmax j k))
D = Pushout D-span
private
module VSplit = PushoutRSplit (λ _ → tt) f g
module C/AToD = VSplit.Split
C/A-to-D : C/A → D
C/A-to-D = C/AToD.f
B/A-to-D : B/A → D
B/A-to-D = left
private
E : Type (lmax i (lmax j k))
E = Cofiber B/A-to-D
private
module HSplit = PushoutLSplit B-to-B/A (λ _ → tt) g
module C/BToE = HSplit.Split
C/B-to-E : C/B → E
C/B-to-E = C/BToE.f
C/B-to-E-glue-β : ∀ x →
ap C/B-to-E (glue x) == glue (cfcod x) ∙' ap cfcod (glue x)
C/B-to-E-glue-β = HSplit.split-glue-β
private
module DToC/B = HSplit.Inner
D-to-C/B : D → C/B
D-to-C/B = DToC/B.f
D-to-E : D → E
D-to-E = cfcod
C/A-to-D-to-C/B : ∀ c/a → D-to-C/B (C/A-to-D c/a) == C/A-to-C/B c/a
C/A-to-D-to-C/B = Cofiber-elim
idp
(λ c → idp)
(λ a → ↓-='-in' $ ! $
ap (D-to-C/B ∘ C/A-to-D) (glue a)
=⟨ ap-∘ D-to-C/B C/A-to-D (glue a) ⟩
ap D-to-C/B (ap C/A-to-D (glue a))
=⟨ C/AToD.glue-β a |in-ctx ap D-to-C/B ⟩
ap D-to-C/B (ap left (glue a) ∙ glue (f a))
=⟨ ap-∙ D-to-C/B (ap left (glue a)) (glue (f a)) ⟩
ap D-to-C/B (ap left (glue a)) ∙ ap D-to-C/B (glue (f a))
=⟨ ap2 _∙_ (∘-ap D-to-C/B left (glue a)) (DToC/B.glue-β (f a)) ⟩
ap (λ _ → cfbase) (glue a) ∙ glue (f a)
=⟨ ap-cst cfbase (glue a) |in-ctx _∙ glue (f a) ⟩
glue (f a)
=⟨ ! $ C/AToC/B.glue-β a ⟩
ap C/A-to-C/B (glue a)
=∎)
D-to-C/B-to-E : ∀ d → C/B-to-E (D-to-C/B d) == D-to-E d
D-to-C/B-to-E = HSplit.split-inner
{- The public interface -}
C/A-to-C/B-comm-square : CommSquare C/A-to-C/B D-to-E C/A-to-D C/B-to-E
C/A-to-C/B-comm-square = comm-sqr λ c/a → ap C/B-to-E (! (C/A-to-D-to-C/B c/a))
∙ D-to-C/B-to-E (C/A-to-D c/a)
B/A-to-C/A-comm-square : CommSquare B/A-to-C/A B/A-to-D (idf B/A) C/A-to-D
B/A-to-C/A-comm-square = comm-sqr VSplit.split-inner
C/A-to-D-is-equiv : is-equiv C/A-to-D
C/A-to-D-is-equiv = snd VSplit.split-equiv
C/B-to-E-is-equiv : is-equiv C/B-to-E
C/B-to-E-is-equiv = snd HSplit.split-equiv
| 28.145631
| 81
| 0.456364
|
1342acb2bc746c8dabe3db5557d2091036019702
| 1,578
|
agda
|
Agda
|
test/Succeed/Issue709.agda
|
cagix/agda
|
cc026a6a97a3e517bb94bafa9d49233b067c7559
|
[
"BSD-2-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Succeed/Issue709.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Succeed/Issue709.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
{-# OPTIONS --sized-types #-}
-- {-# OPTIONS --termination-depth=2 #-} -- not necessary!
-- {-# OPTIONS -v tc.size.solve:60 --show-implicit #-}
-- {-# OPTIONS -v term:5 #-}
module Issue709 where
open import Common.Size
data Bool : Set where true false : Bool
postulate
A : Set
_<=_ : A → A → Bool
data List {i : Size} : Set where
[] : List
cons : (j : Size< i) → A → List {j} → List {i}
module If where
if_then_else_ : {A : Set} → Bool → A → A → A
if true then t else e = t
if false then t else e = e
merge : ∀ {i j} → List {i} → List {j} → List -- {∞}
merge {i} {j} [] ys = ys
merge {i} {j} (cons i' x xs) [] = cons _ x xs
merge {i} {j} (cons i' x xs) (cons j' y ys) =
if x <= y
then cons _ x (merge xs (cons _ y ys))
else cons _ y (merge (cons _ x xs) ys)
module Succeeds where
merge : ∀ {i j} → List {i} → List {j} → List
merge [] ys = ys
merge (cons i' x xs) [] = cons _ x xs
merge {i} {j} (cons i' x xs) (cons j' y ys) with x <= y
... | true = cons _ x (merge {i'} {j} -- removing this implicit application makes it not termination check
xs (cons _ y ys))
... | false = cons _ y (merge (cons _ x xs) ys)
module NeedsTerminationDepthTwo where
merge : ∀ {i j} → List {i} → List {j} → List
merge [] ys = ys
merge (cons j x xs) [] = cons _ x xs
merge {i} {i'} (cons j x xs) (cons j' y ys) with x <= y
... | true = cons _ x (merge xs (cons _ y ys))
... | false = cons _ y (merge (cons _ x xs) ys)
| 30.941176
| 109
| 0.515209
|
3f2981d86b40afa00b1d16bb33bcf579e385b5cd
| 51
|
agda
|
Agda
|
test/Fail/NothingAppliedToHiddenArg.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Fail/NothingAppliedToHiddenArg.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Fail/NothingAppliedToHiddenArg.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
module NothingAppliedToHiddenArg where
bad = {x}
| 10.2
| 38
| 0.784314
|
11c79cffdf90365db4d0705321aa536c8af340a2
| 720
|
agda
|
Agda
|
test/Succeed/Issue689-stevana.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Succeed/Issue689-stevana.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Succeed/Issue689-stevana.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
-- Andreas, 2017-10-04, issue #689, test case by stevana
-- {-# OPTIONS -v tc.data:50 #-}
-- {-# OPTIONS -v tc.force:100 #-}
-- {-# OPTIONS -v tc.constr:50 #-}
-- {-# OPTIONS -v tc.conv.sort:30 #-}
-- {-# OPTIONS -v tc.conv.nat:30 #-}
open import Agda.Primitive
data L {a} (A : Set a) : Set a where
_∷_ : A → L A → L A
data S {a} {A : Set a} : L A → Set₁ where
_∷_ : (x : A) → (xs : L A) → S (x ∷ xs) -- x and xs are forced!
-- Should succeed without unsolved constraints.
-- There was a problem in the forcing analysis which I introduced
-- with apparently improper use of `noConstraints` (still do not know why)
-- for the Big/Small Forced argument analysis.
-- The latter one is obsolete and thus removed.
| 31.304348
| 74
| 0.625
|
1d44b106d0f2739b811a96a69bf28428bd09629e
| 488
|
agda
|
Agda
|
Data/ListSized.agda
|
Lolirofle/stuff-in-agda
|
70f4fba849f2fd779c5aaa5af122ccb6a5b271ba
|
[
"MIT"
] | 6
|
2020-04-07T17:58:13.000Z
|
2022-02-05T06:53:22.000Z
|
Data/ListSized.agda
|
Lolirofle/stuff-in-agda
|
70f4fba849f2fd779c5aaa5af122ccb6a5b271ba
|
[
"MIT"
] | null | null | null |
Data/ListSized.agda
|
Lolirofle/stuff-in-agda
|
70f4fba849f2fd779c5aaa5af122ccb6a5b271ba
|
[
"MIT"
] | null | null | null |
import Lvl
open import Type
module Data.ListSized {ℓ} (T : Type{ℓ}) where
import Data.IndexedList
open import Functional
open import Numeral.Natural
open Data.IndexedList(T){ℕ} using (IndexedList ; intro)
-- A list is a container/collection with elements in order and which allows multiples
List : ℕ → Type{ℓ}
List(n) = IndexedList(intro 𝟎 (const 𝐒))(n)
open Data.IndexedList(T){ℕ} using (∅ ; _⊰_ ; singleton) public
elim = Data.IndexedList.elim(T){ℕ} (intro 𝟎 (const 𝐒))
| 25.684211
| 85
| 0.715164
|
14bf2a6d4bc808367dbc00f8a4c12feb06169750
| 4,762
|
agda
|
Agda
|
presentationsAndExampleCode/agdaImplementorsMeetingGlasgow22April2016AntonSetzer/objectOrientedGui.agda
|
agda/ooAgda
|
7cc45e0148a4a508d20ed67e791544c30fecd795
|
[
"MIT"
] | 23
|
2016-06-19T12:57:55.000Z
|
2020-10-12T23:15:25.000Z
|
presentationsAndExampleCode/agdaImplementorsMeetingGlasgow22April2016AntonSetzer/objectOrientedGui.agda
|
agda/ooAgda
|
7cc45e0148a4a508d20ed67e791544c30fecd795
|
[
"MIT"
] | null | null | null |
presentationsAndExampleCode/agdaImplementorsMeetingGlasgow22April2016AntonSetzer/objectOrientedGui.agda
|
agda/ooAgda
|
7cc45e0148a4a508d20ed67e791544c30fecd795
|
[
"MIT"
] | 2
|
2018-09-01T15:02:37.000Z
|
2022-03-12T11:41:00.000Z
|
module objectOrientedGui where
open import Data.Product hiding (map)
open import Data.List
open import Data.Bool.Base
open import SizedIO.Base
open import NativeIO
open import Relation.Binary.PropositionalEquality hiding ([_])
open import Size
open import Function
open import StateSizedIO.GUI.BaseStateDependent
open import StateSizedIO.GUI.WxBindingsFFI
data VarList : Set₁ where
[]v : VarList
addVar : (A : Set) → Var A → VarList → VarList
prod : VarList → Set
prod []v = Unit
prod (addVar A v []v) = A
prod (addVar A v l) = A × prod l
takeVar : (l : VarList) → NativeIO (prod l)
takeVar []v = nativeReturn _
takeVar (addVar A v []v) = nativeTakeVar {A} v
takeVar (addVar A v (addVar B v' l)) =
nativeTakeVar {A} v native>>= λ a →
takeVar (addVar B v' l) native>>= λ rest →
nativeReturn ( a , rest )
putVar : (l : VarList) → prod l → NativeIO Unit
putVar []v _ = nativeReturn _
putVar (addVar A v []v) a = nativePutVar {A} v a
putVar (addVar A v (addVar B v' l)) (a , rest) =
nativePutVar {A} v a native>>= λ _ →
putVar (addVar B v' l) rest
data GuiLev1Command : Set where
makeFrame : GuiLev1Command
makeButton : Frame → GuiLev1Command
addButton : Frame → Button → GuiLev1Command
drawBitmap : DC → Bitmap → Point → Bool → GuiLev1Command
repaint : Frame → GuiLev1Command
GuiLev1Response : GuiLev1Command → Set
GuiLev1Response makeFrame = Frame
GuiLev1Response (makeButton _) = Button
GuiLev1Response _ = Unit
GuiLev1Interface : IOInterface
Command GuiLev1Interface = GuiLev1Command
Response GuiLev1Interface = GuiLev1Response
GuiLev2State : Set₁
GuiLev2State = VarList
data GuiLev2Command (s : GuiLev2State) : Set₁ where
level1C : GuiLev1Command → GuiLev2Command s
createVar : {A : Set} → A → GuiLev2Command s
setButtonHandler : Button
→ List (prod s → IO GuiLev1Interface ∞ (prod s))
→ GuiLev2Command s
setOnPaint : Frame
→ List (prod s → DC → Rect → IO GuiLev1Interface ∞ (prod s))
→ GuiLev2Command s
GuiLev2Response : (s : GuiLev2State) → GuiLev2Command s → Set
GuiLev2Response _ (level1C c) = GuiLev1Response c
GuiLev2Response _ (createVar {A} a) = Var A
GuiLev2Response _ _ = Unit
GuiLev2Next : (s : GuiLev2State) → (c : GuiLev2Command s)
→ GuiLev2Response s c
→ GuiLev2State
GuiLev2Next s (createVar {A} a) var = addVar A var s
GuiLev2Next s _ _ = s
GuiLev2Interface : IOInterfaceˢ
Stateˢ GuiLev2Interface = GuiLev2State
Commandˢ GuiLev2Interface = GuiLev2Command
Responseˢ GuiLev2Interface = GuiLev2Response
nextˢ GuiLev2Interface = GuiLev2Next
translateLev1Local : (c : GuiLev1Command) → NativeIO (GuiLev1Response c)
translateLev1Local makeFrame = nativeMakeFrame
translateLev1Local (makeButton fra) = nativeMakeButton fra
translateLev1Local (addButton fra bt) = nativeAddButton fra bt
translateLev1Local (drawBitmap dc bm p b) = nativeDrawBitmap dc bm p b
translateLev1Local (repaint fra) = nativeRepaint fra
translateLev1 : {A : Set} → IO GuiLev1Interface ∞ A → NativeIO A
translateLev1 = translateIO translateLev1Local
translateLev1List : {A : Set} → List (IO GuiLev1Interface ∞ A) → List (NativeIO A)
translateLev1List l = map translateLev1 l
dispatch : (l : VarList) → (prod l → NativeIO (prod l)) → NativeIO Unit
dispatch l f = takeVar l native>>= λ a →
f a native>>= λ a₁ →
putVar l a₁
dispatchList : (l : VarList) → List (prod l → NativeIO (prod l)) → NativeIO Unit
dispatchList l [] = nativeReturn _
dispatchList l (p ∷ rest) = dispatch l p native>>= λ _ →
dispatchList l rest
translateLev2Local : (s : GuiLev2State)
→ (c : GuiLev2Command s)
→ NativeIO (GuiLev2Response s c)
translateLev2Local s (level1C c) = translateLev1Local c
translateLev2Local s (createVar {A} a) = nativeNewVar {A} a
translateLev2Local s (setButtonHandler bt proglist) =
nativeSetButtonHandler bt
(dispatchList s (map (λ prog → translateLev1 ∘ prog) proglist))
translateLev2Local s (setOnPaint fra proglist) =
nativeSetOnPaint fra (λ dc rect → dispatchList s
(map (λ prog aa → translateLev1 (prog aa dc rect)) proglist))
translateLev2 : ∀ {A s} → IOˢ GuiLev2Interface ∞ (λ _ → A) s → NativeIO A
translateLev2 = translateIOˢ translateLev2Local
| 38.403226
| 83
| 0.637337
|
36fc217ea3478f5385158d4331c86af8249080ff
| 364
|
agda
|
Agda
|
src/Categories/Category/Instance/SimplicialSet.agda
|
jaykru/agda-categories
|
a4053cf700bcefdf73b857c3352f1eae29382a60
|
[
"MIT"
] | 279
|
2019-06-01T14:36:40.000Z
|
2022-03-22T00:40:14.000Z
|
src/Categories/Category/Instance/SimplicialSet.agda
|
seanpm2001/agda-categories
|
d9e4f578b126313058d105c61707d8c8ae987fa8
|
[
"MIT"
] | 236
|
2019-06-01T14:53:54.000Z
|
2022-03-28T14:31:43.000Z
|
src/Categories/Category/Instance/SimplicialSet.agda
|
seanpm2001/agda-categories
|
d9e4f578b126313058d105c61707d8c8ae987fa8
|
[
"MIT"
] | 64
|
2019-06-02T16:58:15.000Z
|
2022-03-14T02:00:59.000Z
|
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Instance.SimplicialSet where
open import Level
open import Categories.Category
open import Categories.Category.Instance.Simplex
open import Categories.Category.Construction.Presheaves
SimplicialSet : ∀ o ℓ → Category (suc (o ⊔ ℓ)) (o ⊔ ℓ) (o ⊔ ℓ)
SimplicialSet o ℓ = Presheaves {o′ = o} {ℓ′ = ℓ} Δ
| 28
| 62
| 0.733516
|
0d8fcefa0216b9d30dd0fcf60b1444da3d74f82c
| 4,472
|
agda
|
Agda
|
Rings/Ideals/Prime/Lemmas.agda
|
Smaug123/agdaproofs
|
0f4230011039092f58f673abcad8fb0652e6b562
|
[
"MIT"
] | 4
|
2019-08-08T12:44:19.000Z
|
2022-01-28T06:04:15.000Z
|
Rings/Ideals/Prime/Lemmas.agda
|
Smaug123/agdaproofs
|
0f4230011039092f58f673abcad8fb0652e6b562
|
[
"MIT"
] | 14
|
2019-01-06T21:11:59.000Z
|
2020-04-11T11:03:39.000Z
|
Rings/Ideals/Prime/Lemmas.agda
|
Smaug123/agdaproofs
|
0f4230011039092f58f673abcad8fb0652e6b562
|
[
"MIT"
] | 1
|
2021-11-29T13:23:07.000Z
|
2021-11-29T13:23:07.000Z
|
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Groups.Definition
open import Setoids.Setoids
open import Rings.Definition
open import Sets.EquivalenceRelations
open import Rings.Ideals.Definition
open import Rings.IntegralDomains.Definition
open import Rings.Ideals.Prime.Definition
open import Rings.Cosets
module Rings.Ideals.Prime.Lemmas {a b : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ _*_ : A → A → A} {R : Ring S _+_ _*_} {c : _} {pred : A → Set c} (i : Ideal R pred) where
open Ring R
open Group additiveGroup
open Setoid S
open Equivalence eq
open import Rings.Ideals.Lemmas R
idealPrimeImpliesQuotientIntDom : PrimeIdeal i → IntegralDomain (cosetRing R i)
IntegralDomain.intDom (idealPrimeImpliesQuotientIntDom isPrime) {a} {b} ab=0 a!=0 = ans
where
ab=0' : pred (a * b)
ab=0' = translate' i ab=0
a!=0' : (pred a) → False
a!=0' prA = a!=0 (translate i prA)
ans' : pred b
ans' = PrimeIdeal.isPrime isPrime ab=0' a!=0'
ans : pred (inverse (Ring.0R (cosetRing R i)) + b)
ans = translate i ans'
IntegralDomain.nontrivial (idealPrimeImpliesQuotientIntDom isPrime) 1=0 = PrimeIdeal.notContainedIsNotContained isPrime u
where
t : pred (Ring.1R (cosetRing R i))
t = translate' i 1=0
u : pred (PrimeIdeal.notContained isPrime)
u = Ideal.isSubset i identIsIdent (Ideal.accumulatesTimes i {y = PrimeIdeal.notContained isPrime} t)
quotientIntDomImpliesIdealPrime : IntegralDomain (cosetRing R i) → PrimeIdeal i
quotientIntDomImpliesIdealPrime intDom = record { isPrime = isPrime ; notContained = Ring.1R R ; notContainedIsNotContained = notCon }
where
abstract
notCon : pred 1R → False
notCon 1=0 = IntegralDomain.nontrivial intDom (translate i 1=0)
isPrime : {a b : A} → pred (a * b) → (pred a → False) → pred b
isPrime {a} {b} predAB !predA = translate' i (IntegralDomain.intDom intDom (translate i predAB) λ t → !predA (translate' i t))
private
dividesZero : {a : A} → generatedIdealPred R 0R a → a ∼ 0R
dividesZero (c , pr) = symmetric (transitive (symmetric (transitive *Commutative timesZero)) pr)
zeroIdealPrimeImpliesIntDom : PrimeIdeal (generatedIdeal R 0R) → IntegralDomain R
IntegralDomain.intDom (zeroIdealPrimeImpliesIntDom record { isPrime = isPrime ; notContained = notContained ; notContainedIsNotContained = notContainedIsNotContained }) {a} {b} ab=0 a!=0 with isPrime {a} {b} (1R , transitive (transitive *Commutative timesZero) (symmetric ab=0)) (λ 0|a → a!=0 (dividesZero 0|a))
... | c , 0c=b = transitive (symmetric 0c=b) (transitive *Commutative timesZero)
IntegralDomain.nontrivial (zeroIdealPrimeImpliesIntDom record { isPrime = isPrime ; notContained = notContained ; notContainedIsNotContained = notContainedIsNotContained }) 1=0 = notContainedIsNotContained (notContained , transitive (*WellDefined (symmetric 1=0) reflexive) identIsIdent)
intDomImpliesZeroIdealPrime : IntegralDomain R → PrimeIdeal (generatedIdeal R 0R)
PrimeIdeal.isPrime (intDomImpliesZeroIdealPrime intDom) (c , 0=ab) 0not|a with IntegralDomain.intDom intDom (transitive (symmetric 0=ab) (transitive *Commutative timesZero)) (λ a=0 → 0not|a (0R , transitive timesZero (symmetric a=0)))
... | b=0 = 0R , transitive timesZero (symmetric b=0)
PrimeIdeal.notContained (intDomImpliesZeroIdealPrime intDom) = 1R
PrimeIdeal.notContainedIsNotContained (intDomImpliesZeroIdealPrime intDom) (c , 0c=1) = IntegralDomain.nontrivial intDom (symmetric (transitive (symmetric (transitive *Commutative timesZero)) 0c=1))
primeIdealWellDefined : {c : _} {pred2 : A → Set c} (ideal2 : Ideal R pred2) → ({x : A} → pred x → pred2 x) → ({x : A} → pred2 x → pred x) → PrimeIdeal i → PrimeIdeal ideal2
PrimeIdeal.isPrime (primeIdealWellDefined ideal2 predToPred2 pred2ToPred record { isPrime = isPrime ; notContained = notContained ; notContainedIsNotContained = notContainedIsNotContained }) p2ab notP2a = predToPred2 (isPrime (pred2ToPred p2ab) λ p → notP2a (predToPred2 p))
PrimeIdeal.notContained (primeIdealWellDefined ideal2 predToPred2 pred2ToPred record { isPrime = isPrime ; notContained = notContained ; notContainedIsNotContained = notContainedIsNotContained }) = notContained
PrimeIdeal.notContainedIsNotContained (primeIdealWellDefined ideal2 predToPred2 pred2ToPred record { isPrime = isPrime ; notContained = notContained ; notContainedIsNotContained = notContainedIsNotContained }) pred2Not = notContainedIsNotContained (pred2ToPred pred2Not)
| 65.764706
| 311
| 0.750894
|
0d2efa170c36ee679af4777eacaae6af759d6bd8
| 137
|
agda
|
Agda
|
test/Fail/InstanceArgumentsAmbiguous.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Fail/InstanceArgumentsAmbiguous.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Fail/InstanceArgumentsAmbiguous.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
module InstanceArgumentsAmbiguous where
postulate A B : Set
f : {{a : A}} → B
instance a₁ a₂ : A
test : B
test = f
| 15.222222
| 39
| 0.569343
|
7c9026dadfef5cc47e1a3b204ce936893eee8720
| 3,337
|
agda
|
Agda
|
TotalParserCombinators/Examples/PBM.agda
|
yurrriq/parser-combinators
|
b396d35cc2cb7e8aea50b982429ee385f001aa88
|
[
"MIT"
] | 7
|
2016-12-13T05:23:14.000Z
|
2021-06-22T05:35:31.000Z
|
TotalParserCombinators/Examples/PBM.agda
|
yurrriq/parser-combinators
|
b396d35cc2cb7e8aea50b982429ee385f001aa88
|
[
"MIT"
] | 1
|
2018-01-22T22:21:41.000Z
|
2018-01-24T16:39:37.000Z
|
TotalParserCombinators/Examples/PBM.agda
|
yurrriq/parser-combinators
|
b396d35cc2cb7e8aea50b982429ee385f001aa88
|
[
"MIT"
] | null | null | null |
------------------------------------------------------------------------
-- A parser for PBM images; illustrates "essential" use of bind
------------------------------------------------------------------------
-- Note that I am using the simple "Plain PBM" format, and I try to
-- adhere to the following statement from the pbm man page:
--
-- "Programs that read this format should be as lenient as possible,
-- accepting anything that looks remotely like a bitmap."
-- I got the idea to write this particular parser from "The Power of
-- Pi" by Oury and Swierstra.
module TotalParserCombinators.Examples.PBM where
open import Data.Bool
open import Data.Char as Char using (Char; _==_)
open import Data.List as List using (List)
open import Data.Maybe
open import Data.Nat hiding (_^_)
import Data.Nat.Show as ℕ
open import Data.String as String
using (String) renaming (_++_ to _<+>_)
open import Data.Unit
open import Data.Vec as Vec using (Vec; _++_; [_])
open import Function
open import Relation.Binary.PropositionalEquality as P using (_≡_)
open import TotalParserCombinators.BreadthFirst
open import TotalParserCombinators.Lib
open import TotalParserCombinators.Parser
open Token Char Char._≟_
------------------------------------------------------------------------
-- PBM images
module PBM where
-- Colours.
data Colour : Set where
white : Colour
black : Colour
-- Matrices.
Matrix : Set → ℕ → ℕ → Set
Matrix A rows cols = Vec (Vec A cols) rows
-- PBM images.
record PBM : Set where
constructor toPBM
field
{rows cols} : ℕ
matrix : Matrix Colour rows cols
open PBM public
-- Showing PBM images.
showColour : Colour → Char
showColour white = '0'
showColour black = '1'
show : PBM → String
show i = "P1\n" <+>
ℕ.show (cols i) <+> " " <+> ℕ.show (rows i) <+> "\n" <+>
showMatrix (matrix i)
where
showMatrix = String.fromList ∘
Vec.toList ∘
Vec.concat ∘
Vec.map ((λ xs → xs ++ [ '\n' ]) ∘ Vec.map showColour)
open PBM
------------------------------------------------------------------------
-- Parsing PBM images
comment : Parser Char ⊤ _
comment =
tok '#' >>= λ _ →
sat′ (not ∘ _==_ '\n') ⋆ >>= λ _ →
tok '\n' >>= λ _ →
return tt
colour : Parser Char Colour _
colour = const white <$> tok '0'
∣ const black <$> tok '1'
pbm : Parser Char PBM _
pbm =
w∣c ⋆ >>= λ _ →
tok 'P' >>= λ _ → tok '1' >>= λ _ →
w∣c ⋆ >>= λ _ →
number >>= λ cols →
w∣c + >>= λ _ →
number >>= λ rows →
w∣c >>= λ _ →
(w∣c ⋆ >>= λ _ → colour) ^ cols ^ rows >>= λ m →
token ⋆ >>= λ _ →
return (toPBM m)
where
w∣c = whitespace ∣ comment
-- The example is commented out, because it takes ages to run this
-- parser.
-- module Example where
-- open Vec.Vec
-- image = toPBM ((white ∷ black ∷ []) ∷
-- (black ∷ white ∷ []) ∷
-- (black ∷ black ∷ []) ∷ [])
-- ex : parse pbm (String.toList $ show image) ≡ List.[_] image
-- ex = P.refl
| 27.578512
| 72
| 0.503147
|
0d5fb098f0df64edb355b1d6a4b527460a364605
| 281
|
agda
|
Agda
|
src/data/lib/prim/Agda/Builtin/Coinduction.agda
|
pthariensflame/agda
|
222c4c64b2ccf8e0fc2498492731c15e8fef32d4
|
[
"BSD-3-Clause"
] | 3
|
2015-03-28T14:51:03.000Z
|
2015-12-07T20:14:00.000Z
|
src/data/lib/prim/Agda/Builtin/Coinduction.agda
|
Blaisorblade/Agda
|
802a28aa8374f15fe9d011ceb80317fdb1ec0949
|
[
"BSD-3-Clause"
] | null | null | null |
src/data/lib/prim/Agda/Builtin/Coinduction.agda
|
Blaisorblade/Agda
|
802a28aa8374f15fe9d011ceb80317fdb1ec0949
|
[
"BSD-3-Clause"
] | 1
|
2019-03-05T20:02:38.000Z
|
2019-03-05T20:02:38.000Z
|
{-# OPTIONS --without-K #-}
module Agda.Builtin.Coinduction where
infix 1000 ♯_
postulate
∞ : ∀ {a} (A : Set a) → Set a
♯_ : ∀ {a} {A : Set a} → A → ∞ A
♭ : ∀ {a} {A : Set a} → ∞ A → A
{-# BUILTIN INFINITY ∞ #-}
{-# BUILTIN SHARP ♯_ #-}
{-# BUILTIN FLAT ♭ #-}
| 18.733333
| 37
| 0.47331
|
5ededc25716c5abc6ba6aa0c68bc36b885254ab9
| 194
|
agda
|
Agda
|
test/Fail/NotAnExpression.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Fail/NotAnExpression.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Fail/NotAnExpression.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
-- Patterns are parsed as expressions. That means that expressions can contain
-- pattern parts. That's of course not ok.
module NotAnExpression where
X = x @ y -- as pattern as an expression
| 27.714286
| 78
| 0.752577
|
3782a7c2e42c5b3c698afcc4a13288e7f194a51b
| 21,553
|
agda
|
Agda
|
nat-thms.agda
|
heades/AUGL
|
b33c6a59d664aed46cac8ef77d34313e148fecc2
|
[
"MIT"
] | null | null | null |
nat-thms.agda
|
heades/AUGL
|
b33c6a59d664aed46cac8ef77d34313e148fecc2
|
[
"MIT"
] | null | null | null |
nat-thms.agda
|
heades/AUGL
|
b33c6a59d664aed46cac8ef77d34313e148fecc2
|
[
"MIT"
] | null | null | null |
module nat-thms where
open import bool
open import bool-thms
open import bool-thms2
open import eq
open import nat
open import neq
open import product
open import product-thms
open import sum
open import level
open import negation
--------------------------------------------------
-- properties of addition
--------------------------------------------------
0+ : ∀ (x : ℕ) → 0 + x ≡ x
0+ x = refl
+0 : ∀ (x : ℕ) → x + 0 ≡ x
+0 zero = refl
+0 (suc x) rewrite +0 x = refl
+1 : ∀ (x : ℕ) → x + 1 ≡ suc x
+1 zero = refl
+1 (suc x) rewrite +1 x = refl
+suc : ∀ (x y : ℕ) → x + (suc y) ≡ suc(x + y)
+suc zero y = refl
+suc (suc x) y rewrite +suc x y = refl
+assoc : ∀ (x y z : ℕ) → x + (y + z) ≡ (x + y) + z
+assoc zero y z = refl
+assoc (suc x) y z rewrite +assoc x y z = refl
+comm : ∀ (x y : ℕ) → x + y ≡ y + x
+comm zero y rewrite +0 y = refl
+comm (suc x) y rewrite +suc y x | +comm x y = refl
+perm : ∀ (x y z : ℕ) → x + (y + z) ≡ y + (x + z)
+perm x y z rewrite +assoc x y z | +comm x y | sym (+assoc y x z) = refl
+perm2 : ∀ (x y z : ℕ) → (x + y) + z ≡ (x + z) + y
+perm2 x y z rewrite sym (+assoc x y z) | +comm y z | +assoc x z y = refl
+≡0 : ∀ {x y : ℕ} → x + y ≡ 0 → x ≡ 0 ∧ y ≡ 0
+≡0{zero}{zero} p = refl , refl
+≡0{zero}{suc y} ()
+≡0{suc x}{zero} ()
+≡0{suc x}{suc y} ()
--------------------------------------------------
-- properties of multiplication
--------------------------------------------------
*0 : ∀ (x : ℕ) → x * 0 ≡ 0
*0 zero = refl
*0 (suc x) rewrite *0 x = refl
*1 : ∀ {n : ℕ} → n * 1 ≡ n
*1 {0} = refl
*1 {suc n} rewrite *1 {n} = refl
*suc : ∀ (x y : ℕ) → x * (suc y) ≡ x + x * y
*suc zero y = refl
*suc (suc x) y rewrite *suc x y | +assoc y x (x * y) | +assoc x y (x * y) | +comm y x = refl
*distribr : ∀ (x y z : ℕ) → (x + y) * z ≡ x * z + y * z
*distribr zero y z = refl
*distribr (suc x) y z rewrite *distribr x y z = +assoc z (x * z) (y * z)
*distribl : ∀ (x y z : ℕ) → x * (y + z) ≡ x * y + x * z
*distribl 0 y z = refl
*distribl (suc x) y z rewrite *distribl x y z | +assoc (y + z) (x * y) (x * z) | +assoc (y + x * y) z (x * z) | +comm (y + z) (x * y) | +assoc (x * y) y z | +comm (x * y) y = refl
*comm : ∀ (x y : ℕ) → x * y ≡ y * x
*comm zero y rewrite *0 y = refl
*comm (suc x) y rewrite *suc y x | *comm x y = refl
*assoc : ∀ (x y z : ℕ) → x * (y * z) ≡ (x * y) * z
*assoc zero y z = refl
*assoc (suc x) y z rewrite *assoc x y z | *distribr y (x * y) z = refl
--------------------------------------------------
-- basic properties of pred
--------------------------------------------------
sucpred : ∀ {x : ℕ} → iszero x ≡ ff → suc (pred x) ≡ x
sucpred{0} ()
sucpred{suc x} p = refl
pred+ : ∀ (x y : ℕ) → iszero x ≡ ff → (pred x) + y ≡ pred (x + y)
pred+ 0 y ()
pred+ (suc x) y p = refl
--------------------------------------------------
-- properties of <, ≤, and =ℕ, iszero
--------------------------------------------------
<-0 : ∀ (x : ℕ) → x < 0 ≡ ff
<-0 0 = refl
<-0 (suc y) = refl
0-≤ : ∀ (x : ℕ) → 0 ≤ x ≡ tt
0-≤ 0 = refl
0-≤ (suc x) = refl
<-drop : ∀ {x y : ℕ} → (x < (suc y) ≡ tt) → x ≡ y ∨ x < y ≡ tt
<-drop {0} {0} p = inj₁ refl
<-drop {suc x} {0} p rewrite <-0 x = 𝔹-contra p
<-drop {0} {suc y} p = inj₂ refl
<-drop {suc x} {suc y} p with <-drop {x} {y} p
... | inj₁ u rewrite u = inj₁ refl
... | inj₂ u = inj₂ u
=ℕ-refl : ∀ (x : ℕ) → (x =ℕ x) ≡ tt
=ℕ-refl 0 = refl
=ℕ-refl (suc x) = (=ℕ-refl x)
=ℕ-to-≡ : ∀ {x y : ℕ} → x =ℕ y ≡ tt → x ≡ y
=ℕ-to-≡ {0} {0} u = refl
=ℕ-to-≡ {suc x} {0} ()
=ℕ-to-≡ {0} {suc y} ()
=ℕ-to-≡ {suc x} {suc y} u rewrite =ℕ-to-≡ {x} {y} u = refl
=ℕ-from-≡ : ∀ {x y : ℕ} → x ≡ y → x =ℕ y ≡ tt
=ℕ-from-≡ {x} refl = =ℕ-refl x
=ℕ-sym : ∀ (x y : ℕ) → (x =ℕ y) ≡ (y =ℕ x)
=ℕ-sym 0 0 = refl
=ℕ-sym 0 (suc y) = refl
=ℕ-sym (suc x) 0 = refl
=ℕ-sym (suc x) (suc y) rewrite =ℕ-sym x y = refl
=ℕ-suc : ∀ (x : ℕ) → suc x =ℕ x ≡ ff
=ℕ-suc 0 = refl
=ℕ-suc (suc x) = =ℕ-suc x
<-suc : ∀ (n : ℕ) → n < suc n ≡ tt
<-suc 0 = refl
<-suc (suc n) rewrite <-suc n = refl
<-suc2 : ∀ (n : ℕ) → suc n < n ≡ ff
<-suc2 0 = refl
<-suc2 (suc n) = <-suc2 n
≤-suc : ∀ (n : ℕ) → n ≤ suc n ≡ tt
≤-suc n rewrite <-suc n = refl
≤-suc2 : ∀ (n : ℕ) → suc n ≤ n ≡ ff
≤-suc2 n rewrite <-suc2 n | =ℕ-suc n = refl
<-push : ∀ {x y : ℕ} → (suc x) < y ≡ tt → Σ ℕ (λ y' → y ≡ (suc y'))
<-push {x} {0} ()
<-push {0} {suc y} p = (y , refl)
<-push {suc x} {suc y} p with <-push {x} {y} p
... | ( y' , p' ) rewrite p' = (suc y' , refl)
suc-inj : ∀ {n m : ℕ} → suc n ≡ suc m → n ≡ m
suc-inj {n} {m} p rewrite (=ℕ-to-≡{n} (=ℕ-from-≡ p)) = refl
<-implies-suc : ∀ {x y : ℕ} → x < y ≡ tt → Σ ℕ λ y' → y ≡ suc y'
<-implies-suc{x}{0} p rewrite <-0 x = 𝔹-contra p
<-implies-suc{y = suc y} p = y , refl
<=ℕff : ∀ (x : ℕ) → 0 < x ≡ tt → x =ℕ 0 ≡ ff
<=ℕff 0 ()
<=ℕff (suc x) p = refl
nonzero< : ∀ {n : ℕ} → iszero n ≡ ff → 0 < n ≡ tt
nonzero<{0} ()
nonzero<{(suc n)} p = refl
iszerosum : ∀ (x y : ℕ) → iszero(x + y) ≡ iszero(x) && iszero(y)
iszerosum 0 y = refl
iszerosum (suc x) y = refl
iszerosum2 : ∀ (x y : ℕ) → iszero x ≡ ff → iszero(x + y) ≡ ff
iszerosum2 0 y ()
iszerosum2 (suc x) y _ = refl
iszeromult : ∀ (x y : ℕ) → iszero x ≡ ff → iszero y ≡ ff →
iszero (x * y) ≡ ff
iszeromult zero zero () q
iszeromult zero (suc y) () q
iszeromult (suc x) zero p ()
iszeromult (suc x) (suc y) p q = refl
<≤ : ∀ {n m : ℕ} → n < m ≡ tt → n ≤ m ≡ tt
<≤ {n}{m} p rewrite p = refl
≤+1 : ∀(x y : ℕ) → x ≤ x + y ≡ tt
≤+1 zero zero = refl
≤+1 zero (suc y) = refl
≤+1 (suc x) zero rewrite +0 x | =ℕ-refl x | ||-tt (x < x) = refl
≤+1 (suc x) (suc y) = ≤+1 x (suc y)
≤+2 : ∀(x y : ℕ) → y ≤ x + y ≡ tt
≤+2 x y rewrite +comm x y = ≤+1 y x
-- a theorem about quotients q, divisors d, and remainders r
÷< : ∀ {d q r x : ℕ} → 1 < d ≡ tt → q * d + r ≡ suc x → q < suc x ≡ tt
÷<{0} () p
÷<{suc 0} () p
÷<{suc (suc d)}{0} u p = refl
÷<{suc (suc d)}{suc q}{r}{0} u ()
÷<{suc (suc d)}{suc q}{r}{suc x} u p with suc-inj{suc (d + q * suc (suc d) + r)}{suc x} p
... | p' rewrite sym (+suc (d + q * suc (suc d)) r) | +comm d (q * suc (suc d))
| sym (+assoc (q * (suc (suc d))) d (suc r)) = ÷<{suc (suc d)}{q}{d + suc r}{x} refl p'
--------------------------------------------------
-- ordering properties of < and ≤ℕ
--------------------------------------------------
<-irrefl : ∀ (n : ℕ) → n < n ≡ ff
<-irrefl 0 = refl
<-irrefl (suc n) = <-irrefl n
<-asym : ∀ {x y : ℕ} → x < y ≡ tt → y < x ≡ ff
<-asym {0} {0} _ = refl
<-asym {0} {suc y} p = refl
<-asym {suc x}{0} ()
<-asym {suc x}{suc y} p = <-asym {x} {y} p
ℕ-trichotomy𝔹 : ∀ (n m : ℕ) → n < m || n =ℕ m || m < n ≡ tt
ℕ-trichotomy𝔹 0 0 = refl
ℕ-trichotomy𝔹 0 (suc m) = refl
ℕ-trichotomy𝔹 (suc n) 0 = refl
ℕ-trichotomy𝔹 (suc n) (suc m) = ℕ-trichotomy𝔹 n m
ℕ-trichotomy : ∀ (n m : ℕ) → (n < m ≡ tt) ∨ (n =ℕ m ≡ tt) ∨ (m < n ≡ tt)
ℕ-trichotomy n m with ||-split{n < m} (ℕ-trichotomy𝔹 n m)
... | inj₁ p = inj₁ p
... | inj₂ p with ||-split{n =ℕ m} p
... | inj₁ p' = inj₂ (inj₁ p')
... | inj₂ p' = inj₂ (inj₂ p')
<-insert : ∀ {x n m : ℕ} → n ≤ m ≡ tt → (x < n ≡ tt) ∨ (n ≤ x && x ≤ m ≡ tt) ∨ (m < x ≡ tt)
<-insert{x}{n}{m} q with ℕ-trichotomy x n
<-insert{x}{n}{m} q | inj₁ p = inj₁ p
<-insert{x}{n}{m} q | inj₂ (inj₁ p) rewrite (=ℕ-to-≡{x} p) | =ℕ-refl n | ||-tt (n < n) = inj₂ (inj₁ q)
<-insert{x}{n}{m} q | inj₂ (inj₂ p) rewrite p with ℕ-trichotomy x m
<-insert{x}{n}{m} q | inj₂ (inj₂ p) | inj₁ p' rewrite p' = inj₂ (inj₁ refl)
<-insert{x}{n}{m} q | inj₂ (inj₂ p) | inj₂ (inj₁ p') rewrite p' | ||-tt (x < m) = inj₂ (inj₁ refl)
<-insert{x}{n}{m} q | inj₂ (inj₂ p) | inj₂ (inj₂ p') = inj₂ (inj₂ p')
<-insert2 : ∀ {x n m : ℕ} → n ≤ m ≡ tt → (x < n ≡ tt) ∨ (n ≤ x ≡ tt ∧ x ≤ m ≡ tt) ∨ (m < x ≡ tt)
<-insert2{x}{n}{m} p with <-insert{x}{n}{m} p
<-insert2{x}{n}{m} p | inj₁ p' = inj₁ p'
<-insert2{x}{n}{m} p | inj₂ (inj₁ p') with &&-elim {n ≤ x} {x ≤ m} p'
<-insert2{x}{n}{m} p | inj₂ (inj₁ p') | p1 , p2 = inj₂ (inj₁ (p1 , p2))
<-insert2{x}{n}{m} p | inj₂ (inj₂ p') = inj₂ (inj₂ p')
<-trans : ∀ {x y z : ℕ} → x < y ≡ tt → y < z ≡ tt → x < z ≡ tt
<-trans {x} {0} p1 p2 rewrite <-0 x = 𝔹-contra p1
<-trans {0} {suc y} {0} p1 ()
<-trans {0} {suc y} {suc z} p1 p2 = refl
<-trans {suc x} {suc y} {0} p1 ()
<-trans {suc x} {suc y} {suc z} p1 p2 = <-trans {x} {y} {z} p1 p2
-- <≤-trans : ∀ {x y z : ℕ} → x < y ≡ tt → y ≤ z ≡ tt → x < z ≡ tt
-- <≤-trans {x} {y} {z} p1 p2 with ||-split p2
-- ... | inj₁ p' = <-trans{x} p1 p'
-- ... | inj₂ p' rewrite =ℕ-to-≡ {y} {z} p' = p1
≤<-trans : ∀ {x y z : ℕ} → x ≤ y ≡ tt → y < z ≡ tt → x < z ≡ tt
≤<-trans {x} {y} {z} p1 p2 with ||-split p1
... | inj₁ p' = <-trans{x} p' p2
... | inj₂ p' rewrite =ℕ-to-≡ {x} {y} p' = p2
≤-refl : ∀ (x : ℕ) → x ≤ x ≡ tt
≤-refl 0 = refl
≤-refl (suc x) = ≤-refl x
≤-trans : ∀ {x y z : ℕ} → x ≤ y ≡ tt → y ≤ z ≡ tt → x ≤ z ≡ tt
≤-trans {x} {y} {z} p1 p2 with ||-split p1 | ||-split p2
... | inj₁ p' | inj₁ p'' rewrite <-trans {x} p' p'' = refl
... | inj₂ p' | inj₁ p'' rewrite =ℕ-to-≡ {x} p' | p'' = refl
... | inj₁ p' | inj₂ p'' rewrite =ℕ-to-≡ {y} p'' | p' = refl
... | inj₂ p' | inj₂ p'' rewrite =ℕ-to-≡ {x} p' | =ℕ-to-≡ {y} p'' | =ℕ-refl z | ||-tt (z < z) = refl
suc≤ : ∀ {n n' : ℕ} → suc n ≤ suc n' ≡ tt → n ≤ n' ≡ tt
suc≤{n}{n'} p = p
-- suc≤< : ∀ {n n' : ℕ} → suc n ≤ n' ≡ tt → n < n' ≡ tt
-- suc≤<{n} p = <≤-trans{n} (<-suc n) p
suc<< : ∀ {n' n : ℕ} → suc n < n' ≡ tt → n < n' ≡ tt
suc<<{n = n} p = <-trans{n} (<-suc n) p
<-suc-trans : ∀{x y : ℕ} → x < y ≡ tt → x < suc y ≡ tt
<-suc-trans{0}{0} _ = refl
<-suc-trans{suc x}{0} ()
<-suc-trans{0}{suc y} _ = refl
<-suc-trans{suc x}{suc y} p = <-suc-trans{x}{y} p
≤-suc-trans : ∀{x y : ℕ} → x ≤ y ≡ tt → x ≤ suc y ≡ tt
≤-suc-trans{0}{0} _ = refl
≤-suc-trans{suc x}{0} ()
≤-suc-trans{0}{suc y} _ = refl
≤-suc-trans{suc x}{suc y} p = ≤-suc-trans{x}{y} p
-------------------------------------------------------------
-- more properties relating <, ≤ with arithmetic operations
-------------------------------------------------------------
<+ : ∀ {x y : ℕ} → y =ℕ 0 ≡ ff → x < y + x ≡ tt
<+{y = 0} ()
<+{x}{suc 0} p = <-suc x
<+{x}{suc (suc y)} p = <-trans{x}{(suc y) + x}{suc ((suc y) + x)} (<+{x}{suc y} refl) (<-suc ((suc y) + x))
<+2 : ∀ {x y : ℕ} → x < (suc y) + x ≡ tt
<+2{x}{y} = <+{x}{suc y} refl
<-iter-suc-trans-t-h : (n : ℕ) → (x : ℕ) → (accum : ℕ) → Set
<-iter-suc-trans-t-h 0 x accum = x < accum ≡ tt
<-iter-suc-trans-t-h (suc n) x accum = <-iter-suc-trans-t-h n x (suc accum)
<-iter-suc-trans-t : (n : ℕ) → (x : ℕ) → Set
<-iter-suc-trans-t n x = <-iter-suc-trans-t-h n x (suc x)
<-iter-suc-trans-h : ∀ (n : ℕ) → (x : ℕ) → (accum : ℕ) → x < accum ≡ tt → <-iter-suc-trans-t-h n x accum
<-iter-suc-trans-h 0 x accum p = p
<-iter-suc-trans-h (suc n) x accum p = <-iter-suc-trans-h n x (suc accum) (<-suc-trans{x} p)
<-iter-suc-trans : ∀ (n : ℕ) → (x : ℕ) → <-iter-suc-trans-t n x
<-iter-suc-trans n x = <-iter-suc-trans-h n x (suc x) (<-suc x)
≤0 : ∀ (n : ℕ) → 0 ≤ n ≡ tt
≤0 0 = refl
≤0 (suc n) = refl
≤2* : ∀ (x : ℕ) → x ≤ 2 * x ≡ tt
≤2* 0 = refl
≤2* (suc x) rewrite +suc x (x + 0) | ≤<-trans {x} (≤2* x) (<-suc (2 * x)) = refl
0<+ : ∀ (x y : ℕ) → 0 < y ≡ tt → 0 < x + y ≡ tt
0<+ 0 y p = p
0<+ (suc x) y p = refl
<=ℕff2 : ∀ (x : ℕ) → 1 < x ≡ tt → x =ℕ 0 ≡ ff
<=ℕff2 x p = <=ℕff x (<-trans{0}{1}{x} refl p)
*≤ : ∀(x y : ℕ) → x ≤ x * (suc y) ≡ tt
*≤ zero y = refl
*≤ (suc x) y = ≤-trans {x} (*≤ x y) (≤+2 y (x * suc y))
--------------------------------------------------
-- relationships between ≤ and <
--------------------------------------------------
≤ff : ∀ {x y : ℕ} → x ≤ y ≡ ff → y < x ≡ tt
≤ff{0}{0} ()
≤ff{0}{suc y} ()
≤ff{suc x}{0} _ = refl
≤ff{suc x}{suc y} p rewrite ≤ff {x}{y} p = refl
<ff : ∀ {x y : ℕ} → x < y ≡ ff → y ≤ x ≡ tt
<ff{x}{y} p with ℕ-trichotomy x y
... | inj₁ u rewrite u = 𝔹-contra (sym p)
... | inj₂ (inj₁ u) rewrite (=ℕ-to-≡{x} u) | =ℕ-refl y | ||-tt (y < y) = refl
... | inj₂ (inj₂ u) rewrite u = refl
<-not-=ℕ : ∀{x y : ℕ} → x < y ≡ tt → y =ℕ x ≡ ff
<-not-=ℕ{0}{0} ()
<-not-=ℕ{suc x}{0} ()
<-not-=ℕ{0}{suc y} p = refl
<-not-=ℕ{suc x}{suc y} p = <-not-=ℕ{x}{y} p
<-not-> : ∀{x y : ℕ} → x < y ≡ tt → y < x ≡ ff
<-not->{0}{0} ()
<-not->{suc x}{0} ()
<-not->{0}{suc y} p = refl
<-not->{suc x}{suc y} p = <-not->{x}{y} p
<tt : ∀ {x y : ℕ} → x < y ≡ tt → y ≤ x ≡ ff
<tt{x}{y} p rewrite <-not-=ℕ{x}{y} p | <-not->{x}{y} p = refl
≤-antisym : ∀{x y : ℕ} → x ≤ y ≡ tt → y ≤ x ≡ tt → x ≡ y
≤-antisym{x}{y} p q with ||-split {x < y} p
≤-antisym{x}{y} p q | inj₁ u rewrite <tt{x} u with q
≤-antisym{x}{y} p q | inj₁ u | ()
≤-antisym{x}{y} p q | inj₂ u = =ℕ-to-≡ u
--------------------------------------------------
-- monotonicity properties of < and ≤ℕ
--------------------------------------------------
<+mono1 : ∀ {z x y : ℕ} → x < y ≡ tt → z + x < z + y ≡ tt
<+mono1{0} p = p
<+mono1{suc z} p = <+mono1{z} p
<+mono2 : ∀ {x y z : ℕ} → x < y ≡ tt → x + z < y + z ≡ tt
<+mono2{x}{y}{z} p rewrite +comm x z | +comm y z | <+mono1{z}{x}{y} p = refl
--------------------------------------------------
-- properties of subtraction
--------------------------------------------------
0∸ : ∀ {x : ℕ} → 0 ∸ x ≡ 0
0∸{0} = refl
0∸{suc x} = refl
∸≤ : ∀ (x y : ℕ) → x ∸ y ≤ x ≡ tt
∸≤ 0 0 = refl
∸≤ (suc x) 0 rewrite (=ℕ-refl x) = ||-tt (x < x)
∸≤ 0 (suc y) = refl
∸≤ (suc x) (suc y) with ||-split{x ∸ y < x}{x ∸ y =ℕ x} (∸≤ x y)
... | inj₁ u rewrite <-trans {x ∸ y} u (<-suc x) = refl
... | inj₂ u rewrite (=ℕ-to-≡ {x ∸ y} u) | <-suc x = refl
∸< : ∀ {x y : ℕ} → x =ℕ 0 ≡ ff → x ∸ (suc y) < x ≡ tt
∸< {0} {y} ()
∸< {suc x} {y} _ with ||-split{x ∸ y < x}{x ∸ y =ℕ x} (∸≤ x y)
... | inj₁ u = <-trans {x ∸ y} u (<-suc x)
... | inj₂ u rewrite (=ℕ-to-≡ {x ∸ y} u) = <-suc x
∸<1 : ∀ {x y : ℕ} → x ∸ y < suc x ≡ tt
∸<1 {zero} {zero} = refl
∸<1 {zero} {suc y} = refl
∸<1 {suc x} {zero} = <-suc x
∸<1 {suc x} {suc y} = <-trans {x ∸ y}{suc x} (∸<1 {x} {y}) (<-suc x)
+∸1 : ∀ {x y : ℕ} → x < y ≡ tt → x + (y ∸ x) ≡ y
+∸1{0} p = refl
+∸1{suc x}{0} ()
+∸1{suc x}{suc y} p rewrite +∸1{x}{y} p = refl
∸+ : ∀ {x y z : ℕ} → x ∸ (y + z) ≡ (x ∸ y) ∸ z
∸+{x}{0} = refl
∸+{0}{suc y}{z} rewrite 0∸{z} = refl
∸+{suc x}{suc y} = ∸+{x}{y}
∸+2 : ∀ {x y : ℕ} → y ≤ x ≡ tt → (x ∸ y) + y ≡ x
∸+2{0}{0} _ = refl
∸+2{suc x}{0} _ rewrite +0 x = refl
∸+2{0}{suc y} ()
∸+2{suc x}{suc y} p rewrite +suc (x ∸ y) y | ∸+2{x}{y} p = refl
∸eq-swap : ∀ {x y z : ℕ} → y ≤ x ≡ tt → z ≡ x ∸ y → z + y ≡ x
∸eq-swap{x}{y}{z} p q = lem (cong (λ w → w + y) q)
where lem : z + y ≡ (x ∸ y) + y → z + y ≡ x
lem p' rewrite ∸+2{x}{y} p = p'
<∸ : ∀ {x y : ℕ} → (y < x ≡ tt) → ((x ∸ y =ℕ 0) ≡ ff)
<∸ {0}{y} p with <-0 y
... | q rewrite p = 𝔹-contra (sym q)
<∸ {suc x}{0} p = refl
<∸ {suc x}{suc y} p = <∸{x}{y} p
<∸suc : ∀ {x y : ℕ} → (y < x ≡ tt) → Σ ℕ (λ n → x ∸ y ≡ suc n)
<∸suc{x}{y} p with keep (x ∸ y)
<∸suc{x}{y} p | 0 , r with <∸{x}{y} p
<∸suc{x}{y} p | 0 , r | q rewrite r with q
<∸suc{x}{y} p | 0 , r | q | ()
<∸suc{x}{y} p | suc n , r = n , r
∸suc : ∀ {x y z : ℕ } → y < x ≡ tt → x ∸ (y + (suc z)) < x ∸ y ≡ tt
∸suc{x}{y}{z} p rewrite ∸+{x}{y}{suc z} = ∸< {x ∸ y} (<∸{x}{y} p)
∸suc2 : ∀ {x y z : ℕ } → y < x ≡ tt → x ∸ ((suc z) + y) < x ∸ y ≡ tt
∸suc2{x}{y}{z} p rewrite +comm (suc z) y = ∸suc{x}{y}{z} p
∸cancel : ∀ (x y z : ℕ) → (x + y) ∸ (x + z) ≡ y ∸ z
∸cancel 0 y z = refl
∸cancel (suc x) y z = ∸cancel x y z
distribr*∸ : ∀ (x y z : ℕ) → (x ∸ y) * z ≡ x * z ∸ y * z
distribr*∸ 0 y z rewrite 0∸{y} | 0∸{y * z} = refl
distribr*∸ (suc x) 0 z = refl
distribr*∸ (suc x) (suc y) z rewrite distribr*∸ x y z | ∸cancel z (x * z) (y * z) = refl
∸≤2 : ∀ (n x y : ℕ) → x ≤ suc n ≡ tt → y =ℕ 0 ≡ ff → x ∸ y ≤ n ≡ tt
∸≤2 0 0 y p1 p2 rewrite 0∸{y} = refl
∸≤2 0 (suc x) 0 p1 ()
∸≤2 0 (suc 0) (suc y) p1 p2 rewrite 0∸{y}= refl
∸≤2 0 (suc (suc x)) (suc y) () p2
∸≤2 (suc n) 0 y p1 p2 rewrite 0∸{y} = refl
∸≤2 (suc n) (suc x) 0 p1 ()
∸≤2 (suc n) (suc x) (suc 0) p1 p2 = p1
∸≤2 (suc n) (suc x) (suc (suc y)) p1 p2 = ≤-trans{x ∸ suc y}{n}{suc n} (∸≤2 n x (suc y) p1 refl) (≤-suc n)
--------------------------------------------------
-- properties of min, max
--------------------------------------------------
min-forced1 : ∀ {n n' m : ℕ} → n < n' ≡ tt → n ≡ min n' m → n ≡ m
min-forced1{n}{n'}{m} p1 p2 with n' < m
... | tt rewrite p2 = 𝔹-contra (trans (sym (<-irrefl n')) p1)
... | ff = p2
min-suc : ∀ (n m : ℕ) → min (suc n) (suc m) ≡ suc (min n m)
min-suc n m rewrite (ite-arg suc (n < m) n m) = refl
max-suc : ∀ (n m : ℕ) → max (suc n) (suc m) ≡ suc (max n m)
max-suc n m rewrite (ite-arg suc (n < m) m n) = refl
min-mono1 : ∀ (n n' m : ℕ) → n ≤ n' ≡ tt → min n m ≤ min n' m ≡ tt
min-mono1 n n' m p with ||-split{n < n'} p
... | inj₂ p' rewrite =ℕ-to-≡ {n} p' | =ℕ-refl (min n' m) | ||-tt ((min n' m) < (min n' m)) = refl
... | inj₁ p' with ℕ-trichotomy n' m
... | inj₁ p'' rewrite <-trans {n} p' p'' | p'' | p' = refl
... | inj₂ (inj₁ p'') rewrite =ℕ-to-≡ {n'} p'' | p' | =ℕ-refl (min n m) | ||-tt ((min n m) < (min n m)) | <-irrefl m | p' = refl
... | inj₂ (inj₂ p'') rewrite <-asym {m} p'' with ℕ-trichotomy n m
... | inj₁ p''' rewrite p''' | p''' = refl
... | inj₂ (inj₁ p''') rewrite =ℕ-to-≡ {n} p''' | <-irrefl m | =ℕ-refl m | ||-tt (m < m) = refl
... | inj₂ (inj₂ p''') rewrite <-asym {m} p''' | =ℕ-refl m | ||-tt (m < m) = refl
min-comm : ∀ (n m : ℕ) → min n m ≡ min m n
min-comm n m with ℕ-trichotomy n m
... | inj₁ p rewrite p | <-asym {n} p = refl
... | inj₂ (inj₁ p) rewrite =ℕ-to-≡ {n} p = refl
... | inj₂ (inj₂ p) rewrite p | <-asym {m} p = refl
min-mono2 : ∀ (n m m' : ℕ) → m ≤ m' ≡ tt → min n m ≤ min n m' ≡ tt
min-mono2 n m m' p rewrite min-comm n m | min-comm n m' = min-mono1 m m' n p
min-same : ∀ (n : ℕ) → min n n ≡ n
min-same n rewrite <-irrefl n = refl
min-<1 : ∀ {n m : ℕ} → min n m ≤ m ≡ tt
min-<1{0}{0} = refl
min-<1{0}{suc m} = refl
min-<1{suc n}{0} = refl
min-<1{suc n}{suc m} rewrite min-suc n m = min-<1{n}
min-<2 : ∀ {n m : ℕ} → min n m ≤ n ≡ tt
min-<2{0}{0} = refl
min-<2{0}{suc m} = refl
min-<2{suc n}{0} = refl
min-<2{suc n}{suc m} rewrite min-suc n m = min-<2{n}
max-<1 : ∀ {n m : ℕ} → n ≤ max n m ≡ tt
max-<1{0}{0} = refl
max-<1{0}{suc m} = refl
max-<1{suc n}{0} rewrite =ℕ-refl n | ||-tt (n < n) = refl
max-<1{suc n}{suc m} rewrite max-suc n m = max-<1{n}
max-<2 : ∀ {n m : ℕ} → n ≤ max n m ≡ tt
max-<2{0}{0} = refl
max-<2{0}{suc m} = refl
max-<2{suc n}{0} rewrite =ℕ-refl n | ||-tt (n < n) = refl
max-<2{suc n}{suc m} rewrite max-suc n m = max-<2{n}
--------------------------------------------------
-- some disequalities
--------------------------------------------------
+≢ : ∀ (x y : ℕ) → x ≢ x + suc y
+≢ 0 y ()
+≢ (suc x) y p with =ℕ-from-≡ {suc x} p
... | q with =ℕ-to-≡ {x} q
... | r = +≢ x y r
--------------------------------------------------
-- properties of parity
--------------------------------------------------
parity-even : ∀ (x : ℕ) → parity (x * 2) ≡ ff
parity-even 0 = refl
parity-even (suc x) rewrite parity-even x = refl
parity-even2 : ∀ (x : ℕ) → parity (2 * x) ≡ ff
parity-even2 x rewrite *comm 2 x = parity-even x
parity-odd : ∀ (x : ℕ) → parity (x * 2 + 1) ≡ tt
parity-odd 0 = refl
parity-odd (suc x) rewrite parity-odd x = refl
parity-add : ∀ (x y : ℕ) → parity (x + y) ≡ (parity x) xor (parity y)
parity-add 0 y rewrite ff-xor (parity y) = refl
parity-add (suc x) y rewrite parity-add x y | ~-xor-distrb (parity x) (parity y) = refl
parity-mult : ∀ (x y : ℕ) → parity (x * y) ≡ (parity x) && (parity y)
parity-mult 0 y = refl
parity-mult (suc x) y rewrite parity-add y (x * y) | parity-mult x y = xor-distrib-&& (parity y) (parity x)
--------------------------------------------------
-- properties of power
--------------------------------------------------
1-pow : ∀ {n : ℕ} → 1 pow n ≡ 1
1-pow {0} = refl
1-pow {(suc n)} rewrite 1-pow {n} = refl
nonzero-pow : ∀ (x y : ℕ) → x =ℕ 0 ≡ ff → iszero (x pow y) ≡ ff
nonzero-pow x 0 _ = refl
nonzero-pow 0 (suc y) ()
nonzero-pow (suc x) (suc y) p rewrite iszerosum2 (suc x pow y) (x * suc x pow y) (nonzero-pow (suc x) y refl) = refl
pow+ : ∀ (x y z : ℕ) → x pow (y + z) ≡ (x pow y) * (x pow z)
pow+ x 0 z rewrite +0 (x pow z) = refl
pow+ x (suc y) z rewrite pow+ x y z | *assoc x (x pow y) (x pow z) = refl
pow* : ∀ (x y z : ℕ) → x pow (y * z) ≡ (x pow y) pow z
pow* x y 0 rewrite *0 y = refl
pow* x y (suc z) rewrite sym (pow* x y z) | sym (pow+ x y (y * z)) | *comm y (suc z) | *comm y z = refl
--------------------------------------------------
-- properties of factorial
--------------------------------------------------
factorial-nonzero : ∀ (n : ℕ) → iszero (factorial n) ≡ ff
factorial-nonzero zero = refl
factorial-nonzero (suc x) rewrite iszerosum (factorial x) (x * factorial x) | factorial-nonzero x = refl
--------------------------------------------------
-- injectivity properties of addition
--------------------------------------------------
+inj1 : ∀ {x y z : ℕ} → x + y ≡ x + z → y ≡ z
+inj1 {0} {y} {z} p = p
+inj1 {suc x} {y} {z} p = +inj1 {x} {y} {z} (suc-inj p)
+inj2 : ∀ {x y z : ℕ} → x + z ≡ y + z → x ≡ y
+inj2 {x} {y} {z} p rewrite +comm x z | +comm y z = +inj1 {z} {x} {y} p
--------------------------------------------------
-- properties of is-even, is-odd
--------------------------------------------------
even~odd : ∀ (x : ℕ) → is-even x ≡ ~ is-odd x
odd~even : ∀ (x : ℕ) → is-odd x ≡ ~ is-even x
even~odd zero = refl
even~odd (suc x) = odd~even x
odd~even zero = refl
odd~even (suc x) = even~odd x
suc-eq : ∀{x y} → suc x ≡ suc y → x ≡ y
suc-eq refl = refl
suc-eq⊥ : ∀{x y} → ¬ (x ≡ y) → ¬ (suc x ≡ suc y)
suc-eq⊥ p refl = p refl
zero-suc-eq⊥ : ∀{x} → zero ≡ suc x → ⊥ {lzero}
zero-suc-eq⊥ ()
suc-zero-eq⊥ : ∀{x} → suc x ≡ zero → ⊥ {lzero}
suc-zero-eq⊥ ()
| 33.835165
| 179
| 0.44082
|
cc09199c4d757b949f6c8ef54c11800e9e5c8368
| 18,867
|
agda
|
Agda
|
canonical-indeterminate-forms.agda
|
hazelgrove/hazel-palette-agda
|
c3225acc3c94c56376c6842b82b8b5d76912df2a
|
[
"MIT"
] | 4
|
2020-10-04T06:45:06.000Z
|
2021-12-19T15:38:31.000Z
|
canonical-indeterminate-forms.agda
|
hazelgrove/hazel-palette-agda
|
c3225acc3c94c56376c6842b82b8b5d76912df2a
|
[
"MIT"
] | 9
|
2020-09-30T20:27:56.000Z
|
2020-10-20T20:44:13.000Z
|
canonical-indeterminate-forms.agda
|
hazelgrove/hazelnut-livelits-agda
|
c3225acc3c94c56376c6842b82b8b5d76912df2a
|
[
"MIT"
] | null | null | null |
open import Nat
open import Prelude
open import contexts
open import core
open import type-assignment-unicity
module canonical-indeterminate-forms where
-- this type gives somewhat nicer syntax for the output of the canonical
-- forms lemma for indeterminates at base type
data cif-base : (Δ : hctx) (d : iexp) → Set where
CIFBEHole : ∀ {Δ d} →
Σ[ u ∈ Nat ] Σ[ σ ∈ env ] Σ[ Γ ∈ tctx ]
((d == ⦇⦈⟨ u , σ ⟩) ×
((u :: b [ Γ ]) ∈ Δ) ×
(Δ , ∅ ⊢ σ :s: Γ)
)
→ cif-base Δ d
CIFBNEHole : ∀ {Δ d} →
Σ[ u ∈ Nat ] Σ[ σ ∈ env ] Σ[ Γ ∈ tctx ] Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ]
((d == ⦇⌜ d' ⌟⦈⟨ u , σ ⟩) ×
(Δ , ∅ ⊢ d' :: τ') ×
(d' final) ×
((u :: b [ Γ ]) ∈ Δ) ×
(Δ , ∅ ⊢ σ :s: Γ)
)
→ cif-base Δ d
CIFBAp : ∀ {Δ d} →
Σ[ d1 ∈ iexp ] Σ[ d2 ∈ iexp ] Σ[ τ2 ∈ typ ]
((d == d1 ∘ d2) ×
(Δ , ∅ ⊢ d1 :: τ2 ==> b) ×
(Δ , ∅ ⊢ d2 :: τ2) ×
(d1 indet) ×
(d2 final) ×
((τ3 τ4 τ3' τ4' : typ) (d1' : iexp) → d1 ≠ (d1' ⟨ τ3 ==> τ4 ⇒ τ3' ==> τ4' ⟩))
)
→ cif-base Δ d
CIFBFst : ∀{Δ d} →
Σ[ d' ∈ iexp ] Σ[ τ2 ∈ typ ]
((d == fst d') ×
(Δ , ∅ ⊢ d' :: b ⊗ τ2) ×
(d' indet) ×
(∀{d1 d2} → d' ≠ ⟨ d1 , d2 ⟩) ×
(∀{d'' τ1 τ2 τ3 τ4} → d' ≠ (d'' ⟨ τ1 ⊗ τ2 ⇒ τ3 ⊗ τ4 ⟩))
)
→ cif-base Δ d
CIFBSnd : ∀{Δ d} →
Σ[ d' ∈ iexp ] Σ[ τ1 ∈ typ ]
((d == snd d') ×
(Δ , ∅ ⊢ d' :: τ1 ⊗ b) ×
(d' indet) ×
(∀{d1 d2} → d' ≠ ⟨ d1 , d2 ⟩) ×
(∀{d'' τ1 τ2 τ3 τ4} → d' ≠ (d'' ⟨ τ1 ⊗ τ2 ⇒ τ3 ⊗ τ4 ⟩))
)
→ cif-base Δ d
CIFBCast : ∀ {Δ d} →
Σ[ d' ∈ iexp ]
((d == d' ⟨ ⦇·⦈ ⇒ b ⟩) ×
(Δ , ∅ ⊢ d' :: ⦇·⦈) ×
(d' indet) ×
((d'' : iexp) (τ' : typ) → d' ≠ (d'' ⟨ τ' ⇒ ⦇·⦈ ⟩))
)
→ cif-base Δ d
CIFBFailedCast : ∀ {Δ d} →
Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ]
((d == d' ⟨ τ' ⇒⦇⦈⇏ b ⟩) ×
(Δ , ∅ ⊢ d' :: τ') ×
(τ' ground) ×
(τ' ≠ b)
)
→ cif-base Δ d
canonical-indeterminate-forms-base : ∀{Δ d} →
Δ , ∅ ⊢ d :: b →
d indet →
cif-base Δ d
canonical-indeterminate-forms-base TAConst ()
canonical-indeterminate-forms-base (TAVar x₁) ()
canonical-indeterminate-forms-base (TAAp wt wt₁) (IAp x ind x₁) = CIFBAp (_ , _ , _ , refl , wt , wt₁ , ind , x₁ , x)
canonical-indeterminate-forms-base (TAEHole x x₁) IEHole = CIFBEHole (_ , _ , _ , refl , x , x₁)
canonical-indeterminate-forms-base (TANEHole x wt x₁) (INEHole x₂) = CIFBNEHole (_ , _ , _ , _ , _ , refl , wt , x₂ , x , x₁)
canonical-indeterminate-forms-base (TACast wt x) (ICastHoleGround x₁ ind x₂) = CIFBCast (_ , refl , wt , ind , x₁)
canonical-indeterminate-forms-base (TAFailedCast x x₁ x₂ x₃) (IFailedCast x₄ x₅ x₆ x₇) = CIFBFailedCast (_ , _ , refl , x , x₅ , x₇)
canonical-indeterminate-forms-base (TAFst wt) (IFst ind h1 h2) = CIFBFst (_ , _ , refl , wt , ind , h1 , h2)
canonical-indeterminate-forms-base (TASnd wt) (ISnd ind h1 h2) = CIFBSnd (_ , _ , refl , wt , ind , h1 , h2)
-- this type gives somewhat nicer syntax for the output of the canonical
-- forms lemma for indeterminates at arrow type
data cif-arr : (Δ : hctx) (d : iexp) (τ1 τ2 : typ) → Set where
CIFAEHole : ∀{d Δ τ1 τ2} →
Σ[ u ∈ Nat ] Σ[ σ ∈ env ] Σ[ Γ ∈ tctx ]
((d == ⦇⦈⟨ u , σ ⟩) ×
((u :: (τ1 ==> τ2) [ Γ ]) ∈ Δ) ×
(Δ , ∅ ⊢ σ :s: Γ)
)
→ cif-arr Δ d τ1 τ2
CIFANEHole : ∀{d Δ τ1 τ2} →
Σ[ u ∈ Nat ] Σ[ σ ∈ env ] Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ] Σ[ Γ ∈ tctx ]
((d == ⦇⌜ d' ⌟⦈⟨ u , σ ⟩) ×
(Δ , ∅ ⊢ d' :: τ') ×
(d' final) ×
((u :: (τ1 ==> τ2) [ Γ ]) ∈ Δ) ×
(Δ , ∅ ⊢ σ :s: Γ)
)
→ cif-arr Δ d τ1 τ2
CIFAAp : ∀{d Δ τ1 τ2} →
Σ[ d1 ∈ iexp ] Σ[ d2 ∈ iexp ] Σ[ τ2' ∈ typ ] Σ[ τ1 ∈ typ ] Σ[ τ2 ∈ typ ]
((d == d1 ∘ d2) ×
(Δ , ∅ ⊢ d1 :: τ2' ==> (τ1 ==> τ2)) ×
(Δ , ∅ ⊢ d2 :: τ2') ×
(d1 indet) ×
(d2 final) ×
((τ3 τ4 τ3' τ4' : typ) (d1' : iexp) → d1 ≠ (d1' ⟨ τ3 ==> τ4 ⇒ τ3' ==> τ4' ⟩))
)
→ cif-arr Δ d τ1 τ2
CIFAFst : ∀{Δ d τ1 τ2} →
Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ]
((d == fst d') ×
(Δ , ∅ ⊢ d' :: (τ1 ==> τ2) ⊗ τ') ×
(d' indet) ×
(∀{d1 d2} → d' ≠ ⟨ d1 , d2 ⟩) ×
(∀{d'' τ1 τ2 τ3 τ4} → d' ≠ (d'' ⟨ τ1 ⊗ τ2 ⇒ τ3 ⊗ τ4 ⟩))
)
→ cif-arr Δ d τ1 τ2
CIFASnd : ∀{Δ d τ1 τ2} →
Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ]
((d == snd d') ×
(Δ , ∅ ⊢ d' :: τ' ⊗ (τ1 ==> τ2)) ×
(d' indet) ×
(∀{d1 d2} → d' ≠ ⟨ d1 , d2 ⟩) ×
(∀{d'' τ1 τ2 τ3 τ4} → d' ≠ (d'' ⟨ τ1 ⊗ τ2 ⇒ τ3 ⊗ τ4 ⟩))
)
→ cif-arr Δ d τ1 τ2
CIFACast : ∀{d Δ τ1 τ2} →
Σ[ d' ∈ iexp ] Σ[ τ1 ∈ typ ] Σ[ τ2 ∈ typ ] Σ[ τ1' ∈ typ ] Σ[ τ2' ∈ typ ]
((d == d' ⟨ (τ1' ==> τ2') ⇒ (τ1 ==> τ2) ⟩) ×
(Δ , ∅ ⊢ d' :: τ1' ==> τ2') ×
(d' indet) ×
((τ1' ==> τ2') ≠ (τ1 ==> τ2))
)
→ cif-arr Δ d τ1 τ2
CIFACastHole : ∀{d Δ τ1 τ2} →
Σ[ d' ∈ iexp ]
((d == (d' ⟨ ⦇·⦈ ⇒ ⦇·⦈ ==> ⦇·⦈ ⟩)) ×
(τ1 == ⦇·⦈) ×
(τ2 == ⦇·⦈) ×
(Δ , ∅ ⊢ d' :: ⦇·⦈) ×
(d' indet) ×
((d'' : iexp) (τ' : typ) → d' ≠ (d'' ⟨ τ' ⇒ ⦇·⦈ ⟩))
)
→ cif-arr Δ d τ1 τ2
CIFAFailedCast : ∀{d Δ τ1 τ2} →
Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ]
((d == (d' ⟨ τ' ⇒⦇⦈⇏ ⦇·⦈ ==> ⦇·⦈ ⟩) ) ×
(τ1 == ⦇·⦈) ×
(τ2 == ⦇·⦈) ×
(Δ , ∅ ⊢ d' :: τ') ×
(τ' ground) ×
(τ' ≠ (⦇·⦈ ==> ⦇·⦈))
)
→ cif-arr Δ d τ1 τ2
canonical-indeterminate-forms-arr : ∀{Δ d τ1 τ2 } →
Δ , ∅ ⊢ d :: (τ1 ==> τ2) →
d indet →
cif-arr Δ d τ1 τ2
canonical-indeterminate-forms-arr (TAVar x₁) ()
canonical-indeterminate-forms-arr (TALam _ wt) ()
canonical-indeterminate-forms-arr (TAAp wt wt₁) (IAp x ind x₁) = CIFAAp (_ , _ , _ , _ , _ , refl , wt , wt₁ , ind , x₁ , x)
canonical-indeterminate-forms-arr (TAEHole x x₁) IEHole = CIFAEHole (_ , _ , _ , refl , x , x₁)
canonical-indeterminate-forms-arr (TANEHole x wt x₁) (INEHole x₂) = CIFANEHole (_ , _ , _ , _ , _ , refl , wt , x₂ , x , x₁)
canonical-indeterminate-forms-arr (TACast wt x) (ICastArr x₁ ind) = CIFACast (_ , _ , _ , _ , _ , refl , wt , ind , x₁)
canonical-indeterminate-forms-arr (TACast wt TCHole2) (ICastHoleGround x₁ ind GHole) = CIFACastHole (_ , refl , refl , refl , wt , ind , x₁)
canonical-indeterminate-forms-arr (TAFailedCast x x₁ GHole x₃) (IFailedCast x₄ x₅ GHole x₇) = CIFAFailedCast (_ , _ , refl , refl , refl , x , x₅ , x₇)
canonical-indeterminate-forms-arr (TAFst wt) (IFst ind h1 h2) = CIFAFst (_ , _ , refl , wt , ind , h1 , h2)
canonical-indeterminate-forms-arr (TASnd wt) (ISnd ind h1 h2) = CIFASnd (_ , _ , refl , wt , ind , h1 , h2)
-- this type gives somewhat nicer syntax for the output of the canonical
-- forms lemma for indeterminates at hole type
data cif-hole : (Δ : hctx) (d : iexp) → Set where
CIFHEHole : ∀ {Δ d} →
Σ[ u ∈ Nat ] Σ[ σ ∈ env ] Σ[ Γ ∈ tctx ]
((d == ⦇⦈⟨ u , σ ⟩) ×
((u :: ⦇·⦈ [ Γ ]) ∈ Δ) ×
(Δ , ∅ ⊢ σ :s: Γ)
)
→ cif-hole Δ d
CIFHNEHole : ∀ {Δ d} →
Σ[ u ∈ Nat ] Σ[ σ ∈ env ] Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ] Σ[ Γ ∈ tctx ]
((d == ⦇⌜ d' ⌟⦈⟨ u , σ ⟩) ×
(Δ , ∅ ⊢ d' :: τ') ×
(d' final) ×
((u :: ⦇·⦈ [ Γ ]) ∈ Δ) ×
(Δ , ∅ ⊢ σ :s: Γ)
)
→ cif-hole Δ d
CIFHAp : ∀ {Δ d} →
Σ[ d1 ∈ iexp ] Σ[ d2 ∈ iexp ] Σ[ τ2 ∈ typ ]
((d == d1 ∘ d2) ×
(Δ , ∅ ⊢ d1 :: (τ2 ==> ⦇·⦈)) ×
(Δ , ∅ ⊢ d2 :: τ2) ×
(d1 indet) ×
(d2 final) ×
((τ3 τ4 τ3' τ4' : typ) (d1' : iexp) → d1 ≠ (d1' ⟨ τ3 ==> τ4 ⇒ τ3' ==> τ4' ⟩))
)
→ cif-hole Δ d
CIFHFst : ∀{Δ d} →
Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ]
((d == fst d') ×
(Δ , ∅ ⊢ d' :: ⦇·⦈ ⊗ τ') ×
(d' indet) ×
(∀{d1 d2} → d' ≠ ⟨ d1 , d2 ⟩) ×
(∀{d'' τ1 τ2 τ3 τ4} → d' ≠ (d'' ⟨ τ1 ⊗ τ2 ⇒ τ3 ⊗ τ4 ⟩))
)
→ cif-hole Δ d
CIFHSnd : ∀{Δ d} →
Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ]
((d == snd d') ×
(Δ , ∅ ⊢ d' :: τ' ⊗ ⦇·⦈) ×
(d' indet) ×
(∀{d1 d2} → d' ≠ ⟨ d1 , d2 ⟩) ×
(∀{d'' τ1 τ2 τ3 τ4} → d' ≠ (d'' ⟨ τ1 ⊗ τ2 ⇒ τ3 ⊗ τ4 ⟩))
)
→ cif-hole Δ d
CIFHCast : ∀ {Δ d} →
Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ]
((d == d' ⟨ τ' ⇒ ⦇·⦈ ⟩) ×
(Δ , ∅ ⊢ d' :: τ') ×
(τ' ground) ×
(d' indet)
)
→ cif-hole Δ d
canonical-indeterminate-forms-hole : ∀{Δ d} →
Δ , ∅ ⊢ d :: ⦇·⦈ →
d indet →
cif-hole Δ d
canonical-indeterminate-forms-hole (TAVar x₁) ()
canonical-indeterminate-forms-hole (TAAp wt wt₁) (IAp x ind x₁) = CIFHAp (_ , _ , _ , refl , wt , wt₁ , ind , x₁ , x)
canonical-indeterminate-forms-hole (TAEHole x x₁) IEHole = CIFHEHole (_ , _ , _ , refl , x , x₁)
canonical-indeterminate-forms-hole (TANEHole x wt x₁) (INEHole x₂) = CIFHNEHole (_ , _ , _ , _ , _ , refl , wt , x₂ , x , x₁)
canonical-indeterminate-forms-hole (TACast wt x) (ICastGroundHole x₁ ind) = CIFHCast (_ , _ , refl , wt , x₁ , ind)
canonical-indeterminate-forms-hole (TACast wt x) (ICastHoleGround x₁ ind ())
canonical-indeterminate-forms-hole (TAFailedCast x x₁ () x₃) (IFailedCast x₄ x₅ x₆ x₇)
canonical-indeterminate-forms-hole (TAFst wt) (IFst ind h1 h2) = CIFHFst (_ , _ , refl , wt , ind , h1 , h2)
canonical-indeterminate-forms-hole (TASnd wt) (ISnd ind h1 h2) = CIFHSnd (_ , _ , refl , wt , ind , h1 , h2)
-- this type gives somewhat nicer syntax for the output of the canonical
-- forms lemma for indeterminates at product type
data cif-prod : (Δ : hctx) (d : iexp) (τ1 τ2 : typ) → Set where
CIFPEHole : ∀{d Δ τ1 τ2} →
Σ[ u ∈ Nat ] Σ[ σ ∈ env ] Σ[ Γ ∈ tctx ]
((d == ⦇⦈⟨ u , σ ⟩) ×
((u :: (τ1 ⊗ τ2) [ Γ ]) ∈ Δ) ×
(Δ , ∅ ⊢ σ :s: Γ)
)
→ cif-prod Δ d τ1 τ2
CIFPNEHole : ∀{d Δ τ1 τ2} →
Σ[ u ∈ Nat ] Σ[ σ ∈ env ] Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ] Σ[ Γ ∈ tctx ]
((d == ⦇⌜ d' ⌟⦈⟨ u , σ ⟩) ×
(Δ , ∅ ⊢ d' :: τ') ×
(d' final) ×
((u :: (τ1 ⊗ τ2) [ Γ ]) ∈ Δ) ×
(Δ , ∅ ⊢ σ :s: Γ)
)
→ cif-prod Δ d τ1 τ2
CIFPAp : ∀{d Δ τ1 τ2} →
Σ[ d1 ∈ iexp ] Σ[ d2 ∈ iexp ] Σ[ τ2' ∈ typ ] Σ[ τ1 ∈ typ ] Σ[ τ2 ∈ typ ]
((d == d1 ∘ d2) ×
(Δ , ∅ ⊢ d1 :: τ2' ==> (τ1 ⊗ τ2)) ×
(Δ , ∅ ⊢ d2 :: τ2') ×
(d1 indet) ×
(d2 final) ×
((τ3 τ4 τ3' τ4' : typ) (d1' : iexp) → d1 ≠ (d1' ⟨ τ3 ==> τ4 ⇒ τ3' ==> τ4' ⟩))
)
→ cif-prod Δ d τ1 τ2
CIFPFst : ∀{Δ d τ1 τ2} →
Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ]
((d == fst d') ×
(Δ , ∅ ⊢ d' :: (τ1 ⊗ τ2) ⊗ τ') ×
(d' indet) ×
(∀{d1 d2} → d' ≠ ⟨ d1 , d2 ⟩) ×
(∀{d'' τ1 τ2 τ3 τ4} → d' ≠ (d'' ⟨ τ1 ⊗ τ2 ⇒ τ3 ⊗ τ4 ⟩))
)
→ cif-prod Δ d τ1 τ2
CIFPSnd : ∀{Δ d τ1 τ2} →
Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ]
((d == snd d') ×
(Δ , ∅ ⊢ d' :: τ' ⊗ (τ1 ⊗ τ2)) ×
(d' indet) ×
(∀{d1 d2} → d' ≠ ⟨ d1 , d2 ⟩) ×
(∀{d'' τ1 τ2 τ3 τ4} → d' ≠ (d'' ⟨ τ1 ⊗ τ2 ⇒ τ3 ⊗ τ4 ⟩))
)
→ cif-prod Δ d τ1 τ2
CIFPPair1 : ∀{Δ d τ1 τ2} →
Σ[ d1 ∈ iexp ] Σ[ d2 ∈ iexp ]
((d == ⟨ d1 , d2 ⟩) ×
(Δ , ∅ ⊢ d1 :: τ1) ×
(Δ , ∅ ⊢ d2 :: τ2) ×
d1 indet ×
d2 final
)
→ cif-prod Δ d τ1 τ2
CIFPPair2 : ∀{Δ d τ1 τ2} →
Σ[ d1 ∈ iexp ] Σ[ d2 ∈ iexp ]
((d == ⟨ d1 , d2 ⟩) ×
(Δ , ∅ ⊢ d1 :: τ1) ×
(Δ , ∅ ⊢ d2 :: τ2) ×
d1 final ×
d2 indet
)
→ cif-prod Δ d τ1 τ2
CIFPCast : ∀{d Δ τ1 τ2} →
Σ[ d' ∈ iexp ] Σ[ τ1 ∈ typ ] Σ[ τ2 ∈ typ ] Σ[ τ1' ∈ typ ] Σ[ τ2' ∈ typ ]
((d == d' ⟨ (τ1' ⊗ τ2') ⇒ (τ1 ⊗ τ2) ⟩) ×
(Δ , ∅ ⊢ d' :: τ1' ⊗ τ2') ×
(d' indet) ×
((τ1' ⊗ τ2') ≠ (τ1 ⊗ τ2)) ×
((τ1' ⊗ τ2') ~ (τ1 ⊗ τ2))
)
→ cif-prod Δ d τ1 τ2
CIFPCastHole : ∀{d Δ τ1 τ2} →
Σ[ d' ∈ iexp ]
((d == (d' ⟨ ⦇·⦈ ⇒ ⦇·⦈ ⊗ ⦇·⦈ ⟩)) ×
(τ1 == ⦇·⦈) ×
(τ2 == ⦇·⦈) ×
(Δ , ∅ ⊢ d' :: ⦇·⦈) ×
(d' indet) ×
((d'' : iexp) (τ' : typ) → d' ≠ (d'' ⟨ τ' ⇒ ⦇·⦈ ⟩))
)
→ cif-prod Δ d τ1 τ2
CIFPFailedCast : ∀{d Δ τ1 τ2} →
Σ[ d' ∈ iexp ] Σ[ τ' ∈ typ ]
((d == (d' ⟨ τ' ⇒⦇⦈⇏ ⦇·⦈ ⊗ ⦇·⦈ ⟩) ) ×
(τ1 == ⦇·⦈) ×
(τ2 == ⦇·⦈) ×
(Δ , ∅ ⊢ d' :: τ') ×
(τ' ground) ×
(τ' ≠ (⦇·⦈ ⊗ ⦇·⦈) ×
d' final))
→ cif-prod Δ d τ1 τ2
canonical-indeterminate-forms-prod : ∀{Δ d τ1 τ2 } →
Δ , ∅ ⊢ d :: (τ1 ⊗ τ2) →
d indet →
cif-prod Δ d τ1 τ2
canonical-indeterminate-forms-prod (TAVar x₁) ()
canonical-indeterminate-forms-prod (TAAp wt wt₁) (IAp x ind x₁) = CIFPAp (_ , _ , _ , _ , _ , refl , wt , wt₁ , ind , x₁ , x)
canonical-indeterminate-forms-prod (TAEHole x x₁) IEHole = CIFPEHole (_ , _ , _ , refl , x , x₁)
canonical-indeterminate-forms-prod (TANEHole x wt x₁) (INEHole x₂) = CIFPNEHole (_ , _ , _ , _ , _ , refl , wt , x₂ , x , x₁)
canonical-indeterminate-forms-prod (TACast wt x) (ICastProd x₁ ind) = CIFPCast (_ , _ , _ , _ , _ , refl , wt , ind , x₁ , x)
canonical-indeterminate-forms-prod (TACast wt TCHole2) (ICastHoleGround x₁ ind GProd) = CIFPCastHole (_ , refl , refl , refl , wt , ind , x₁)
canonical-indeterminate-forms-prod (TAFailedCast wt x GProd x₂) (IFailedCast x₃ x₄ GProd x₆) = CIFPFailedCast (_ , _ , refl , refl , refl , wt , x₄ , x₆ , x₃)
canonical-indeterminate-forms-prod (TAFst wt) (IFst ind h1 h2) = CIFPFst (_ , _ , refl , wt , ind , h1 , h2)
canonical-indeterminate-forms-prod (TASnd wt) (ISnd ind h1 h2) = CIFPSnd (_ , _ , refl , wt , ind , h1 , h2)
canonical-indeterminate-forms-prod (TAPair wt wt₁) (IPair1 ind x) = CIFPPair1 (_ , _ , refl , wt , wt₁ , ind , x)
canonical-indeterminate-forms-prod (TAPair wt wt₁) (IPair2 x ind) = CIFPPair2 (_ , _ , refl , wt , wt₁ , x , ind)
canonical-indeterminate-forms-coverage : ∀{Δ d τ} →
Δ , ∅ ⊢ d :: τ →
d indet →
τ ≠ b →
((τ1 : typ) (τ2 : typ) → τ ≠ (τ1 ==> τ2)) →
τ ≠ ⦇·⦈ →
((τ1 : typ) (τ2 : typ) → τ ≠ (τ1 ⊗ τ2)) →
⊥
canonical-indeterminate-forms-coverage TAConst () nb na nh
canonical-indeterminate-forms-coverage (TAVar x₁) () nb na nh
canonical-indeterminate-forms-coverage (TALam _ wt) () nb na nh
canonical-indeterminate-forms-coverage {τ = b} (TAAp wt wt₁) (IAp x ind x₁) nb na nh _ = nb refl
canonical-indeterminate-forms-coverage {τ = ⦇·⦈} (TAAp wt wt₁) (IAp x ind x₁) nb na nh _ = nh refl
canonical-indeterminate-forms-coverage {τ = τ ==> τ₁} (TAAp wt wt₁) (IAp x ind x₁) nb na nh _ = na τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = b} (TAEHole x x₁) IEHole nb na nh _ = nb refl
canonical-indeterminate-forms-coverage {τ = ⦇·⦈} (TAEHole x x₁) IEHole nb na nh _ = nh refl
canonical-indeterminate-forms-coverage {τ = τ ==> τ₁} (TAEHole x x₁) IEHole nb na nh _ = na τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = b} (TANEHole x wt x₁) (INEHole x₂) nb na nh _ = nb refl
canonical-indeterminate-forms-coverage {τ = ⦇·⦈} (TANEHole x wt x₁) (INEHole x₂) nb na nh _ = nh refl
canonical-indeterminate-forms-coverage {τ = τ ==> τ₁} (TANEHole x wt x₁) (INEHole x₂) nb na nh _ = na τ τ₁ refl
canonical-indeterminate-forms-coverage (TACast wt x) (ICastArr x₁ ind) nb na nh _ = na _ _ refl
canonical-indeterminate-forms-coverage (TACast wt x) (ICastGroundHole x₁ ind) nb na nh _ = nh refl
canonical-indeterminate-forms-coverage {τ = b} (TACast wt x) (ICastHoleGround x₁ ind x₂) nb na nh _ = nb refl
canonical-indeterminate-forms-coverage {τ = ⦇·⦈} (TACast wt x) (ICastHoleGround x₁ ind x₂) nb na nh _ = nh refl
canonical-indeterminate-forms-coverage {τ = τ ==> τ₁} (TACast wt x) (ICastHoleGround x₁ ind x₂) nb na nh _ = na τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = b} (TAFailedCast x x₁ x₂ x₃) (IFailedCast x₄ x₅ x₆ x₇) z _ _ _ = z refl
canonical-indeterminate-forms-coverage {τ = ⦇·⦈} (TAFailedCast x x₁ x₂ x₃) (IFailedCast x₄ x₅ x₆ x₇) _ _ z _ = z refl
canonical-indeterminate-forms-coverage {τ = τ ==> τ₁} (TAFailedCast x x₁ x₂ x₃) (IFailedCast x₄ x₅ x₆ x₇) _ z _ _ = z τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = b} (TAFst wt) (IFst ind x _) nb na nh np = nb refl
canonical-indeterminate-forms-coverage {τ = b} (TASnd wt) (ISnd ind x _) nb na nh np = nb refl
canonical-indeterminate-forms-coverage {τ = ⦇·⦈} (TAFst wt) (IFst ind x _) nb na nh np = nh refl
canonical-indeterminate-forms-coverage {τ = ⦇·⦈} (TASnd wt) (ISnd ind x _) nb na nh np = nh refl
canonical-indeterminate-forms-coverage {τ = τ ==> τ₁} (TAFst wt) (IFst ind x _) nb na nh np = na τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = τ ==> τ₁} (TASnd wt) (ISnd ind x _) nb na nh np = na τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = τ ⊗ τ₁} (TAAp wt wt₁) (IAp x ind x₁) nb na nh np = np τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = τ ⊗ τ₁} (TAEHole x x₁) IEHole nb na nh np = np τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = τ ⊗ τ₁} (TANEHole x wt x₁) (INEHole x₂) nb na nh np = np τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = τ ⊗ τ₁} (TACast wt x) (ICastProd x₁ ind) nb na nh np = np τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = τ ⊗ τ₁} (TACast wt x) (ICastHoleGround x₁ ind x₂) nb na nh np = np τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = τ ⊗ τ₁} (TAFailedCast wt x x₁ x₂) (IFailedCast x₃ x₄ x₅ x₆) nb na nh np = np τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = τ ⊗ τ₁} (TAFst wt) (IFst ind x _) nb na nh np = np τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = τ ⊗ τ₁} (TASnd wt) (ISnd ind x _) nb na nh np = np τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = τ ⊗ τ₁} (TAPair wt wt₁) (IPair1 ind x) nb na nh np = np τ τ₁ refl
canonical-indeterminate-forms-coverage {τ = τ ⊗ τ₁} (TAPair wt wt₁) (IPair2 x ind) nb na nh np = np τ τ₁ refl
| 46.816377
| 160
| 0.457094
|
11866cc169686b648f7bf25515516114ab57dafa
| 64,420
|
agda
|
Agda
|
Cubical/ZCohomology/RingStructure/GradedCommutativity.agda
|
thomas-lamiaux/cubical
|
58c0b83bb0fed0dc683f3d29b1709effe51c1689
|
[
"MIT"
] | null | null | null |
Cubical/ZCohomology/RingStructure/GradedCommutativity.agda
|
thomas-lamiaux/cubical
|
58c0b83bb0fed0dc683f3d29b1709effe51c1689
|
[
"MIT"
] | null | null | null |
Cubical/ZCohomology/RingStructure/GradedCommutativity.agda
|
thomas-lamiaux/cubical
|
58c0b83bb0fed0dc683f3d29b1709effe51c1689
|
[
"MIT"
] | null | null | null |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.ZCohomology.RingStructure.GradedCommutativity where
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Function
open import Cubical.Foundations.Transport
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Pointed
open import Cubical.Foundations.Pointed.Homogeneous
open import Cubical.Foundations.GroupoidLaws hiding (assoc)
open import Cubical.Foundations.Path
open import Cubical.Data.Empty as ⊥
open import Cubical.Data.Nat
open import Cubical.Data.Int
renaming (_+_ to _ℤ+_ ; _·_ to _ℤ∙_ ; +Comm to +ℤ-comm ; ·Comm to ∙-comm ; +Assoc to ℤ+-assoc ; -_ to -ℤ_)
hiding (_+'_ ; +'≡+)
open import Cubical.Data.Sigma
open import Cubical.Data.Sum
open import Cubical.HITs.SetTruncation as ST
open import Cubical.HITs.Truncation as T
open import Cubical.HITs.S1 hiding (_·_)
open import Cubical.HITs.Sn
open import Cubical.HITs.Susp
open import Cubical.Homotopy.Loopspace
open import Cubical.ZCohomology.Base
open import Cubical.ZCohomology.GroupStructure
open import Cubical.ZCohomology.RingStructure.CupProduct
open import Cubical.ZCohomology.RingStructure.RingLaws
open import Cubical.ZCohomology.Properties
private
variable
ℓ : Level
open PlusBis
natTranspLem : ∀ {ℓ} {A B : ℕ → Type ℓ} {n m : ℕ} (a : A n)
(f : (n : ℕ) → (a : A n) → B n) (p : n ≡ m)
→ f m (subst A p a) ≡ subst B p (f n a)
natTranspLem {A = A} {B = B} a f p = sym (substCommSlice A B f p a)
transp0₁ : (n : ℕ) → subst coHomK (+'-comm 1 (suc n)) (0ₖ _) ≡ 0ₖ _
transp0₁ zero = refl
transp0₁ (suc n) = refl
transp0₂ : (n m : ℕ) → subst coHomK (+'-comm (suc (suc n)) (suc m)) (0ₖ _) ≡ 0ₖ _
transp0₂ n zero = refl
transp0₂ n (suc m) = refl
-- Recurring expressions
private
ΩKn+1→Ω²Kn+2 : {k : ℕ} → typ (Ω (coHomK-ptd k)) → typ ((Ω^ 2) (coHomK-ptd (suc k)))
ΩKn+1→Ω²Kn+2 x = sym (Kn→ΩKn+10ₖ _) ∙∙ cong (Kn→ΩKn+1 _) x ∙∙ Kn→ΩKn+10ₖ _
ΩKn+1→Ω²Kn+2' : {k : ℕ} → Kn→ΩKn+1 k (0ₖ k) ≡ Kn→ΩKn+1 k (0ₖ k) → typ ((Ω^ 2) (coHomK-ptd (suc k)))
ΩKn+1→Ω²Kn+2' p = sym (Kn→ΩKn+10ₖ _) ∙∙ p ∙∙ Kn→ΩKn+10ₖ _
Kn→Ω²Kn+2 : {k : ℕ} → coHomK k → typ ((Ω^ 2) (coHomK-ptd (2 + k)))
Kn→Ω²Kn+2 x = ΩKn+1→Ω²Kn+2 (Kn→ΩKn+1 _ x)
-- Definition of of -ₖ'ⁿ̇*ᵐ
-- This definition is introduced to facilite the proofs
-ₖ'-helper : {k : ℕ} (n m : ℕ)
→ isEvenT n ⊎ isOddT n → isEvenT m ⊎ isOddT m
→ coHomKType k → coHomKType k
-ₖ'-helper {k = zero} n m (inl x₁) q x = x
-ₖ'-helper {k = zero} n m (inr x₁) (inl x₂) x = x
-ₖ'-helper {k = zero} n m (inr x₁) (inr x₂) x = 0 - x
-ₖ'-helper {k = suc zero} n m p q base = base
-ₖ'-helper {k = suc zero} n m (inl x) q (loop i) = loop i
-ₖ'-helper {k = suc zero} n m (inr x) (inl x₁) (loop i) = loop i
-ₖ'-helper {k = suc zero} n m (inr x) (inr x₁) (loop i) = loop (~ i)
-ₖ'-helper {k = suc (suc k)} n m p q north = north
-ₖ'-helper {k = suc (suc k)} n m p q south = north
-ₖ'-helper {k = suc (suc k)} n m (inl x) q (merid a i) =
(merid a ∙ sym (merid (ptSn (suc k)))) i
-ₖ'-helper {k = suc (suc k)} n m (inr x) (inl x₁) (merid a i) =
(merid a ∙ sym (merid (ptSn (suc k)))) i
-ₖ'-helper {k = suc (suc k)} n m (inr x) (inr x₁) (merid a i) =
(merid a ∙ sym (merid (ptSn (suc k)))) (~ i)
-ₖ'-gen : {k : ℕ} (n m : ℕ)
(p : isEvenT n ⊎ isOddT n)
(q : isEvenT m ⊎ isOddT m)
→ coHomK k → coHomK k
-ₖ'-gen {k = zero} = -ₖ'-helper {k = zero}
-ₖ'-gen {k = suc k} n m p q = T.map (-ₖ'-helper {k = suc k} n m p q)
-- -ₖ'ⁿ̇*ᵐ
-ₖ'^_·_ : {k : ℕ} (n m : ℕ) → coHomK k → coHomK k
-ₖ'^_·_ {k = k} n m = -ₖ'-gen n m (evenOrOdd n) (evenOrOdd m)
-- cohomology version
-ₕ'^_·_ : {k : ℕ} {A : Type ℓ} (n m : ℕ) → coHom k A → coHom k A
-ₕ'^_·_ n m = ST.map λ f x → (-ₖ'^ n · m) (f x)
-- -ₖ'ⁿ̇*ᵐ = -ₖ' for n m odd
-ₖ'-gen-inr≡-ₖ' : {k : ℕ} (n m : ℕ) (p : _) (q : _) (x : coHomK k)
→ -ₖ'-gen n m (inr p) (inr q) x ≡ (-ₖ x)
-ₖ'-gen-inr≡-ₖ' {k = zero} n m p q _ = refl
-ₖ'-gen-inr≡-ₖ' {k = suc zero} n m p q =
T.elim ((λ _ → isOfHLevelTruncPath))
λ { base → refl
; (loop i) → refl}
-ₖ'-gen-inr≡-ₖ' {k = suc (suc k)} n m p q =
T.elim ((λ _ → isOfHLevelTruncPath))
λ { north → refl
; south → refl
; (merid a i) k → ∣ symDistr (merid (ptSn _)) (sym (merid a)) (~ k) (~ i) ∣ₕ}
-- -ₖ'ⁿ̇*ᵐ x = x for n even
-ₖ'-gen-inl-left : {k : ℕ} (n m : ℕ) (p : _) (q : _) (x : coHomK k)
→ -ₖ'-gen n m (inl p) q x ≡ x
-ₖ'-gen-inl-left {k = zero} n m p q x = refl
-ₖ'-gen-inl-left {k = suc zero} n m p q =
T.elim (λ _ → isOfHLevelTruncPath)
λ { base → refl ; (loop i) → refl}
-ₖ'-gen-inl-left {k = suc (suc k)} n m p q =
T.elim (λ _ → isOfHLevelPath (4 + k) (isOfHLevelTrunc (4 + k)) _ _)
λ { north → refl
; south → cong ∣_∣ₕ (merid (ptSn _))
; (merid a i) k → ∣ compPath-filler (merid a) (sym (merid (ptSn _))) (~ k) i ∣ₕ}
-- -ₖ'ⁿ̇*ᵐ x = x for m even
-ₖ'-gen-inl-right : {k : ℕ} (n m : ℕ) (p : _) (q : _) (x : coHomK k)
→ -ₖ'-gen n m p (inl q) x ≡ x
-ₖ'-gen-inl-right {k = zero} n m (inl x₁) q x = refl
-ₖ'-gen-inl-right {k = zero} n m (inr x₁) q x = refl
-ₖ'-gen-inl-right {k = suc zero} n m (inl x₁) q =
T.elim (λ _ → isOfHLevelTruncPath)
λ { base → refl ; (loop i) → refl}
-ₖ'-gen-inl-right {k = suc zero} n m (inr x₁) q =
T.elim (λ _ → isOfHLevelTruncPath)
λ { base → refl ; (loop i) → refl}
-ₖ'-gen-inl-right {k = suc (suc k)} n m (inl x₁) q =
T.elim (λ _ → isOfHLevelTruncPath)
λ { north → refl
; south → cong ∣_∣ₕ (merid (ptSn _))
; (merid a i) k → ∣ compPath-filler (merid a) (sym (merid (ptSn _))) (~ k) i ∣ₕ}
-ₖ'-gen-inl-right {k = suc (suc k)} n m (inr x₁) q =
T.elim (λ _ → isOfHLevelTruncPath)
λ { north → refl
; south → cong ∣_∣ₕ (merid (ptSn _))
; (merid a i) k → ∣ compPath-filler (merid a) (sym (merid (ptSn _))) (~ k) i ∣ₕ}
-ₖ'-gen² : {k : ℕ} (n m : ℕ)
(p : isEvenT n ⊎ isOddT n)
(q : isEvenT m ⊎ isOddT m)
→ (x : coHomK k) → -ₖ'-gen n m p q (-ₖ'-gen n m p q x) ≡ x
-ₖ'-gen² {k = zero} n m (inl x₁) q x = refl
-ₖ'-gen² {k = zero} n m (inr x₁) (inl x₂) x = refl
-ₖ'-gen² {k = zero} n m (inr x₁) (inr x₂) x =
cong (pos 0 -_) (-AntiComm (pos 0) x)
∙∙ -AntiComm (pos 0) (-ℤ (x - pos 0))
∙∙ h x
where
h : (x : _) → -ℤ (-ℤ (x - pos 0) - pos 0) ≡ x
h (pos zero) = refl
h (pos (suc n)) = refl
h (negsuc n) = refl
-ₖ'-gen² {k = suc k} n m (inl x₁) q x i =
-ₖ'-gen-inl-left n m x₁ q (-ₖ'-gen-inl-left n m x₁ q x i) i
-ₖ'-gen² {k = suc k} n m (inr x₁) (inl x₂) x i =
-ₖ'-gen-inl-right n m (inr x₁) x₂ (-ₖ'-gen-inl-right n m (inr x₁) x₂ x i) i
-ₖ'-gen² {k = suc k} n m (inr x₁) (inr x₂) x =
(λ i → -ₖ'-gen-inr≡-ₖ' n m x₁ x₂ (-ₖ'-gen-inr≡-ₖ' n m x₁ x₂ x i) i) ∙ -ₖ^2 x
-ₖ'-genIso : {k : ℕ} (n m : ℕ)
(p : isEvenT n ⊎ isOddT n)
(q : isEvenT m ⊎ isOddT m)
→ Iso (coHomK k) (coHomK k)
Iso.fun (-ₖ'-genIso {k = k} n m p q) = -ₖ'-gen n m p q
Iso.inv (-ₖ'-genIso {k = k} n m p q) = -ₖ'-gen n m p q
Iso.rightInv (-ₖ'-genIso {k = k} n m p q) = -ₖ'-gen² n m p q
Iso.leftInv (-ₖ'-genIso {k = k} n m p q) = -ₖ'-gen² n m p q
-- action of cong on -ₖ'ⁿ̇*ᵐ
cong-ₖ'-gen-inr : {k : ℕ} (n m : ℕ) (p : _) (q : _) (P : Path (coHomK (2 + k)) (0ₖ _) (0ₖ _))
→ cong (-ₖ'-gen n m (inr p) (inr q)) P ≡ sym P
cong-ₖ'-gen-inr {k = k} n m p q P = code≡sym (0ₖ _) P
where
code : (x : coHomK (2 + k)) → 0ₖ _ ≡ x → x ≡ 0ₖ _
code = T.elim (λ _ → isOfHLevelΠ (4 + k) λ _ → isOfHLevelTruncPath)
λ { north → cong (-ₖ'-gen n m (inr p) (inr q))
; south P → cong ∣_∣ₕ (sym (merid (ptSn _))) ∙ (cong (-ₖ'-gen n m (inr p) (inr q)) P)
; (merid a i) → t a i}
where
t : (a : S₊ (suc k)) → PathP (λ i → 0ₖ (2 + k) ≡ ∣ merid a i ∣ₕ → ∣ merid a i ∣ₕ ≡ 0ₖ (2 + k))
(cong (-ₖ'-gen n m (inr p) (inr q)))
(λ P → cong ∣_∣ₕ (sym (merid (ptSn _))) ∙ (cong (-ₖ'-gen n m (inr p) (inr q)) P))
t a = toPathP (funExt λ P → cong (transport (λ i → ∣ merid a i ∣ ≡ 0ₖ (suc (suc k))))
(cong (cong (-ₖ'-gen n m (inr p) (inr q))) (λ i → (transp (λ j → 0ₖ (suc (suc k)) ≡ ∣ merid a (~ j ∧ ~ i) ∣) i
(compPath-filler P (λ j → ∣ merid a (~ j) ∣ₕ) i))))
∙∙ cong (transport (λ i → ∣ merid a i ∣ ≡ 0ₖ (suc (suc k)))) (congFunct (-ₖ'-gen n m (inr p) (inr q)) P (sym (cong ∣_∣ₕ (merid a))))
∙∙ (λ j → transp (λ i → ∣ merid a (i ∨ j) ∣ ≡ 0ₖ (suc (suc k))) j
(compPath-filler' (cong ∣_∣ₕ (sym (merid a)))
(cong (-ₖ'-gen n m (inr p) (inr q)) P
∙ cong (-ₖ'-gen n m (inr p) (inr q)) (sym (cong ∣_∣ₕ (merid a)))) j))
∙∙ (λ i → sym (cong ∣_∣ₕ (merid a))
∙ isCommΩK (2 + k) (cong (-ₖ'-gen n m (inr p) (inr q)) P)
(cong (-ₖ'-gen n m (inr p) (inr q)) (sym (cong ∣_∣ₕ (merid a)))) i)
∙∙ (λ j → (λ i → ∣ merid a (~ i ∨ j) ∣)
∙ (cong ∣_∣ₕ (compPath-filler' (merid a) (sym (merid (ptSn _))) (~ j)) ∙ (λ i → -ₖ'-gen n m (inr p) (inr q) (P i))))
∙ sym (lUnit _))
code≡sym : (x : coHomK (2 + k)) → (p : 0ₖ _ ≡ x) → code x p ≡ sym p
code≡sym x = J (λ x p → code x p ≡ sym p) refl
cong-cong-ₖ'-gen-inr : {k : ℕ} (n m : ℕ) (p : _) (q : _)
(P : Square (refl {x = 0ₖ (suc (suc k))}) refl refl refl)
→ cong (cong (-ₖ'-gen n m (inr p) (inr q))) P ≡ sym P
cong-cong-ₖ'-gen-inr n m p q P =
rUnit _
∙∙ (λ k → (λ i → cong-ₖ'-gen-inr n m p q refl (i ∧ k))
∙∙ (λ i → cong-ₖ'-gen-inr n m p q (P i) k)
∙∙ λ i → cong-ₖ'-gen-inr n m p q refl (~ i ∧ k))
∙∙ (λ k → transportRefl refl k
∙∙ cong sym P
∙∙ transportRefl refl k)
∙∙ sym (rUnit (cong sym P))
∙∙ sym (sym≡cong-sym P)
Kn→ΩKn+1-ₖ'' : {k : ℕ} (n m : ℕ) (p : _) (q : _) (x : coHomK k)
→ Kn→ΩKn+1 k (-ₖ'-gen n m (inr p) (inr q) x) ≡ sym (Kn→ΩKn+1 k x)
Kn→ΩKn+1-ₖ'' n m p q x = cong (Kn→ΩKn+1 _) (-ₖ'-gen-inr≡-ₖ' n m p q x) ∙ Kn→ΩKn+1-ₖ _ x
transpΩ² : {n m : ℕ} (p q : n ≡ m) → (P : _)
→ transport (λ i → refl {x = 0ₖ (p i)} ≡ refl {x = 0ₖ (p i)}) P
≡ transport (λ i → refl {x = 0ₖ (q i)} ≡ refl {x = 0ₖ (q i)}) P
transpΩ² p q P k = subst (λ n → refl {x = 0ₖ n} ≡ refl {x = 0ₖ n}) (isSetℕ _ _ p q k) P
-- Some technical lemmas about Kn→Ω²Kn+2 and its interaction with -ₖ'ⁿ̇*ᵐ and transports
-- TODO : Check if this can be cleaned up more by having more general lemmas
private
lem₁ : (n : ℕ) (a : _)
→ (cong (cong (subst coHomK (+'-comm (suc zero) (suc (suc n)))))
(Kn→Ω²Kn+2 ∣ a ∣ₕ))
≡ ΩKn+1→Ω²Kn+2
(sym (transp0₁ n) ∙∙ cong (subst coHomK (+'-comm (suc zero) (suc n))) (Kn→ΩKn+1 (suc n) ∣ a ∣ₕ) ∙∙ transp0₁ n)
lem₁ zero a =
(λ k i j → transportRefl (Kn→Ω²Kn+2 ∣ a ∣ₕ i j) k)
∙ cong ΩKn+1→Ω²Kn+2 λ k → rUnit (λ i → transportRefl (Kn→ΩKn+1 1 ∣ a ∣ i) (~ k)) k
lem₁ (suc n) a =
(λ k → transp (λ i → refl {x = 0ₖ (+'-comm 1 (suc (suc (suc n))) (i ∨ ~ k))}
≡ refl {x = 0ₖ (+'-comm 1 (suc (suc (suc n))) (i ∨ ~ k))}) (~ k)
(λ i j → transp (λ i → coHomK (+'-comm 1 (suc (suc (suc n))) (i ∧ ~ k))) k
(Kn→Ω²Kn+2 ∣ a ∣ₕ i j)))
∙∙ transpΩ² (+'-comm 1 (suc (suc (suc n))))
(cong suc (+'-comm (suc zero) (suc (suc n))))
(Kn→Ω²Kn+2 ∣ a ∣ₕ)
∙∙ sym (natTranspLem {A = λ n → 0ₖ n ≡ 0ₖ n}
(Kn→ΩKn+1 (suc (suc n)) ∣ a ∣)
(λ _ → ΩKn+1→Ω²Kn+2)
(+'-comm 1 (suc (suc n))))
∙∙ cong ΩKn+1→Ω²Kn+2
(λ k → transp (λ i → 0ₖ (+'-comm (suc zero) (suc (suc n)) (i ∨ k))
≡ 0ₖ (+'-comm (suc zero) (suc (suc n)) (i ∨ k))) k
(λ i → transp (λ i → coHomK (+'-comm (suc zero) (suc (suc n)) (i ∧ k))) (~ k)
(Kn→ΩKn+1 _ ∣ a ∣ₕ i)))
∙∙ cong ΩKn+1→Ω²Kn+2 (rUnit (cong (subst coHomK (+'-comm (suc zero) (suc (suc n))))
(Kn→ΩKn+1 (suc (suc n)) ∣ a ∣ₕ)))
lem₂ : (n : ℕ) (a : _) (p : _) (q : _)
→ (cong (cong (-ₖ'-gen (suc (suc n)) (suc zero) p q
∘ (subst coHomK (+'-comm 1 (suc (suc n))))))
(Kn→Ω²Kn+2 (∣ a ∣ₕ)))
≡ ΩKn+1→Ω²Kn+2
(sym (transp0₁ n)
∙∙ cong (subst coHomK (+'-comm (suc zero) (suc n)))
(cong (-ₖ'-gen (suc (suc n)) (suc zero) p q)
(Kn→ΩKn+1 (suc n) ∣ a ∣ₕ))
∙∙ transp0₁ n)
lem₂ n a (inl x) (inr y) =
(λ k i j → (-ₖ'-gen-inl-left (suc (suc n)) 1 x (inr y) (
subst coHomK (+'-comm 1 (suc (suc n)))
(Kn→Ω²Kn+2 ∣ a ∣ₕ i j))) k)
∙∙ lem₁ n a
∙∙ cong ΩKn+1→Ω²Kn+2 (cong (sym (transp0₁ n) ∙∙_∙∙ transp0₁ n)
λ k i → subst coHomK (+'-comm 1 (suc n))
(-ₖ'-gen-inl-left (suc (suc n)) 1 x (inr y) (Kn→ΩKn+1 (suc n) ∣ a ∣ i) (~ k)))
lem₂ n a (inr x) (inr y) =
cong-cong-ₖ'-gen-inr (suc (suc n)) 1 x y
(cong
(cong
(subst coHomK (+'-comm 1 (suc (suc n)))))
(Kn→Ω²Kn+2 ∣ a ∣ₕ))
∙∙ cong sym (lem₁ n a)
∙∙ λ k → ΩKn+1→Ω²Kn+2
(sym (transp0₁ n) ∙∙
cong (subst coHomK (+'-comm 1 (suc n)))
(cong-ₖ'-gen-inr (suc (suc n)) 1 x y
(Kn→ΩKn+1 (suc n) ∣ a ∣) (~ k))
∙∙ transp0₁ n)
lem₃ : (n m : ℕ) (q : _) (p : isEvenT (suc (suc n)) ⊎ isOddT (suc (suc n))) (x : _)
→ (((sym (cong (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q) (transp0₂ m n))
∙∙ (λ j → -ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q
(subst coHomK (+'-comm (suc (suc m)) (suc n)) (Kn→ΩKn+1 _ x j)))
∙∙ cong (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q) (transp0₂ m n))))
≡ (Kn→ΩKn+1 _ (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q
(subst coHomK (cong suc (+-comm (suc m) n)) x)))
lem₃ n m q p x =
sym (cong-∙∙ (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q) (sym (transp0₂ m n))
(λ j → subst coHomK (+'-comm (suc (suc m)) (suc n)) (Kn→ΩKn+1 _ x j))
(transp0₂ m n))
∙ h n m p q x
where
help : (n m : ℕ) (x : _)
→ ((sym (transp0₂ m n))
∙∙ (λ j → subst coHomK (+'-comm (suc (suc m)) (suc n))
(Kn→ΩKn+1 (suc (suc (m + n))) x j))
∙∙ transp0₂ m n)
≡ Kn→ΩKn+1 (suc (n + suc m))
(subst coHomK (cong suc (+-comm (suc m) n)) x)
help zero m x =
sym (rUnit _)
∙∙ (λ k i → transp (λ i → coHomK (+'-comm (suc (suc m)) 1 (i ∨ k))) k
(Kn→ΩKn+1 _
(transp (λ i → coHomK (predℕ (+'-comm (suc (suc m)) 1 (i ∧ k)))) (~ k) x) i))
∙∙ cong (Kn→ΩKn+1 _)
λ k → subst coHomK (isSetℕ _ _ (cong predℕ (+'-comm (suc (suc m)) 1))
(cong suc (+-comm (suc m) zero)) k) x
help (suc n) m x =
sym (rUnit _)
∙∙ ((λ k i → transp (λ i → coHomK (+'-comm (suc (suc m)) (suc (suc n)) (i ∨ k))) k
(Kn→ΩKn+1 _
(transp (λ i → coHomK (predℕ (+'-comm (suc (suc m)) (suc (suc n)) (i ∧ k)))) (~ k) x) i)))
∙∙ cong (Kn→ΩKn+1 _)
(λ k → subst coHomK (isSetℕ _ _ (cong predℕ (+'-comm (suc (suc m)) (suc (suc n))))
(cong suc (+-comm (suc m) (suc n))) k) x)
h : (n m : ℕ) (p : isEvenT (suc (suc n)) ⊎ isOddT (suc (suc n))) (q : _) (x : _)
→ cong (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q)
(sym (transp0₂ m n)
∙∙ (λ j → subst coHomK (+'-comm (suc (suc m)) (suc n))
(Kn→ΩKn+1 (suc (suc (m + n))) x j))
∙∙ transp0₂ m n)
≡ Kn→ΩKn+1 (suc (n + suc m))
(-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q
(subst coHomK (cong suc (+-comm (suc m) n)) x))
h n m (inl p) (inl q) x =
(λ k → cong (-ₖ'-gen (suc n) (suc (suc m))
(isPropEvenOrOdd (suc n) (evenOrOdd (suc n)) (inr p) k) (inl q))
(help n m x k))
∙∙ ((λ k i → -ₖ'-gen-inl-right (suc n) (suc (suc m)) (inr p) q (help n m x i1 i) k))
∙∙ λ i → Kn→ΩKn+1 (suc (n + suc m))
(-ₖ'-gen-inl-right (suc n) (suc (suc m)) (isPropEvenOrOdd (suc n) (inr p) (evenOrOdd (suc n)) i) q
(subst coHomK (cong suc (+-comm (suc m) n)) x) (~ i))
h n m (inl p) (inr q) x =
(λ k → cong (-ₖ'-gen (suc n) (suc (suc m)) (isPropEvenOrOdd (suc n) (evenOrOdd (suc n)) (inr p) k) (inr q))
(help n m x k))
∙∙ cong-ₖ'-gen-inr (suc n) (suc (suc m)) p q (help n m x i1)
∙∙ sym (Kn→ΩKn+1-ₖ'' (suc n) (suc (suc m)) p q
(subst coHomK (λ i → suc (+-comm (suc m) n i)) x))
∙ λ k → Kn→ΩKn+1 (suc (n + suc m))
(-ₖ'-gen (suc n) (suc (suc m)) (isPropEvenOrOdd (suc n) (inr p) (evenOrOdd (suc n)) k) (inr q)
(subst coHomK (cong suc (+-comm (suc m) n)) x))
h n m (inr p) (inl q) x =
(λ k → cong (-ₖ'-gen (suc n) (suc (suc m)) (isPropEvenOrOdd (suc n) (evenOrOdd (suc n)) (inl p) k) (inl q))
(help n m x k))
∙∙ (λ k i → -ₖ'-gen-inl-left (suc n) (suc (suc m)) p (inl q) (help n m x i1 i) k)
∙∙ λ k → Kn→ΩKn+1 (suc (n + suc m))
(-ₖ'-gen-inl-right (suc n) (suc (suc m)) (evenOrOdd (suc n)) q
(subst coHomK (cong suc (+-comm (suc m) n)) x) (~ k))
h n m (inr p) (inr q) x =
(λ k → cong (-ₖ'-gen (suc n) (suc (suc m)) (isPropEvenOrOdd (suc n) (evenOrOdd (suc n)) (inl p) k) (inr q))
(help n m x k))
∙∙ (λ k i → -ₖ'-gen-inl-left (suc n) (suc (suc m)) p (inr q) (help n m x i1 i) k)
∙∙ cong (Kn→ΩKn+1 (suc (n + suc m)))
(sym (-ₖ'-gen-inl-left (suc n) (suc (suc m)) p (inr q)
(subst coHomK (λ i → suc (+-comm (suc m) n i)) x)))
∙ λ k → Kn→ΩKn+1 (suc (n + suc m))
(-ₖ'-gen (suc n) (suc (suc m)) (isPropEvenOrOdd (suc n) (inl p) (evenOrOdd (suc n)) k) (inr q)
(subst coHomK (cong suc (+-comm (suc m) n)) x))
lem₄ : (n m : ℕ) (q : _) (p : isEvenT (suc (suc n)) ⊎ isOddT (suc (suc n))) (a : _) (b : _)
→ cong (Kn→ΩKn+1 _) (((sym (cong (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q) (transp0₂ m n))
∙∙ (λ j → -ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q
(subst coHomK (+'-comm (suc (suc m)) (suc n))
(_⌣ₖ_ {n = suc (suc m)} {m = (suc n)} ∣ merid b j ∣ₕ ∣ a ∣)))
∙∙ cong (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q) (transp0₂ m n))))
≡ cong (Kn→ΩKn+1 _) (Kn→ΩKn+1 _ (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q
(subst coHomK (cong suc (+-comm (suc m) n))
(_⌣ₖ_ {n = suc m} {m = (suc n)} ∣ b ∣ₕ ∣ a ∣))))
lem₄ n m q p a b = cong (cong (Kn→ΩKn+1 _)) (lem₃ n m q p (_⌣ₖ_ {n = suc m} {m = (suc n)} ∣ b ∣ₕ ∣ a ∣))
lem₅ : (n m : ℕ) (p : _) (q : _) (a : _) (b : _)
→ cong (cong (-ₖ'-gen (suc (suc n)) (suc (suc m)) p q
∘ (subst coHomK (+'-comm (suc (suc m)) (suc (suc n))))))
(ΩKn+1→Ω²Kn+2 (sym (cong (-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p) (transp0₂ n m))
∙∙ (λ i → -ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p
(subst coHomK (+'-comm (suc (suc n)) (suc m))
(_⌣ₖ_ {n = suc (suc n)} {m = suc m} ∣ merid a i ∣ₕ ∣ b ∣ₕ)))
∙∙ cong (-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p) (transp0₂ n m)))
≡ Kn→Ω²Kn+2 (-ₖ'-gen (suc (suc n)) (suc (suc m)) p q
(-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p
(subst coHomK (cong suc (sym (+-suc n m))) (_⌣ₖ_ {n = suc n} {m = suc m} ∣ a ∣ₕ ∣ b ∣ₕ))))
lem₅ n m p q a b =
cong (cong (cong (-ₖ'-gen (suc (suc n)) (suc (suc m)) p q
∘ (subst coHomK (+'-comm (suc (suc m)) (suc (suc n)))))))
(cong (sym (Kn→ΩKn+10ₖ _) ∙∙_∙∙ Kn→ΩKn+10ₖ _)
(lem₄ m n p q b a))
∙ help p q (_⌣ₖ_ {n = suc n} {m = suc m} ∣ a ∣ ∣ b ∣)
where
annoying : (x : _)
→ cong (cong (subst coHomK (+'-comm (suc (suc m)) (suc (suc n)))))
(Kn→Ω²Kn+2 (subst coHomK (cong suc (+-comm (suc n) m)) x))
≡ Kn→Ω²Kn+2 (subst coHomK (cong suc (sym (+-suc n m))) x)
annoying x =
((λ k → transp (λ i → refl {x = 0ₖ ((+'-comm (suc (suc m)) (suc (suc n))) (i ∨ ~ k))}
≡ refl {x = 0ₖ ((+'-comm (suc (suc m)) (suc (suc n))) (i ∨ ~ k))}) (~ k)
λ i j → transp (λ i → coHomK (+'-comm (suc (suc m)) (suc (suc n)) (i ∧ ~ k))) k
(Kn→Ω²Kn+2 (subst coHomK (cong suc (+-comm (suc n) m)) x) i j)))
∙∙ cong (transport (λ i → refl {x = 0ₖ ((+'-comm (suc (suc m)) (suc (suc n))) i)}
≡ refl {x = 0ₖ ((+'-comm (suc (suc m)) (suc (suc n))) i)}))
(natTranspLem {A = coHomK} x (λ _ → Kn→Ω²Kn+2) (cong suc (+-comm (suc n) m)))
∙∙ sym (substComposite (λ n → refl {x = 0ₖ n} ≡ refl {x = 0ₖ n})
(cong (suc ∘ suc ∘ suc) (+-comm (suc n) m)) (+'-comm (suc (suc m)) (suc (suc n)))
(Kn→Ω²Kn+2 x))
∙∙ (λ k → subst (λ n → refl {x = 0ₖ n} ≡ refl {x = 0ₖ n})
(isSetℕ _ _
(cong (suc ∘ suc ∘ suc) (+-comm (suc n) m) ∙ (+'-comm (suc (suc m)) (suc (suc n))))
(cong (suc ∘ suc ∘ suc) (sym (+-suc n m))) k)
(Kn→Ω²Kn+2 x))
∙∙ sym (natTranspLem {A = coHomK} x (λ _ → Kn→Ω²Kn+2) (cong suc (sym (+-suc n m))))
help : (p : _) (q : _) (x : _) →
cong (cong (-ₖ'-gen (suc (suc n)) (suc (suc m)) p q
∘ subst coHomK (+'-comm (suc (suc m)) (suc (suc n)))))
(Kn→Ω²Kn+2 (-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p
(subst coHomK (cong suc (+-comm (suc n) m)) x)))
≡ Kn→Ω²Kn+2
(-ₖ'-gen (suc (suc n)) (suc (suc m)) p q
(-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p
(subst coHomK (cong suc (sym (+-suc n m))) x)))
help (inl x) (inl y) z =
(λ k i j →
-ₖ'-gen-inl-right (suc (suc n)) (suc (suc m)) (inl x) y
(subst coHomK (+'-comm (suc (suc m)) (suc (suc n)))
((ΩKn+1→Ω²Kn+2
(Kn→ΩKn+1 _ (-ₖ'-gen-inl-right (suc m) (suc (suc n)) (evenOrOdd (suc m)) x
(subst coHomK (cong suc (+-comm (suc n) m)) z) k))) i j)) k)
∙∙ annoying z
∙∙ cong Kn→Ω²Kn+2
λ k → (-ₖ'-gen-inl-right (suc (suc n)) (suc (suc m)) (inl x) y
(-ₖ'-gen-inl-right (suc m) (suc (suc n)) (evenOrOdd (suc m)) x
(subst coHomK (cong suc (sym (+-suc n m))) z) (~ k)) (~ k))
help (inl x) (inr y) z =
(λ k i j →
-ₖ'-gen-inl-left (suc (suc n)) (suc (suc m)) x (inr y)
(subst coHomK (+'-comm (suc (suc m)) (suc (suc n)))
(Kn→Ω²Kn+2 (-ₖ'-gen-inl-right (suc m) (suc (suc n)) (evenOrOdd (suc m)) x
(subst coHomK (cong suc (+-comm (suc n) m)) z) k) i j)) k)
∙∙ annoying z
∙∙ cong Kn→Ω²Kn+2
(λ k → (-ₖ'-gen-inl-left (suc (suc n)) (suc (suc m)) x (inr y)
(-ₖ'-gen-inl-right (suc m) (suc (suc n)) (evenOrOdd (suc m)) x
(subst coHomK (cong suc (sym (+-suc n m))) z) (~ k)) (~ k)))
help (inr x) (inl y) z =
(λ k i j → -ₖ'-gen-inl-right (suc (suc n)) (suc (suc m)) (inr x) y
(subst coHomK (+'-comm (suc (suc m)) (suc (suc n)))
(Kn→Ω²Kn+2
(-ₖ'-gen (suc m) (suc (suc n)) (isPropEvenOrOdd (suc m) (evenOrOdd (suc m)) (inr y) k) (inr x)
(subst coHomK (cong suc (+-comm (suc n) m)) z)) i j)) k)
∙∙ cong (cong (cong (subst coHomK (+'-comm (suc (suc m)) (suc (suc n))))) ∘ ΩKn+1→Ω²Kn+2)
(Kn→ΩKn+1-ₖ'' (suc m) (suc (suc n)) y x
(subst coHomK (cong suc (+-comm (suc n) m)) z))
∙∙ cong sym (annoying z)
∙∙ cong ΩKn+1→Ω²Kn+2 (sym (Kn→ΩKn+1-ₖ'' (suc m) (suc (suc n)) y x
(subst coHomK (cong suc (sym (+-suc n m))) z)))
∙∙ cong Kn→Ω²Kn+2 λ k → (-ₖ'-gen-inl-right (suc (suc n)) (suc (suc m)) (inr x) y
(-ₖ'-gen (suc m) (suc (suc n)) (isPropEvenOrOdd (suc m) (evenOrOdd (suc m)) (inr y) (~ k)) (inr x)
(subst coHomK (cong suc (sym (+-suc n m))) z)) (~ k))
help (inr x) (inr y) z =
(λ k → cong-cong-ₖ'-gen-inr (suc (suc n)) (suc (suc m)) x y
(λ i j → subst coHomK (+'-comm (suc (suc m)) (suc (suc n)))
(Kn→Ω²Kn+2
(-ₖ'-gen (suc m) (suc (suc n))
(isPropEvenOrOdd (suc m) (evenOrOdd (suc m)) (inl y) k) (inr x)
(subst coHomK (cong suc (+-comm (suc n) m)) z)) i j)) k)
∙∙ cong (sym ∘ cong (cong (subst coHomK (+'-comm (suc (suc m)) (suc (suc n))))) ∘ Kn→Ω²Kn+2)
(-ₖ'-gen-inl-left (suc m) (suc (suc n)) y (inr x)
(subst coHomK (cong suc (+-comm (suc n) m)) z))
∙∙ cong sym (annoying z)
∙∙ cong (sym ∘ Kn→Ω²Kn+2)
(sym (-ₖ'-gen-inl-left (suc m) (suc (suc n)) y (inr x)
(subst coHomK (cong suc (sym (+-suc n m))) z)))
∙∙ cong ΩKn+1→Ω²Kn+2
λ k → (Kn→ΩKn+1-ₖ'' (suc (suc n)) (suc (suc m)) x y
(-ₖ'-gen (suc m) (suc (suc n)) (
isPropEvenOrOdd (suc m) (evenOrOdd (suc m)) (inl y) (~ k)) (inr x)
(subst coHomK (cong suc (sym (+-suc n m))) z))) (~ k)
lem₆ : (n m : ℕ) (p : _) (q : _) (a : _) (b : _)
→ flipSquare
(Kn→Ω²Kn+2 (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q
(subst coHomK (cong suc (+-comm (suc m) n))
(_⌣ₖ_ {n = suc m} {m = (suc n)} ∣ b ∣ₕ ∣ a ∣))))
≡ Kn→Ω²Kn+2
(-ₖ'-gen (suc (suc n)) (suc (suc m)) p q
(-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p
(subst coHomK (cong suc (sym (+-suc n m)))
(-ₖ'-gen (suc n) (suc m) (evenOrOdd (suc n)) (evenOrOdd (suc m))
(subst coHomK (+'-comm (suc m) (suc n)) (∣ b ∣ₕ ⌣ₖ ∣ a ∣ₕ))))))
lem₆ n m p q a b =
sym (sym≡flipSquare (Kn→Ω²Kn+2 (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q
(subst coHomK (cong suc (+-comm (suc m) n))
(_⌣ₖ_ {n = suc m} {m = (suc n)} ∣ b ∣ₕ ∣ a ∣)))))
∙ cong ΩKn+1→Ω²Kn+2
(help₁
(subst coHomK (cong suc (+-comm (suc m) n))
(_⌣ₖ_ {n = suc m} {m = (suc n)} ∣ b ∣ ∣ a ∣)) p q
∙ cong (Kn→ΩKn+1 _) (sym (help₂ (∣ b ∣ ⌣ₖ ∣ a ∣))))
where
help₁ : (x : _) (p : _) (q : _)
→ sym (Kn→ΩKn+1 (suc (n + suc m)) (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q x))
≡ Kn→ΩKn+1 (suc (n + suc m)) ((-ₖ'-gen (suc (suc n)) (suc (suc m)) p q
(-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p
(-ₖ'-gen (suc n) (suc m) (evenOrOdd (suc n)) (evenOrOdd (suc m)) x))))
help₁ z (inl x) (inl y) =
cong (λ x → sym (Kn→ΩKn+1 (suc (n + suc m)) x))
(-ₖ'-gen-inl-right (suc n) (suc (suc m)) (evenOrOdd (suc n)) y z)
∙∙ sym (Kn→ΩKn+1-ₖ'' (suc n) (suc m) x y z)
∙∙ λ k → Kn→ΩKn+1 (suc (n + suc m))
(-ₖ'-gen-inl-right (suc (suc n)) (suc (suc m)) (inl x) y
(-ₖ'-gen-inl-right (suc m) (suc (suc n)) (evenOrOdd (suc m)) x
(-ₖ'-gen (suc n) (suc m)
(isPropEvenOrOdd (suc n) (inr x) (evenOrOdd (suc n)) k)
(isPropEvenOrOdd (suc m) (inr y) (evenOrOdd (suc m)) k) z) (~ k)) (~ k))
help₁ z (inl x) (inr y) =
(λ k → sym (Kn→ΩKn+1 (suc (n + suc m))
(-ₖ'-gen (suc n) (suc (suc m))
(isPropEvenOrOdd (suc n) (evenOrOdd (suc n)) (inr x) k) (inr y) z)))
∙∙ cong sym (Kn→ΩKn+1-ₖ'' (suc n) (suc (suc m)) x y z)
∙∙ cong (Kn→ΩKn+1 (suc (n + suc m))) (sym (-ₖ'-gen-inl-right (suc n) (suc m) (inr x) y z))
∙ λ k → Kn→ΩKn+1 (suc (n + suc m))
(-ₖ'-gen-inl-left (suc (suc n)) (suc (suc m)) x (inr y)
(-ₖ'-gen-inl-right (suc m) (suc (suc n)) (evenOrOdd (suc m)) x
(-ₖ'-gen (suc n) (suc m)
(isPropEvenOrOdd (suc n) (inr x) (evenOrOdd (suc n)) k)
(isPropEvenOrOdd (suc m) (inl y) (evenOrOdd (suc m)) k) z) (~ k)) (~ k))
help₁ z (inr x) (inl y) =
cong (λ x → sym (Kn→ΩKn+1 (suc (n + suc m)) x))
(-ₖ'-gen-inl-right (suc n) (suc (suc m)) (evenOrOdd (suc n)) y z)
∙∙ (λ k → Kn→ΩKn+1-ₖ'' (suc m) (suc (suc n)) y x
(-ₖ'-gen-inl-left (suc n) (suc m) x (inr y) z (~ k)) (~ k))
∙∙ λ k → Kn→ΩKn+1 (suc (n + suc m))
(-ₖ'-gen-inl-right (suc (suc n)) (suc (suc m)) (inr x) y
(-ₖ'-gen (suc m) (suc (suc n))
(isPropEvenOrOdd (suc m) (inr y) (evenOrOdd (suc m)) k) (inr x)
(-ₖ'-gen (suc n) (suc m)
(isPropEvenOrOdd (suc n) (inl x) (evenOrOdd (suc n)) k)
(isPropEvenOrOdd (suc m) (inr y) (evenOrOdd (suc m)) k) z)) (~ k))
help₁ z (inr x) (inr y) =
((λ k → sym (Kn→ΩKn+1 (suc (n + suc m))
(-ₖ'-gen (suc n) (suc (suc m))
(isPropEvenOrOdd (suc n) (evenOrOdd (suc n)) (inl x) k) (inr y) z))))
∙∙ cong sym (cong (Kn→ΩKn+1 (suc (n + suc m))) (-ₖ'-gen-inl-left (suc n) (suc (suc m)) x (inr y) z))
∙∙ (λ k → sym (Kn→ΩKn+1 (suc (n + suc m))
(-ₖ'-gen-inl-left (suc m) (suc (suc n)) y (inr x)
(-ₖ'-gen-inl-right (suc n) (suc m) (inl x) y z (~ k)) (~ k))))
∙ λ k → Kn→ΩKn+1-ₖ'' (suc (suc n)) (suc (suc m)) x y
(-ₖ'-gen (suc m) (suc (suc n)) (isPropEvenOrOdd (suc m) (inl y) (evenOrOdd (suc m)) k) (inr x)
(-ₖ'-gen (suc n) (suc m)
(isPropEvenOrOdd (suc n) (inl x) (evenOrOdd (suc n)) k)
(isPropEvenOrOdd (suc m) (inl y) (evenOrOdd (suc m)) k) z)) (~ k)
help₂ : (x : _) →
(-ₖ'-gen (suc (suc n)) (suc (suc m)) p q
(-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p
(subst coHomK (cong suc (sym (+-suc n m)))
(-ₖ'-gen (suc n) (suc m) (evenOrOdd (suc n)) (evenOrOdd (suc m))
(subst coHomK (+'-comm (suc m) (suc n)) x)))))
≡ -ₖ'-gen (suc (suc n)) (suc (suc m)) p q
(-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p
(-ₖ'-gen (suc n) (suc m) (evenOrOdd (suc n)) (evenOrOdd (suc m))
(subst coHomK (cong suc (+-comm (suc m) n)) x)))
help₂ x =
(λ k → -ₖ'-gen (suc (suc n)) (suc (suc m)) p q
(-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p
(transp (λ i → coHomK ((cong suc (sym (+-suc n m))) (i ∨ k))) k
(-ₖ'-gen (suc n) (suc m) (evenOrOdd (suc n)) (evenOrOdd (suc m))
(transp (λ i → coHomK ((cong suc (sym (+-suc n m))) (i ∧ k))) (~ k)
(subst coHomK (+'-comm (suc m) (suc n)) x))))))
∙ cong (-ₖ'-gen (suc (suc n)) (suc (suc m)) p q
∘ -ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p
∘ -ₖ'-gen (suc n) (suc m) (evenOrOdd (suc n)) (evenOrOdd (suc m)))
(sym (substComposite coHomK (+'-comm (suc m) (suc n)) ((cong suc (sym (+-suc n m)))) x)
∙ λ k → subst coHomK (isSetℕ _ _ (+'-comm (suc m) (suc n) ∙ cong suc (sym (+-suc n m)))
((cong suc (+-comm (suc m) n))) k) x)
lem₇ : (n : ℕ) (a : _) (p : _) (q : _)
→ ((λ i → Kn→ΩKn+1 _ (-ₖ'-gen (suc n) (suc zero) (evenOrOdd (suc n)) (inr tt)
(transp0₁ n (~ i))))
∙∙ (λ i j → Kn→ΩKn+1 _ (-ₖ'-gen (suc n) (suc zero) (evenOrOdd (suc n)) (inr tt)
(subst coHomK (+'-comm (suc zero) (suc n)) (Kn→ΩKn+1 (suc n) ∣ a ∣ₕ i))) j)
∙∙ (λ i → Kn→ΩKn+1 _ (-ₖ'-gen (suc n) (suc zero) (evenOrOdd (suc n)) (inr tt)
(transp0₁ n i))))
≡ (cong (Kn→ΩKn+1 (suc (suc (n + zero))))
(sym (transp0₁ n)
∙∙ sym (cong (subst coHomK (+'-comm (suc zero) (suc n)))
(cong (-ₖ'-gen (suc (suc n)) (suc zero) p q) (Kn→ΩKn+1 (suc n) ∣ a ∣ₕ)))
∙∙ transp0₁ n))
lem₇ zero a (inl x) (inr tt) =
(λ k → rUnit ((cong (Kn→ΩKn+1 _) (cong-ₖ'-gen-inr (suc zero) (suc zero) tt tt
(λ i → (subst coHomK (+'-comm (suc zero) (suc zero))
(Kn→ΩKn+1 (suc zero) ∣ a ∣ₕ i))) k))) (~ k))
∙ λ k → ((cong (Kn→ΩKn+1 (suc (suc zero)))
(rUnit (λ i → subst coHomK (+'-comm (suc zero) (suc zero))
(-ₖ'-gen-inl-left (suc (suc zero)) (suc zero) tt (inr tt)
(Kn→ΩKn+1 (suc zero) ∣ a ∣ₕ (~ i)) (~ k))) k)))
lem₇ (suc n) a (inl x) (inr tt) =
((λ k → rUnit (cong (Kn→ΩKn+1 _)
(λ i → -ₖ'-gen (suc (suc n)) (suc zero)
(isPropEvenOrOdd n (evenOrOdd (suc (suc n))) (inr x) k) (inr tt)
(subst coHomK (+'-comm (suc zero) (suc (suc n)))
(Kn→ΩKn+1 (suc (suc n)) ∣ a ∣ₕ i)))) (~ k)))
∙∙ (((λ k → ((cong (Kn→ΩKn+1 _) (cong-ₖ'-gen-inr (suc (suc n)) (suc zero) x tt
(λ i → (subst coHomK (+'-comm (suc zero) (suc (suc n)))
(Kn→ΩKn+1 (suc (suc n)) ∣ a ∣ₕ i))) k))))))
∙∙ λ k → ((cong (Kn→ΩKn+1 (suc (suc (suc n + zero))))
(rUnit (λ i → subst coHomK (+'-comm (suc zero) (suc (suc n)))
(-ₖ'-gen-inl-left (suc (suc (suc n))) (suc zero) x (inr tt)
(Kn→ΩKn+1 (suc (suc n)) ∣ a ∣ₕ (~ i)) (~ k))) k)))
lem₇ (suc n) a (inr x) (inr tt) =
(λ k → rUnit (λ i j → Kn→ΩKn+1 _
(-ₖ'-gen (suc (suc n)) (suc zero)
(isPropEvenOrOdd (suc (suc n)) (evenOrOdd (suc (suc n))) (inl x) k) (inr tt)
(subst coHomK (+'-comm (suc zero) (suc (suc n)))
(Kn→ΩKn+1 (suc (suc n)) ∣ a ∣ₕ i))) j) (~ k))
∙∙ (λ k i j → Kn→ΩKn+1 _ (-ₖ'-gen-inl-left (suc (suc n)) (suc zero) x (inr tt)
(subst coHomK (+'-comm (suc zero) (suc (suc n)))
(Kn→ΩKn+1 (suc (suc n)) ∣ a ∣ₕ i)) k) j)
∙∙ λ k → cong (Kn→ΩKn+1 _)
(rUnit (sym (cong (subst coHomK (+'-comm (suc zero) (suc (suc n))))
(cong-ₖ'-gen-inr (suc (suc (suc n))) (suc zero) x tt (Kn→ΩKn+1 (suc (suc n)) ∣ a ∣ₕ) (~ k)))) k)
-- ∣ a ∣ ⌣ₖ ∣ b ∣ ≡ -ₖ'ⁿ*ᵐ (∣ b ∣ ⌣ₖ ∣ a ∣) for n ≥ 1, m = 1
gradedComm'-elimCase-left : (n : ℕ) (p : _) (q : _) (a : S₊ (suc n)) (b : S¹) →
(_⌣ₖ_ {n = suc n} {m = (suc zero)} ∣ a ∣ₕ ∣ b ∣ₕ)
≡ (-ₖ'-gen (suc n) (suc zero) p q)
(subst coHomK (+'-comm (suc zero) (suc n))
(_⌣ₖ_ {n = suc zero} {m = suc n} ∣ b ∣ₕ ∣ a ∣ₕ))
gradedComm'-elimCase-left zero (inr tt) (inr tt) a b =
proof a b
∙ cong (-ₖ'-gen 1 1 (inr tt) (inr tt))
(sym (transportRefl ((_⌣ₖ_ {n = suc zero} {m = suc zero} ∣ b ∣ ∣ a ∣))))
where
help : flipSquare (ΩKn+1→Ω²Kn+2' (λ j i → _⌣ₖ_ {n = suc zero} {m = suc zero} ∣ loop i ∣ₕ ∣ loop j ∣ₕ)) ≡
cong (cong (-ₖ'-gen 1 1 (inr tt) (inr tt)))
(ΩKn+1→Ω²Kn+2' (λ i j → _⌣ₖ_ {n = suc zero} {m = suc zero} ∣ loop j ∣ₕ ∣ loop i ∣ₕ))
help = sym (sym≡flipSquare _)
∙ sym (cong-cong-ₖ'-gen-inr 1 1 tt tt
(ΩKn+1→Ω²Kn+2' (λ i j → _⌣ₖ_ {n = suc zero} {m = suc zero} ∣ loop j ∣ ∣ loop i ∣)))
proof : (a b : S¹) → _⌣ₖ_ {n = suc zero} {m = suc zero} ∣ a ∣ₕ ∣ b ∣ₕ ≡
-ₖ'-gen 1 1 (inr tt) (inr tt) (_⌣ₖ_ {n = suc zero} {m = suc zero} ∣ b ∣ ∣ a ∣)
proof base base = refl
proof base (loop i) k = -ₖ'-gen 1 1 (inr tt) (inr tt) (Kn→ΩKn+10ₖ _ (~ k) i)
proof (loop i) base k = Kn→ΩKn+10ₖ _ k i
proof (loop i) (loop j) k =
hcomp (λ r → λ { (i = i0) → -ₖ'-gen 1 1 (inr tt) (inr tt) (Kn→ΩKn+10ₖ _ (~ k ∨ ~ r) j)
; (i = i1) → -ₖ'-gen 1 1 (inr tt) (inr tt) (Kn→ΩKn+10ₖ _ (~ k ∨ ~ r) j)
; (j = i0) → Kn→ΩKn+10ₖ _ (k ∨ ~ r) i
; (j = i1) → Kn→ΩKn+10ₖ _ (k ∨ ~ r) i
; (k = i0) → doubleCompPath-filler
(sym (Kn→ΩKn+10ₖ _))
(λ j i → _⌣ₖ_ {n = suc zero} {m = suc zero} ∣ loop i ∣ₕ ∣ loop j ∣ₕ)
(Kn→ΩKn+10ₖ _) (~ r) j i
; (k = i1) → (-ₖ'-gen 1 1 (inr tt) (inr tt)
(doubleCompPath-filler
(sym (Kn→ΩKn+10ₖ _))
(λ i j → _⌣ₖ_ {n = suc zero} {m = suc zero} ∣ loop j ∣ₕ ∣ loop i ∣ₕ)
(Kn→ΩKn+10ₖ _) (~ r) i j))})
(help k i j)
gradedComm'-elimCase-left (suc n) p q north b =
cong (-ₖ'-gen (suc (suc n)) 1 p q ∘
(subst coHomK (+'-comm 1 (suc (suc n)))))
(sym (⌣ₖ-0ₖ _ (suc (suc n)) ∣ b ∣ₕ))
gradedComm'-elimCase-left (suc n) p q south b =
cong (-ₖ'-gen (suc (suc n)) 1 p q ∘
(subst coHomK (+'-comm 1 (suc (suc n)))))
((sym (⌣ₖ-0ₖ _ (suc (suc n)) ∣ b ∣ₕ)) ∙ λ i → ∣ b ∣ ⌣ₖ ∣ merid (ptSn (suc n)) i ∣ₕ)
gradedComm'-elimCase-left (suc n) p q (merid a i) base k =
hcomp (λ j → λ {(i = i0) → (-ₖ'-gen (suc (suc n)) 1 p q ∘
(subst coHomK (+'-comm 1 (suc (suc n)))))
(0ₖ _)
; (i = i1) → (-ₖ'-gen (suc (suc n)) 1 p q ∘
(subst coHomK (+'-comm 1 (suc (suc n)))))
(compPath-filler (sym (⌣ₖ-0ₖ _ (suc (suc n)) ∣ base ∣ₕ))
(λ i → ∣ base ∣ ⌣ₖ ∣ merid a i ∣ₕ) j k)
; (k = i0) → _⌣ₖ_ {n = suc (suc n)} {m = suc zero} ∣ merid a i ∣ₕ ∣ base ∣ₕ
; (k = i1) → -ₖ'-gen (suc (suc n)) 1 p q
(subst coHomK (+'-comm 1 (suc (suc n)))
(∣ base ∣ₕ ⌣ₖ ∣ merid a i ∣ₕ))})
(hcomp (λ j → λ {(i = i0) → ∣ north ∣
; (i = i1) → ∣ north ∣
; (k = i0) → (sym (Kn→ΩKn+10ₖ _)
∙ (λ j → Kn→ΩKn+1 _
(sym (gradedComm'-elimCase-left n (evenOrOdd (suc n)) (inr tt) a base
∙ cong (-ₖ'-gen (suc n) 1 (evenOrOdd (suc n)) (inr tt)) (transp0₁ n)) j))) j i
; (k = i1) → ∣ north ∣})
∣ north ∣)
gradedComm'-elimCase-left (suc n) p q (merid a i) (loop j) k =
hcomp (λ r →
λ { (i = i0) → (-ₖ'-gen (suc (suc n)) 1 p q ∘
(subst coHomK (+'-comm 1 (suc (suc n)))))
(sym (⌣ₖ-0ₖ _ (suc (suc n)) ∣ (loop j) ∣ₕ) k)
; (i = i1) → (-ₖ'-gen (suc (suc n)) 1 p q ∘
(subst coHomK (+'-comm 1 (suc (suc n)))))
(compPath-filler (sym (⌣ₖ-0ₖ _ (suc (suc n)) ∣ (loop j) ∣ₕ))
(λ i → ∣ loop j ∣ ⌣ₖ ∣ merid (ptSn (suc n)) i ∣ₕ) r k)
; (k = i0) → _⌣ₖ_ {n = suc (suc n)} {m = suc zero} ∣ merid a i ∣ₕ ∣ loop j ∣ₕ
; (k = i1) → -ₖ'-gen (suc (suc n)) 1 p q
(subst coHomK (+'-comm 1 (suc (suc n)))
(_⌣ₖ_ {n = suc zero} {m = suc (suc n)} ∣ loop j ∣ₕ
∣ compPath-filler (merid a) (sym (merid (ptSn (suc n)))) (~ r) i ∣ₕ))})
(hcomp (λ r →
λ { (i = i0) → (-ₖ'-gen (suc (suc n)) 1 p q ∘
(subst coHomK (+'-comm 1 (suc (suc n)))))
∣ rCancel (merid (ptSn (suc (suc n)))) (~ k ∧ r) j ∣
; (i = i1) → (-ₖ'-gen (suc (suc n)) 1 p q ∘
(subst coHomK (+'-comm 1 (suc (suc n)))))
∣ rCancel (merid (ptSn (suc (suc n)))) (~ k ∧ r) j ∣
; (k = i0) → help₂ r i j
; (k = i1) → -ₖ'-gen (suc (suc n)) 1 p q
(subst coHomK (+'-comm 1 (suc (suc n)))
(_⌣ₖ_ {n = suc zero} {m = suc (suc n)} ∣ loop j ∣ₕ
(Kn→ΩKn+1 _ ∣ a ∣ₕ i)))})
(-ₖ'-gen (suc (suc n)) 1 p q
(subst coHomK (+'-comm 1 (suc (suc n)))
(_⌣ₖ_ {n = suc zero} {m = suc (suc n)} ∣ loop j ∣ₕ
(Kn→ΩKn+1 _ ∣ a ∣ₕ i)))))
where
P : Path _ (Kn→ΩKn+1 (suc (suc (n + 0))) (0ₖ _))
(Kn→ΩKn+1 (suc (suc (n + 0))) (_⌣ₖ_ {n = (suc n)} {m = suc zero} ∣ a ∣ ∣ base ∣))
P i = Kn→ΩKn+1 (suc (suc (n + 0)))
((sym (gradedComm'-elimCase-left n (evenOrOdd (suc n)) (inr tt) a base
∙ cong (-ₖ'-gen (suc n) 1 (evenOrOdd (suc n)) (inr tt)) (transp0₁ n)) i))
help₁ : (P ∙∙ ((λ i j → _⌣ₖ_ {n = suc (suc n)} {m = suc zero} ∣ merid a j ∣ₕ ∣ loop i ∣ₕ)) ∙∙ sym P)
≡ ((λ i → Kn→ΩKn+1 _ (-ₖ'-gen (suc n) 1 (evenOrOdd (suc n)) (inr tt)
(transp0₁ n (~ i))))
∙∙ (λ i j → Kn→ΩKn+1 _ (-ₖ'-gen (suc n) 1 (evenOrOdd (suc n)) (inr tt)
(subst coHomK (+'-comm 1 (suc n)) (∣ loop i ∣ₕ ⌣ₖ ∣ a ∣ₕ))) j)
∙∙ (λ i → Kn→ΩKn+1 _ (-ₖ'-gen (suc n) 1 (evenOrOdd (suc n)) (inr tt)
(transp0₁ n i))))
help₁ k i j =
((λ i → (Kn→ΩKn+1 (suc (suc (n + 0))))
(compPath-filler'
((gradedComm'-elimCase-left n (evenOrOdd (suc n)) (inr tt) a base))
(cong (-ₖ'-gen (suc n) 1 (evenOrOdd (suc n)) (inr tt))
(transp0₁ n)) (~ k) (~ i)))
∙∙ (λ i j → (Kn→ΩKn+1 _
(gradedComm'-elimCase-left n (evenOrOdd (suc n)) (inr tt) a (loop i) k) j))
∙∙ λ i → (Kn→ΩKn+1 (suc (suc (n + 0))))
(compPath-filler'
((gradedComm'-elimCase-left n (evenOrOdd (suc n)) (inr tt) a base))
(cong (-ₖ'-gen (suc n) 1 (evenOrOdd (suc n)) (inr tt))
(transp0₁ n)) (~ k) i)) i j
help₂ : I → I → I → coHomK _
help₂ r i j =
hcomp (λ k →
λ { (i = i0) → (-ₖ'-gen (suc (suc n)) 1 p q ∘
subst coHomK (+'-comm 1 (suc (suc n))))
∣ rCancel (merid (ptSn (suc (suc n)))) (~ k ∨ r) j ∣
; (i = i1) → (-ₖ'-gen (suc (suc n)) 1 p q ∘
subst coHomK (+'-comm 1 (suc (suc n))))
∣ rCancel (merid (ptSn (suc (suc n)))) (~ k ∨ r) j ∣
; (j = i0) → compPath-filler (sym (Kn→ΩKn+10ₖ (suc (suc (n + 0)))))
P k r i
; (j = i1) → compPath-filler (sym (Kn→ΩKn+10ₖ (suc (suc (n + 0)))))
P k r i
; (r = i0) → -ₖ'-gen (suc (suc n)) 1 p q
(subst coHomK (+'-comm 1 (suc (suc n)))
(doubleCompPath-filler (sym (Kn→ΩKn+10ₖ _))
(λ i j → _⌣ₖ_ {n = suc zero} {m = suc (suc n)} ∣ loop j ∣ₕ
(Kn→ΩKn+1 (suc n) ∣ a ∣ₕ i)) (Kn→ΩKn+10ₖ _) (~ k) i j))
; (r = i1) → doubleCompPath-filler P
(λ i j → _⌣ₖ_ {n = suc (suc n)} {m = suc zero} ∣ merid a j ∣ₕ ∣ loop i ∣ₕ)
(sym P) (~ k) j i})
(hcomp (λ k →
λ { (i = i0) → ∣ north ∣
; (i = i1) → ∣ north ∣
; (j = i0) → (Kn→ΩKn+10ₖ (suc (suc (n + 0)))) (~ r) i
; (j = i1) → (Kn→ΩKn+10ₖ (suc (suc (n + 0)))) (~ r) i
; (r = i0) → lem₂ n a p q (~ k) i j
; (r = i1) → help₁ (~ k) j i})
(hcomp (λ k →
λ { (i = i0) → ∣ north ∣
; (i = i1) → ∣ north ∣
; (j = i0) → Kn→ΩKn+10ₖ (suc (suc (n + 0))) (~ r) i
; (j = i1) → Kn→ΩKn+10ₖ (suc (suc (n + 0))) (~ r) i
; (r = i0) → flipSquare≡cong-sym (flipSquare (ΩKn+1→Ω²Kn+2
(sym (transp0₁ n)
∙∙ cong (subst coHomK (+'-comm 1 (suc n)))
(cong (-ₖ'-gen (suc (suc n)) 1 p q)
(Kn→ΩKn+1 (suc n) ∣ a ∣ₕ))
∙∙ transp0₁ n))) (~ k) i j
; (r = i1) → ((λ i → Kn→ΩKn+1 _ (-ₖ'-gen (suc n) 1 (evenOrOdd (suc n)) (inr tt)
(transp0₁ n (~ i))))
∙∙ (λ i j → Kn→ΩKn+1 _ (-ₖ'-gen (suc n) 1 (evenOrOdd (suc n)) (inr tt)
(subst coHomK (+'-comm 1 (suc n)) (Kn→ΩKn+1 (suc n) ∣ a ∣ₕ i))) j)
∙∙ (λ i → Kn→ΩKn+1 _ (-ₖ'-gen (suc n) 1 (evenOrOdd (suc n)) (inr tt)
(transp0₁ n i)))) j i})
(hcomp (λ k →
λ { (i = i0) → ∣ north ∣
; (i = i1) → ∣ north ∣
; (j = i0) → Kn→ΩKn+10ₖ (suc (suc (n + 0))) (~ r ∧ k) i
; (j = i1) → Kn→ΩKn+10ₖ (suc (suc (n + 0))) (~ r ∧ k) i
; (r = i0) → doubleCompPath-filler
(sym (Kn→ΩKn+10ₖ _))
(cong (Kn→ΩKn+1 (suc (suc (n + 0))))
(sym (transp0₁ n)
∙∙ sym (cong (subst coHomK (+'-comm 1 (suc n)))
(cong (-ₖ'-gen (suc (suc n)) 1 p q)
(Kn→ΩKn+1 (suc n) ∣ a ∣ₕ)))
∙∙ transp0₁ n))
(Kn→ΩKn+10ₖ _) k j i
; (r = i1) → lem₇ n a p q (~ k) j i})
(lem₇ n a p q i1 j i))))
-- ∣ a ∣ ⌣ₖ ∣ b ∣ ≡ -ₖ'ⁿ*ᵐ (∣ b ∣ ⌣ₖ ∣ a ∣) for all n, m ≥ 1
gradedComm'-elimCase : (k n m : ℕ) (term : n + m ≡ k) (p : _) (q : _) (a : _) (b : _) →
(_⌣ₖ_ {n = suc n} {m = (suc m)} ∣ a ∣ₕ ∣ b ∣ₕ)
≡ (-ₖ'-gen (suc n) (suc m) p q)
(subst coHomK (+'-comm (suc m) (suc n))
(_⌣ₖ_ {n = suc m} {m = suc n} ∣ b ∣ₕ ∣ a ∣ₕ))
gradedComm'-elimCase k zero zero term p q a b = gradedComm'-elimCase-left zero p q a b
gradedComm'-elimCase k zero (suc m) term (inr tt) q a b =
help q
∙ sym (cong (-ₖ'-gen 1 (suc (suc m)) (inr tt) q
∘ (subst coHomK (+'-comm (suc (suc m)) 1)))
(gradedComm'-elimCase-left (suc m) q (inr tt) b a))
where
help : (q : _) → ∣ a ∣ₕ ⌣ₖ ∣ b ∣ₕ ≡
-ₖ'-gen 1 (suc (suc m)) (inr tt) q
(subst coHomK (+'-comm (suc (suc m)) 1)
(-ₖ'-gen (suc (suc m)) 1 q (inr tt)
(subst coHomK (+'-comm 1 (suc (suc m))) (∣ a ∣ₕ ⌣ₖ ∣ b ∣ₕ))))
help (inl x) =
(sym (transportRefl _)
∙ (λ i → subst coHomK (isSetℕ _ _ refl (+'-comm 1 (suc (suc m)) ∙ +'-comm (suc (suc m)) 1) i)
(∣ a ∣ₕ ⌣ₖ ∣ b ∣ₕ)))
∙∙ substComposite coHomK
(+'-comm 1 (suc (suc m)))
(+'-comm (suc (suc m)) 1)
((∣ a ∣ₕ ⌣ₖ ∣ b ∣ₕ))
∙∙ λ i → -ₖ'-gen-inl-right (suc zero) (suc (suc m)) (inr tt) x
((subst coHomK (+'-comm (suc (suc m)) 1)
(-ₖ'-gen-inl-left (suc (suc m)) 1 x (inr tt)
(subst coHomK (+'-comm 1 (suc (suc m))) (∣ a ∣ₕ ⌣ₖ ∣ b ∣ₕ)) (~ i)))) (~ i)
help (inr x) =
(sym (transportRefl _)
∙∙ (λ k → subst coHomK (isSetℕ _ _ refl (+'-comm 1 (suc (suc m)) ∙ +'-comm (suc (suc m)) 1) k) (∣ a ∣ₕ ⌣ₖ ∣ b ∣ₕ))
∙∙ sym (-ₖ^2 (subst coHomK (+'-comm 1 (suc (suc m)) ∙ +'-comm (suc (suc m)) 1) (∣ a ∣ₕ ⌣ₖ ∣ b ∣ₕ))))
∙∙ (λ i → -ₖ'-gen-inr≡-ₖ' 1 (suc (suc m)) tt x
(-ₖ'-gen-inr≡-ₖ' (suc (suc m)) 1 x tt
(substComposite coHomK (+'-comm 1 (suc (suc m))) (+'-comm (suc (suc m)) 1) (∣ a ∣ₕ ⌣ₖ ∣ b ∣ₕ) i)
(~ i)) (~ i))
∙∙ λ i → (-ₖ'-gen 1 (suc (suc m)) (inr tt) (inr x)
(transp (λ j → coHomK ((+'-comm (suc (suc m)) 1) (j ∨ ~ i))) (~ i)
(-ₖ'-gen (suc (suc m)) 1 (inr x) (inr tt)
(transp (λ j → coHomK ((+'-comm (suc (suc m)) 1) (j ∧ ~ i))) i
((subst coHomK (+'-comm 1 (suc (suc m))) (∣ a ∣ₕ ⌣ₖ ∣ b ∣ₕ)))))))
gradedComm'-elimCase k (suc n) zero term p q a b =
gradedComm'-elimCase-left (suc n) p q a b
gradedComm'-elimCase zero (suc n) (suc m) term p q a b =
⊥.rec (snotz (sym (+-suc n m) ∙ cong predℕ term))
gradedComm'-elimCase (suc zero) (suc n) (suc m) term p q a b =
⊥.rec (snotz (sym (+-suc n m) ∙ cong predℕ term))
gradedComm'-elimCase (suc (suc k)) (suc n) (suc m) term p q north north = refl
gradedComm'-elimCase (suc (suc k)) (suc n) (suc m) term p q north south = refl
gradedComm'-elimCase (suc (suc k)) (suc n) (suc m) term p q north (merid a i) r =
-ₖ'-gen (suc (suc n)) (suc (suc m)) p q (
(subst coHomK (+'-comm (suc (suc m)) (suc (suc n))))
((sym (Kn→ΩKn+10ₖ _)
∙ cong (Kn→ΩKn+1 _)
(cong (-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p) (sym (transp0₂ n m))
∙ sym (gradedComm'-elimCase (suc k) m (suc n) (+-suc m n ∙ +-comm (suc m) n ∙ cong predℕ term)
(evenOrOdd (suc m)) p a north))) r i))
gradedComm'-elimCase (suc (suc k)) (suc n) (suc m) term p q south north = refl
gradedComm'-elimCase (suc (suc k)) (suc n) (suc m) term p q south south = refl
gradedComm'-elimCase (suc (suc k)) (suc n) (suc m) term p q south (merid a i) r =
-ₖ'-gen (suc (suc n)) (suc (suc m)) p q (
(subst coHomK (+'-comm (suc (suc m)) (suc (suc n))))
((sym (Kn→ΩKn+10ₖ _)
∙ cong (Kn→ΩKn+1 _)
(cong (-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p) (sym (transp0₂ n m))
∙ sym (gradedComm'-elimCase (suc k) m (suc n) (+-suc m n ∙ +-comm (suc m) n ∙ cong predℕ term)
(evenOrOdd (suc m)) p a south))) r i))
gradedComm'-elimCase (suc (suc k)) (suc n) (suc m) term p q (merid a i) north r =
(cong (Kn→ΩKn+1 (suc (suc (n + suc m))))
(gradedComm'-elimCase (suc k) n (suc m) (cong predℕ term) (evenOrOdd (suc n)) q a north
∙ cong (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q) (transp0₂ m n))
∙' Kn→ΩKn+10ₖ _) r i
gradedComm'-elimCase (suc (suc k)) (suc n) (suc m) term p q (merid a i) south r =
(cong (Kn→ΩKn+1 (suc (suc (n + suc m))))
(gradedComm'-elimCase (suc k) n (suc m) (cong predℕ term) (evenOrOdd (suc n)) q a south
∙ cong (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q) (transp0₂ m n))
∙' Kn→ΩKn+10ₖ _) r i
gradedComm'-elimCase (suc (suc k)) (suc n) (suc m) term p q (merid a i) (merid b j) r =
hcomp (λ l →
λ { (i = i0) → -ₖ'-gen (suc (suc n)) (suc (suc m)) p q (
(subst coHomK (+'-comm (suc (suc m)) (suc (suc n))))
((compPath-filler (sym (Kn→ΩKn+10ₖ _))
(cong (Kn→ΩKn+1 _)
(cong (-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p) (sym (transp0₂ n m))
∙ sym (gradedComm'-elimCase (suc k) m (suc n) (+-suc m n ∙ +-comm (suc m) n ∙ cong predℕ term)
(evenOrOdd (suc m)) p b north))) l r j)))
; (i = i1) → -ₖ'-gen (suc (suc n)) (suc (suc m)) p q (
(subst coHomK (+'-comm (suc (suc m)) (suc (suc n))))
((compPath-filler (sym (Kn→ΩKn+10ₖ _))
(cong (Kn→ΩKn+1 _)
(cong (-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p) (sym (transp0₂ n m))
∙ sym (gradedComm'-elimCase (suc k) m (suc n) (+-suc m n ∙ +-comm (suc m) n ∙ cong predℕ term)
(evenOrOdd (suc m)) p b south))) l r j)))
; (r = i0) → help₂ l i j
; (r = i1) → -ₖ'-gen (suc (suc n)) (suc (suc m)) p q
(subst coHomK (+'-comm (suc (suc m)) (suc (suc n)))
(help₁ l i j))})
(hcomp (λ l →
λ { (i = i0) → -ₖ'-gen (suc (suc n)) (suc (suc m)) p q
(subst coHomK (+'-comm (suc (suc m)) (suc (suc n)))
(Kn→ΩKn+10ₖ _ (~ r ∨ ~ l) j))
; (i = i1) → -ₖ'-gen (suc (suc n)) (suc (suc m)) p q
(subst coHomK (+'-comm (suc (suc m)) (suc (suc n)))
(Kn→ΩKn+10ₖ _ (~ r ∨ ~ l) j))
; (j = i0) → Kn→ΩKn+10ₖ _ r i
; (j = i1) → Kn→ΩKn+10ₖ _ r i
; (r = i0) → lem₄ n m q p a b (~ l) j i
; (r = i1) → -ₖ'-gen (suc (suc n)) (suc (suc m)) p q
(subst coHomK (+'-comm (suc (suc m)) (suc (suc n)))
(doubleCompPath-filler
(sym (Kn→ΩKn+10ₖ _))
(λ i j → Kn→ΩKn+1 _ ((sym (cong (-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p) (transp0₂ n m))
∙∙ (λ i → -ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p
(subst coHomK (+'-comm (suc (suc n)) (suc m))
(_⌣ₖ_ {n = suc (suc n)} {m = suc m} ∣ merid a i ∣ₕ ∣ b ∣ₕ)))
∙∙ cong (-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p) (transp0₂ n m)) i) j)
(Kn→ΩKn+10ₖ _) (~ l) i j))})
(hcomp (λ l →
λ { (i = i0) → ∣ north ∣
; (i = i1) → ∣ north ∣
; (j = i0) → Kn→ΩKn+10ₖ _ r i
; (j = i1) → Kn→ΩKn+10ₖ _ r i
; (r = i0) → lem₄ n m q p a b i1 j i
; (r = i1) → lem₅ n m p q a b (~ l) i j})
(hcomp (λ l →
λ { (i = i0) → ∣ north ∣
; (i = i1) → ∣ north ∣
; (j = i0) → Kn→ΩKn+10ₖ _ (r ∨ ~ l) i
; (j = i1) → Kn→ΩKn+10ₖ _ (r ∨ ~ l) i
; (r = i0) → doubleCompPath-filler
(sym (Kn→ΩKn+10ₖ _))
(lem₄ n m q p a b i1)
(Kn→ΩKn+10ₖ _) (~ l) j i
; (r = i1) → Kn→Ω²Kn+2 (-ₖ'-gen (suc (suc n)) (suc (suc m)) p q
(-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p
(subst coHomK (cong suc (sym (+-suc n m)))
(gradedComm'-elimCase k n m
(+-comm n m ∙∙ cong predℕ (+-comm (suc m) n) ∙∙ cong (predℕ ∘ predℕ) term)
(evenOrOdd (suc n)) (evenOrOdd (suc m)) a b (~ l))))) i j})
(lem₆ n m p q a b r i j))))
where
help₁ : I → I → I → coHomK _
help₁ l i j =
Kn→ΩKn+1 _
(hcomp (λ r
→ λ { (i = i0) → compPath-filler' (cong ((-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p)) (sym (transp0₂ n m)))
(sym (gradedComm'-elimCase (suc k) m (suc n) (+-suc m n ∙ +-comm (suc m) n ∙ cong predℕ term)
(evenOrOdd (suc m)) p b north)) r l
; (i = i1) → compPath-filler' (cong ((-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p)) (sym (transp0₂ n m)))
(sym (gradedComm'-elimCase (suc k) m (suc n) (+-suc m n ∙ +-comm (suc m) n ∙ cong predℕ term)
(evenOrOdd (suc m)) p b south)) r l
; (l = i0) → doubleCompPath-filler (sym (cong (-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p) (transp0₂ n m)))
(λ i → -ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p
(subst coHomK (+'-comm (suc (suc n)) (suc m))
(_⌣ₖ_ {n = suc (suc n)} {m = suc m} ∣ merid a i ∣ₕ ∣ b ∣ₕ)))
(cong (-ₖ'-gen (suc m) (suc (suc n)) (evenOrOdd (suc m)) p) (transp0₂ n m)) r i
; (l = i1) → _⌣ₖ_ {n = suc m} {m = suc (suc n)} ∣ b ∣ₕ ∣ merid a i ∣ₕ})
(gradedComm'-elimCase (suc k) m (suc n) (+-suc m n ∙ +-comm (suc m) n ∙ cong predℕ term)
(evenOrOdd (suc m)) p b (merid a i) (~ l))) j
help₂ : I → I → I → coHomK _
help₂ l i j =
hcomp (λ r →
λ { (i = i0) → ∣ north ∣
; (i = i1) → ∣ north ∣
; (j = i0) →
Kn→ΩKn+1 (suc (suc (n + suc m)))
(compPath-filler (gradedComm'-elimCase (suc k) n (suc m)
(cong predℕ term) (evenOrOdd (suc n)) q a north)
(cong (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q) (transp0₂ m n)) r (~ l)) i
; (j = i1) →
Kn→ΩKn+1 (suc (suc (n + suc m)))
(compPath-filler (gradedComm'-elimCase (suc k) n (suc m)
(cong predℕ term) (evenOrOdd (suc n)) q a south)
(cong (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q) (transp0₂ m n)) r (~ l)) i
; (l = i0) →
Kn→ΩKn+1 _
(doubleCompPath-filler (sym (cong (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q) (transp0₂ m n)))
(λ j → -ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q
(subst coHomK (+'-comm (suc (suc m)) (suc n))
(_⌣ₖ_ {n = suc (suc m)} {m = (suc n)} ∣ merid b j ∣ₕ ∣ a ∣)))
(cong (-ₖ'-gen (suc n) (suc (suc m)) (evenOrOdd (suc n)) q) (transp0₂ m n)) r j) i
; (l = i1) → Kn→ΩKn+1 _ (_⌣ₖ_ {n = (suc n)} {m = suc (suc m)} ∣ a ∣ ∣ merid b j ∣ₕ) i})
(hcomp (λ r →
λ { (i = i0) → ∣ north ∣
; (i = i1) → ∣ north ∣
; (j = i0) → Kn→ΩKn+1 (suc (suc (n + suc m)))
(gradedComm'-elimCase (suc k) n (suc m)
(cong predℕ term) (evenOrOdd (suc n)) q a north (~ l ∨ ~ r)) i
; (j = i1) → Kn→ΩKn+1 (suc (suc (n + suc m)))
(gradedComm'-elimCase (suc k) n (suc m)
(cong predℕ term) (evenOrOdd (suc n)) q a south (~ l ∨ ~ r)) i
; (l = i0) → Kn→ΩKn+1 (suc (suc (n + suc m)))
(gradedComm'-elimCase (suc k) n (suc m)
(cong predℕ term) (evenOrOdd (suc n)) q a (merid b j) i1) i
; (l = i1) → Kn→ΩKn+1 _ (gradedComm'-elimCase (suc k) n (suc m) (cong predℕ term)
(evenOrOdd (suc n)) q a (merid b j) (~ r)) i})
(Kn→ΩKn+1 (suc (suc (n + suc m)))
(gradedComm'-elimCase (suc k) n (suc m) (cong predℕ term)
(evenOrOdd (suc n)) q a (merid b j) i1) i))
private
coherence-transp : (n m : ℕ) (p : _) (q : _)
→ -ₖ'-gen (suc n) (suc m) p q
(subst coHomK (+'-comm (suc m) (suc n)) (0ₖ (suc m +' suc n))) ≡ 0ₖ _
coherence-transp zero zero p q = refl
coherence-transp zero (suc m) p q = refl
coherence-transp (suc n) zero p q = refl
coherence-transp (suc n) (suc m) p q = refl
gradedComm'-⌣ₖ∙ : (n m : ℕ) (p : _) (q : _) (a : _)
→ ⌣ₖ∙ (suc n) (suc m) a
≡ ((λ b → -ₖ'-gen (suc n) (suc m) p q (subst coHomK (+'-comm (suc m) (suc n)) (b ⌣ₖ a)))
, (cong (-ₖ'-gen (suc n) (suc m) p q)
(cong (subst coHomK (+'-comm (suc m) (suc n)))
(0ₖ-⌣ₖ (suc m) (suc n) a))
∙ coherence-transp n m p q))
gradedComm'-⌣ₖ∙ n m p q =
T.elim (λ _ → isOfHLevelPath (3 + n) ((isOfHLevel↑∙ (suc n) m)) _ _)
λ a → →∙Homogeneous≡ (isHomogeneousKn _) (funExt λ b → funExt⁻ (cong fst (f₁≡f₂ b)) a)
where
f₁ : coHomK (suc m) → S₊∙ (suc n) →∙ coHomK-ptd (suc n +' suc m)
fst (f₁ b) a = _⌣ₖ_ {n = suc n} {m = suc m} ∣ a ∣ₕ b
snd (f₁ b) = 0ₖ-⌣ₖ (suc n) (suc m) b
f₂ : coHomK (suc m) → S₊∙ (suc n) →∙ coHomK-ptd (suc n +' suc m)
fst (f₂ b) a =
-ₖ'-gen (suc n) (suc m) p q (subst coHomK (+'-comm (suc m) (suc n))
(_⌣ₖ_ {n = suc m} {m = suc n} b ∣ a ∣ₕ))
snd (f₂ b) =
(cong (-ₖ'-gen (suc n) (suc m) p q)
(cong (subst coHomK (+'-comm (suc m) (suc n)))
(⌣ₖ-0ₖ (suc m) (suc n) b))
∙ coherence-transp n m p q)
f₁≡f₂ : (b : _) → f₁ b ≡ f₂ b
f₁≡f₂ =
T.elim (λ _ → isOfHLevelPath (3 + m)
(subst (isOfHLevel (3 + m))
(λ i → S₊∙ (suc n) →∙ coHomK-ptd (+'-comm (suc n) (suc m) (~ i)))
(isOfHLevel↑∙' (suc m) n)) _ _)
λ b → →∙Homogeneous≡ (isHomogeneousKn _)
(funExt λ a → gradedComm'-elimCase (n + m) n m refl p q a b)
-- Finally, graded commutativity:
gradedComm'-⌣ₖ : (n m : ℕ) (a : coHomK n) (b : coHomK m)
→ a ⌣ₖ b ≡ (-ₖ'^ n · m) (subst coHomK (+'-comm m n) (b ⌣ₖ a))
gradedComm'-⌣ₖ zero zero a b = sym (transportRefl _) ∙ cong (transport refl) (comm-·₀ a b)
gradedComm'-⌣ₖ zero (suc m) a b =
sym (transportRefl _)
∙∙ (λ k → subst coHomK (isSetℕ _ _ refl (+'-comm (suc m) zero) k) (b ⌣ₖ a))
∙∙ sym (-ₖ'-gen-inl-left zero (suc m) tt (evenOrOdd (suc m))
(subst coHomK (+'-comm (suc m) zero) (b ⌣ₖ a)))
gradedComm'-⌣ₖ (suc n) zero a b =
sym (transportRefl _)
∙∙ ((λ k → subst coHomK (isSetℕ _ _ refl (+'-comm zero (suc n)) k) (b ⌣ₖ a)))
∙∙ sym (-ₖ'-gen-inl-right (suc n) zero (evenOrOdd (suc n)) tt
(subst coHomK (+'-comm zero (suc n)) (b ⌣ₖ a)))
gradedComm'-⌣ₖ (suc n) (suc m) a b =
funExt⁻ (cong fst (gradedComm'-⌣ₖ∙ n m (evenOrOdd (suc n)) (evenOrOdd (suc m)) a)) b
gradedComm'-⌣ : {A : Type ℓ} (n m : ℕ) (a : coHom n A) (b : coHom m A)
→ a ⌣ b ≡ (-ₕ'^ n · m) (subst (λ n → coHom n A) (+'-comm m n) (b ⌣ a))
gradedComm'-⌣ n m =
ST.elim2 (λ _ _ → isOfHLevelPath 2 squash₂ _ _)
λ f g →
cong ∣_∣₂ (funExt (λ x →
gradedComm'-⌣ₖ n m (f x) (g x)
∙ cong ((-ₖ'^ n · m) ∘ (subst coHomK (+'-comm m n)))
λ i → g (transportRefl x (~ i)) ⌣ₖ f (transportRefl x (~ i))))
-----------------------------------------------------------------------------
-- The previous code introduces another - to facilitate proof
-- This a reformulation with the usual -ₕ' definition (the one of the ring) of the results
-ₕ^-gen : {k : ℕ} → {A : Type ℓ} → (n m : ℕ)
→ (p : isEvenT n ⊎ isOddT n)
→ (q : isEvenT m ⊎ isOddT m)
→ (a : coHom k A) → coHom k A
-ₕ^-gen n m (inl p) q a = a
-ₕ^-gen n m (inr p) (inl q) a = a
-ₕ^-gen n m (inr p) (inr q) a = -ₕ a
-ₕ^_·_ : {k : ℕ} → {A : Type ℓ} → (n m : ℕ) → (a : coHom k A) → coHom k A
-ₕ^_·_ n m a = -ₕ^-gen n m (evenOrOdd n) (evenOrOdd m) a
-ₕ^-gen-eq : ∀ {ℓ} {k : ℕ} {A : Type ℓ} (n m : ℕ)
→ (p : isEvenT n ⊎ isOddT n) (q : isEvenT m ⊎ isOddT m)
→ (x : coHom k A)
→ -ₕ^-gen n m p q x ≡ (ST.map λ f x → (-ₖ'-gen n m p q) (f x)) x
-ₕ^-gen-eq {k = k} n m (inl p) q = ST.elim (λ _ → isSetPathImplicit) λ f → cong ∣_∣₂ (funExt λ x → sym (-ₖ'-gen-inl-left n m p q (f x)))
-ₕ^-gen-eq {k = k} n m (inr p) (inl q) = ST.elim (λ _ → isSetPathImplicit) λ f → cong ∣_∣₂ (funExt λ z → sym (-ₖ'-gen-inl-right n m (inr p) q (f z)))
-ₕ^-gen-eq {k = k} n m (inr p) (inr q) = ST.elim (λ _ → isSetPathImplicit) λ f → cong ∣_∣₂ (funExt λ z → sym (-ₖ'-gen-inr≡-ₖ' n m p q (f z)))
-ₕ^-eq : ∀ {ℓ} {k : ℕ} {A : Type ℓ} (n m : ℕ) → (a : coHom k A)
→ (-ₕ^ n · m) a ≡ (-ₕ'^ n · m) a
-ₕ^-eq n m a = -ₕ^-gen-eq n m (evenOrOdd n) (evenOrOdd m) a
gradedComm-⌣ : ∀ {ℓ} {A : Type ℓ} (n m : ℕ) (a : coHom n A) (b : coHom m A)
→ a ⌣ b ≡ (-ₕ^ n · m) (subst (λ n → coHom n A) (+'-comm m n) (b ⌣ a))
gradedComm-⌣ n m a b = (gradedComm'-⌣ n m a b) ∙ (sym (-ₕ^-eq n m (subst (λ n₁ → coHom n₁ _) (+'-comm m n) (b ⌣ a))))
| 56.80776
| 149
| 0.424604
|
0d42c109f2de89cbd199b974467e206ccd8ade6f
| 32,093
|
agda
|
Agda
|
Cubical/ZCohomology/Properties.agda
|
ecavallo/cubical
|
b1d105aeeab1ba9888394c6a919b99a476390b7b
|
[
"MIT"
] | null | null | null |
Cubical/ZCohomology/Properties.agda
|
ecavallo/cubical
|
b1d105aeeab1ba9888394c6a919b99a476390b7b
|
[
"MIT"
] | null | null | null |
Cubical/ZCohomology/Properties.agda
|
ecavallo/cubical
|
b1d105aeeab1ba9888394c6a919b99a476390b7b
|
[
"MIT"
] | null | null | null |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.ZCohomology.Properties where
{-
This module contains:
1. direct proofs of connectedness of Kn and ΩKn
2. Induction principles for cohomology groups of pointed types
3. Equivalence between cohomology of A and reduced cohomology of (A + 1)
4. Equivalence between cohomology and reduced cohomology for dimension ≥ 1
5. Encode-decode proof of Kₙ ≃ ΩKₙ₊₁ and proofs that this equivalence
and its inverse are morphisms
6. A proof of coHomGr ≅ coHomGrΩ
7. A locked (non-reducing) version of Kₙ ≃ ΩKₙ₊₁
8. Some HLevel lemmas used for the cup product
-}
open import Cubical.ZCohomology.Base
open import Cubical.ZCohomology.GroupStructure
open import Cubical.HITs.S1 hiding (encode ; decode ; _·_)
open import Cubical.HITs.Sn
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Transport
open import Cubical.Foundations.Function
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed
open import Cubical.Foundations.Pointed.Homogeneous
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.GroupoidLaws renaming (assoc to assoc∙)
open import Cubical.Foundations.Univalence
open import Cubical.HITs.Susp
open import Cubical.HITs.SetTruncation renaming (rec to sRec ; rec2 to sRec2 ; elim to sElim ; elim2 to sElim2 ; isSetSetTrunc to §)
open import Cubical.Data.Int renaming (_+_ to _ℤ+_) hiding (-_)
open import Cubical.Data.Nat
open import Cubical.HITs.Truncation renaming (elim to trElim ; map to trMap ; map2 to trMap2; rec to trRec ; elim3 to trElim3)
open import Cubical.Homotopy.Loopspace
open import Cubical.Homotopy.Connected
open import Cubical.Algebra.Group hiding (Unit ; ℤ)
open import Cubical.Algebra.AbGroup
open import Cubical.Algebra.Semigroup
open import Cubical.Algebra.Monoid
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Data.Sum.Base hiding (map)
open import Cubical.Functions.Morphism
open import Cubical.Data.Sigma
open Iso renaming (inv to inv')
private
variable
ℓ ℓ' : Level
------------------- Connectedness ---------------------
is2ConnectedKn : (n : ℕ) → isConnected 2 (coHomK (suc n))
is2ConnectedKn zero = ∣ ∣ base ∣ ∣
, trElim (λ _ → isOfHLevelPath 2 (isOfHLevelTrunc 2) _ _)
(trElim (λ _ → isOfHLevelPath 3 (isOfHLevelSuc 2 (isOfHLevelTrunc 2)) _ _)
(toPropElim (λ _ → isOfHLevelTrunc 2 _ _) refl))
is2ConnectedKn (suc n) = ∣ ∣ north ∣ ∣
, trElim (λ _ → isOfHLevelPath 2 (isOfHLevelTrunc 2) _ _)
(trElim (λ _ → isProp→isOfHLevelSuc (3 + n) (isOfHLevelTrunc 2 _ _))
(suspToPropElim (ptSn (suc n)) (λ _ → isOfHLevelTrunc 2 _ _) refl))
isConnectedKn : (n : ℕ) → isConnected (2 + n) (coHomK (suc n))
isConnectedKn n = isOfHLevelRetractFromIso 0 (invIso (truncOfTruncIso (2 + n) 1)) (sphereConnected (suc n))
-- direct proof of connectedness of ΩKₙ₊₁ not relying on the equivalence ∥ a ≡ b ∥ₙ ≃ (∣ a ∣ₙ₊₁ ≡ ∣ b ∣ₙ₊₁)
isConnectedPathKn : (n : ℕ) (x y : (coHomK (suc n))) → isConnected (suc n) (x ≡ y)
isConnectedPathKn n =
trElim (λ _ → isProp→isOfHLevelSuc (2 + n) (isPropΠ λ _ → isPropIsContr))
(sphereElim _ (λ _ → isProp→isOfHLevelSuc n (isPropΠ λ _ → isPropIsContr))
λ y → isContrRetractOfConstFun
{B = (hLevelTrunc (suc n) (ptSn (suc n) ≡ ptSn (suc n)))} ∣ refl ∣
(fun⁻ n y
, trElim (λ _ → isOfHLevelPath (suc n) (isOfHLevelTrunc (suc n)) _ _)
(J (λ y p → fun⁻ n y _ ≡ _) (funExt⁻ (fun⁻Id n) ∣ refl ∣))))
where
fun⁻ : (n : ℕ) → (y : coHomK (suc n)) →
hLevelTrunc (suc n) (ptSn (suc n) ≡ ptSn (suc n))
→ hLevelTrunc (suc n) (∣ ptSn (suc n) ∣ ≡ y)
fun⁻ n =
trElim (λ _ → isOfHLevelΠ (3 + n) λ _ → isOfHLevelSuc (2 + n) (isOfHLevelSuc (suc n) (isOfHLevelTrunc (suc n))))
(sphereElim n (λ _ → isOfHLevelΠ (suc n) λ _ → isOfHLevelTrunc (suc n)) λ _ → ∣ refl ∣)
fun⁻Id : (n : ℕ) → fun⁻ n ∣ ptSn (suc n) ∣ ≡ λ _ → ∣ refl ∣
fun⁻Id zero = refl
fun⁻Id (suc n) = refl
-------------------
-- Induction principles for cohomology groups (n ≥ 1)
-- If we want to show a proposition about some x : Hⁿ(A), it suffices to show it under the
-- assumption that x = ∣ f ∣₂ for some f : A → Kₙ and that f is pointed
coHomPointedElim : {A : Type ℓ} (n : ℕ) (a : A) {B : coHom (suc n) A → Type ℓ'}
→ ((x : coHom (suc n) A) → isProp (B x))
→ ((f : A → coHomK (suc n)) → f a ≡ coHom-pt (suc n) → B ∣ f ∣₂)
→ (x : coHom (suc n) A) → B x
coHomPointedElim {ℓ' = ℓ'} {A = A} n a isprop indp =
sElim (λ _ → isOfHLevelSuc 1 (isprop _))
λ f → helper n isprop indp f (f a) refl
where
helper : (n : ℕ) {B : coHom (suc n) A → Type ℓ'}
→ ((x : coHom (suc n) A) → isProp (B x))
→ ((f : A → coHomK (suc n)) → f a ≡ coHom-pt (suc n) → B ∣ f ∣₂)
→ (f : A → coHomK (suc n))
→ (x : coHomK (suc n))
→ f a ≡ x → B ∣ f ∣₂
-- pattern matching a bit extra to avoid isOfHLevelPlus'
helper zero isprop ind f =
trElim (λ _ → isOfHLevelPlus {n = 1} 2 (isPropΠ λ _ → isprop _))
(toPropElim (λ _ → isPropΠ λ _ → isprop _) (ind f))
helper (suc zero) isprop ind f =
trElim (λ _ → isOfHLevelPlus {n = 1} 3 (isPropΠ λ _ → isprop _))
(suspToPropElim base (λ _ → isPropΠ λ _ → isprop _) (ind f))
helper (suc (suc zero)) isprop ind f =
trElim (λ _ → isOfHLevelPlus {n = 1} 4 (isPropΠ λ _ → isprop _))
(suspToPropElim north (λ _ → isPropΠ λ _ → isprop _) (ind f))
helper (suc (suc (suc n))) isprop ind f =
trElim (λ _ → isOfHLevelPlus' {n = 5 + n} 1 (isPropΠ λ _ → isprop _))
(suspToPropElim north (λ _ → isPropΠ λ _ → isprop _) (ind f))
coHomPointedElim2 : {A : Type ℓ} (n : ℕ) (a : A) {B : coHom (suc n) A → coHom (suc n) A → Type ℓ'}
→ ((x y : coHom (suc n) A) → isProp (B x y))
→ ((f g : A → coHomK (suc n)) → f a ≡ coHom-pt (suc n) → g a ≡ coHom-pt (suc n) → B ∣ f ∣₂ ∣ g ∣₂)
→ (x y : coHom (suc n) A) → B x y
coHomPointedElim2 {ℓ' = ℓ'} {A = A} n a isprop indp = sElim2 (λ _ _ → isOfHLevelSuc 1 (isprop _ _))
λ f g → helper n a isprop indp f g (f a) (g a) refl refl
where
helper : (n : ℕ) (a : A) {B : coHom (suc n) A → coHom (suc n) A → Type ℓ'}
→ ((x y : coHom (suc n) A) → isProp (B x y))
→ ((f g : A → coHomK (suc n)) → f a ≡ coHom-pt (suc n) → g a ≡ coHom-pt (suc n) → B ∣ f ∣₂ ∣ g ∣₂)
→ (f g : A → coHomK (suc n))
→ (x y : coHomK (suc n))
→ f a ≡ x → g a ≡ y
→ B ∣ f ∣₂ ∣ g ∣₂
helper zero a isprop indp f g =
elim2 (λ _ _ → isOfHLevelPlus {n = 1} 2 (isPropΠ2 λ _ _ → isprop _ _))
(toPropElim2 (λ _ _ → isPropΠ2 λ _ _ → isprop _ _) (indp f g))
helper (suc zero) a isprop indp f g =
elim2 (λ _ _ → isOfHLevelPlus {n = 1} 3 (isPropΠ2 λ _ _ → isprop _ _))
(suspToPropElim2 base (λ _ _ → isPropΠ2 λ _ _ → isprop _ _) (indp f g))
helper (suc (suc zero)) a isprop indp f g =
elim2 (λ _ _ → isOfHLevelPlus {n = 1} 4 (isPropΠ2 λ _ _ → isprop _ _))
(suspToPropElim2 north (λ _ _ → isPropΠ2 λ _ _ → isprop _ _) (indp f g))
helper (suc (suc (suc n))) a isprop indp f g =
elim2 (λ _ _ → isOfHLevelPlus' {n = 5 + n} 1 (isPropΠ2 λ _ _ → isprop _ _))
(suspToPropElim2 north (λ _ _ → isPropΠ2 λ _ _ → isprop _ _) (indp f g))
coHomK-elim : ∀ {ℓ} (n : ℕ) {B : coHomK (suc n) → Type ℓ}
→ ((x : _) → isOfHLevel (suc n) (B x))
→ B (0ₖ (suc n))
→ (x : _) → B x
coHomK-elim n {B = B } hlev b =
trElim (λ _ → isOfHLevelPlus {n = (suc n)} 2 (hlev _))
(sphereElim _ (hlev ∘ ∣_∣) b)
{- Equivalence between cohomology of A and reduced cohomology of (A + 1) -}
coHomRed+1Equiv : (n : ℕ) →
(A : Type ℓ) →
(coHom n A) ≡ (coHomRed n ((A ⊎ Unit , inr (tt))))
coHomRed+1Equiv zero A i = ∥ helpLemma {C = (ℤ , pos 0)} i ∥₂
module coHomRed+1 where
helpLemma : {C : Pointed ℓ} → ( (A → (typ C)) ≡ ((((A ⊎ Unit) , inr (tt)) →∙ C)))
helpLemma {C = C} = isoToPath (iso map1
map2
(λ b → linvPf b)
(λ _ → refl))
where
map1 : (A → typ C) → ((((A ⊎ Unit) , inr (tt)) →∙ C))
map1 f = map1' , refl
module helpmap where
map1' : A ⊎ Unit → fst C
map1' (inl x) = f x
map1' (inr x) = pt C
map2 : ((((A ⊎ Unit) , inr (tt)) →∙ C)) → (A → typ C)
map2 (g , pf) x = g (inl x)
linvPf : (b :((((A ⊎ Unit) , inr (tt)) →∙ C))) → map1 (map2 b) ≡ b
linvPf (f , snd) i = (λ x → helper x i) , λ j → snd ((~ i) ∨ j)
where
helper : (x : A ⊎ Unit) → ((helpmap.map1') (map2 (f , snd)) x) ≡ f x
helper (inl x) = refl
helper (inr tt) = sym snd
coHomRed+1Equiv (suc zero) A i = ∥ coHomRed+1.helpLemma A i {C = (coHomK 1 , ∣ base ∣)} i ∥₂
coHomRed+1Equiv (suc (suc n)) A i = ∥ coHomRed+1.helpLemma A i {C = (coHomK (2 + n) , ∣ north ∣)} i ∥₂
Iso-coHom-coHomRed : ∀ {ℓ} {A : Pointed ℓ} (n : ℕ) → Iso (coHomRed (suc n) A) (coHom (suc n) (typ A))
fun (Iso-coHom-coHomRed {A = A , a} n) = map fst
inv' (Iso-coHom-coHomRed {A = A , a} n) = map λ f → (λ x → f x -ₖ f a) , rCancelₖ _ _
rightInv (Iso-coHom-coHomRed {A = A , a} n) =
sElim (λ _ → isOfHLevelPath 2 § _ _)
λ f → trRec (isProp→isOfHLevelSuc _ (§ _ _))
(λ p → cong ∣_∣₂ (funExt λ x → cong (λ y → f x +ₖ y) (cong -ₖ_ p ∙ -0ₖ) ∙ rUnitₖ _ (f x)))
(Iso.fun (PathIdTruncIso (suc n)) (isContr→isProp (isConnectedKn n) ∣ f a ∣ ∣ 0ₖ _ ∣))
leftInv (Iso-coHom-coHomRed {A = A , a} n) =
sElim (λ _ → isOfHLevelPath 2 § _ _)
λ {(f , p) → cong ∣_∣₂ (ΣPathP (((funExt λ x → (cong (λ y → f x -ₖ y) p
∙∙ cong (λ y → f x +ₖ y) -0ₖ
∙∙ rUnitₖ _ (f x)) ∙ refl))
, helper n (f a) (sym p)))}
where
path : (n : ℕ) (x : coHomK (suc n)) (p : 0ₖ _ ≡ x) → _
path n x p = (cong (λ y → x -ₖ y) (sym p) ∙∙ cong (λ y → x +ₖ y) -0ₖ ∙∙ rUnitₖ _ x) ∙ refl
helper : (n : ℕ) (x : coHomK (suc n)) (p : 0ₖ _ ≡ x)
→ PathP (λ i → path n x p i ≡ 0ₖ _) (rCancelₖ _ x) (sym p)
helper zero x =
J (λ x p → PathP (λ i → path 0 x p i ≡ 0ₖ _)
(rCancelₖ _ x) (sym p))
λ i j → rUnit (rUnit (λ _ → 0ₖ 1) (~ j)) (~ j) i
helper (suc n) x =
J (λ x p → PathP (λ i → path (suc n) x p i ≡ 0ₖ _) (rCancelₖ _ x) (sym p))
λ i j → rCancelₖ (suc (suc n)) (0ₖ (suc (suc n))) (~ i ∧ ~ j)
+∙≡+ : (n : ℕ) {A : Pointed ℓ} (x y : coHomRed (suc n) A)
→ Iso.fun (Iso-coHom-coHomRed n) (x +ₕ∙ y)
≡ Iso.fun (Iso-coHom-coHomRed n) x +ₕ Iso.fun (Iso-coHom-coHomRed n) y
+∙≡+ zero = sElim2 (λ _ _ → isOfHLevelPath 2 § _ _) λ _ _ → refl
+∙≡+ (suc n) = sElim2 (λ _ _ → isOfHLevelPath 2 § _ _) λ _ _ → refl
private
homhelp : ∀ {ℓ} (n : ℕ) (A : Pointed ℓ) (x y : coHom (suc n) (typ A))
→ Iso.inv (Iso-coHom-coHomRed {A = A} n) (x +ₕ y)
≡ Iso.inv (Iso-coHom-coHomRed n) x +ₕ∙ Iso.inv (Iso-coHom-coHomRed n) y
homhelp n A = morphLemmas.isMorphInv _+ₕ∙_ _+ₕ_
(Iso.fun (Iso-coHom-coHomRed n)) (+∙≡+ n) _
(Iso.rightInv (Iso-coHom-coHomRed n)) (Iso.leftInv (Iso-coHom-coHomRed n))
coHomGr≅coHomRedGr : ∀ {ℓ} (n : ℕ) (A : Pointed ℓ)
→ GroupEquiv (coHomRedGrDir (suc n) A) (coHomGr (suc n) (typ A))
fst (coHomGr≅coHomRedGr n A) = isoToEquiv (Iso-coHom-coHomRed n)
snd (coHomGr≅coHomRedGr n A) = makeIsGroupHom (+∙≡+ n)
coHomRedGroup : ∀ {ℓ} (n : ℕ) (A : Pointed ℓ) → AbGroup ℓ
coHomRedGroup zero A = coHomRedGroupDir zero A
coHomRedGroup (suc n) A =
InducedAbGroup (coHomGroup (suc n) (typ A))
_+ₕ∙_
(isoToEquiv (invIso (Iso-coHom-coHomRed n)))
(homhelp n A)
abstract
coHomGroup≡coHomRedGroup : ∀ {ℓ} (n : ℕ) (A : Pointed ℓ)
→ coHomGroup (suc n) (typ A) ≡ coHomRedGroup (suc n) A
coHomGroup≡coHomRedGroup n A =
InducedAbGroupPath (coHomGroup (suc n) (typ A))
_+ₕ∙_
(isoToEquiv (invIso (Iso-coHom-coHomRed n)))
(homhelp n A)
------------------- Kₙ ≃ ΩKₙ₊₁ ---------------------
-- This proof uses the encode-decode method rather than Freudenthal
-- We define the map σ : Kₙ → ΩKₙ₊₁ and prove that it is a morphism
private
module _ (n : ℕ) where
σ : {n : ℕ} → coHomK (suc n) → Path (coHomK (2 + n)) ∣ north ∣ ∣ north ∣
σ {n = n} = trRec (isOfHLevelTrunc (4 + n) _ _)
λ a → cong ∣_∣ (merid a ∙ sym (merid (ptSn (suc n))))
σ-hom-helper : ∀ {ℓ} {A : Type ℓ} {a : A} (p : a ≡ a) (r : refl ≡ p)
→ lUnit p ∙ cong (_∙ p) r ≡ rUnit p ∙ cong (p ∙_) r
σ-hom-helper p = J (λ p r → lUnit p ∙ cong (_∙ p) r ≡ rUnit p ∙ cong (p ∙_) r) refl
σ-hom : {n : ℕ} (x y : coHomK (suc n)) → σ (x +ₖ y) ≡ σ x ∙ σ y
σ-hom {n = zero} =
elim2 (λ _ _ → isOfHLevelPath 3 (isOfHLevelTrunc 4 _ _) _ _)
(wedgeconFun _ _
(λ _ _ → isOfHLevelTrunc 4 _ _ _ _)
(λ x → lUnit _
∙ cong (_∙ σ ∣ x ∣) (cong (cong ∣_∣) (sym (rCancel (merid base)))))
(λ y → cong σ (rUnitₖ 1 ∣ y ∣)
∙∙ rUnit _
∙∙ cong (σ ∣ y ∣ ∙_) (cong (cong ∣_∣) (sym (rCancel (merid base)))))
(sym (σ-hom-helper (σ ∣ base ∣) (cong (cong ∣_∣) (sym (rCancel (merid base)))))))
σ-hom {n = suc n} =
elim2 (λ _ _ → isOfHLevelPath (4 + n) (isOfHLevelTrunc (5 + n) _ _) _ _)
(wedgeconFun _ _ (λ _ _ → isOfHLevelPath ((2 + n) + (2 + n)) (wedgeConHLev' n) _ _)
(λ x → lUnit _
∙ cong (_∙ σ ∣ x ∣) (cong (cong ∣_∣) (sym (rCancel (merid north)))))
(λ y → cong σ (rUnitₖ (2 + n) ∣ y ∣)
∙∙ rUnit _
∙∙ cong (σ ∣ y ∣ ∙_) (cong (cong ∣_∣) (sym (rCancel (merid north)))))
(sym (σ-hom-helper (σ ∣ north ∣) (cong (cong ∣_∣) (sym (rCancel (merid north)))))))
-- We will need to following lemma
σ-minusDistr : {n : ℕ} (x y : coHomK (suc n)) → σ (x -ₖ y) ≡ σ x ∙ sym (σ y)
σ-minusDistr {n = n} =
morphLemmas.distrMinus'
_+ₖ_ _∙_
σ σ-hom ∣ (ptSn (suc n)) ∣ refl
-ₖ_ sym
(λ x → sym (lUnit x)) (λ x → sym (rUnit x))
(rUnitₖ (suc n))
(lCancelₖ (suc n)) rCancel
(assocₖ (suc n)) assoc∙
(cong (cong ∣_∣) (rCancel (merid (ptSn (suc n)))))
-- we define the code using addIso
Code : (n : ℕ) → coHomK (2 + n) → Type₀
Code n x = (trRec {B = TypeOfHLevel ℓ-zero (3 + n)} (isOfHLevelTypeOfHLevel (3 + n))
λ a → Code' a , hLevCode' a) x .fst
where
Code' : (S₊ (2 + n)) → Type₀
Code' north = coHomK (suc n)
Code' south = coHomK (suc n)
Code' (merid a i) = isoToPath (addIso (suc n) ∣ a ∣) i
hLevCode' : (x : S₊ (2 + n)) → isOfHLevel (3 + n) (Code' x)
hLevCode' = suspToPropElim (ptSn (suc n)) (λ _ → isPropIsOfHLevel (3 + n)) (isOfHLevelTrunc (3 + n))
symMeridLem : (n : ℕ) → (x : S₊ (suc n)) (y : coHomK (suc n))
→ subst (Code n) (cong ∣_∣ (sym (merid x))) y ≡ y -ₖ ∣ x ∣
symMeridLem n x = trElim (λ _ → isOfHLevelPath (3 + n) (isOfHLevelTrunc (3 + n)) _ _)
(λ y → cong (_-ₖ ∣ x ∣) (transportRefl ∣ y ∣))
decode : {n : ℕ} (x : coHomK (2 + n)) → Code n x → ∣ north ∣ ≡ x
decode {n = n} = trElim (λ _ → isOfHLevelΠ (4 + n) λ _ → isOfHLevelPath (4 + n) (isOfHLevelTrunc (4 + n)) _ _)
decode-elim
where
north≡merid : (a : S₊ (suc n))
→ Path (coHomK (2 + n)) ∣ north ∣ ∣ north ∣
≡ (Path (coHomK (2 + n)) ∣ north ∣ ∣ south ∣)
north≡merid a i = Path (coHomK (2 + n)) ∣ north ∣ ∣ merid a i ∣
decode-elim : (a : S₊ (2 + n)) → Code n ∣ a ∣ → Path (coHomK (2 + n)) ∣ north ∣ ∣ a ∣
decode-elim north = σ
decode-elim south = trRec (isOfHLevelTrunc (4 + n) _ _)
λ a → cong ∣_∣ (merid a)
decode-elim (merid a i) =
hcomp (λ k → λ { (i = i0) → σ
; (i = i1) → mainPath a k})
(funTypeTransp (Code n) (λ x → ∣ north ∣ ≡ x) (cong ∣_∣ (merid a)) σ i)
where
mainPath : (a : (S₊ (suc n))) →
transport (north≡merid a) ∘ σ ∘ transport (λ i → Code n ∣ merid a (~ i) ∣)
≡ trRec (isOfHLevelTrunc (4 + n) _ _) λ a → cong ∣_∣ (merid a)
mainPath a = funExt (trElim (λ _ → isOfHLevelPath (3 + n) (isOfHLevelTrunc (4 + n) _ _) _ _)
(λ x → (λ i → transport (north≡merid a) (σ (symMeridLem n a ∣ x ∣ i)))
∙∙ cong (transport (north≡merid a)) (-distrHelp x)
∙∙ (substAbove x)))
where
-distrHelp : (x : S₊ (suc n)) → σ (∣ x ∣ -ₖ ∣ a ∣) ≡ cong ∣_∣ (merid x) ∙ cong ∣_∣ (sym (merid a))
-distrHelp x =
σ-minusDistr ∣ x ∣ ∣ a ∣
∙ (λ i → (cong ∣_∣ (compPath-filler (merid x) (λ j → merid (ptSn (suc n)) (~ j ∨ i)) (~ i)))
∙ (cong ∣_∣ (sym (compPath-filler (merid a) (λ j → merid (ptSn (suc n)) (~ j ∨ i)) (~ i)))))
substAbove : (x : S₊ (suc n)) → transport (north≡merid a) (cong ∣_∣ (merid x) ∙ cong ∣_∣ (sym (merid a)))
≡ cong ∣_∣ (merid x)
substAbove x i = transp (λ j → north≡merid a (i ∨ j)) i
(compPath-filler (cong ∣_∣ (merid x)) (λ j → ∣ merid a (~ j ∨ i) ∣) (~ i))
encode : {n : ℕ} {x : coHomK (2 + n)} → Path (coHomK (2 + n)) ∣ north ∣ x → Code n x
encode {n = n} p = transport (cong (Code n) p) ∣ (ptSn (suc n)) ∣
decode-encode : {n : ℕ} {x : coHomK (2 + n)} (p : Path (coHomK (2 + n)) ∣ north ∣ x)
→ decode _ (encode p) ≡ p
decode-encode {n = n} =
J (λ y p → decode _ (encode p) ≡ p)
(cong (decode ∣ north ∣) (transportRefl ∣ ptSn (suc n) ∣)
∙ cong (cong ∣_∣) (rCancel (merid (ptSn (suc n)))))
-- We define an addition operation on Code which we can use in order to show that encode is a
-- morphism (in a very loose sense)
hLevCode : {n : ℕ} (x : coHomK (2 + n)) → isOfHLevel (3 + n) (Code n x)
hLevCode {n = n} =
trElim (λ _ → isProp→isOfHLevelSuc (3 + n) (isPropIsOfHLevel (3 + n)))
(sphereToPropElim _
(λ _ → (isPropIsOfHLevel (3 + n))) (isOfHLevelTrunc (3 + n)))
Code-add' : {n : ℕ} (x : _) → Code n ∣ north ∣ → Code n ∣ x ∣ → Code n ∣ x ∣
Code-add' {n = n} north = _+ₖ_
Code-add' {n = n} south = _+ₖ_
Code-add' {n = n} (merid a i) = helper n a i
where
help : (n : ℕ) → (x y a : S₊ (suc n))
→ transport (λ i → Code n ∣ north ∣ → Code n ∣ merid a i ∣ → Code n ∣ merid a i ∣)
(_+ₖ_) ∣ x ∣ ∣ y ∣
≡ ∣ x ∣ +ₖ ∣ y ∣
help n x y a =
(λ i → transportRefl ((∣ transportRefl x i ∣ +ₖ (∣ transportRefl y i ∣ -ₖ ∣ a ∣)) +ₖ ∣ a ∣) i)
∙∙ cong (_+ₖ ∣ a ∣) (assocₖ _ ∣ x ∣ ∣ y ∣ (-ₖ ∣ a ∣))
∙∙ sym (assocₖ _ (∣ x ∣ +ₖ ∣ y ∣) (-ₖ ∣ a ∣) ∣ a ∣)
∙∙ cong ((∣ x ∣ +ₖ ∣ y ∣) +ₖ_) (lCancelₖ _ ∣ a ∣)
∙∙ rUnitₖ _ _
helper : (n : ℕ) (a : S₊ (suc n))
→ PathP (λ i → Code n ∣ north ∣ → Code n ∣ merid a i ∣ → Code n ∣ merid a i ∣) _+ₖ_ _+ₖ_
helper n a =
toPathP (funExt
(trElim (λ _ → isOfHLevelPath (3 + n) (isOfHLevelΠ (3 + n) (λ _ → isOfHLevelTrunc (3 + n))) _ _)
λ x → funExt
(trElim (λ _ → isOfHLevelPath (3 + n) (isOfHLevelTrunc (3 + n)) _ _)
λ y → help n x y a)))
Code-add : {n : ℕ} (x : _) → Code n ∣ north ∣ → Code n x → Code n x
Code-add {n = n} =
trElim (λ x → isOfHLevelΠ (4 + n) λ _ → isOfHLevelΠ (4 + n) λ _ → isOfHLevelSuc (3 + n) (hLevCode {n = n} x))
Code-add'
encode-hom : {n : ℕ} {x : _} (q : 0ₖ _ ≡ 0ₖ _) (p : 0ₖ _ ≡ x)
→ encode (q ∙ p) ≡ Code-add {n = n} x (encode q) (encode p)
encode-hom {n = n} q = J (λ x p → encode (q ∙ p) ≡ Code-add {n = n} x (encode q) (encode p))
(cong encode (sym (rUnit q))
∙∙ sym (rUnitₖ _ (encode q))
∙∙ cong (encode q +ₖ_) (cong ∣_∣ (sym (transportRefl _))))
stabSpheres : (n : ℕ) → Iso (coHomK (suc n)) (typ (Ω (coHomK-ptd (2 + n))))
fun (stabSpheres n) = decode _
inv' (stabSpheres n) = encode
rightInv (stabSpheres n) p = decode-encode p
leftInv (stabSpheres n) =
trElim (λ _ → isOfHLevelPath (3 + n) (isOfHLevelTrunc (3 + n)) _ _)
λ a → cong encode (congFunct ∣_∣ (merid a) (sym (merid (ptSn (suc n)))))
∙∙ (λ i → transport (congFunct (Code n) (cong ∣_∣ (merid a))
(cong ∣_∣ (sym (merid (ptSn (suc n))))) i) ∣ ptSn (suc n) ∣)
∙∙ (substComposite (λ x → x)
(cong (Code n) (cong ∣_∣ (merid a)))
(cong (Code n) (cong ∣_∣ (sym (merid (ptSn (suc n)))))) ∣ ptSn (suc n) ∣
∙∙ cong (transport (λ i → Code n ∣ merid (ptSn (suc n)) (~ i) ∣))
(transportRefl (∣ (ptSn (suc n)) ∣ +ₖ ∣ a ∣) ∙ lUnitₖ (suc n) ∣ a ∣)
∙∙ symMeridLem n (ptSn (suc n)) ∣ a ∣
∙∙ cong (∣ a ∣ +ₖ_) -0ₖ
∙∙ rUnitₖ (suc n) ∣ a ∣)
Iso-Kn-ΩKn+1 : (n : HLevel) → Iso (coHomK n) (typ (Ω (coHomK-ptd (suc n))))
Iso-Kn-ΩKn+1 zero = invIso (compIso (congIso (truncIdempotentIso _ isGroupoidS¹)) ΩS¹Isoℤ)
Iso-Kn-ΩKn+1 (suc n) = stabSpheres n
Kn≃ΩKn+1 : {n : ℕ} → coHomK n ≃ typ (Ω (coHomK-ptd (suc n)))
Kn≃ΩKn+1 {n = n} = isoToEquiv (Iso-Kn-ΩKn+1 n)
-- Some properties of the Iso
Kn→ΩKn+1 : (n : ℕ) → coHomK n → typ (Ω (coHomK-ptd (suc n)))
Kn→ΩKn+1 n = Iso.fun (Iso-Kn-ΩKn+1 n)
ΩKn+1→Kn : (n : ℕ) → typ (Ω (coHomK-ptd (suc n))) → coHomK n
ΩKn+1→Kn n = Iso.inv (Iso-Kn-ΩKn+1 n)
Kn→ΩKn+10ₖ : (n : ℕ) → Kn→ΩKn+1 n (0ₖ n) ≡ refl
Kn→ΩKn+10ₖ zero = sym (rUnit refl)
Kn→ΩKn+10ₖ (suc n) i j = ∣ (rCancel (merid (ptSn (suc n))) i j) ∣
ΩKn+1→Kn-refl : (n : ℕ) → ΩKn+1→Kn n refl ≡ 0ₖ n
ΩKn+1→Kn-refl zero = refl
ΩKn+1→Kn-refl (suc zero) = refl
ΩKn+1→Kn-refl (suc (suc n)) = refl
Kn≃ΩKn+1∙ : {n : ℕ} → coHomK-ptd n ≡ (Ω (coHomK-ptd (suc n)))
Kn≃ΩKn+1∙ {n = n} = ua∙ Kn≃ΩKn+1 (Kn→ΩKn+10ₖ n)
Kn→ΩKn+1-hom : (n : ℕ) (x y : coHomK n) → Kn→ΩKn+1 n (x +[ n ]ₖ y) ≡ Kn→ΩKn+1 n x ∙ Kn→ΩKn+1 n y
Kn→ΩKn+1-hom zero x y = (λ j i → hfill (doubleComp-faces (λ i₁ → ∣ base ∣) (λ _ → ∣ base ∣) i)
(inS (∣ intLoop (x ℤ+ y) i ∣)) (~ j))
∙∙ (λ j i → ∣ intLoop-hom x y (~ j) i ∣)
∙∙ (congFunct ∣_∣ (intLoop x) (intLoop y)
∙ cong₂ _∙_ (λ j i → hfill (doubleComp-faces (λ i₁ → ∣ base ∣) (λ _ → ∣ base ∣) i)
(inS (∣ intLoop x i ∣)) j)
λ j i → hfill (doubleComp-faces (λ i₁ → ∣ base ∣) (λ _ → ∣ base ∣) i)
(inS (∣ intLoop y i ∣)) j)
Kn→ΩKn+1-hom (suc n) = σ-hom
ΩKn+1→Kn-hom : (n : ℕ) (x y : Path (coHomK (suc n)) (0ₖ _) (0ₖ _))
→ ΩKn+1→Kn n (x ∙ y) ≡ ΩKn+1→Kn n x +[ n ]ₖ ΩKn+1→Kn n y
ΩKn+1→Kn-hom zero p q =
cong winding (congFunct (trRec isGroupoidS¹ (λ x → x)) p q)
∙ winding-hom (cong (trRec isGroupoidS¹ (λ x → x)) p) (cong (trRec isGroupoidS¹ (λ x → x)) q)
ΩKn+1→Kn-hom (suc n) = encode-hom
Kn→ΩKn+1-ₖ : (n : ℕ) (x : coHomK n) → Kn→ΩKn+1 n (-ₖ x) ≡ sym (Kn→ΩKn+1 n x)
Kn→ΩKn+1-ₖ n x =
lUnit _
∙∙ cong (_∙ Kn→ΩKn+1 n (-ₖ x)) (sym (lCancel _))
∙∙ sym (assoc∙ _ _ _)
∙∙ cong (sym (Kn→ΩKn+1 n x) ∙_) help
∙∙ sym (rUnit _)
where
help : Kn→ΩKn+1 n x ∙ Kn→ΩKn+1 n (-ₖ x) ≡ refl
help = sym (Kn→ΩKn+1-hom n x (-ₖ x)) ∙∙ cong (Kn→ΩKn+1 n) (rCancelₖ n x) ∙∙ Kn→ΩKn+10ₖ n
isHomogeneousKn : (n : HLevel) → isHomogeneous (coHomK-ptd n)
isHomogeneousKn n =
subst isHomogeneous
(sym (ΣPathP (ua Kn≃ΩKn+1 , ua-gluePath _ (Kn→ΩKn+10ₖ n))))
(isHomogeneousPath _ _)
-- With the equivalence Kn≃ΩKn+1, we get that the two definitions of cohomology groups agree
open IsGroupHom
coHom≅coHomΩ : ∀ {ℓ} (n : ℕ) (A : Type ℓ) → GroupIso (coHomGr n A) (coHomGrΩ n A)
fun (fst (coHom≅coHomΩ n A)) = map λ f a → Kn→ΩKn+1 n (f a)
inv' (fst (coHom≅coHomΩ n A)) = map λ f a → ΩKn+1→Kn n (f a)
rightInv (fst (coHom≅coHomΩ n A)) =
sElim (λ _ → isOfHLevelPath 2 § _ _)
λ f → cong ∣_∣₂ (funExt λ x → rightInv (Iso-Kn-ΩKn+1 n) (f x))
leftInv (fst (coHom≅coHomΩ n A)) =
sElim (λ _ → isOfHLevelPath 2 § _ _)
λ f → cong ∣_∣₂ (funExt λ x → leftInv (Iso-Kn-ΩKn+1 n) (f x))
snd (coHom≅coHomΩ n A) =
makeIsGroupHom
(sElim2 (λ _ _ → isOfHLevelPath 2 § _ _)
λ f g → cong ∣_∣₂ (funExt λ x → Kn→ΩKn+1-hom n (f x) (g x)))
module lockedKnIso (key : Unit') where
Kn→ΩKn+1' : (n : ℕ) → coHomK n → typ (Ω (coHomK-ptd (suc n)))
Kn→ΩKn+1' n = lock key (Iso.fun (Iso-Kn-ΩKn+1 n))
ΩKn+1→Kn' : (n : ℕ) → typ (Ω (coHomK-ptd (suc n))) → coHomK n
ΩKn+1→Kn' n = lock key (Iso.inv (Iso-Kn-ΩKn+1 n))
ΩKn+1→Kn→ΩKn+1 : (n : ℕ) → (x : typ (Ω (coHomK-ptd (suc n)))) → Kn→ΩKn+1' n (ΩKn+1→Kn' n x) ≡ x
ΩKn+1→Kn→ΩKn+1 n x = pm key
where
pm : (key : Unit') → lock key (Iso.fun (Iso-Kn-ΩKn+1 n)) (lock key (Iso.inv (Iso-Kn-ΩKn+1 n)) x) ≡ x
pm unlock = Iso.rightInv (Iso-Kn-ΩKn+1 n) x
Kn→ΩKn+1→Kn : (n : ℕ) → (x : coHomK n) → ΩKn+1→Kn' n (Kn→ΩKn+1' n x) ≡ x
Kn→ΩKn+1→Kn n x = pm key
where
pm : (key : Unit') → lock key (Iso.inv (Iso-Kn-ΩKn+1 n)) (lock key (Iso.fun (Iso-Kn-ΩKn+1 n)) x) ≡ x
pm unlock = Iso.leftInv (Iso-Kn-ΩKn+1 n) x
-distrLemma : ∀ {ℓ ℓ'} {A : Type ℓ} {B : Type ℓ'} (n m : ℕ) (f : GroupHom (coHomGr n A) (coHomGr m B))
(x y : coHom n A)
→ fst f (x -[ n ]ₕ y) ≡ fst f x -[ m ]ₕ fst f y
-distrLemma n m f' x y = sym (-cancelRₕ m (f y) (f (x -[ n ]ₕ y)))
∙∙ cong (λ x → x -[ m ]ₕ f y) (sym (f' .snd .pres· (x -[ n ]ₕ y) y))
∙∙ cong (λ x → x -[ m ]ₕ f y) ( cong f (-+cancelₕ n _ _))
where
f = fst f'
-- HLevel stuff for cup product
isContr-↓∙ : (n : ℕ) → isContr (coHomK-ptd (suc n) →∙ coHomK-ptd n)
fst (isContr-↓∙ zero) = (λ _ → 0) , refl
snd (isContr-↓∙ zero) (f , p) =
Σ≡Prop (λ f → isSetℤ _ _)
(funExt (trElim (λ _ → isOfHLevelPath 3 (isOfHLevelSuc 2 isSetℤ) _ _)
(toPropElim (λ _ → isSetℤ _ _) (sym p))))
fst (isContr-↓∙ (suc n)) = (λ _ → 0ₖ _) , refl
fst (snd (isContr-↓∙ (suc n)) f i) x =
trElim {B = λ x → 0ₖ (suc n) ≡ fst f x}
(λ _ → isOfHLevelPath (4 + n) (isOfHLevelSuc (3 + n) (isOfHLevelTrunc (3 + n))) _ _)
(sphereElim _ (λ _ → isOfHLevelTrunc (3 + n) _ _)
(sym (snd f))) x i
snd (snd (isContr-↓∙ (suc n)) f i) j = snd f (~ i ∨ j)
isContr-↓∙' : (n : ℕ) → isContr (S₊∙ (suc n) →∙ coHomK-ptd n)
fst (isContr-↓∙' zero) = (λ _ → 0) , refl
snd (isContr-↓∙' zero) (f , p) =
Σ≡Prop (λ f → isSetℤ _ _)
(funExt (toPropElim (λ _ → isSetℤ _ _) (sym p)))
fst (isContr-↓∙' (suc n)) = (λ _ → 0ₖ _) , refl
fst (snd (isContr-↓∙' (suc n)) f i) x =
sphereElim _ {A = λ x → 0ₖ (suc n) ≡ fst f x}
(λ _ → isOfHLevelTrunc (3 + n) _ _)
(sym (snd f)) x i
snd (snd (isContr-↓∙' (suc n)) f i) j = snd f (~ i ∨ j)
isOfHLevel→∙Kn : {A : Pointed₀} (n m : ℕ)
→ isOfHLevel (suc m) (A →∙ coHomK-ptd n) → isOfHLevel (suc (suc m)) (A →∙ coHomK-ptd (suc n))
isOfHLevel→∙Kn {A = A} n m hlev = step₃
where
step₁ : isOfHLevel (suc m) (A →∙ Ω (coHomK-ptd (suc n)))
step₁ =
subst (isOfHLevel (suc m))
(λ i → A →∙ ua∙ {A = Ω (coHomK-ptd (suc n))} {B = coHomK-ptd n}
(invEquiv Kn≃ΩKn+1)
(ΩKn+1→Kn-refl n) (~ i)) hlev
step₂ : isOfHLevel (suc m) (typ (Ω (A →∙ coHomK-ptd (suc n) ∙)))
step₂ = isOfHLevelRetractFromIso (suc m) (invIso (invIso (ΩfunExtIso _ _))) step₁
step₃ : isOfHLevel (suc (suc m)) (A →∙ coHomK-ptd (suc n))
step₃ =
isOfHLevelΩ→isOfHLevel m
λ f → subst (λ x → isOfHLevel (suc m) (typ (Ω x)))
(isHomogeneous→∙ (isHomogeneousKn (suc n)) f)
step₂
isOfHLevel↑∙ : ∀ n m → isOfHLevel (2 + n) (coHomK-ptd (suc m) →∙ coHomK-ptd (suc (n + m)))
isOfHLevel↑∙ zero m = isOfHLevel→∙Kn m 0 (isContr→isProp (isContr-↓∙ m))
isOfHLevel↑∙ (suc n) m = isOfHLevel→∙Kn (suc (n + m)) (suc n) (isOfHLevel↑∙ n m)
isOfHLevel↑∙' : ∀ n m → isOfHLevel (2 + n) (S₊∙ (suc m) →∙ coHomK-ptd (suc (n + m)))
isOfHLevel↑∙' zero m = isOfHLevel→∙Kn m 0 (isContr→isProp (isContr-↓∙' m))
isOfHLevel↑∙' (suc n) m = isOfHLevel→∙Kn (suc (n + m)) (suc n) (isOfHLevel↑∙' n m)
→∙KnPath : (A : Pointed₀) (n : ℕ) → Ω (A →∙ coHomK-ptd (suc n) ∙) ≡ (A →∙ coHomK-ptd n ∙)
→∙KnPath A n =
ua∙ (isoToEquiv (ΩfunExtIso A (coHomK-ptd (suc n)))) refl
∙ (λ i → (A →∙ Kn≃ΩKn+1∙ {n = n} (~ i) ∙))
contr∙-lem : (n m : ℕ)
→ isContr (coHomK-ptd (suc n)
→∙ (coHomK-ptd (suc m)
→∙ coHomK-ptd (suc (n + m)) ∙))
fst (contr∙-lem n m) = (λ _ → (λ _ → 0ₖ _) , refl) , refl
snd (contr∙-lem n m) (f , p) = →∙Homogeneous≡ (isHomogeneous→∙ (isHomogeneousKn _)) (sym (funExt help))
where
help : (x : _) → (f x) ≡ ((λ _ → 0ₖ _) , refl)
help =
trElim (λ _ → isOfHLevelPath (3 + n)
(subst (λ x → isOfHLevel x (coHomK-ptd (suc m) →∙ coHomK-ptd (suc (n + m)))) (λ i → suc (suc (+-comm n 1 i)))
(isOfHLevelPlus' {n = 1} (2 + n) (isOfHLevel↑∙ n m))) _ _)
(sphereElim _ (λ _ → isOfHLevel↑∙ n m _ _) p)
isOfHLevel↑∙∙ : ∀ n m l
→ isOfHLevel (2 + l) (coHomK-ptd (suc n)
→∙ (coHomK-ptd (suc m)
→∙ coHomK-ptd (suc (suc (l + n + m))) ∙))
isOfHLevel↑∙∙ n m zero =
isOfHLevelΩ→isOfHLevel 0 λ f
→ subst
isProp (cong (λ x → typ (Ω x))
(isHomogeneous→∙ (isHomogeneous→∙ (isHomogeneousKn _)) f))
(isOfHLevelRetractFromIso 1 (ΩfunExtIso _ _) h)
where
h : isProp (coHomK-ptd (suc n)
→∙ (Ω (coHomK-ptd (suc m)
→∙ coHomK-ptd (suc (suc (n + m))) ∙)))
h =
subst isProp (λ i → coHomK-ptd (suc n) →∙ (→∙KnPath (coHomK-ptd (suc m)) (suc (n + m)) (~ i)))
(isContr→isProp (contr∙-lem n m))
isOfHLevel↑∙∙ n m (suc l) =
isOfHLevelΩ→isOfHLevel (suc l)
λ f →
subst
(isOfHLevel (2 + l)) (cong (λ x → typ (Ω x))
(isHomogeneous→∙ (isHomogeneous→∙ (isHomogeneousKn _)) f))
(isOfHLevelRetractFromIso (2 + l) (ΩfunExtIso _ _) h)
where
h : isOfHLevel (2 + l)
(coHomK-ptd (suc n)
→∙ (Ω (coHomK-ptd (suc m)
→∙ coHomK-ptd (suc (suc (suc (l + n + m)))) ∙)))
h =
subst (isOfHLevel (2 + l))
(λ i → coHomK-ptd (suc n) →∙ →∙KnPath (coHomK-ptd (suc m)) (suc (suc (l + n + m))) (~ i))
(isOfHLevel↑∙∙ n m l)
----------- Misc. ------------
isoType→isoCohom : {A : Type ℓ} {B : Type ℓ'} (n : ℕ)
→ Iso A B
→ GroupIso (coHomGr n A) (coHomGr n B)
fst (isoType→isoCohom n is) = setTruncIso (domIso is)
snd (isoType→isoCohom n is) =
makeIsGroupHom (sElim2 (λ _ _ → isOfHLevelPath 2 squash₂ _ _)
(λ _ _ → refl))
-- Explicit index swapping for cohomology groups
transportCohomIso : {A : Type ℓ} {n m : ℕ}
→ (p : n ≡ m)
→ GroupIso (coHomGr n A) (coHomGr m A)
Iso.fun (fst (transportCohomIso {A = A} p)) = subst (λ n → coHom n A) p
Iso.inv (fst (transportCohomIso {A = A} p)) = subst (λ n → coHom n A) (sym p)
Iso.rightInv (fst (transportCohomIso p)) = transportTransport⁻ _
Iso.leftInv (fst (transportCohomIso p)) = transportTransport⁻ _
snd (transportCohomIso {A = A} {n = n} {m = m} p) =
makeIsGroupHom (λ x y → help x y p)
where
help : (x y : coHom n A) (p : n ≡ m)
→ subst (λ n → coHom n A) p (x +ₕ y)
≡ subst (λ n → coHom n A) p x +ₕ subst (λ n → coHom n A) p y
help x y =
J (λ m p → subst (λ n → coHom n A) p (x +ₕ y)
≡ subst (λ n → coHom n A) p x +ₕ subst (λ n → coHom n A) p y)
(transportRefl (x +ₕ y)
∙ cong₂ _+ₕ_ (sym (transportRefl x)) (sym (transportRefl y)))
| 47.545185
| 132
| 0.518867
|
5739152ac8392426a996d4699e39e8754133cc5b
| 1,271
|
agda
|
Agda
|
Cubical/HITs/ListedFiniteSet/Properties.agda
|
jorge-jbs/cubical
|
ebbe824fda41ab6524b62a42959665be4e67b847
|
[
"MIT"
] | null | null | null |
Cubical/HITs/ListedFiniteSet/Properties.agda
|
jorge-jbs/cubical
|
ebbe824fda41ab6524b62a42959665be4e67b847
|
[
"MIT"
] | 1
|
2022-01-27T02:07:48.000Z
|
2022-01-27T02:07:48.000Z
|
Cubical/HITs/ListedFiniteSet/Properties.agda
|
jorge-jbs/cubical
|
ebbe824fda41ab6524b62a42959665be4e67b847
|
[
"MIT"
] | null | null | null |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.ListedFiniteSet.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.HITs.ListedFiniteSet.Base
private
variable
A : Type₀
_++_ : ∀ (xs ys : LFSet A) → LFSet A
[] ++ ys = ys
(x ∷ xs) ++ ys = x ∷ (xs ++ ys)
---------------------------------------------
dup x xs i ++ ys = proof i
where
proof :
-- Need: (x ∷ x ∷ xs) ++ ys ≡ (x ∷ xs) ++ ys
-- which reduces to:
x ∷ x ∷ (xs ++ ys) ≡ x ∷ (xs ++ ys)
proof = dup x (xs ++ ys)
comm x y xs i ++ ys = comm x y (xs ++ ys) i
trunc xs zs p q i j ++ ys
= trunc (xs ++ ys) (zs ++ ys) (cong (_++ ys) p) (cong (_++ ys) q) i j
assoc-++ : ∀ (xs : LFSet A) ys zs → xs ++ (ys ++ zs) ≡ (xs ++ ys) ++ zs
assoc-++ [] ys zs = refl
assoc-++ (x ∷ xs) ys zs
= cong (x ∷_) (assoc-++ xs ys zs)
------------------------------------
assoc-++ (dup x xs i) ys zs j
= dup x (assoc-++ xs ys zs j) i
assoc-++ (comm x y xs i) ys zs j
= comm x y (assoc-++ xs ys zs j) i
assoc-++ (trunc xs xs' p q i k) ys zs j
= trunc (assoc-++ xs ys zs j) (assoc-++ xs' ys zs j)
(cong (\ xs -> assoc-++ xs ys zs j) p) (cong (\ xs -> assoc-++ xs ys zs j) q) i k
| 31.775
| 91
| 0.461841
|
11f6444f4bde817bca774e7d2bce2e31aed8a1ed
| 857
|
agda
|
Agda
|
test/Succeed/Issue175b.agda
|
LaloHao/agda
|
7de768bb7bc65dbe1efa35c699cfa8b8f9510573
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Succeed/Issue175b.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Succeed/Issue175b.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
module Issue175b where
data _≡_ {A : Set}(x : A) : A → Set where
refl : x ≡ x
data Bool : Set where
true : Bool
false : Bool
{-# BUILTIN BOOL Bool #-}
{-# BUILTIN TRUE true #-}
{-# BUILTIN FALSE false #-}
postulate ℝ : Set
{-# BUILTIN FLOAT ℝ #-}
primitive
-- ℝ functions
primFloatMinus : ℝ -> ℝ -> ℝ
primFloatLess : ℝ -> ℝ -> Bool
_<_ : ℝ -> ℝ -> Bool
a < b = primFloatLess a b
data _≤_ : ℝ -> ℝ -> Set where
≤_ : {x y : ℝ} -> (x < y) ≡ true -> x ≤ y
--absolute value
[|_|] : ℝ -> ℝ
[| a |] with (a < 0.0)
[| a |] | true = primFloatMinus 0.0 a
[| a |] | false = a
--error variable
ε : ℝ
ε = 1.0e-5
-- two floating point numbers can be said to be equal if their
-- difference is less than the given error variable
postulate
reflℝ : {a b : ℝ} -> [| primFloatMinus a b |] ≤ ε -> a ≡ b
test : 1.0 ≡ 1.0000001
test = reflℝ (≤ refl)
| 19.044444
| 62
| 0.567095
|
435c035a5a9f25557d808476ee64c45a557de8d3
| 935
|
agda
|
Agda
|
Cubical/Data/Int/Base.agda
|
kiana-S/univalent-foundations
|
8bdb0766260489f9c89a14f4c0f2ad26e5190dec
|
[
"MIT"
] | null | null | null |
Cubical/Data/Int/Base.agda
|
kiana-S/univalent-foundations
|
8bdb0766260489f9c89a14f4c0f2ad26e5190dec
|
[
"MIT"
] | null | null | null |
Cubical/Data/Int/Base.agda
|
kiana-S/univalent-foundations
|
8bdb0766260489f9c89a14f4c0f2ad26e5190dec
|
[
"MIT"
] | null | null | null |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Data.Int.Base where
open import Cubical.Core.Everything
open import Cubical.Data.Nat
data ℤ : Type₀ where
pos : (n : ℕ) → ℤ
negsuc : (n : ℕ) → ℤ
neg : (n : ℕ) → ℤ
neg zero = pos zero
neg (suc n) = negsuc n
infix 100 -_
-_ : ℕ → ℤ
-_ = neg
{-# DISPLAY pos n = n #-}
{-# DISPLAY negsuc n = - (suc n) #-}
sucInt : ℤ → ℤ
sucInt (pos n) = pos (suc n)
sucInt (negsuc zero) = pos zero
sucInt (negsuc (suc n)) = negsuc n
predInt : ℤ → ℤ
predInt (pos zero) = negsuc zero
predInt (pos (suc n)) = pos n
predInt (negsuc n) = negsuc (suc n)
-- Natural number and negative integer literals for ℤ
open import Cubical.Data.Nat.Literals public
instance
fromNatℤ : FromNat ℤ
fromNatℤ = record { Constraint = λ _ → ⊤ ; fromNat = λ n → pos n }
instance
negativeℤ : Negative ℤ
negativeℤ = record { Constraint = λ _ → ⊤ ; fromNeg = λ n → neg n }
| 21.25
| 69
| 0.62139
|
0d20e214e3f50e3ca0ee50bafaa67ca47f1416e6
| 24
|
agda
|
Agda
|
examples/outdated-and-incorrect/Alonzo/Primitive.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
examples/outdated-and-incorrect/Alonzo/Primitive.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
examples/outdated-and-incorrect/Alonzo/Primitive.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
module Primitive where
| 8
| 22
| 0.833333
|
373230121e7b041d44642aa0f0d79e1432ac1912
| 566
|
agda
|
Agda
|
Type/Properties/Singleton.agda
|
Lolirofle/stuff-in-agda
|
70f4fba849f2fd779c5aaa5af122ccb6a5b271ba
|
[
"MIT"
] | 6
|
2020-04-07T17:58:13.000Z
|
2022-02-05T06:53:22.000Z
|
Type/Properties/Singleton.agda
|
Lolirofle/stuff-in-agda
|
70f4fba849f2fd779c5aaa5af122ccb6a5b271ba
|
[
"MIT"
] | null | null | null |
Type/Properties/Singleton.agda
|
Lolirofle/stuff-in-agda
|
70f4fba849f2fd779c5aaa5af122ccb6a5b271ba
|
[
"MIT"
] | null | null | null |
module Type.Properties.Singleton {ℓ ℓₑ} where
import Lvl
open import Lang.Instance
open import Structure.Setoid
open import Type
-- A type is a singleton type when it has exactly one inhabitant (there is only one object with this type).
-- In other words: There is an unique inhabitant of type T.
-- Also called:
-- • "singleton type"
-- • "unit type"
-- • "contractible"
record IsUnit (T : Type{ℓ}) ⦃ _ : Equiv{ℓₑ}(T) ⦄ : Type{ℓ Lvl.⊔ ℓₑ} where
constructor intro
field
unit : T
uniqueness : ∀{x : T} → (x ≡ unit)
open IsUnit ⦃ ... ⦄ using (unit)
| 28.3
| 107
| 0.671378
|
3f9946c26680b774ff7f8730ad03886e3352e53a
| 92
|
agda
|
Agda
|
test/Succeed/Issue2332.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Succeed/Issue2332.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Succeed/Issue2332.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
record R : Set₁
where
field
_f_ : Set → Set
postulate A : Set
I₁ : R
I₁ R.f x = A
| 8.363636
| 19
| 0.565217
|
30605e9621b8d6f53917fb547887edab10e422b7
| 2,194
|
agda
|
Agda
|
src/Categories/Morphism/Properties.agda
|
jaykru/agda-categories
|
a4053cf700bcefdf73b857c3352f1eae29382a60
|
[
"MIT"
] | 5
|
2020-10-07T12:07:53.000Z
|
2020-10-10T21:41:32.000Z
|
src/Categories/Morphism/Properties.agda
|
jaykru/agda-categories
|
a4053cf700bcefdf73b857c3352f1eae29382a60
|
[
"MIT"
] | null | null | null |
src/Categories/Morphism/Properties.agda
|
jaykru/agda-categories
|
a4053cf700bcefdf73b857c3352f1eae29382a60
|
[
"MIT"
] | 1
|
2021-11-04T06:54:45.000Z
|
2021-11-04T06:54:45.000Z
|
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Morphism.Properties {o ℓ e} (𝒞 : Category o ℓ e) where
open import Data.Product using (_,_; _×_)
open Category 𝒞
open Definitions 𝒞
open HomReasoning
import Categories.Morphism as M
open M 𝒞
open import Categories.Morphism.Reasoning 𝒞
private
variable
A B C D : Obj
f g h i : A ⇒ B
module _ (iso : Iso f g) where
open Iso iso
Iso-resp-≈ : f ≈ h → g ≈ i → Iso h i
Iso-resp-≈ {h = h} {i = i} eq₁ eq₂ = record
{ isoˡ = begin
i ∘ h ≈˘⟨ eq₂ ⟩∘⟨ eq₁ ⟩
g ∘ f ≈⟨ isoˡ ⟩
id ∎
; isoʳ = begin
h ∘ i ≈˘⟨ eq₁ ⟩∘⟨ eq₂ ⟩
f ∘ g ≈⟨ isoʳ ⟩
id ∎
}
Iso-swap : Iso g f
Iso-swap = record
{ isoˡ = isoʳ
; isoʳ = isoˡ
}
Iso⇒Mono : Mono f
Iso⇒Mono h i eq = begin
h ≈⟨ introˡ isoˡ ⟩
(g ∘ f) ∘ h ≈⟨ pullʳ eq ⟩
g ∘ f ∘ i ≈⟨ cancelˡ isoˡ ⟩
i ∎
Iso⇒Epi : Epi f
Iso⇒Epi h i eq = begin
h ≈⟨ introʳ isoʳ ⟩
h ∘ f ∘ g ≈⟨ pullˡ eq ⟩
(i ∘ f) ∘ g ≈⟨ cancelʳ isoʳ ⟩
i ∎
Iso-∘ : Iso f g → Iso h i → Iso (h ∘ f) (g ∘ i)
Iso-∘ {f = f} {g = g} {h = h} {i = i} iso iso′ = record
{ isoˡ = begin
(g ∘ i) ∘ h ∘ f ≈⟨ cancelInner (isoˡ iso′) ⟩
g ∘ f ≈⟨ isoˡ iso ⟩
id ∎
; isoʳ = begin
(h ∘ f) ∘ g ∘ i ≈⟨ cancelInner (isoʳ iso) ⟩
h ∘ i ≈⟨ isoʳ iso′ ⟩
id ∎
}
where open Iso
Iso-≈ : f ≈ h → Iso f g → Iso h i → g ≈ i
Iso-≈ {f = f} {h = h} {g = g} {i = i} eq iso iso′ = begin
g ≈⟨ introˡ (isoˡ iso′) ⟩
(i ∘ h) ∘ g ≈˘⟨ (refl⟩∘⟨ eq) ⟩∘⟨refl ⟩
(i ∘ f) ∘ g ≈⟨ cancelʳ (isoʳ iso) ⟩
i ∎
where open Iso
module _ where
open _≅_
isos×≈⇒≈ : ∀ {f g : A ⇒ B} → h ≈ i → (iso₁ : A ≅ C) → (iso₂ : B ≅ D) →
CommutativeSquare f (from iso₁) (from iso₂) h →
CommutativeSquare g (from iso₁) (from iso₂) i →
f ≈ g
isos×≈⇒≈ {h = h} {i = i} {f = f} {g = g} eq iso₁ iso₂ sq₁ sq₂ = begin
f ≈⟨ switch-fromtoˡ iso₂ sq₁ ⟩
to iso₂ ∘ h ∘ from iso₁ ≈⟨ refl⟩∘⟨ (eq ⟩∘⟨refl ) ⟩
to iso₂ ∘ i ∘ from iso₁ ≈˘⟨ switch-fromtoˡ iso₂ sq₂ ⟩
g ∎
| 24.377778
| 72
| 0.466727
|
147c3610c58f25187946147a6e638ef893782b78
| 70
|
agda
|
Agda
|
a/Agda.agda
|
tylerlmccart/hello-world
|
7368535ee06d277b23b06be10fe4475cff89e8f6
|
[
"MIT"
] | 8,076
|
2015-01-02T04:55:03.000Z
|
2022-03-31T16:09:18.000Z
|
a/Agda.agda
|
tylerlmccart/hello-world
|
7368535ee06d277b23b06be10fe4475cff89e8f6
|
[
"MIT"
] | 514
|
2015-01-08T21:48:21.000Z
|
2022-03-31T11:55:07.000Z
|
a/Agda.agda
|
tylerlmccart/hello-world
|
7368535ee06d277b23b06be10fe4475cff89e8f6
|
[
"MIT"
] | 1,978
|
2015-01-01T14:24:01.000Z
|
2022-03-31T11:38:08.000Z
|
module agda where
open import IO
main = run (putStrLn "Hello World")
| 14
| 35
| 0.742857
|
7c3f034774c1d9a6d7ec78500f2041edbb40bf48
| 5,647
|
agda
|
Agda
|
BasicICML/Syntax/DyadicGentzenSpinalNormalForm.agda
|
mietek/hilbert-gentzen
|
fcd187db70f0a39b894fe44fad0107f61849405c
|
[
"X11"
] | 29
|
2016-07-03T18:51:56.000Z
|
2022-01-01T10:29:18.000Z
|
BasicICML/Syntax/DyadicGentzenSpinalNormalForm.agda
|
mietek/hilbert-gentzen
|
fcd187db70f0a39b894fe44fad0107f61849405c
|
[
"X11"
] | 1
|
2018-06-10T09:11:22.000Z
|
2018-06-10T09:11:22.000Z
|
BasicICML/Syntax/DyadicGentzenSpinalNormalForm.agda
|
mietek/hilbert-gentzen
|
fcd187db70f0a39b894fe44fad0107f61849405c
|
[
"X11"
] | null | null | null |
-- Basic intuitionistic contextual modal logic, without ∨ or ⊥.
-- Gentzen-style formalisation of syntax with context pairs, after Nanevski-Pfenning-Pientka.
-- Normal forms, neutrals, and spines.
module BasicICML.Syntax.DyadicGentzenSpinalNormalForm where
open import BasicICML.Syntax.DyadicGentzen public
-- Commuting propositions for neutrals.
data Tyⁿᵉ : Ty → Set where
α_ : (P : Atom) → Tyⁿᵉ (α P)
[_]_ : (Ψ : Cx Ty) (A : Ty) → Tyⁿᵉ ([ Ψ ] A)
-- Derivations.
mutual
-- Normal forms, or introductions.
infix 3 _⊢ⁿᶠ_
data _⊢ⁿᶠ_ : Cx² Ty Box → Ty → Set where
neⁿᶠ : ∀ {A Γ Δ} → Γ ⁏ Δ ⊢ⁿᵉ A → {{_ : Tyⁿᵉ A}} → Γ ⁏ Δ ⊢ⁿᶠ A
lamⁿᶠ : ∀ {A B Γ Δ} → Γ , A ⁏ Δ ⊢ⁿᶠ B → Γ ⁏ Δ ⊢ⁿᶠ A ▻ B
boxⁿᶠ : ∀ {Ψ A Γ Δ} → Ψ ⁏ Δ ⊢ⁿᶠ A → Γ ⁏ Δ ⊢ⁿᶠ [ Ψ ] A
pairⁿᶠ : ∀ {A B Γ Δ} → Γ ⁏ Δ ⊢ⁿᶠ A → Γ ⁏ Δ ⊢ⁿᶠ B → Γ ⁏ Δ ⊢ⁿᶠ A ∧ B
unitⁿᶠ : ∀ {Γ Δ} → Γ ⁏ Δ ⊢ⁿᶠ ⊤
-- Neutrals, or eliminations.
infix 3 _⊢ⁿᵉ_
data _⊢ⁿᵉ_ : Cx² Ty Box → Ty → Set where
spⁿᵉ : ∀ {A B C Γ Δ} → A ∈ Γ → Γ ⁏ Δ ⊢ˢᵖ A ⦙ B → Γ ⁏ Δ ⊢ᵗᵖ B ⦙ C → Γ ⁏ Δ ⊢ⁿᵉ C
mspⁿᵉ : ∀ {Ψ A B C Γ Δ} → [ Ψ ] A ∈ Δ → {{_ : Γ ⁏ Δ ⊢⋆ⁿᶠ Ψ}} → Γ ⁏ Δ ⊢ˢᵖ A ⦙ B → Γ ⁏ Δ ⊢ᵗᵖ B ⦙ C → Γ ⁏ Δ ⊢ⁿᵉ C
-- Spines.
infix 3 _⊢ˢᵖ_⦙_
data _⊢ˢᵖ_⦙_ : Cx² Ty Box → Ty → Ty → Set where
nilˢᵖ : ∀ {C Γ Δ} → Γ ⁏ Δ ⊢ˢᵖ C ⦙ C
appˢᵖ : ∀ {A B C Γ Δ} → Γ ⁏ Δ ⊢ˢᵖ B ⦙ C → Γ ⁏ Δ ⊢ⁿᶠ A → Γ ⁏ Δ ⊢ˢᵖ A ▻ B ⦙ C
fstˢᵖ : ∀ {A B C Γ Δ} → Γ ⁏ Δ ⊢ˢᵖ A ⦙ C → Γ ⁏ Δ ⊢ˢᵖ A ∧ B ⦙ C
sndˢᵖ : ∀ {A B C Γ Δ} → Γ ⁏ Δ ⊢ˢᵖ B ⦙ C → Γ ⁏ Δ ⊢ˢᵖ A ∧ B ⦙ C
-- Spine tips.
infix 3 _⊢ᵗᵖ_⦙_
data _⊢ᵗᵖ_⦙_ : Cx² Ty Box → Ty → Ty → Set where
nilᵗᵖ : ∀ {C Γ Δ} → Γ ⁏ Δ ⊢ᵗᵖ C ⦙ C
unboxᵗᵖ : ∀ {Ψ A C Γ Δ} → Γ ⁏ Δ , [ Ψ ] A ⊢ⁿᶠ C → Γ ⁏ Δ ⊢ᵗᵖ [ Ψ ] A ⦙ C
infix 3 _⊢⋆ⁿᶠ_
_⊢⋆ⁿᶠ_ : Cx² Ty Box → Cx Ty → Set
Γ ⁏ Δ ⊢⋆ⁿᶠ ∅ = 𝟙
Γ ⁏ Δ ⊢⋆ⁿᶠ Ξ , A = Γ ⁏ Δ ⊢⋆ⁿᶠ Ξ × Γ ⁏ Δ ⊢ⁿᶠ A
-- Translation to simple terms.
mutual
nf→tm : ∀ {A Γ Δ} → Γ ⁏ Δ ⊢ⁿᶠ A → Γ ⁏ Δ ⊢ A
nf→tm (neⁿᶠ t) = ne→tm t
nf→tm (lamⁿᶠ t) = lam (nf→tm t)
nf→tm (boxⁿᶠ t) = box (nf→tm t)
nf→tm (pairⁿᶠ t u) = pair (nf→tm t) (nf→tm u)
nf→tm unitⁿᶠ = unit
ne→tm : ∀ {A Γ Δ} → Γ ⁏ Δ ⊢ⁿᵉ A → Γ ⁏ Δ ⊢ A
ne→tm (spⁿᵉ i xs y) = tp→tm (var i) xs y
ne→tm (mspⁿᵉ i {{ts}} xs y) = tp→tm (mvar i {{nf→tm⋆ ts}}) xs y
sp→tm : ∀ {A C Γ Δ} → Γ ⁏ Δ ⊢ A → Γ ⁏ Δ ⊢ˢᵖ A ⦙ C → Γ ⁏ Δ ⊢ C
sp→tm t nilˢᵖ = t
sp→tm t (appˢᵖ xs u) = sp→tm (app t (nf→tm u)) xs
sp→tm t (fstˢᵖ xs) = sp→tm (fst t) xs
sp→tm t (sndˢᵖ xs) = sp→tm (snd t) xs
tp→tm : ∀ {A B C Γ Δ} → Γ ⁏ Δ ⊢ A → Γ ⁏ Δ ⊢ˢᵖ A ⦙ B → Γ ⁏ Δ ⊢ᵗᵖ B ⦙ C → Γ ⁏ Δ ⊢ C
tp→tm t xs nilᵗᵖ = sp→tm t xs
tp→tm t xs (unboxᵗᵖ u) = unbox (sp→tm t xs) (nf→tm u)
nf→tm⋆ : ∀ {Ξ Γ Δ} → Γ ⁏ Δ ⊢⋆ⁿᶠ Ξ → Γ ⁏ Δ ⊢⋆ Ξ
nf→tm⋆ {∅} ∙ = ∙
nf→tm⋆ {Ξ , A} (ts , t) = nf→tm⋆ ts , nf→tm t
-- Monotonicity with respect to context inclusion.
mutual
mono⊢ⁿᶠ : ∀ {A Γ Γ′ Δ} → Γ ⊆ Γ′ → Γ ⁏ Δ ⊢ⁿᶠ A → Γ′ ⁏ Δ ⊢ⁿᶠ A
mono⊢ⁿᶠ η (neⁿᶠ t) = neⁿᶠ (mono⊢ⁿᵉ η t)
mono⊢ⁿᶠ η (lamⁿᶠ t) = lamⁿᶠ (mono⊢ⁿᶠ (keep η) t)
mono⊢ⁿᶠ η (boxⁿᶠ t) = boxⁿᶠ t
mono⊢ⁿᶠ η (pairⁿᶠ t u) = pairⁿᶠ (mono⊢ⁿᶠ η t) (mono⊢ⁿᶠ η u)
mono⊢ⁿᶠ η unitⁿᶠ = unitⁿᶠ
mono⊢ⁿᵉ : ∀ {A Γ Γ′ Δ} → Γ ⊆ Γ′ → Γ ⁏ Δ ⊢ⁿᵉ A → Γ′ ⁏ Δ ⊢ⁿᵉ A
mono⊢ⁿᵉ η (spⁿᵉ i xs y) = spⁿᵉ (mono∈ η i) (mono⊢ˢᵖ η xs) (mono⊢ᵗᵖ η y)
mono⊢ⁿᵉ η (mspⁿᵉ i {{ts}} xs y) = mspⁿᵉ i {{mono⊢⋆ⁿᶠ η ts}} (mono⊢ˢᵖ η xs) (mono⊢ᵗᵖ η y)
mono⊢ˢᵖ : ∀ {A C Γ Γ′ Δ} → Γ ⊆ Γ′ → Γ ⁏ Δ ⊢ˢᵖ A ⦙ C → Γ′ ⁏ Δ ⊢ˢᵖ A ⦙ C
mono⊢ˢᵖ η nilˢᵖ = nilˢᵖ
mono⊢ˢᵖ η (appˢᵖ xs u) = appˢᵖ (mono⊢ˢᵖ η xs) (mono⊢ⁿᶠ η u)
mono⊢ˢᵖ η (fstˢᵖ xs) = fstˢᵖ (mono⊢ˢᵖ η xs)
mono⊢ˢᵖ η (sndˢᵖ xs) = sndˢᵖ (mono⊢ˢᵖ η xs)
mono⊢ᵗᵖ : ∀ {A C Γ Γ′ Δ} → Γ ⊆ Γ′ → Γ ⁏ Δ ⊢ᵗᵖ A ⦙ C → Γ′ ⁏ Δ ⊢ᵗᵖ A ⦙ C
mono⊢ᵗᵖ η nilᵗᵖ = nilᵗᵖ
mono⊢ᵗᵖ η (unboxᵗᵖ u) = unboxᵗᵖ (mono⊢ⁿᶠ η u)
mono⊢⋆ⁿᶠ : ∀ {Ξ Γ Γ′ Δ} → Γ ⊆ Γ′ → Γ ⁏ Δ ⊢⋆ⁿᶠ Ξ → Γ′ ⁏ Δ ⊢⋆ⁿᶠ Ξ
mono⊢⋆ⁿᶠ {∅} η ∙ = ∙
mono⊢⋆ⁿᶠ {Ξ , A} η (ts , t) = mono⊢⋆ⁿᶠ η ts , mono⊢ⁿᶠ η t
-- Monotonicity with respect to modal context inclusion.
mutual
mmono⊢ⁿᶠ : ∀ {A Γ Δ Δ′} → Δ ⊆ Δ′ → Γ ⁏ Δ ⊢ⁿᶠ A → Γ ⁏ Δ′ ⊢ⁿᶠ A
mmono⊢ⁿᶠ θ (neⁿᶠ t) = neⁿᶠ (mmono⊢ⁿᵉ θ t)
mmono⊢ⁿᶠ θ (lamⁿᶠ t) = lamⁿᶠ (mmono⊢ⁿᶠ θ t)
mmono⊢ⁿᶠ θ (boxⁿᶠ t) = boxⁿᶠ (mmono⊢ⁿᶠ θ t)
mmono⊢ⁿᶠ θ (pairⁿᶠ t u) = pairⁿᶠ (mmono⊢ⁿᶠ θ t) (mmono⊢ⁿᶠ θ u)
mmono⊢ⁿᶠ θ unitⁿᶠ = unitⁿᶠ
mmono⊢ⁿᵉ : ∀ {A Γ Δ Δ′} → Δ ⊆ Δ′ → Γ ⁏ Δ ⊢ⁿᵉ A → Γ ⁏ Δ′ ⊢ⁿᵉ A
mmono⊢ⁿᵉ θ (spⁿᵉ i xs y) = spⁿᵉ i (mmono⊢ˢᵖ θ xs) (mmono⊢ᵗᵖ θ y)
mmono⊢ⁿᵉ θ (mspⁿᵉ i {{ts}} xs y) = mspⁿᵉ (mono∈ θ i) {{mmono⊢⋆ⁿᶠ θ ts}} (mmono⊢ˢᵖ θ xs) (mmono⊢ᵗᵖ θ y)
mmono⊢ˢᵖ : ∀ {A C Γ Δ Δ′} → Δ ⊆ Δ′ → Γ ⁏ Δ ⊢ˢᵖ A ⦙ C → Γ ⁏ Δ′ ⊢ˢᵖ A ⦙ C
mmono⊢ˢᵖ θ nilˢᵖ = nilˢᵖ
mmono⊢ˢᵖ θ (appˢᵖ xs u) = appˢᵖ (mmono⊢ˢᵖ θ xs) (mmono⊢ⁿᶠ θ u)
mmono⊢ˢᵖ θ (fstˢᵖ xs) = fstˢᵖ (mmono⊢ˢᵖ θ xs)
mmono⊢ˢᵖ θ (sndˢᵖ xs) = sndˢᵖ (mmono⊢ˢᵖ θ xs)
mmono⊢ᵗᵖ : ∀ {A C Γ Δ Δ′} → Δ ⊆ Δ′ → Γ ⁏ Δ ⊢ᵗᵖ A ⦙ C → Γ ⁏ Δ′ ⊢ᵗᵖ A ⦙ C
mmono⊢ᵗᵖ θ nilᵗᵖ = nilᵗᵖ
mmono⊢ᵗᵖ θ (unboxᵗᵖ u) = unboxᵗᵖ (mmono⊢ⁿᶠ (keep θ) u)
mmono⊢⋆ⁿᶠ : ∀ {Ξ Γ Δ Δ′} → Δ ⊆ Δ′ → Γ ⁏ Δ ⊢⋆ⁿᶠ Ξ → Γ ⁏ Δ′ ⊢⋆ⁿᶠ Ξ
mmono⊢⋆ⁿᶠ {∅} θ ∙ = ∙
mmono⊢⋆ⁿᶠ {Ξ , A} θ (ts , t) = mmono⊢⋆ⁿᶠ θ ts , mmono⊢ⁿᶠ θ t
-- Monotonicity using context pairs.
mono²⊢ⁿᶠ : ∀ {A Π Π′} → Π ⊆² Π′ → Π ⊢ⁿᶠ A → Π′ ⊢ⁿᶠ A
mono²⊢ⁿᶠ (η , θ) = mono⊢ⁿᶠ η ∘ mmono⊢ⁿᶠ θ
mono²⊢ⁿᵉ : ∀ {A Π Π′} → Π ⊆² Π′ → Π ⊢ⁿᵉ A → Π′ ⊢ⁿᵉ A
mono²⊢ⁿᵉ (η , θ) = mono⊢ⁿᵉ η ∘ mmono⊢ⁿᵉ θ
mono²⊢ˢᵖ : ∀ {A C Π Π′} → Π ⊆² Π′ → Π ⊢ˢᵖ A ⦙ C → Π′ ⊢ˢᵖ A ⦙ C
mono²⊢ˢᵖ (η , θ) = mono⊢ˢᵖ η ∘ mmono⊢ˢᵖ θ
mono²⊢ᵗᵖ : ∀ {A C Π Π′} → Π ⊆² Π′ → Π ⊢ᵗᵖ A ⦙ C → Π′ ⊢ᵗᵖ A ⦙ C
mono²⊢ᵗᵖ (η , θ) = mono⊢ᵗᵖ η ∘ mmono⊢ᵗᵖ θ
| 36.432258
| 114
| 0.487338
|
5ed72de15b837c588fca05501a1f6a8f0a9b751d
| 166
|
agda
|
Agda
|
test/Common/Coinduction.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 2
|
2019-10-29T09:40:30.000Z
|
2020-09-20T00:28:57.000Z
|
test/Common/Coinduction.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 3
|
2018-11-14T15:31:44.000Z
|
2019-04-01T19:39:26.000Z
|
test/Common/Coinduction.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1
|
2015-09-15T14:36:15.000Z
|
2015-09-15T14:36:15.000Z
|
{-# OPTIONS --without-K #-}
module Common.Coinduction where
open import Agda.Builtin.Coinduction public
private
my-♯ : ∀ {a} {A : Set a} → A → ∞ A
my-♯ x = ♯ x
| 18.444444
| 43
| 0.614458
|
3f09b9c13ea55d501a46c34681bfe961c049191c
| 3,794
|
agda
|
Agda
|
Cubical/Data/Maybe/Properties.agda
|
Rotsor/cubical
|
d55cd4834ca1f171f58b4a0c46b804ea6d18191f
|
[
"MIT"
] | null | null | null |
Cubical/Data/Maybe/Properties.agda
|
Rotsor/cubical
|
d55cd4834ca1f171f58b4a0c46b804ea6d18191f
|
[
"MIT"
] | null | null | null |
Cubical/Data/Maybe/Properties.agda
|
Rotsor/cubical
|
d55cd4834ca1f171f58b4a0c46b804ea6d18191f
|
[
"MIT"
] | null | null | null |
{-# OPTIONS --cubical --safe #-}
module Cubical.Data.Maybe.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Empty
open import Cubical.Data.Unit
open import Cubical.Data.Nat
open import Cubical.Relation.Nullary
open import Cubical.Data.Sum
open import Cubical.Data.Maybe.Base
-- Path space of Maybe type
module MaybePath {ℓ} {A : Type ℓ} where
Cover : Maybe A → Maybe A → Type ℓ
Cover nothing nothing = Lift Unit
Cover nothing (just _) = Lift ⊥
Cover (just _) nothing = Lift ⊥
Cover (just a) (just a') = a ≡ a'
reflCode : (c : Maybe A) → Cover c c
reflCode nothing = lift tt
reflCode (just b) = refl
encode : ∀ c c' → c ≡ c' → Cover c c'
encode c _ = J (λ c' _ → Cover c c') (reflCode c)
encodeRefl : ∀ c → encode c c refl ≡ reflCode c
encodeRefl c = JRefl (λ c' _ → Cover c c') (reflCode c)
decode : ∀ c c' → Cover c c' → c ≡ c'
decode nothing nothing _ = refl
decode (just _) (just _) p = cong just p
decodeRefl : ∀ c → decode c c (reflCode c) ≡ refl
decodeRefl nothing = refl
decodeRefl (just _) = refl
decodeEncode : ∀ c c' → (p : c ≡ c') → decode c c' (encode c c' p) ≡ p
decodeEncode c _ =
J (λ c' p → decode c c' (encode c c' p) ≡ p)
(cong (decode c c) (encodeRefl c) ∙ decodeRefl c)
isOfHLevelCover : (n : ℕ)
→ isOfHLevel (suc (suc n)) A
→ ∀ c c' → isOfHLevel (suc n) (Cover c c')
isOfHLevelCover n p nothing nothing = isOfHLevelLift (suc n) (isOfHLevelUnit (suc n))
isOfHLevelCover n p nothing (just a') = isOfHLevelLift (suc n)
(subst (λ m → isOfHLevel m ⊥) (+-comm n 1) (hLevelLift n isProp⊥))
isOfHLevelCover n p (just a) nothing = isOfHLevelLift (suc n)
(subst (λ m → isOfHLevel m ⊥) (+-comm n 1) (hLevelLift n isProp⊥))
isOfHLevelCover n p (just a) (just a') = p a a'
isOfHLevelMaybe : ∀ {ℓ} (n : ℕ) {A : Type ℓ}
→ isOfHLevel (suc (suc n)) A
→ isOfHLevel (suc (suc n)) (Maybe A)
isOfHLevelMaybe n lA c c' =
retractIsOfHLevel (suc n)
(MaybePath.encode c c')
(MaybePath.decode c c')
(MaybePath.decodeEncode c c')
(MaybePath.isOfHLevelCover n lA c c')
private
variable
ℓ : Level
A : Type ℓ
fromJust-def : A → Maybe A → A
fromJust-def a nothing = a
fromJust-def _ (just a) = a
just-inj : (x y : A) → just x ≡ just y → x ≡ y
just-inj x _ eq = cong (fromJust-def x) eq
¬nothing≡just : ∀ {x : A} → ¬ (nothing ≡ just x)
¬nothing≡just {A = A} {x = x} p = lower (subst (caseMaybe (Maybe A) (Lift ⊥)) p (just x))
¬just≡nothing : ∀ {x : A} → ¬ (just x ≡ nothing)
¬just≡nothing {A = A} {x = x} p = lower (subst (caseMaybe (Lift ⊥) (Maybe A)) p (just x))
discreteMaybe : Discrete A → Discrete (Maybe A)
discreteMaybe eqA nothing nothing = yes refl
discreteMaybe eqA nothing (just a') = no ¬nothing≡just
discreteMaybe eqA (just a) nothing = no ¬just≡nothing
discreteMaybe eqA (just a) (just a') with eqA a a'
... | yes p = yes (cong just p)
... | no ¬p = no (λ p → ¬p (just-inj _ _ p))
module SumUnit where
Maybe→SumUnit : Maybe A → Unit ⊎ A
Maybe→SumUnit nothing = inl tt
Maybe→SumUnit (just a) = inr a
SumUnit→Maybe : Unit ⊎ A → Maybe A
SumUnit→Maybe (inl _) = nothing
SumUnit→Maybe (inr a) = just a
Maybe→SumUnit→Maybe : (x : Maybe A) → SumUnit→Maybe (Maybe→SumUnit x) ≡ x
Maybe→SumUnit→Maybe nothing = refl
Maybe→SumUnit→Maybe (just _) = refl
SumUnit→Maybe→SumUnit : (x : Unit ⊎ A) → Maybe→SumUnit (SumUnit→Maybe x) ≡ x
SumUnit→Maybe→SumUnit (inl _) = refl
SumUnit→Maybe→SumUnit (inr _) = refl
Maybe≡SumUnit : Maybe A ≡ Unit ⊎ A
Maybe≡SumUnit = isoToPath (iso SumUnit.Maybe→SumUnit SumUnit.SumUnit→Maybe SumUnit.SumUnit→Maybe→SumUnit SumUnit.Maybe→SumUnit→Maybe)
| 33.875
| 133
| 0.648129
|
52270ac1ae872bb244844475ce32ec24417358ee
| 783
|
agda
|
Agda
|
test/Fail/Issue1428c.agda
|
cagix/agda
|
cc026a6a97a3e517bb94bafa9d49233b067c7559
|
[
"BSD-2-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Fail/Issue1428c.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Fail/Issue1428c.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
-- Andreas, 2015-03-17
-- Andreas, 2020-10-26 conform to Issue1428a
{-# OPTIONS --sized-types #-}
open import Agda.Builtin.Size
data ⊥ : Set where
data SizeLt (i : Size) : Set where
wrap : Size< i → SizeLt i
-- This definition of size predecessor should be forbidden...
module _ (i : Size) where
postulate
pred : Size< i
-- ...otherwise the injectivity test loops here.
iter : ∀ i → SizeLt i → ⊥
iter i (wrap j) = iter j (wrap (pred j))
loop : Size → ⊥
loop i = iter i (wrap (pred i))
absurd : ⊥
absurd = FIXME loop ∞
-- Testcase temporarily mutilated, original error:
--
-- -Issue1428c.agda:...
-- -We don't like postulated sizes in parametrized modules.
--
-- +Issue1428c.agda:...
-- +Not in scope:
-- + FIXME at Issue1428c.agda:...
-- +when scope checking FIXME
| 21.162162
| 61
| 0.655172
|
3648c91a12c5bd3a05c81f291699f3f039a182c9
| 259
|
agda
|
Agda
|
test/Succeed/Issue1809.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Succeed/Issue1809.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Succeed/Issue1809.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
{-# OPTIONS -v tc.lhs.unify:80 #-}
data _≡_ {A : Set} (x : A) : A → Set where
refl : x ≡ x
postulate
A : Set
a : A
record Foo : Set where
constructor foo
field anA : A
test : (f : A → A) (x : Foo) → foo (f a) ≡ x → A
test f .(foo (f a)) refl = a
| 17.266667
| 48
| 0.521236
|
4353bda76d0c98c3b10ed4cc70c570e46ef5e439
| 459
|
agda
|
Agda
|
test/Succeed/Issue1597/Main2.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Succeed/Issue1597/Main2.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Succeed/Issue1597/Main2.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
-- Andreas, Jesper, 2015-07-02 Error in copyScope
{-# OPTIONS -v tc.decl:5 #-} -- KEEP, this forced Agda to look at A.Decls and loop
-- To trigger the bug, it is important that
-- the main module is in a subdirectory of the imported module.
module Issue1597.Main2 where
open import Issue1597 -- external import is needed
module B where
open A public -- public is needed
module C = B
-- hanged when trying to print the Syntax.Abstract.Declarations
| 28.6875
| 82
| 0.729847
|
34ca481895438ecb71664b4a5356906950fd4882
| 3,778
|
agda
|
Agda
|
theorems/cohomology/WithCoefficients.agda
|
cmknapp/HoTT-Agda
|
bc849346a17b33e2679a5b3f2b8efbe7835dc4b6
|
[
"MIT"
] | null | null | null |
theorems/cohomology/WithCoefficients.agda
|
cmknapp/HoTT-Agda
|
bc849346a17b33e2679a5b3f2b8efbe7835dc4b6
|
[
"MIT"
] | null | null | null |
theorems/cohomology/WithCoefficients.agda
|
cmknapp/HoTT-Agda
|
bc849346a17b33e2679a5b3f2b8efbe7835dc4b6
|
[
"MIT"
] | null | null | null |
{-# OPTIONS --without-K #-}
open import HoTT
module cohomology.WithCoefficients where
→Ω-group-structure : ∀ {i j} (X : Ptd i) (Y : Ptd j)
→ GroupStructure (fst (X ⊙→ ⊙Ω Y))
→Ω-group-structure X Y = record {
ident = ⊙cst;
inv = λ F → ((! ∘ fst F) , ap ! (snd F));
comp = λ F G → ⊙conc ⊙∘ ⊙×-in F G;
unitl = λ G → pair= idp (unitl-lemma (snd G));
unitr = λ F → ⊙λ= (∙-unit-r ∘ fst F) (unitr-lemma (snd F));
assoc = λ F G H → ⊙λ=
(λ x → ∙-assoc (fst F x) (fst G x) (fst H x))
(assoc-lemma (snd F) (snd G) (snd H));
invl = λ F → ⊙λ= (!-inv-l ∘ fst F) (invl-lemma (snd F));
invr = λ F → ⊙λ= (!-inv-r ∘ fst F) (invr-lemma (snd F))}
where
unitl-lemma : ∀ {i} {A : Type i} {x : A} {p : x == x} (α : p == idp)
→ ap (uncurry _∙_) (ap2 _,_ idp α) ∙ idp == α
unitl-lemma idp = idp
unitr-lemma : ∀ {i} {A : Type i} {x : A} {p : x == x} (α : p == idp)
→ ap (uncurry _∙_) (ap2 _,_ α idp) ∙ idp == ∙-unit-r p ∙ α
unitr-lemma idp = idp
assoc-lemma : ∀ {i} {A : Type i} {x : A} {p q r : x == x}
(α : p == idp) (β : q == idp) (γ : r == idp)
→ ap (uncurry _∙_) (ap2 _,_ (ap (uncurry _∙_) (ap2 _,_ α β) ∙ idp) γ) ∙ idp
== ∙-assoc p q r
∙ ap (uncurry _∙_) (ap2 _,_ α (ap (uncurry _∙_) (ap2 _,_ β γ) ∙ idp)) ∙ idp
assoc-lemma idp idp idp = idp
invl-lemma : ∀ {i} {A : Type i} {x : A} {p : x == x} (α : p == idp)
→ ap (uncurry _∙_) (ap2 _,_ (ap ! α) α) ∙ idp == !-inv-l p ∙ idp
invl-lemma idp = idp
invr-lemma : ∀ {i} {A : Type i} {x : A} {p : x == x} (α : p == idp)
→ ap (uncurry _∙_) (ap2 _,_ α (ap ! α)) ∙ idp == !-inv-r p ∙ idp
invr-lemma idp = idp
→Ω-group : ∀ {i j} (X : Ptd i) (Y : Ptd j) → Group (lmax i j)
→Ω-group X Y = Trunc-group (→Ω-group-structure X Y)
{- →Ω-group is functorial in the first argument -}
→Ω-group-dom-act : ∀ {i j k} {X : Ptd i} {Y : Ptd j}
(f : fst (X ⊙→ Y)) (Z : Ptd k)
→ (→Ω-group Y Z →ᴳ →Ω-group X Z)
→Ω-group-dom-act {Y = Y} f Z =
Trunc-group-hom (λ g → g ⊙∘ f)
(λ g₁ g₂ → ⊙∘-assoc ⊙conc (⊙×-in g₁ g₂) f
∙ ap (λ w → ⊙conc ⊙∘ w) (⊙×-in-pre∘ g₁ g₂ f))
→Ω-group-dom-idf : ∀ {i j} {X : Ptd i} (Y : Ptd j)
→ →Ω-group-dom-act (⊙idf X) Y == idhom (→Ω-group X Y)
→Ω-group-dom-idf Y = hom= _ _ $ λ= $ Trunc-elim
(λ _ → =-preserves-level _ Trunc-level) (λ _ → idp)
→Ω-group-dom-∘ : ∀ {i j k l} {X : Ptd i} {Y : Ptd j} {Z : Ptd k}
(g : fst (Y ⊙→ Z)) (f : fst (X ⊙→ Y)) (W : Ptd l)
→ →Ω-group-dom-act (g ⊙∘ f) W
== →Ω-group-dom-act f W ∘ᴳ →Ω-group-dom-act g W
→Ω-group-dom-∘ g f W = hom= _ _ $ λ= $
Trunc-elim (λ _ → =-preserves-level _ Trunc-level)
(λ h → ap [_] (! (⊙∘-assoc h g f)))
{- Pointed maps out of bool -}
Bool⊙→-out : ∀ {i} {X : Ptd i}
→ fst (⊙Lift {j = i} ⊙Bool ⊙→ X) → fst X
Bool⊙→-out (h , _) = h (lift false)
Bool⊙→-equiv : ∀ {i} (X : Ptd i)
→ fst (⊙Lift {j = i} ⊙Bool ⊙→ X) ≃ fst X
Bool⊙→-equiv {i} X = equiv Bool⊙→-out g f-g g-f
where
g : fst X → fst (⊙Lift {j = i} ⊙Bool ⊙→ X)
g x = ((λ {(lift b) → if b then snd X else x}) , idp)
f-g : ∀ x → Bool⊙→-out (g x) == x
f-g x = idp
g-f : ∀ H → g (Bool⊙→-out H) == H
g-f (h , hpt) = pair=
(λ= lemma)
(↓-app=cst-in $
idp
=⟨ ! (!-inv-l hpt) ⟩
! hpt ∙ hpt
=⟨ ! (app=-β lemma (lift true)) |in-ctx (λ w → w ∙ hpt) ⟩
app= (λ= lemma) (lift true) ∙ hpt ∎)
where lemma : ∀ b → fst (g (h (lift false))) b == h b
lemma (lift true) = ! hpt
lemma (lift false) = idp
abstract
Bool⊙→-path : ∀ {i} (X : Ptd i)
→ fst (⊙Lift {j = i} ⊙Bool ⊙→ X) == fst X
Bool⊙→-path X = ua (Bool⊙→-equiv X)
abstract
Bool⊙→Ω-is-π₁ : ∀ {i} (X : Ptd i)
→ →Ω-group (⊙Lift {j = i} ⊙Bool) X == πS 0 X
Bool⊙→Ω-is-π₁ {i} X = group-ua $
Trunc-group-iso Bool⊙→-out (λ _ _ → idp) (snd (Bool⊙→-equiv (⊙Ω X)))
| 34.66055
| 84
| 0.477766
|
1b54f51a54bb32fd24859e83e93c93f68e5fbd61
| 236
|
agda
|
Agda
|
test/Fail/ShouldBeAppliedToTheDatatypeParameters.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Fail/ShouldBeAppliedToTheDatatypeParameters.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Fail/ShouldBeAppliedToTheDatatypeParameters.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
module ShouldBeAppliedToTheDatatypeParameters where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
mutual
F : Nat -> Set
F zero = Nat
F (suc n) = Foo (F n)
data Foo (A : Set) : Set where
fooI1 : F (suc zero)
| 13.882353
| 51
| 0.605932
|
d1af52f3f9b75635195effe4d9fc3f54a586a1e8
| 2,133
|
agda
|
Agda
|
BasicIPC/Metatheory/Hilbert-KripkeMcKinseyTarski.agda
|
mietek/hilbert-gentzen
|
fcd187db70f0a39b894fe44fad0107f61849405c
|
[
"X11"
] | 29
|
2016-07-03T18:51:56.000Z
|
2022-01-01T10:29:18.000Z
|
BasicIPC/Metatheory/Hilbert-KripkeMcKinseyTarski.agda
|
mietek/hilbert-gentzen
|
fcd187db70f0a39b894fe44fad0107f61849405c
|
[
"X11"
] | 1
|
2018-06-10T09:11:22.000Z
|
2018-06-10T09:11:22.000Z
|
BasicIPC/Metatheory/Hilbert-KripkeMcKinseyTarski.agda
|
mietek/hilbert-gentzen
|
fcd187db70f0a39b894fe44fad0107f61849405c
|
[
"X11"
] | null | null | null |
module BasicIPC.Metatheory.Hilbert-KripkeMcKinseyTarski where
open import BasicIPC.Syntax.Hilbert public
open import BasicIPC.Semantics.KripkeMcKinseyTarski public
-- Soundness with respect to all models, or evaluation.
eval : ∀ {A Γ} → Γ ⊢ A → Γ ⊨ A
eval (var i) γ = lookup i γ
eval (app {A} {B} t u) γ = _⟪$⟫_ {A} {B} (eval t γ) (eval u γ)
eval ci γ = K I
eval (ck {A} {B}) γ = K (⟪K⟫ {A} {B})
eval (cs {A} {B} {C}) γ = K (⟪S⟫′ {A} {B} {C})
eval (cpair {A} {B}) γ = K (_⟪,⟫′_ {A} {B})
eval cfst γ = K π₁
eval csnd γ = K π₂
eval unit γ = ∙
-- TODO: Correctness of evaluation with respect to conversion.
-- The canonical model.
private
instance
canon : Model
canon = record
{ World = Cx Ty
; _≤_ = _⊆_
; refl≤ = refl⊆
; trans≤ = trans⊆
; _⊩ᵅ_ = λ Γ P → Γ ⊢ α P
; mono⊩ᵅ = mono⊢
}
-- Soundness and completeness with respect to the canonical model.
mutual
reflectᶜ : ∀ {A Γ} → Γ ⊢ A → Γ ⊩ A
reflectᶜ {α P} t = t
reflectᶜ {A ▻ B} t = λ η a → reflectᶜ (app (mono⊢ η t) (reifyᶜ a))
reflectᶜ {A ∧ B} t = reflectᶜ (fst t) , reflectᶜ (snd t)
reflectᶜ {⊤} t = ∙
reifyᶜ : ∀ {A Γ} → Γ ⊩ A → Γ ⊢ A
reifyᶜ {α P} s = s
reifyᶜ {A ▻ B} s = lam (reifyᶜ (s weak⊆ (reflectᶜ {A} v₀)))
reifyᶜ {A ∧ B} s = pair (reifyᶜ (π₁ s)) (reifyᶜ (π₂ s))
reifyᶜ {⊤} s = unit
reflectᶜ⋆ : ∀ {Ξ Γ} → Γ ⊢⋆ Ξ → Γ ⊩⋆ Ξ
reflectᶜ⋆ {∅} ∙ = ∙
reflectᶜ⋆ {Ξ , A} (ts , t) = reflectᶜ⋆ ts , reflectᶜ t
reifyᶜ⋆ : ∀ {Ξ Γ} → Γ ⊩⋆ Ξ → Γ ⊢⋆ Ξ
reifyᶜ⋆ {∅} ∙ = ∙
reifyᶜ⋆ {Ξ , A} (ts , t) = reifyᶜ⋆ ts , reifyᶜ t
-- Reflexivity and transitivity.
refl⊩⋆ : ∀ {Γ} → Γ ⊩⋆ Γ
refl⊩⋆ = reflectᶜ⋆ refl⊢⋆
trans⊩⋆ : ∀ {Γ Γ′ Γ″} → Γ ⊩⋆ Γ′ → Γ′ ⊩⋆ Γ″ → Γ ⊩⋆ Γ″
trans⊩⋆ ts us = reflectᶜ⋆ (trans⊢⋆ (reifyᶜ⋆ ts) (reifyᶜ⋆ us))
-- Completeness with respect to all models, or quotation.
quot : ∀ {A Γ} → Γ ⊨ A → Γ ⊢ A
quot s = reifyᶜ (s refl⊩⋆)
-- Normalisation by evaluation.
norm : ∀ {A Γ} → Γ ⊢ A → Γ ⊢ A
norm = quot ∘ eval
-- TODO: Correctness of normalisation with respect to conversion.
| 25.094118
| 68
| 0.524613
|
5e22508c80d5506148d86b788a80d372bba99d0f
| 493
|
agda
|
Agda
|
Cubical/Data/DescendingList/Strict.agda
|
kiana-S/univalent-foundations
|
8bdb0766260489f9c89a14f4c0f2ad26e5190dec
|
[
"MIT"
] | null | null | null |
Cubical/Data/DescendingList/Strict.agda
|
kiana-S/univalent-foundations
|
8bdb0766260489f9c89a14f4c0f2ad26e5190dec
|
[
"MIT"
] | 1
|
2022-01-27T02:07:48.000Z
|
2022-01-27T02:07:48.000Z
|
Cubical/Data/DescendingList/Strict.agda
|
kiana-S/univalent-foundations
|
8bdb0766260489f9c89a14f4c0f2ad26e5190dec
|
[
"MIT"
] | 1
|
2021-11-22T02:02:01.000Z
|
2021-11-22T02:02:01.000Z
|
------------------------------------------------------------------------
-- Strictly descending lists
------------------------------------------------------------------------
{-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
module Cubical.Data.DescendingList.Strict
(A : Type₀)
(_>_ : A → A → Type₀)
where
open import Cubical.Data.DescendingList.Base A _>_ renaming (_≥ᴴ_ to _>ᴴ_; ≥ᴴ[] to >ᴴ[]; ≥ᴴcons to >ᴴcons; DL to SDL) using ([]; cons) public
| 32.866667
| 141
| 0.482759
|
36060671b9ce14d3b35c88f1c4a091964ade9563
| 7,891
|
agda
|
Agda
|
List.agda
|
hazelgrove/hazelnat-myth
|
a8f9299090d95f4ef1a6c2f15954c2981c0ee25c
|
[
"MIT"
] | 1
|
2019-12-19T23:42:31.000Z
|
2019-12-19T23:42:31.000Z
|
List.agda
|
hazelgrove/hazelnat-myth
|
a8f9299090d95f4ef1a6c2f15954c2981c0ee25c
|
[
"MIT"
] | null | null | null |
List.agda
|
hazelgrove/hazelnat-myth
|
a8f9299090d95f4ef1a6c2f15954c2981c0ee25c
|
[
"MIT"
] | null | null | null |
open import Prelude
open import Nat
open import Agda.Primitive using (Level; lzero; lsuc) renaming (_⊔_ to lmax)
module List where
-- definitions
data List (A : Set) : Set where
[] : List A
_::_ : A → List A → List A
_++_ : {A : Set} → List A → List A → List A
[] ++ l₂ = l₂
(h :: l₁) ++ l₂ = h :: (l₁ ++ l₂)
infixl 50 _++_
∥_∥ : {A : Set} → List A → Nat
∥ [] ∥ = Z
∥ a :: as ∥ = 1+ ∥ as ∥
_⟦_⟧ : {A : Set} → List A → Nat → Maybe A
[] ⟦ i ⟧ = None
(a :: as) ⟦ Z ⟧ = Some a
(a :: as) ⟦ 1+ i ⟧ = as ⟦ i ⟧
map : {A B : Set} → (A → B) → List A → List B
map f [] = []
map f (a :: as) = f a :: map f as
foldl : {A B : Set} → (B → A → B) → B → List A → B
foldl f b [] = b
foldl f b (a :: as) = foldl f (f b a) as
concat : {A : Set} → List (List A) → List A
concat [] = []
concat (l1 :: rest) = l1 ++ (concat rest)
-- if the lists aren't the same length,
-- the extra elements of the longer list are ignored
zip : {A B : Set} → List A → List B → List (A ∧ B)
zip [] _ = []
zip (a :: as) [] = []
zip (a :: as) (b :: bs) = (a , b) :: zip as bs
unzip : {A B : Set} → List (A ∧ B) → (List A ∧ List B)
unzip [] = ([] , [])
unzip ((a , b) :: rest)
with unzip rest
... | (as , bs) = (a :: as , b :: bs)
reverse : {A : Set} → List A → List A
reverse [] = []
reverse (a :: as) = reverse as ++ (a :: [])
-- theorems
list-==-dec : {A : Set} →
(l1 l2 : List A) →
((a1 a2 : A) → a1 == a2 ∨ a1 ≠ a2) →
l1 == l2 ∨ l1 ≠ l2
list-==-dec [] [] A-==-dec = Inl refl
list-==-dec [] (_ :: _) A-==-dec = Inr (λ ())
list-==-dec (_ :: _) [] A-==-dec = Inr (λ ())
list-==-dec (h1 :: t1) (h2 :: t2) A-==-dec
with A-==-dec h1 h2
... | Inr ne = Inr (λ where refl → ne refl)
... | Inl refl
with list-==-dec t1 t2 A-==-dec
... | Inr ne = Inr (λ where refl → ne refl)
... | Inl refl = Inl refl
-- if the items of two lists are equal, then the lists are equal
==-per-elem : {A : Set} → {l1 l2 : List A} →
((i : Nat) → l1 ⟦ i ⟧ == l2 ⟦ i ⟧) →
l1 == l2
==-per-elem {l1 = []} {[]} items== = refl
==-per-elem {l1 = []} {h2 :: t2} items== = abort (somenotnone (! (items== Z)))
==-per-elem {l1 = h1 :: t1} {[]} items== = abort (somenotnone (items== Z))
==-per-elem {l1 = h1 :: t1} {h2 :: t2} items==
rewrite someinj (items== Z) | ==-per-elem {l1 = t1} {t2} (λ i → items== (1+ i))
= refl
-- _++_ theorems
++assc : ∀{A a1 a2 a3} → (_++_ {A} a1 a2) ++ a3 == a1 ++ (a2 ++ a3)
++assc {A} {[]} {a2} {a3} = refl
++assc {A} {x :: a1} {a2} {a3} with a1 ++ a2 ++ a3 | ++assc {A} {a1} {a2} {a3}
++assc {A} {x :: a1} {a2} {a3} | _ | refl = refl
l++[]==l : {A : Set} (l : List A) →
l ++ [] == l
l++[]==l [] = refl
l++[]==l (a :: as)
rewrite l++[]==l as
= refl
-- ∥_∥ theorem
∥-++-comm : ∀{A a1 a2} → ∥ a1 ∥ + (∥_∥ {A} a2) == ∥ a1 ++ a2 ∥
∥-++-comm {A} {[]} {a2} = refl
∥-++-comm {A} {a :: a1} {a2} = 1+ap (∥-++-comm {A} {a1})
-- _⟦_⟧ and ++ theorem
⦇l1++[a]++l2⦈⟦∥l1∥⟧==a : {A : Set} {l1 l2 : List A} {a : A} →
(h : ∥ l1 ∥ < ∥ l1 ++ (a :: []) ++ l2 ∥) →
((l1 ++ (a :: []) ++ l2) ⟦ ∥ l1 ∥ ⟧ == Some a)
⦇l1++[a]++l2⦈⟦∥l1∥⟧==a {l1 = []} h = refl
⦇l1++[a]++l2⦈⟦∥l1∥⟧==a {l1 = a1 :: l1rest} {l2} {a} h = ⦇l1++[a]++l2⦈⟦∥l1∥⟧==a {l1 = l1rest} {l2} {a} (1+n<1+m→n<m h)
-- packaging of list indexing results
list-index-dec : {A : Set} (l : List A) (i : Nat) →
l ⟦ i ⟧ == None ∨ Σ[ a ∈ A ] (l ⟦ i ⟧ == Some a)
list-index-dec l i
with l ⟦ i ⟧
... | None = Inl refl
... | Some a = Inr (a , refl)
-- theorems characterizing the partiality of list indexing
list-index-some : {A : Set} {l : List A} {i : Nat} →
i < ∥ l ∥ →
Σ[ a ∈ A ] (l ⟦ i ⟧ == Some a)
list-index-some {l = []} {Z} i<∥l∥ = abort (n≮0 i<∥l∥)
list-index-some {l = a :: as} {Z} i<∥l∥ = _ , refl
list-index-some {l = a :: as} {1+ i} i<∥l∥ = list-index-some (1+n<1+m→n<m i<∥l∥)
list-index-none : {A : Set} {l : List A} {i : Nat} →
∥ l ∥ ≤ i →
l ⟦ i ⟧ == None
list-index-none {l = []} i≥∥l∥ = refl
list-index-none {l = a :: as} {1+ i} i≥∥l∥ = list-index-none (1+n≤1+m→n≤m i≥∥l∥)
list-index-some-conv : {A : Set} {l : List A} {i : Nat} {a : A} →
l ⟦ i ⟧ == Some a →
i < ∥ l ∥
list-index-some-conv {l = l} {i} i≥∥l∥
with <dec ∥ l ∥ i
... | Inr (Inr i<∥l∥) = i<∥l∥
... | Inr (Inl refl)
rewrite list-index-none {l = l} {∥ l ∥} ≤refl
= abort (somenotnone (! i≥∥l∥))
... | Inl ∥l∥<i
rewrite list-index-none (n<m→n≤m ∥l∥<i)
= abort (somenotnone (! i≥∥l∥))
list-index-none-conv : {A : Set} {l : List A} {i : Nat} →
l ⟦ i ⟧ == None →
∥ l ∥ ≤ i
list-index-none-conv {l = l} {i} i≥∥l∥
with <dec ∥ l ∥ i
... | Inl ∥l∥<i = n<m→n≤m ∥l∥<i
... | Inr (Inl refl) = ≤refl
... | Inr (Inr i<∥l∥)
with list-index-some i<∥l∥
... | _ , i≱∥l∥ rewrite i≥∥l∥ = abort (somenotnone (! i≱∥l∥))
∥l1∥==∥l2∥→l1[i]→l2[i] : {A B : Set} {la : List A} {lb : List B} {i : Nat} {a : A} →
∥ la ∥ == ∥ lb ∥ →
la ⟦ i ⟧ == Some a →
Σ[ b ∈ B ] (lb ⟦ i ⟧ == Some b)
∥l1∥==∥l2∥→l1[i]→l2[i] {i = i} ∥la∥==∥lb∥ la[i]==a
= list-index-some (tr (λ y → i < y) ∥la∥==∥lb∥ (list-index-some-conv la[i]==a))
∥l1∥==∥l2∥→¬l1[i]→¬l2[i] : {A B : Set} {la : List A} {lb : List B} {i : Nat} →
∥ la ∥ == ∥ lb ∥ →
la ⟦ i ⟧ == None →
lb ⟦ i ⟧ == None
∥l1∥==∥l2∥→¬l1[i]→¬l2[i] {i = i} ∥la∥==∥lb∥ la[i]==None
= list-index-none (tr (λ y → y ≤ i) ∥la∥==∥lb∥ (list-index-none-conv la[i]==None))
-- map theorem
map-++-comm : ∀{A B f a b} → map f a ++ map f b == map {A} {B} f (a ++ b)
map-++-comm {a = []} = refl
map-++-comm {A} {B} {f} {h :: t} {b} with map f (t ++ b) | map-++-comm {A} {B} {f} {t} {b}
map-++-comm {A} {B} {f} {h :: t} {b} | _ | refl = refl
-- foldl theorem
foldl-++ : {A B : Set} {l1 l2 : List A} {f : B → A → B} {b0 : B} →
foldl f b0 (l1 ++ l2) == foldl f (foldl f b0 l1) l2
foldl-++ {l1 = []} = refl
foldl-++ {l1 = a1 :: l1rest} = foldl-++ {l1 = l1rest}
-- zip/unzip theorems
unzip-inv : {A B : Set} {l : List (A ∧ B)} {la : List A} {lb : List B} →
unzip l == (la , lb) →
l == zip la lb
unzip-inv {l = []} form
with form
... | refl = refl
unzip-inv {l = (a' , b') :: rest} {a :: as} {b :: bs} form
with unzip rest | unzip-inv {l = rest} refl | form
... | (as' , bs') | refl | refl = refl
zip-inv : {A B : Set} {la : List A} {lb : List B} →
∥ la ∥ == ∥ lb ∥ →
unzip (zip la lb) == (la , lb)
zip-inv {la = []} {[]} len-eq = refl
zip-inv {la = a :: as} {b :: bs} len-eq
with unzip (zip as bs) | zip-inv (1+inj len-eq)
... | (as' , bs') | refl = refl
-- reverse theorems
reverse-single : {A : Set} {a : A} → reverse (a :: []) == a :: []
reverse-single = refl
reverse-++ : {A : Set} {l1 l2 : List A} →
reverse (l1 ++ l2) == reverse l2 ++ reverse l1
reverse-++ {l1 = []} {l2}
rewrite l++[]==l (reverse l2)
= refl
reverse-++ {l1 = a1 :: as1} {l2}
rewrite reverse-++ {l1 = as1} {l2}
= ++assc {a1 = reverse l2}
reverse-inv : {A : Set} {l : List A} → reverse (reverse l) == l
reverse-inv {l = []} = refl
reverse-inv {l = a :: as}
rewrite reverse-++ {l1 = reverse as} {a :: []} | reverse-inv {l = as}
= refl
| 36.031963
| 119
| 0.407046
|
cc27df0200a5a462ecf4bc49a0ada70387acd98b
| 1,672
|
agda
|
Agda
|
Cubical/Foundations/Surjection.agda
|
limemloh/cubical
|
df4ef7edffd1c1deb3d4ff342c7178e9901c44f1
|
[
"MIT"
] | null | null | null |
Cubical/Foundations/Surjection.agda
|
limemloh/cubical
|
df4ef7edffd1c1deb3d4ff342c7178e9901c44f1
|
[
"MIT"
] | null | null | null |
Cubical/Foundations/Surjection.agda
|
limemloh/cubical
|
df4ef7edffd1c1deb3d4ff342c7178e9901c44f1
|
[
"MIT"
] | null | null | null |
{-# OPTIONS --cubical --safe #-}
module Cubical.Foundations.Surjection where
open import Cubical.Core.Everything
open import Cubical.Data.Prod
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Embedding
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.HITs.PropositionalTruncation
private
variable
ℓ ℓ' : Level
A : Type ℓ
B : Type ℓ'
f : A → B
isSurjection : (A → B) → Type _
isSurjection f = ∀ b → ∥ fiber f b ∥
section→isSurjection : {g : B → A} → section f g → isSurjection f
section→isSurjection {g = g} s b = ∣ g b , s b ∣
isSurjectionIsProp : isProp (isSurjection f)
isSurjectionIsProp = propPi λ _ → squash
isEquiv→isSurjection : isEquiv f → isSurjection f
isEquiv→isSurjection e b = ∣ fst (equiv-proof e b) ∣
isEquiv→isEmbedding×isSurjection : isEquiv f → isEmbedding f × isSurjection f
isEquiv→isEmbedding×isSurjection e = isEquiv→isEmbedding e , isEquiv→isSurjection e
isEmbedding×isSurjection→isEquiv : isEmbedding f × isSurjection f → isEquiv f
equiv-proof (isEmbedding×isSurjection→isEquiv {f = f} (emb , sur)) b =
inhProp→isContr (recPropTrunc fib' (λ x → x) fib) fib'
where
hpf : hasPropFibers f
hpf = isEmbedding→hasPropFibers emb
fib : ∥ fiber f b ∥
fib = sur b
fib' : isProp (fiber f b)
fib' = hpf b
isEquiv≃isEmbedding×isSurjection : isEquiv f ≃ isEmbedding f × isSurjection f
isEquiv≃isEmbedding×isSurjection = isoToEquiv (iso
isEquiv→isEmbedding×isSurjection
isEmbedding×isSurjection→isEquiv
(λ _ → hLevelProd 1 isEmbeddingIsProp isSurjectionIsProp _ _)
(λ _ → isPropIsEquiv _ _ _))
| 30.962963
| 83
| 0.740431
|
2eaeaf0f5a043a493e29364c4f8402b5c79bafe9
| 1,570
|
agda
|
Agda
|
agda-stdlib/src/Data/AVL/Sets.agda
|
DreamLinuxer/popl21-artifact
|
fb380f2e67dcb4a94f353dbaec91624fcb5b8933
|
[
"MIT"
] | 5
|
2020-10-07T12:07:53.000Z
|
2020-10-10T21:41:32.000Z
|
agda-stdlib/src/Data/AVL/Sets.agda
|
DreamLinuxer/popl21-artifact
|
fb380f2e67dcb4a94f353dbaec91624fcb5b8933
|
[
"MIT"
] | null | null | null |
agda-stdlib/src/Data/AVL/Sets.agda
|
DreamLinuxer/popl21-artifact
|
fb380f2e67dcb4a94f353dbaec91624fcb5b8933
|
[
"MIT"
] | 1
|
2021-11-04T06:54:45.000Z
|
2021-11-04T06:54:45.000Z
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Finite sets, based on AVL trees
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (StrictTotalOrder)
module Data.AVL.Sets
{a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
where
open import Data.Bool.Base
open import Data.List.Base as List using (List)
open import Data.Maybe.Base as Maybe
open import Data.Product as Prod using (_×_; _,_; proj₁)
open import Data.Unit
open import Function
open import Level
import Data.AVL strictTotalOrder as AVL
open StrictTotalOrder strictTotalOrder renaming (Carrier to A)
------------------------------------------------------------------------
-- The set type (note that Set is a reserved word)
⟨Set⟩ : Set (a ⊔ ℓ₂)
⟨Set⟩ = AVL.Tree (AVL.const ⊤)
------------------------------------------------------------------------
-- Repackaged functions
empty : ⟨Set⟩
empty = AVL.empty
singleton : A → ⟨Set⟩
singleton k = AVL.singleton k _
insert : A → ⟨Set⟩ → ⟨Set⟩
insert k = AVL.insert k _
delete : A → ⟨Set⟩ → ⟨Set⟩
delete = AVL.delete
infix 4 _∈?_
_∈?_ : A → ⟨Set⟩ → Bool
_∈?_ = AVL._∈?_
headTail : ⟨Set⟩ → Maybe (A × ⟨Set⟩)
headTail s = Maybe.map (Prod.map₁ proj₁) (AVL.headTail s)
initLast : ⟨Set⟩ → Maybe (⟨Set⟩ × A)
initLast s = Maybe.map (Prod.map₂ proj₁) (AVL.initLast s)
fromList : List A → ⟨Set⟩
fromList = AVL.fromList ∘ List.map (_, _)
toList : ⟨Set⟩ → List A
toList = List.map proj₁ ∘ AVL.toList
| 24.920635
| 72
| 0.558599
|
148568f2bfc61dbdec3003eaa376ac20547434ae
| 455
|
agda
|
Agda
|
test/Succeed/ProjectionsPreserveGuardednessTrivialExample.agda
|
alex-mckenna/agda
|
78b62cd24bbd570271a7153e44ad280e52ef3e29
|
[
"BSD-3-Clause"
] | 3
|
2015-03-28T14:51:03.000Z
|
2015-12-07T20:14:00.000Z
|
test/Succeed/ProjectionsPreserveGuardednessTrivialExample.agda
|
andersk/agda
|
56928ff709dcb931cb9a48c4790e5ed3739e3032
|
[
"BSD-3-Clause"
] | null | null | null |
test/Succeed/ProjectionsPreserveGuardednessTrivialExample.agda
|
andersk/agda
|
56928ff709dcb931cb9a48c4790e5ed3739e3032
|
[
"BSD-3-Clause"
] | 1
|
2019-03-05T20:02:38.000Z
|
2019-03-05T20:02:38.000Z
|
-- {-# OPTIONS -v term:30 #-}
-- 2010-10-14
module ProjectionsPreserveGuardednessTrivialExample where
open import Common.Level
open import Common.Coinduction
open import Common.Product
-- Streams
infixr 5 _∷_
data Stream (A : Set) : Set where
_∷_ : (x : A) (xs : ∞ (Stream A)) → Stream A
mutual
repeat : {A : Set}(a : A) → Stream A
repeat a = a ∷ proj₂ (repeat' a)
repeat' : {A : Set}(a : A) → A × ∞ (Stream A)
repeat' a = a , ♯ repeat a
| 19.782609
| 57
| 0.628571
|
37b39eb2f05ffe9992c0aae3948d6093ede23a3b
| 265
|
agda
|
Agda
|
agda/Order/Total.agda
|
bgbianchi/sorting
|
b8d428bccbdd1b13613e8f6ead6c81a8f9298399
|
[
"MIT"
] | 6
|
2015-05-21T12:50:35.000Z
|
2021-08-24T22:11:15.000Z
|
agda/Order/Total.agda
|
bgbianchi/sorting
|
b8d428bccbdd1b13613e8f6ead6c81a8f9298399
|
[
"MIT"
] | null | null | null |
agda/Order/Total.agda
|
bgbianchi/sorting
|
b8d428bccbdd1b13613e8f6ead6c81a8f9298399
|
[
"MIT"
] | null | null | null |
open import Relation.Binary.Core
module Order.Total {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_) where
open import Data.Sum
refl≤ : {x : A} → x ≤ x
refl≤ {x}
with tot≤ x x
... | inj₁ x≤x = x≤x
... | inj₂ x≤x = x≤x
| 18.928571
| 43
| 0.471698
|
3fcdecc17e6f3da92e135fa04141cbc65594a51a
| 167
|
agda
|
Agda
|
test/Fail/Issue5448-4.agda
|
favonia/agda
|
8d433b967567c08afe15d04a5cb63b6f6d8884ee
|
[
"BSD-2-Clause"
] | null | null | null |
test/Fail/Issue5448-4.agda
|
favonia/agda
|
8d433b967567c08afe15d04a5cb63b6f6d8884ee
|
[
"BSD-2-Clause"
] | 6
|
2021-10-18T08:12:24.000Z
|
2021-11-24T08:31:10.000Z
|
test/Fail/Issue5448-4.agda
|
antoinevanmuylder/agda
|
bd59d5b07ffe02a43b28d186d95e1747aac5bc8c
|
[
"BSD-2-Clause"
] | null | null | null |
{-# OPTIONS --cubical-compatible #-}
open import Agda.Builtin.Equality
subst :
{@0 A : Set} {@0 x y : A}
(@0 P : A → Set) → x ≡ y → P x → P y
subst P refl p = p
| 18.555556
| 38
| 0.54491
|
14efefb9ca291bb9dc25f622d58d612c74cd2fa9
| 696
|
agda
|
Agda
|
test/LibSucceed/InstanceArguments/09-higherOrderClasses.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/LibSucceed/InstanceArguments/09-higherOrderClasses.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/LibSucceed/InstanceArguments/09-higherOrderClasses.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
{-# OPTIONS --universe-polymorphism #-}
module InstanceArguments.09-higherOrderClasses where
open import Category.Applicative
open import Category.Monad
open import Category.Monad.Indexed
open import Function
lift : ∀ {a b c} {A : Set a} {C : Set c} {B : A → Set b} →
({{x : A}} → B x) → (f : C → A) → {{x : C}} → B (f x)
lift m f {{x}} = m {{f x}}
monadToApplicative : ∀ {l} {M : Set l → Set l} → RawMonad M → RawApplicative M
monadToApplicative = RawIMonad.rawIApplicative
liftAToM : ∀ {l} {V : Set l} {M : Set l → Set l} → ({{appM : RawApplicative M}} → M V) →
{{monadM : RawMonad M}} → M V
liftAToM app {{x}} = lift (λ {{appM}} → app {{appM}}) monadToApplicative {{x}}
| 34.8
| 88
| 0.606322
|
4e855045830c762dc85d199e0d3c13bc56483ce1
| 357
|
agda
|
Agda
|
examples/outdated-and-incorrect/clowns/Zipper.agda
|
asr/agda-kanso
|
aa10ae6a29dc79964fe9dec2de07b9df28b61ed5
|
[
"MIT"
] | 1
|
2018-10-10T17:08:44.000Z
|
2018-10-10T17:08:44.000Z
|
examples/outdated-and-incorrect/clowns/Zipper.agda
|
np/agda-git-experiment
|
20596e9dd9867166a64470dd24ea68925ff380ce
|
[
"MIT"
] | null | null | null |
examples/outdated-and-incorrect/clowns/Zipper.agda
|
np/agda-git-experiment
|
20596e9dd9867166a64470dd24ea68925ff380ce
|
[
"MIT"
] | 1
|
2022-03-12T11:35:18.000Z
|
2022-03-12T11:35:18.000Z
|
module Zipper where
import Derivative
import Functor
import Sets
open Functor
open Derivative
open Semantics
open Recursive
open Sets
Zipper : U -> Set
Zipper F = List (⟦ ∂ F ⟧ (μ F))
-- Plugging a zipper
unzip : {F : U} -> Zipper F -> μ F -> μ F
unzip [] t = t
unzip {F} (c :: γ) t = inn (plug-∂ F c (unzip γ t))
| 16.227273
| 53
| 0.571429
|
d109aa5c8718a67c2bf1e8a9dc98dea2964f15ab
| 1,084
|
agda
|
Agda
|
examples/outdated-and-incorrect/cat/Unique.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
examples/outdated-and-incorrect/cat/Unique.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
examples/outdated-and-incorrect/cat/Unique.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
module Unique where
open import Category
module Uniq (ℂ : Cat) where
private open module C = Cat ℂ
-- We say that f ∈! P iff f is the unique arrow satisfying P.
data _∈!_ {A B : Obj}(f : A ─→ B)(P : A ─→ B -> Set) : Set where
unique : (forall g -> P g -> f == g) -> f ∈! P
itsUnique : {A B : Obj}{f : A ─→ B}{P : A ─→ B -> Set} ->
f ∈! P -> (g : A ─→ B) -> P g -> f == g
itsUnique (unique h) = h
data ∃! {A B : Obj}(P : A ─→ B -> Set) : Set where
witness : (f : A ─→ B) -> f ∈! P -> ∃! P
getWitness : {A B : Obj}{P : A ─→ B -> Set} -> ∃! P -> A ─→ B
getWitness (witness w _) = w
uniqueWitness : {A B : Obj}{P : A ─→ B -> Set}(u : ∃! P) ->
getWitness u ∈! P
uniqueWitness (witness _ u) = u
witnessEqual : {A B : Obj}{P : A ─→ B -> Set} -> ∃! P ->
{f g : A ─→ B} -> P f -> P g -> f == g
witnessEqual u {f} {g} pf pg = trans (sym hf) hg
where
h = getWitness u
hf : h == f
hf = itsUnique (uniqueWitness u) f pf
hg : h == g
hg = itsUnique (uniqueWitness u) g pg
| 27.794872
| 66
| 0.462177
|
0db681b5d1b4ce0eab43f4b06b10ebf58d9f3dcf
| 2,298
|
agda
|
Agda
|
src/LibraBFT/Impl/IO/OBM/InputOutputHandlers.agda
|
LaudateCorpus1/bft-consensus-agda
|
a4674fc473f2457fd3fe5123af48253cfb2404ef
|
[
"UPL-1.0"
] | null | null | null |
src/LibraBFT/Impl/IO/OBM/InputOutputHandlers.agda
|
LaudateCorpus1/bft-consensus-agda
|
a4674fc473f2457fd3fe5123af48253cfb2404ef
|
[
"UPL-1.0"
] | null | null | null |
src/LibraBFT/Impl/IO/OBM/InputOutputHandlers.agda
|
LaudateCorpus1/bft-consensus-agda
|
a4674fc473f2457fd3fe5123af48253cfb2404ef
|
[
"UPL-1.0"
] | null | null | null |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2021, 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.Base.Types
import LibraBFT.Impl.Consensus.Network as Network
import LibraBFT.Impl.Consensus.RoundManager as RoundManager
open import LibraBFT.Impl.OBM.Logging.Logging
open import LibraBFT.ImplShared.Consensus.Types
open import LibraBFT.ImplShared.Util.Dijkstra.All
open import Optics.All
open import Util.Prelude
-- This module defines the handler for our implementation. For most message types, it does some
-- initial validation before passing the message on to the proper handlers.
module LibraBFT.Impl.IO.OBM.InputOutputHandlers where
epvv : LBFT (Epoch × ValidatorVerifier)
epvv = _,_ <$> gets (_^∙ rmSafetyRules ∙ srPersistentStorage ∙ pssSafetyData ∙ sdEpoch)
<*> gets (_^∙ rmEpochState ∙ esVerifier)
module handleProposal (now : Instant) (pm : ProposalMsg) where
step₀ : LBFT Unit
step₁ : Epoch → ValidatorVerifier → LBFT Unit
step₀ = do
(myEpoch , vv) ← epvv
step₁ myEpoch vv
step₁ myEpoch vv = do
case⊎D Network.processProposal {- {!!} -} pm myEpoch vv of λ where
(Left (Left e)) → logErr e
(Left (Right i)) → logInfo i
(Right _) → RoundManager.processProposalMsgM now pm
handleProposal : Instant → ProposalMsg → LBFT Unit
handleProposal = handleProposal.step₀
module handleVote (now : Instant) (vm : VoteMsg) where
step₀ : LBFT Unit
step₁ : Epoch → ValidatorVerifier → LBFT Unit
step₀ = do
(myEpoch , vv) ← epvv
step₁ myEpoch vv
step₁ myEpoch vv = do
case Network.processVote vm myEpoch vv of λ where
(Left (Left e)) → logErr e
(Left (Right i)) → logInfo i
(Right _) → RoundManager.processVoteMsgM now vm
abstract
handleVote = handleVote.step₀
handleVote≡ : handleVote ≡ handleVote.step₀
handleVote≡ = refl
handle : NodeId → NetworkMsg → Instant → LBFT Unit
handle _self msg now =
case msg of λ where
(P pm) → handleProposal now pm
(V vm) → handleVote now vm
(C cm) → pure unit -- We don't do anything with commit messages, they are just for defining Correctness.
| 33.794118
| 111
| 0.712359
|
355b2cfa72272aaf4a031b46bdf1d6732fb85ef2
| 208
|
agda
|
Agda
|
test/Fail/NegativeIntegerLiteral.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Fail/NegativeIntegerLiteral.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Fail/NegativeIntegerLiteral.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
-- Andreas, 2014-05-02
-- As of now, we have no negative integer literals, and these parse as identifiers.
module _ where
open import Common.Prelude
n : Nat
n = -1
-- Should give error "not in scope: -1"
| 17.333333
| 83
| 0.701923
|
d163bba88380f9e4dd3da1b0b59bc3047fc066a4
| 2,601
|
agda
|
Agda
|
theorems/homotopy/elims/SuspSmash.agda
|
AntoineAllioux/HoTT-Agda
|
1037d82edcf29b620677a311dcfd4fc2ade2faa6
|
[
"MIT"
] | 294
|
2015-01-09T16:23:23.000Z
|
2022-03-20T13:54:45.000Z
|
theorems/homotopy/elims/SuspSmash.agda
|
AntoineAllioux/HoTT-Agda
|
1037d82edcf29b620677a311dcfd4fc2ade2faa6
|
[
"MIT"
] | 31
|
2015-03-05T20:09:00.000Z
|
2021-10-03T19:15:25.000Z
|
theorems/homotopy/elims/SuspSmash.agda
|
AntoineAllioux/HoTT-Agda
|
1037d82edcf29b620677a311dcfd4fc2ade2faa6
|
[
"MIT"
] | 50
|
2015-01-10T01:48:08.000Z
|
2022-02-14T03:03:25.000Z
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.elims.Lemmas
module homotopy.elims.SuspSmash {i j k} {X : Ptd i} {Y : Ptd j}
{P : Susp (X ∧ Y) → Type k}
(north* : P north) (south* : P south)
(smin* : (x : de⊙ X) (y : de⊙ Y) → north* == south* [ P ↓ merid (smin x y) ])
where
private
smbase*-template : ∀ {s} (p : smin (pt X) (pt Y) == s)
→ north* == south* [ P ↓ merid s ]
smbase*-template p = transport (λ κ → north* == south* [ P ↓ merid κ ])
p (smin* (pt X) (pt Y))
smbasel* = smbase*-template (smgluel (pt X))
smbaser* = smbase*-template (smgluer (pt Y))
-- note that [smin*] is adjusted.
coh* : (s : X ∧ Y) → north* == south* [ P ↓ merid s ]
coh* = Smash-elim
(λ x y → fst (fill-l x) ◃ fst (fill-r y) ◃ fst fill-base ◃ smin* x y)
smbasel* smbaser*
(λ x → ↓↓-from-squareover $
ap (λ p → fst (fill-l x) ◃ p ◃ fst fill-base ◃ smin* x (pt Y)) fill-r-β
∙h↓⊡ ap (fst (fill-l x) ◃_) (idp◃ _)
∙h↓⊡ snd (fill-l x))
(λ y → ↓↓-from-squareover $
ap (λ p → p ◃ fst (fill-r y) ◃ fst fill-base ◃ smin* (pt X) y) fill-l-β
∙h↓⊡ idp◃ _
∙h↓⊡ snd (fill-r y))
where
fill-template : ∀ {s₁ s₂} (p : s₁ == s₂)
(α : north* == south* [ P ↓ merid s₁ ])
(β : north* == south* [ P ↓ merid s₂ ])
→ Σ (north* == north*)
(λ q → SquareOver P (natural-square merid p)
(q ◃ α)
(↓-ap-in _ _ (apd (λ _ → north*) p))
(↓-ap-in _ _ (apd (λ _ → south*) p))
β)
fill-template p α β = fill-upper-left _ _ _ _ _
fill-base = fill-template (smgluel (pt X)) (smin* (pt X) (pt Y)) smbasel*
fill-l = λ x → fill-template (smgluel x) (fst fill-base ◃ smin* x (pt Y)) smbasel*
fill-l-β : fst (fill-l (pt X)) == idp
fill-l-β = ! $
fill-upper-left-unique _ _ _ _ _ idp (idp◃ _ ∙h↓⊡ snd fill-base)
fill-r = λ y → fill-template (smgluer y) (fst fill-base ◃ smin* (pt X) y) smbaser*
fill-r-β : fst (fill-r (pt Y)) == idp
fill-r-β = ! $
fill-upper-left-unique _ _ _ _ _ idp (idp◃ _ ∙h↓⊡ snd fill-base)
∙ ap (λ sp → fst (fill-template (snd sp)
(fst fill-base ◃ smin* (pt X) (pt Y))
(smbase*-template (snd sp))))
(contr-has-all-paths {{pathfrom-is-contr (smin (pt X) (pt Y))}}
(smbasel , smgluel (pt X))
(smbaser , smgluer (pt Y)))
SuspSmash-elim : Π (Susp (X ∧ Y)) P
SuspSmash-elim = Susp-elim north* south* coh*
| 40.015385
| 86
| 0.489043
|
35d140c2d46ef02080f6ddecc2111f2fd40ade36
| 176
|
agda
|
Agda
|
Cubical/Codata/Conat.agda
|
kiana-S/univalent-foundations
|
8bdb0766260489f9c89a14f4c0f2ad26e5190dec
|
[
"MIT"
] | null | null | null |
Cubical/Codata/Conat.agda
|
kiana-S/univalent-foundations
|
8bdb0766260489f9c89a14f4c0f2ad26e5190dec
|
[
"MIT"
] | 1
|
2022-01-27T02:07:48.000Z
|
2022-01-27T02:07:48.000Z
|
Cubical/Codata/Conat.agda
|
kiana-S/univalent-foundations
|
8bdb0766260489f9c89a14f4c0f2ad26e5190dec
|
[
"MIT"
] | 1
|
2021-11-22T02:02:01.000Z
|
2021-11-22T02:02:01.000Z
|
{-# OPTIONS --cubical --no-import-sorts #-}
module Cubical.Codata.Conat where
open import Cubical.Codata.Conat.Base public
open import Cubical.Codata.Conat.Properties public
| 25.142857
| 50
| 0.784091
|
7c9e4edd58349bedcf15320d2536d395a371b5af
| 684
|
agda
|
Agda
|
Cubical/Algebra/NatSolver/NatExpression.agda
|
FernandoLarrain/cubical
|
9acdecfa6437ec455568be4e5ff04849cc2bc13b
|
[
"MIT"
] | 1
|
2022-03-05T00:29:41.000Z
|
2022-03-05T00:29:41.000Z
|
Cubical/Algebra/NatSolver/NatExpression.agda
|
FernandoLarrain/cubical
|
9acdecfa6437ec455568be4e5ff04849cc2bc13b
|
[
"MIT"
] | null | null | null |
Cubical/Algebra/NatSolver/NatExpression.agda
|
FernandoLarrain/cubical
|
9acdecfa6437ec455568be4e5ff04849cc2bc13b
|
[
"MIT"
] | null | null | null |
{-# OPTIONS --safe #-}
module Cubical.Algebra.NatSolver.NatExpression where
open import Cubical.Foundations.Prelude
open import Cubical.Data.FinData
open import Cubical.Data.Nat
open import Cubical.Data.Nat.Order using (zero-≤)
open import Cubical.Data.Vec.Base
infixl 6 _+'_
infixl 7 _·'_
-- Expression in a ring on A with n variables
data Expr (n : ℕ) : Type ℓ-zero where
K : ℕ → Expr n
∣ : Fin n → Expr n
_+'_ : Expr n → Expr n → Expr n
_·'_ : Expr n → Expr n → Expr n
module Eval where
open import Cubical.Data.Vec
⟦_⟧ : ∀ {n} → Expr n → Vec ℕ n → ℕ
⟦ K r ⟧ v = r
⟦ ∣ k ⟧ v = lookup k v
⟦ x +' y ⟧ v = ⟦ x ⟧ v + ⟦ y ⟧ v
⟦ x ·' y ⟧ v = ⟦ x ⟧ v · ⟦ y ⟧ v
| 23.586207
| 52
| 0.609649
|
14cdc1a49430ca17607904706e12f63a0e903375
| 801
|
agda
|
Agda
|
test/Succeed/Issue1357.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Succeed/Issue1357.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Succeed/Issue1357.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
-- Andrea & Andreas, 2014-11-12
-- Pruning projected vars during solving
open import Common.Product
open import Common.Equality
postulate
A : Set
works1 : {q1 : Set} {q2 : Set → Set} ->
let M : Set -> Set; M = _ in {z : Set} -> q1 ≡ M (q2 z)
works1 = refl
works2 : {q1 : Set} {q2 : Set → Set} ->
let M : Set -> Set; M = _ in q1 ≡ M (q2 A)
works2 = refl
works3 : {q : Set × Set} ->
let M : Set -> Set; M = _ in proj₁ q ≡ M (proj₂ q)
works3 = refl
test1 : {q : Set × (Set → Set)} ->
let M : Set -> Set; M = _ in {z : Set} -> proj₁ q ≡ M (proj₂ q z)
test1 = refl
test2 : {q : Set × (Set → Set)} ->
let M : Set -> Set; M = _ in proj₁ q ≡ M (proj₂ q A)
test2 = refl
-- these tests should succeed, as expanding q into a pair gets us back to
-- works1 and works2
| 25.03125
| 73
| 0.555556
|
3675e3b3fd231352b9fc9d872b2f6d164c3d1081
| 8,537
|
agda
|
Agda
|
Cubical/Algebra/Ring/QuotientRing.agda
|
L-TChen/cubical
|
60226aacd7b386aef95d43a0c29c4eec996348a8
|
[
"MIT"
] | null | null | null |
Cubical/Algebra/Ring/QuotientRing.agda
|
L-TChen/cubical
|
60226aacd7b386aef95d43a0c29c4eec996348a8
|
[
"MIT"
] | null | null | null |
Cubical/Algebra/Ring/QuotientRing.agda
|
L-TChen/cubical
|
60226aacd7b386aef95d43a0c29c4eec996348a8
|
[
"MIT"
] | null | null | null |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Ring.QuotientRing where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Structure
open import Cubical.Foundations.Powerset using (_∈_; _⊆_) -- \in, \sub=
open import Cubical.HITs.SetQuotients.Base renaming (_/_ to _/ₛ_)
open import Cubical.HITs.SetQuotients.Properties
open import Cubical.Algebra.Ring
private
variable
ℓ : Level
module _ (R' : Ring {ℓ}) (I : ⟨ R' ⟩ → hProp ℓ) (I-isIdeal : isIdeal R' I) where
open RingStr (snd R')
private R = ⟨ R' ⟩
open isIdeal I-isIdeal
open Theory R'
R/I : Type ℓ
R/I = R /ₛ (λ x y → x - y ∈ I)
private
homogeneity : ∀ (x a b : R)
→ (a - b ∈ I)
→ (x + a) - (x + b) ∈ I
homogeneity x a b p = subst (λ u → u ∈ I) (translatedDifference x a b) p
isSetR/I : isSet R/I
isSetR/I = squash/
[_]/I : (a : R) → R/I
[ a ]/I = [ a ]
lemma : (x y a : R)
→ x - y ∈ I
→ [ x + a ]/I ≡ [ y + a ]/I
lemma x y a x-y∈I = eq/ (x + a) (y + a) (subst (λ u → u ∈ I) calculate x-y∈I)
where calculate : x - y ≡ (x + a) - (y + a)
calculate =
x - y ≡⟨ translatedDifference a x y ⟩
((a + x) - (a + y)) ≡⟨ cong (λ u → u - (a + y)) (+Comm _ _) ⟩
((x + a) - (a + y)) ≡⟨ cong (λ u → (x + a) - u) (+Comm _ _) ⟩
((x + a) - (y + a)) ∎
pre-+/I : R → R/I → R/I
pre-+/I x = elim
(λ _ → squash/)
(λ y → [ x + y ])
λ y y' diffrenceInIdeal
→ eq/ (x + y) (x + y') (homogeneity x y y' diffrenceInIdeal)
pre-+/I-DescendsToQuotient : (x y : R) → (x - y ∈ I)
→ pre-+/I x ≡ pre-+/I y
pre-+/I-DescendsToQuotient x y x-y∈I i r = pointwise-equal r i
where
pointwise-equal : ∀ (u : R/I)
→ pre-+/I x u ≡ pre-+/I y u
pointwise-equal = elimProp (λ u → isSetR/I (pre-+/I x u) (pre-+/I y u))
(λ a → lemma x y a x-y∈I)
_+/I_ : R/I → R/I → R/I
x +/I y = (elim R/I→R/I-isSet pre-+/I pre-+/I-DescendsToQuotient x) y
where
R/I→R/I-isSet : R/I → isSet (R/I → R/I)
R/I→R/I-isSet _ = isSetΠ (λ _ → squash/)
+/I-comm : (x y : R/I) → x +/I y ≡ y +/I x
+/I-comm = elimProp2 (λ _ _ → squash/ _ _) eq
where eq : (x y : R) → [ x ] +/I [ y ] ≡ [ y ] +/I [ x ]
eq x y i = [ +Comm x y i ]
+/I-assoc : (x y z : R/I) → x +/I (y +/I z) ≡ (x +/I y) +/I z
+/I-assoc = elimProp3 (λ _ _ _ → squash/ _ _) eq
where eq : (x y z : R) → [ x ] +/I ([ y ] +/I [ z ]) ≡ ([ x ] +/I [ y ]) +/I [ z ]
eq x y z i = [ +Assoc x y z i ]
0/I : R/I
0/I = [ 0r ]
1/I : R/I
1/I = [ 1r ]
-/I : R/I → R/I
-/I = elim (λ _ → squash/) (λ x' → [ - x' ]) eq
where
eq : (x y : R) → (x - y ∈ I) → [ - x ] ≡ [ - y ]
eq x y x-y∈I = eq/ (- x) (- y) (subst (λ u → u ∈ I) eq' (isIdeal.-closed I-isIdeal x-y∈I))
where
eq' = - (x + (- y)) ≡⟨ sym (-Dist _ _) ⟩
(- x) - (- y) ∎
+/I-rinv : (x : R/I) → x +/I (-/I x) ≡ 0/I
+/I-rinv = elimProp (λ x → squash/ _ _) eq
where
eq : (x : R) → [ x ] +/I (-/I [ x ]) ≡ 0/I
eq x i = [ +Rinv x i ]
+/I-rid : (x : R/I) → x +/I 0/I ≡ x
+/I-rid = elimProp (λ x → squash/ _ _) eq
where
eq : (x : R) → [ x ] +/I 0/I ≡ [ x ]
eq x i = [ +Rid x i ]
_·/I_ : R/I → R/I → R/I
_·/I_ =
elim (λ _ → isSetΠ (λ _ → squash/))
(λ x → left· x)
eq'
where
eq : (x y y' : R) → (y - y' ∈ I) → [ x · y ] ≡ [ x · y' ]
eq x y y' y-y'∈I = eq/ _ _
(subst (λ u → u ∈ I)
(x · (y - y') ≡⟨ ·Rdist+ _ _ _ ⟩
((x · y) + x · (- y')) ≡⟨ cong (λ u → (x · y) + u)
(-DistR· x y') ⟩
(x · y) - (x · y') ∎)
(isIdeal.·-closedLeft I-isIdeal x y-y'∈I))
left· : (x : R) → R/I → R/I
left· x = elim (λ y → squash/)
(λ y → [ x · y ])
(eq x)
eq' : (x x' : R) → (x - x' ∈ I) → left· x ≡ left· x'
eq' x x' x-x'∈I i y = elimProp (λ y → squash/ (left· x y) (left· x' y))
(λ y → eq′ y)
y i
where
eq′ : (y : R) → left· x [ y ] ≡ left· x' [ y ]
eq′ y = eq/ (x · y) (x' · y)
(subst (λ u → u ∈ I)
((x - x') · y ≡⟨ ·Ldist+ x (- x') y ⟩
x · y + (- x') · y ≡⟨ cong
(λ u → x · y + u)
(-DistL· x' y) ⟩
x · y - x' · y ∎)
(isIdeal.·-closedRight I-isIdeal y x-x'∈I))
-- more or less copy paste from '+/I' - this is preliminary anyway
·/I-assoc : (x y z : R/I) → x ·/I (y ·/I z) ≡ (x ·/I y) ·/I z
·/I-assoc = elimProp3 (λ _ _ _ → squash/ _ _) eq
where eq : (x y z : R) → [ x ] ·/I ([ y ] ·/I [ z ]) ≡ ([ x ] ·/I [ y ]) ·/I [ z ]
eq x y z i = [ ·Assoc x y z i ]
·/I-lid : (x : R/I) → 1/I ·/I x ≡ x
·/I-lid = elimProp (λ x → squash/ _ _) eq
where
eq : (x : R) → 1/I ·/I [ x ] ≡ [ x ]
eq x i = [ ·Lid x i ]
·/I-rid : (x : R/I) → x ·/I 1/I ≡ x
·/I-rid = elimProp (λ x → squash/ _ _) eq
where
eq : (x : R) → [ x ] ·/I 1/I ≡ [ x ]
eq x i = [ ·Rid x i ]
/I-ldist : (x y z : R/I) → (x +/I y) ·/I z ≡ (x ·/I z) +/I (y ·/I z)
/I-ldist = elimProp3 (λ _ _ _ → squash/ _ _) eq
where
eq : (x y z : R) → ([ x ] +/I [ y ]) ·/I [ z ] ≡ ([ x ] ·/I [ z ]) +/I ([ y ] ·/I [ z ])
eq x y z i = [ ·Ldist+ x y z i ]
/I-rdist : (x y z : R/I) → x ·/I (y +/I z) ≡ (x ·/I y) +/I (x ·/I z)
/I-rdist = elimProp3 (λ _ _ _ → squash/ _ _) eq
where
eq : (x y z : R) → [ x ] ·/I ([ y ] +/I [ z ]) ≡ ([ x ] ·/I [ y ]) +/I ([ x ] ·/I [ z ])
eq x y z i = [ ·Rdist+ x y z i ]
asRing : Ring {ℓ}
asRing = makeRing 0/I 1/I _+/I_ _·/I_ -/I isSetR/I
+/I-assoc +/I-rid +/I-rinv +/I-comm
·/I-assoc ·/I-rid ·/I-lid /I-rdist /I-ldist
_/_ : (R : Ring {ℓ}) → (I : IdealsIn R) → Ring {ℓ}
R / (I , IisIdeal) = asRing R I IisIdeal
[_]/I : {R : Ring {ℓ}} {I : IdealsIn R} → (a : ⟨ R ⟩) → ⟨ R / I ⟩
[ a ]/I = [ a ]
module UniversalProperty (R : Ring {ℓ}) (I : IdealsIn R) where
open RingStr ⦃...⦄
open Theory ⦃...⦄
Iₛ = fst I
private
instance
_ = R
_ = snd R
module _ {S : Ring {ℓ}} (φ : RingHom R S) where
open RingHom φ
open HomTheory φ
private
instance
_ = S
_ = snd S
inducedHom : Iₛ ⊆ kernel φ → RingHom (R / I) S
f (inducedHom Iₛ⊆kernel) = elim
(λ _ → isSetRing S)
f
λ r₁ r₂ r₁-r₂∈I → equalByDifference (f r₁) (f r₂)
(f r₁ - f r₂ ≡⟨ cong (λ u → f r₁ + u) (sym (-commutesWithHom _)) ⟩
f r₁ + f (- r₂) ≡⟨ sym (isHom+ _ _) ⟩
f (r₁ - r₂) ≡⟨ Iₛ⊆kernel (r₁ - r₂) r₁-r₂∈I ⟩
0r ∎)
pres1 (inducedHom Iₛ⊆kernel) = pres1
isHom+ (inducedHom Iₛ⊆kernel) =
elimProp2 (λ _ _ → isSetRing S _ _) isHom+
isHom· (inducedHom Iₛ⊆kernel) =
elimProp2 (λ _ _ → isSetRing S _ _) isHom·
solution : (p : Iₛ ⊆ kernel φ)
→ (x : ⟨ R ⟩) → inducedHom p $ [ x ] ≡ φ $ x
solution p x = refl
unique : (p : Iₛ ⊆ kernel φ)
→ (ψ : RingHom (R / I) S) → (ψIsSolution : (x : ⟨ R ⟩) → ψ $ [ x ] ≡ φ $ x)
→ (x : ⟨ R ⟩) → ψ $ [ x ] ≡ inducedHom p $ [ x ]
unique p ψ ψIsSolution x = ψIsSolution x
| 37.279476
| 105
| 0.362774
|
30b140163a13dc8e738e56c788aa8a379fdb0fb6
| 1,337
|
agda
|
Agda
|
src/Generics/Mu/All.agda
|
flupe/generics
|
db764f858d908aa39ea4901669a6bbce1525f757
|
[
"MIT"
] | 11
|
2021-04-08T15:10:20.000Z
|
2022-02-05T09:35:17.000Z
|
src/Generics/Mu/All.agda
|
flupe/generics
|
db764f858d908aa39ea4901669a6bbce1525f757
|
[
"MIT"
] | 4
|
2021-09-13T07:33:50.000Z
|
2022-01-14T10:48:30.000Z
|
src/Generics/Mu/All.agda
|
flupe/generics
|
db764f858d908aa39ea4901669a6bbce1525f757
|
[
"MIT"
] | 3
|
2021-04-08T08:32:42.000Z
|
2022-01-14T10:35:16.000Z
|
{-# OPTIONS --safe --without-K #-}
module Generics.Mu.All where
open import Generics.Prelude hiding (lookup)
open import Generics.Telescope
open import Generics.Desc
open import Generics.Mu
private
variable
P : Telescope ⊤
p : ⟦ P ⟧tel tt
V I : ExTele P
ℓ c : Level
n : ℕ
AllIndArgωω
: {X : ⟦ P , I ⟧xtel → Setω}
(Pr : ∀ {i} → X (p , i) → Setω)
(C : ConDesc P V I)
→ ∀ {v} → ⟦ C ⟧IndArgω X (p , v) → Setω
AllIndArgωω Pr (var _) x = Pr x
AllIndArgωω Pr (π (n , ai) S C) x = (s : < relevance ai > S _) → AllIndArgωω Pr C (x s)
AllIndArgωω Pr (A ⊗ B) (xa , xb) = AllIndArgωω Pr A xa ×ω AllIndArgωω Pr B xb
AllConωω
: {X : ⟦ P , I ⟧xtel → Setω}
(Pr : ∀ {i} → X (p , i) → Setω)
(C : ConDesc P V I)
→ ∀ {v i} → ⟦ C ⟧Conω X (p , v , i) → Setω
AllConωω Pr (var f) x = ⊤ω
AllConωω Pr (π ia S C) (_ , x) = AllConωω Pr C x
AllConωω Pr (A ⊗ B) (xa , xb) = AllIndArgωω Pr A xa ×ω AllConωω Pr B xb
AllDataωω : {X : ⟦ P , I ⟧xtel → Setω}
(Pr : ∀ {i} → X (p , i) → Setω)
(D : DataDesc P I n)
→ ∀ {i} (x : ⟦ D ⟧Dataω X (p , i))
→ Setω
AllDataωω Pr D (k , x) = AllConωω Pr (lookupCon D k) x
All : ∀ (D : DataDesc P I n) {c}
(Pr : ∀ {i} → μ D (p , i) → Set c)
→ ∀ {i} → μ D (p , i) → Setω
All D Pr ⟨ x ⟩ = AllDataωω (λ x → Liftω (Pr x)) D x
| 25.711538
| 87
| 0.511593
|
4e8e17ed7947a09c62ffed9d59f496ff8a7e5391
| 79
|
agda
|
Agda
|
test/Fail/UselessAbstractAbstract.agda
|
pthariensflame/agda
|
222c4c64b2ccf8e0fc2498492731c15e8fef32d4
|
[
"BSD-3-Clause"
] | 3
|
2015-03-28T14:51:03.000Z
|
2015-12-07T20:14:00.000Z
|
test/fail/UselessAbstractAbstract.agda
|
np/agda-git-experiment
|
20596e9dd9867166a64470dd24ea68925ff380ce
|
[
"MIT"
] | null | null | null |
test/fail/UselessAbstractAbstract.agda
|
np/agda-git-experiment
|
20596e9dd9867166a64470dd24ea68925ff380ce
|
[
"MIT"
] | 1
|
2022-03-12T11:35:18.000Z
|
2022-03-12T11:35:18.000Z
|
module UselessAbstractAbstract where
A : Set₁
abstract
abstract
A = Set
| 11.285714
| 36
| 0.746835
|
34735d17c6db3427e1dc7f3160a25a003c2edf19
| 820
|
agda
|
Agda
|
test/Succeed/Issue3695.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Succeed/Issue3695.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Succeed/Issue3695.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
{-# OPTIONS --cubical #-}
open import Agda.Builtin.Cubical.Path using (_≡_)
open import Agda.Builtin.Sigma using (Σ; fst; _,_)
postulate
Is-proposition : Set → Set
subst : ∀ {A : Set} (P : A → Set) {x y} → x ≡ y → P x → P y
Proposition : Set₁
Proposition = Σ _ Is-proposition
data _/_ (A : Set) (R : A → A → Proposition) : Set where
[_] : A → A / R
resp : ∀ {x y} → fst (R x y) → [ x ] ≡ [ y ]
variable
A : Set
R : A → A → Proposition
postulate
F : (P : A / R → Set)
(p-[] : ∀ x → P [ x ]) →
(∀ {x y} (r : fst (R x y)) → subst P (resp r) (p-[] x) ≡ p-[] y) →
Set
F' : (A : Set)
(R : A → A → Proposition)
(P : A / R → Set)
(p-[] : ∀ x → P [ x ]) →
(∀ {x y} (r : fst (R x y)) → subst P (resp r) (p-[] x) ≡ p-[] y) →
Set
F' A R = F {A = A} {R = R}
| 23.428571
| 72
| 0.44878
|
4ef897dde3bc38eea24f8e3237f61994238cb793
| 1,018
|
agda
|
Agda
|
README/Safe/Cubical.agda
|
nad/equality
|
402b20615cfe9ca944662380d7b2d69b0f175200
|
[
"MIT"
] | 3
|
2020-05-21T22:58:50.000Z
|
2021-09-02T17:18:15.000Z
|
README/Safe/Cubical.agda
|
nad/equality
|
402b20615cfe9ca944662380d7b2d69b0f175200
|
[
"MIT"
] | null | null | null |
README/Safe/Cubical.agda
|
nad/equality
|
402b20615cfe9ca944662380d7b2d69b0f175200
|
[
"MIT"
] | null | null | null |
------------------------------------------------------------------------
-- Safe modules that use --cubical
------------------------------------------------------------------------
{-# OPTIONS --safe --cubical #-}
module README.Safe.Cubical where
-- A proof of univalence.
import Equality.Path.Univalence
-- A proof of univalence for an arbitrary "equality with J".
import Equality.Path.Isomorphisms.Univalence
-- Very stable booleans.
import Bool.Very-stable
-- Listed finite subsets.
import Finite-subset.Listed
-- An alternative definition of listed finite subsets.
import Finite-subset.Listed.Alternative
-- Kuratowski finite subsets.
import Finite-subset.Kuratowski
-- An example related to Nat.Wrapper, defined in Cubical Agda.
import Nat.Wrapper.Cubical
-- Abstract binding trees, based on Harper's "Practical Foundations
-- for Programming Languages".
import Abstract-binding-tree
import README.Abstract-binding-tree
-- Overview of code related to a paper.
import README.HITs-without-paths
| 22.130435
| 72
| 0.662083
|
1454cd6c8d3bf40cc7b63fdd75bb451b51803645
| 386
|
agda
|
Agda
|
test/Succeed/Issue695.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Succeed/Issue695.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Succeed/Issue695.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
{-# OPTIONS --auto-inline #-}
module _ where
data Sigma (A : Set)(B : A → Set) : Set where
_,_ : (x : A) → B x → Sigma A B
record Top : Set where
_o_ : {A B : Set}{C : Set1} →
(f : B → C) → (g : A → B) → (A → C)
f o g = \ x → f (g x)
mutual
data U : Set where
top : U
sig : (X : U) → (T X → U) → U
T : U → Set
T top = Top
T (sig a b) = Sigma (T a) (T o b)
| 18.380952
| 45
| 0.448187
|
3618fefced8346abf8907a433e845ca7ee9d46fa
| 2,785
|
agda
|
Agda
|
gen/templates/Syntax.agda
|
JoeyEremondi/agda-soas
|
ff1a985a6be9b780d3ba2beff68e902394f0a9d8
|
[
"MIT"
] | 39
|
2021-11-09T20:39:55.000Z
|
2022-03-19T17:33:12.000Z
|
gen/templates/Syntax.agda
|
JoeyEremondi/agda-soas
|
ff1a985a6be9b780d3ba2beff68e902394f0a9d8
|
[
"MIT"
] | 1
|
2021-11-21T12:19:32.000Z
|
2021-11-21T12:19:32.000Z
|
gen/templates/Syntax.agda
|
JoeyEremondi/agda-soas
|
ff1a985a6be9b780d3ba2beff68e902394f0a9d8
|
[
"MIT"
] | 4
|
2021-11-09T20:39:59.000Z
|
2022-01-24T12:49:17.000Z
|
{-
This second-order term syntax was created from the following second-order syntax description:
$sig_string
-}
module ${syn_name}.Syntax where
open import SOAS.Common
open import SOAS.Context
open import SOAS.Variable
open import SOAS.Families.Core
open import SOAS.Construction.Structure
open import SOAS.ContextMaps.Inductive
open import SOAS.Metatheory.Syntax
open import ${syn_name}.Signature
private
variable
Γ Δ Π : Ctx
$ty_vars : $type
𝔛 : Familyₛ
-- Inductive term declaration
module ${sig}:Terms (𝔛 : Familyₛ) where
data ${sig} : Familyₛ where
var : ℐ ⇾̣ ${sig}
mvar : 𝔛 $fst_ty_var Π → Sub ${sig} Π Γ → ${sig} $fst_ty_var Γ
$syn_constructors
$op_fixity
open import SOAS.Metatheory.MetaAlgebra ⅀F 𝔛
${sig}ᵃ : MetaAlg ${sig}
${sig}ᵃ = record
{ 𝑎𝑙𝑔 = λ where
$alg_patterns
; 𝑣𝑎𝑟 = var ; 𝑚𝑣𝑎𝑟 = λ 𝔪 mε → mvar 𝔪 (tabulate mε) }
module ${sig}ᵃ = MetaAlg ${sig}ᵃ
module _ {𝒜 : Familyₛ}(𝒜ᵃ : MetaAlg 𝒜) where
open MetaAlg 𝒜ᵃ
𝕤𝕖𝕞 : ${sig} ⇾̣ 𝒜
𝕊 : Sub ${sig} Π Γ → Π ~[ 𝒜 ]↝ Γ
𝕊 (t ◂ σ) new = 𝕤𝕖𝕞 t
𝕊 (t ◂ σ) (old v) = 𝕊 σ v
𝕤𝕖𝕞 (mvar 𝔪 mε) = 𝑚𝑣𝑎𝑟 𝔪 (𝕊 mε)
𝕤𝕖𝕞 (var v) = 𝑣𝑎𝑟 v
$sem_patterns
𝕤𝕖𝕞ᵃ⇒ : MetaAlg⇒ ${sig}ᵃ 𝒜ᵃ 𝕤𝕖𝕞
𝕤𝕖𝕞ᵃ⇒ = record
{ ⟨𝑎𝑙𝑔⟩ = λ{ {t = t} → ⟨𝑎𝑙𝑔⟩ t }
; ⟨𝑣𝑎𝑟⟩ = refl
; ⟨𝑚𝑣𝑎𝑟⟩ = λ{ {𝔪 = 𝔪}{mε} → cong (𝑚𝑣𝑎𝑟 𝔪) (dext (𝕊-tab mε)) } }
where
open ≡-Reasoning
⟨𝑎𝑙𝑔⟩ : (t : ⅀ ${sig} $fst_ty_var Γ) → 𝕤𝕖𝕞 (${sig}ᵃ.𝑎𝑙𝑔 t) ≡ 𝑎𝑙𝑔 (⅀₁ 𝕤𝕖𝕞 t)
$alg_hom_patterns
𝕊-tab : (mε : Π ~[ ${sig} ]↝ Γ)(v : ℐ α Π) → 𝕊 (tabulate mε) v ≡ 𝕤𝕖𝕞 (mε v)
𝕊-tab mε new = refl
𝕊-tab mε (old v) = 𝕊-tab (mε ∘ old) v
module _ (g : ${sig} ⇾̣ 𝒜)(gᵃ⇒ : MetaAlg⇒ ${sig}ᵃ 𝒜ᵃ g) where
open MetaAlg⇒ gᵃ⇒
𝕤𝕖𝕞! : (t : ${sig} $fst_ty_var Γ) → 𝕤𝕖𝕞 t ≡ g t
𝕊-ix : (mε : Sub ${sig} Π Γ)(v : ℐ $fst_ty_var Π) → 𝕊 mε v ≡ g (index mε v)
𝕊-ix (x ◂ mε) new = 𝕤𝕖𝕞! x
𝕊-ix (x ◂ mε) (old v) = 𝕊-ix mε v
𝕤𝕖𝕞! (mvar 𝔪 mε) rewrite cong (𝑚𝑣𝑎𝑟 𝔪) (dext (𝕊-ix mε))
= trans (sym ⟨𝑚𝑣𝑎𝑟⟩) (cong (g ∘ mvar 𝔪) (tab∘ix≈id mε))
𝕤𝕖𝕞! (var v) = sym ⟨𝑣𝑎𝑟⟩
$alg_unique_patterns
-- Syntax instance for the signature
${sig}:Syn : Syntax
${sig}:Syn = record
{ ⅀F = ⅀F
; ⅀:CS = ⅀:CompatStr
; mvarᵢ = ${sig}:Terms.mvar
; 𝕋:Init = λ 𝔛 → let open ${sig}:Terms 𝔛 in record
{ ⊥ = ${sig} ⋉ ${sig}ᵃ
; ⊥-is-initial = record { ! = λ{ {𝒜 ⋉ 𝒜ᵃ} → 𝕤𝕖𝕞 𝒜ᵃ ⋉ 𝕤𝕖𝕞ᵃ⇒ 𝒜ᵃ }
; !-unique = λ{ {𝒜 ⋉ 𝒜ᵃ} (f ⋉ fᵃ⇒) {x = t} → 𝕤𝕖𝕞! 𝒜ᵃ f fᵃ⇒ t } } } }
-- Instantiation of the syntax and metatheory
open Syntax ${sig}:Syn public
open ${sig}:Terms public
open import SOAS.Families.Build public
open import SOAS.Syntax.Shorthands ${sig}ᵃ public
open import SOAS.Metatheory ${sig}:Syn public
$derived_tm_ops
| 25.550459
| 93
| 0.569838
|
0d5220c94118c7711aa730d63d6d838699072706
| 919
|
agda
|
Agda
|
test/succeed/IrrelevantRecordFields.agda
|
asr/agda-kanso
|
aa10ae6a29dc79964fe9dec2de07b9df28b61ed5
|
[
"MIT"
] | 1
|
2019-11-27T07:26:06.000Z
|
2019-11-27T07:26:06.000Z
|
test/succeed/IrrelevantRecordFields.agda
|
dagit/agda
|
4383a3d20328a6c43689161496cee8eb479aca08
|
[
"MIT"
] | null | null | null |
test/succeed/IrrelevantRecordFields.agda
|
dagit/agda
|
4383a3d20328a6c43689161496cee8eb479aca08
|
[
"MIT"
] | null | null | null |
-- 2010-09-24
-- example originally stolen from Andrea Vezzosi's post on the Agda list
{-# OPTIONS --no-irrelevant-projections #-}
module IrrelevantRecordFields where
-- import Common.Irrelevance
infix 4 _≡_
data _≡_ {A : Set}(a : A) : A -> Set where
refl : a ≡ a
sym : {A : Set}{a b : A} → a ≡ b → b ≡ a
sym refl = refl
record SemiG : Set1 where
constructor _,_,_,_,_,_
field
M : Set
unit : M
_+_ : M -> M -> M
.assoc : ∀ {x y z} -> x + (y + z) ≡ (x + y) + z
.leftUnit : ∀ {x} -> unit + x ≡ x
.rightUnit : ∀ {x} -> x + unit ≡ x
dual : SemiG -> SemiG
dual (M , e , _+_ , assoc , leftUnit , rightUnit) =
M , e , (λ x y -> y + x) , sym assoc , rightUnit , leftUnit
data _≡₁_ {A : Set1}(a : A) : A -> Set where
refl : a ≡₁ a
open SemiG
-- trivId : ∀ (M : SemiG) -> M ≡₁ M
-- trivId M = refl
dual∘dual≡id : ∀ M -> dual (dual M) ≡₁ M
dual∘dual≡id M = refl {a = M}
| 20.422222
| 73
| 0.536453
|
7c5d653faeae3a998374f1e8e3540fc1f6d2d9fd
| 993
|
agda
|
Agda
|
Categories/Functor/Cocontinuous.agda
|
rei1024/agda-categories
|
89d163f72caa7deeac9413f27bc1b4ed7f9e025b
|
[
"MIT"
] | null | null | null |
Categories/Functor/Cocontinuous.agda
|
rei1024/agda-categories
|
89d163f72caa7deeac9413f27bc1b4ed7f9e025b
|
[
"MIT"
] | null | null | null |
Categories/Functor/Cocontinuous.agda
|
rei1024/agda-categories
|
89d163f72caa7deeac9413f27bc1b4ed7f9e025b
|
[
"MIT"
] | null | null | null |
{-# OPTIONS --without-K --safe #-}
module Categories.Functor.Cocontinuous where
open import Level
open import Data.Product using (Σ)
open import Categories.Category
open import Categories.Functor
import Categories.Category.Construction.Cocones as Coc
import Categories.Diagram.Cocone.Properties as Cocₚ
import Categories.Diagram.Colimit as Col
import Categories.Morphism as Mor
private
variable
o ℓ e : Level
C D E J : Category o ℓ e
-- G preserves the colimit of F.
CoimitPreserving : (G : Functor C D) {F : Functor J C} (L : Col.Colimit F) → Set _
CoimitPreserving {C = C} {D = D} G {F} L = Σ (Col.Colimit (G ∘F F)) λ L′ → G.F₀ (Col.Colimit.coapex L) ≅ Col.Colimit.coapex L′
where module F = Functor F
module G = Functor G
open Mor D
-- cocontinuous functors preserves all colimits.
Cocontinuous : ∀ (o ℓ e : Level) (G : Functor C D) → Set _
Cocontinuous {C = C} o ℓ e G = ∀ {J : Category o ℓ e} {F : Functor J C} (L : Col.Colimit F) → CoimitPreserving G L
| 33.1
| 126
| 0.693857
|
37d6df2051c5d675f298cca96fd7566d0a2fc91e
| 7,513
|
agda
|
Agda
|
main/Util/Finite.agda
|
awswan/nielsenschreier-hott
|
84be713b8a8e41ea6f01f8ccf7251ebbbd73ad5d
|
[
"MIT"
] | null | null | null |
main/Util/Finite.agda
|
awswan/nielsenschreier-hott
|
84be713b8a8e41ea6f01f8ccf7251ebbbd73ad5d
|
[
"MIT"
] | null | null | null |
main/Util/Finite.agda
|
awswan/nielsenschreier-hott
|
84be713b8a8e41ea6f01f8ccf7251ebbbd73ad5d
|
[
"MIT"
] | null | null | null |
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Coproduct
open import lib.types.Sigma
open import lib.types.Pi
open import lib.types.Fin
open import lib.types.Nat
open import lib.types.Empty
open import lib.NType2
open import lib.Equivalence2
open import Util.Misc
open import Util.Coproducts
{- Some useful lemmas about working with finite sets. E.g. An injection from a finite set
to itself is an equivalence, an injection from a finite set to a large finite set has
at least one element not in its image.
-}
module Util.Finite where
ℕ=-to-Fin= : {n : ℕ} {x y : Fin n} → (fst x == fst y) → x == y
ℕ=-to-Fin= p = pair= p prop-has-all-paths-↓
finite-lpo : {i : ULevel} {n : ℕ} (P : Fin n → Type i) (dec : (x : Fin n) → Dec (P x)) →
(Σ (Fin n) P ⊔ ((x : Fin n) → ¬ (P x)))
finite-lpo {n = 0} P dec = inr (λ x _ → –> Fin-equiv-Empty x)
finite-lpo {i} {n = S n} P dec = ⊔-fmap (–> el) (–> er) lemma
where
P' : Fin n ⊔ ⊤ → Type i
P' z = P (<– Fin-equiv-Coprod z)
el : Σ (Fin n ⊔ ⊤) P' ≃ Σ (Fin (S n)) P
el = Σ-emap-l P (Fin-equiv-Coprod ⁻¹)
er : ((x : Fin n ⊔ ⊤) → ¬ (P' x)) ≃ ((x : Fin (S n)) → ¬ (P x))
er = Π-emap-l (¬ ∘ P) (Fin-equiv-Coprod ⁻¹)
lemma : Σ (Fin n ⊔ ⊤) P' ⊔ ((x : Fin n ⊔ ⊤) → ¬ (P' x))
lemma = ⊔-rec (λ np → inl ((inl (fst np)) , (snd np)))
(λ f → ⊔-rec (λ p → inl ((inr unit) , p)) (λ np → inr (λ { (inl k) → f k ; (inr _) → np})) (dec (n , ltS))) (finite-lpo {n = n} (P' ∘ inl) λ x → dec (<– Fin-equiv-Coprod (inl x)))
fin-img-dec : {i : ULevel} {A : Type i} (dec : has-dec-eq A) {n : ℕ} (inc : Fin n → A) → (a : A) → ((hfiber inc a) ⊔ ¬ (hfiber inc a))
fin-img-dec dec inc a = ⊔-rec (λ np → inl np) (λ f → inr (λ np → f (fst np) (snd np))) (finite-lpo (λ k → inc k == a) λ k → dec (inc k) a)
Fin-eq : {n : ℕ} {x y : Fin n} → (fst x == fst y) → x == y
Fin-eq p = pair= p prop-has-all-paths-↓
<-or-≥ : (n m : ℕ) → ((n < m) ⊔ (m ≤ n))
<-or-≥ n m = ⊔-rec (λ p → inr (inl (! p))) (⊔-rec inl (λ l → inr (inr l))) (ℕ-trichotomy n m)
≤-or-> : (n m : ℕ) → ((n ≤ m) ⊔ (m < n))
≤-or-> m n = ⊔-rec (inl ∘ inl) (⊔-fmap inr (idf _)) (ℕ-trichotomy m n)
<-≤-trans : {l m n : ℕ} → (l < m) → (m ≤ n) → (l < n)
<-≤-trans p (inl q) = transport _ q p
<-≤-trans p (inr q) = <-trans p q
≤-<-trans : {l m n : ℕ} → (l ≤ m) → (m < n) → (l < n)
≤-<-trans (inl p) q = transport _ (! p) q
≤-<-trans (inr p) q = <-trans p q
<S≠-to-< : {a b : ℕ} → (a < S b) → (a ≠ b) → (a < b)
<S≠-to-< ltS ne = ⊥-elim (ne idp)
<S≠-to-< (ltSR lt) ne = lt
module _ {n : ℕ} (k : Fin n) where
private
degeneracy-aux : (x : Fin (S n)) → ((fst x ≤ fst k) ⊔ (fst k < fst x)) → Fin n
degeneracy-aux x (inl z) = (fst x) , ≤-<-trans z (snd k)
degeneracy-aux (.(S (fst k)) , snd) (inr ltS) = k
degeneracy-aux (.(S _) , snd) (inr (ltSR z)) = _ , (<-cancel-S snd)
degeneracy-almost-inj-aux : {x y : Fin (S n)} → (fst x ≠ fst k) → (fst y ≠ fst k) →
(z : ((fst x) ≤ (fst k)) ⊔ ((fst k) < (fst x))) → (w : ((fst y) ≤ (fst k)) ⊔ ((fst k) < (fst y))) →
(degeneracy-aux x z == degeneracy-aux y w) → x == y
degeneracy-almost-inj-aux f g (inl z) (inl w) p = ℕ=-to-Fin= (ap fst p)
degeneracy-almost-inj-aux f g (inl z) (inr ltS) p = ⊥-rec (f (ap fst p))
degeneracy-almost-inj-aux f g (inl z) (inr (ltSR w)) p = ⊥-rec (<-to-≠ (≤-<-trans z w) (ap fst p))
degeneracy-almost-inj-aux f g (inr ltS) (inl w) p = ⊥-rec (g (ap fst (! p)))
degeneracy-almost-inj-aux f g (inr (ltSR z)) (inl w) p = ⊥-rec (<-to-≠ (≤-<-trans w z) (ap fst (! p)))
degeneracy-almost-inj-aux f g (inr ltS) (inr ltS) p = ℕ=-to-Fin= idp
degeneracy-almost-inj-aux f g (inr ltS) (inr (ltSR w)) p = ℕ=-to-Fin= (ap S (ap fst p))
degeneracy-almost-inj-aux f g (inr (ltSR z)) (inr ltS) p = ℕ=-to-Fin= (ap S (ap fst p))
degeneracy-almost-inj-aux f g (inr (ltSR z)) (inr (ltSR w)) p = ℕ=-to-Fin= (ap S (ap fst p))
abstract
degeneracy : (x : Fin (S n)) → Fin n
degeneracy x = degeneracy-aux x (≤-or-> _ _)
degeneracy-almost-inj : {x y : Fin (S n)} → (fst x ≠ fst k) → (fst y ≠ fst k) →
(degeneracy x == degeneracy y) → x == y
degeneracy-almost-inj f g = degeneracy-almost-inj-aux f g (≤-or-> _ _) (≤-or-> _ _)
Fin-hfiber-dec : {i : ULevel} {X : Type i} {n : ℕ} (dec : has-dec-eq X) → (f : Fin n → X) →
(x : X) → Dec (hfiber f x)
Fin-hfiber-dec dec f x = ⊔-fmap (idf _) (λ g p → g (fst p) (snd p))
(finite-lpo (λ z → f z == x) (λ z → dec (f z) x))
Fin-inj-to-surj : (n : ℕ) → (inc : Fin n → Fin n) → (inc-inj : is-inj inc) → (y : Fin n) → hfiber inc y
Fin-inj-to-surj O inc inc-inj y = ⊥-rec (–> Fin-equiv-Empty y)
Fin-inj-to-surj (S n) inc inc-inj y =
⊔-rec (λ p → n<Sn , (! p))
(λ f → ⊔-rec (λ p → case1 p f) (λ g → case2 g f) (Fin-has-dec-eq k n<Sn))
(Fin-has-dec-eq y k)
where
n<Sn = (n , ltS)
k = inc n<Sn
case1 : k == n<Sn → (y ≠ k) → hfiber inc y
case1 p f = Fin-S (fst x') , ℕ=-to-Fin= (ap fst (snd x'))
where
inc' : Fin n → Fin n
inc' x = (fst (inc (Fin-S x))) , <S≠-to-< (snd (inc (Fin-S x))) λ q → <-to-≠ (snd x) (ap fst (inc-inj _ _ (ℕ=-to-Fin= q ∙ ! p)))
inc-inj' : is-inj inc'
inc-inj' x x' p = Fin-S-is-inj _ _ (inc-inj _ _ (ℕ=-to-Fin= (ap fst p)))
y' : Fin n
y' = (fst y) , (<S≠-to-< (snd y) (λ q → f (ℕ=-to-Fin= q ∙ ! p)))
x' : hfiber inc' y'
x' = Fin-inj-to-surj n inc' inc-inj' y'
case2 : k ≠ n<Sn → (y ≠ k) → hfiber inc y
case2 f g = Fin-S (fst x') , degeneracy-almost-inj k' (λ q → <-to-≠ (snd (fst x')) (ap fst (inc-inj (Fin-S (fst x')) n<Sn (ℕ=-to-Fin= q))))
(λ q → g (ℕ=-to-Fin= q)) (snd x')
where
k' = (fst k) , (<S≠-to-< (snd k) (λ q → f (ℕ=-to-Fin= q)))
inc' : Fin n → Fin n
inc' x = degeneracy k' (inc (Fin-S x))
inc-inj' : is-inj inc'
inc-inj' x x' p =
Fin-S-is-inj _ _ (inc-inj _ _ (degeneracy-almost-inj k' (λ q → <-to-≠ (snd x) (ap fst (inc-inj _ _ (ℕ=-to-Fin= q))))
(λ q → <-to-≠ (snd x') (ap fst (inc-inj _ _ (ℕ=-to-Fin= q))))
p))
x' : hfiber inc' (degeneracy k' y)
x' = Fin-inj-to-surj n inc' inc-inj' ((degeneracy k' y))
Fin-inj-to-equiv : {n : ℕ} → (inc : Fin (S n) → Fin (S n)) → (inc-inj : is-inj inc) → (is-equiv inc)
Fin-inj-to-equiv inc inc-inj =
contr-map-is-equiv λ x → inhab-prop-is-contr (Fin-inj-to-surj _ inc inc-inj x) ⦃ inj-to-embed ⦃ Fin-is-set ⦄ inc inc-inj x ⦄
Fin-smaller-is-smaller : {m n : ℕ} (l : m < n) (f : Fin m → Fin n) → Σ (Fin n) (λ k → ¬ (hfiber f k))
Fin-smaller-is-smaller {m} {n} l f = ⊔-cancel-r (finite-lpo _ (λ k → ⊔-rec (λ x → inr (λ g → g x)) inl (Fin-hfiber-dec Fin-has-dec-eq f k))) lemma
where
lemma : ((k : Fin n) → ¬ (¬ (hfiber f k))) → ⊥
lemma g = <-to-≠ (snd (g'' (fst k))) (ap fst (snd k))
where
g' : (k : Fin n) → (hfiber f k)
g' k = ⊔-cancel-r (Fin-hfiber-dec Fin-has-dec-eq f k) (g k)
g'' : Fin n → Fin m
g'' = fst ∘ g'
g''-is-inj : is-inj g''
g''-is-inj y y' p = ! (snd (g' y)) ∙ ap f p ∙ snd (g' y')
h : Fin n → Fin n
h k = (fst (g'' k)) , (<-trans (snd (g'' k)) l)
h-is-inj : is-inj h
h-is-inj x y p = g''-is-inj _ _ (ℕ=-to-Fin= (ap fst p))
k : hfiber h (m , l)
k = Fin-inj-to-surj n h h-is-inj ((m , l))
| 42.6875
| 185
| 0.485026
|
039d72ce7f277b712e438b482e50bddf24ac0b3d
| 357
|
agda
|
Agda
|
test/interaction/ExtendedLambdaCase.agda
|
asr/agda-kanso
|
aa10ae6a29dc79964fe9dec2de07b9df28b61ed5
|
[
"MIT"
] | null | null | null |
test/interaction/ExtendedLambdaCase.agda
|
asr/agda-kanso
|
aa10ae6a29dc79964fe9dec2de07b9df28b61ed5
|
[
"MIT"
] | null | null | null |
test/interaction/ExtendedLambdaCase.agda
|
asr/agda-kanso
|
aa10ae6a29dc79964fe9dec2de07b9df28b61ed5
|
[
"MIT"
] | null | null | null |
module ExtendedLambdaCase where
data Bool : Set where
true false : Bool
data Void : Set where
foo : Bool -> Bool -> Bool -> Bool
foo = λ { x → λ { y z → {!!} } }
data Bar : (Bool -> Bool) -> Set where
baz : (t : Void) -> Bar λ { x → {!!} }
-- with hidden argument
data Bar' : (Bool -> Bool) -> Set where
baz' : {t : Void} -> Bar' λ { x' → {!!} }
| 21
| 43
| 0.535014
|
04b4746d05a3bd121add166430251177730bc9f5
| 4,517
|
agda
|
Agda
|
old/Homotopy/PushoutUP.agda
|
danbornside/HoTT-Agda
|
1695a7f3dc60177457855ae846bbd86fcd96983e
|
[
"MIT"
] | 294
|
2015-01-09T16:23:23.000Z
|
2022-03-20T13:54:45.000Z
|
old/Homotopy/PushoutUP.agda
|
danbornside/HoTT-Agda
|
1695a7f3dc60177457855ae846bbd86fcd96983e
|
[
"MIT"
] | 31
|
2015-03-05T20:09:00.000Z
|
2021-10-03T19:15:25.000Z
|
old/Homotopy/PushoutUP.agda
|
danbornside/HoTT-Agda
|
1695a7f3dc60177457855ae846bbd86fcd96983e
|
[
"MIT"
] | 50
|
2015-01-10T01:48:08.000Z
|
2022-02-14T03:03:25.000Z
|
{-# OPTIONS --without-K #-}
open import Base
open import Homotopy.PushoutDef
module Homotopy.PushoutUP {m} (D : pushout-diag m) (P : Set m → Set m)
⦃ PA : P (pushout-diag.A D) ⦄ ⦃ PB : P (pushout-diag.B D) ⦄
⦃ PC : P (pushout-diag.C D) ⦄ where
open pushout-diag D
-- Idea : [cocone E = (A → E) ×_(C → E) (B → E)]
record cocone (top : Set m) : Set m where
constructor _,_,_
field
A→top : A → top
B→top : B → top
h : (c : C) → (A→top (f c)) ≡ (B→top (g c))
open cocone public
cocone-eq-raw : (top : Set m) {a1 a2 : A → top} {b1 b2 : B → top}
{h1 : (c : C) → a1 (f c) ≡ b1 (g c)} {h2 : (c : C) → a2 (f c) ≡ b2 (g c)}
(p1 : a1 ≡ a2) (p2 : b1 ≡ b2) (p3 : transport _ p1 (transport _ p2 h1) ≡ h2)
→ (a1 , b1 , h1) ≡ (a2 , b2 , h2)
cocone-eq-raw top refl refl refl = refl
cocone-eq : (top : Set m) {a1 a2 : A → top} {b1 b2 : B → top}
{h1 : (c : C) → a1 (f c) ≡ b1 (g c)} {h2 : (c : C) → a2 (f c) ≡ b2 (g c)}
(p1 : a1 ≡ a2) (p2 : b1 ≡ b2)
(p3 : (c : C) → happly p1 (f c) ∘ h2 c ≡ h1 c ∘ happly p2 (g c))
→ (a1 , b1 , h1) ≡ (a2 , b2 , h2)
cocone-eq top refl refl p3 =
cocone-eq-raw top refl refl
(funext (λ c → ! (refl-right-unit _) ∘ ! (p3 c)))
open import Homotopy.PullbackDef
D→top : (top : Set m) → pullback-diag m
D→top top = diag (A → top) , (B → top) , (C → top)
, (λ u → u ◯ f) , (λ u → u ◯ g)
cocone-to-pullback : (top : Set m) → cocone top → pullback (D→top top)
cocone-to-pullback top (a , b , h) = (a , b , funext h)
pullback-to-cocone : (top : Set m)
→ pullback (D→top top)
→ cocone top
pullback-to-cocone top (a , b , h) = (a , b , happly h)
cocone-equiv-pullback : (top : Set m) → cocone top ≃ pullback (D→top top)
cocone-equiv-pullback top = (cocone-to-pullback top
, iso-is-eq _
(pullback-to-cocone top)
(λ p → ap (λ u → _ , _ , u) (funext-happly _))
(λ c → ap (λ u → _ , _ , u) (happly-funext _)))
pullback-equiv-cocone : (top : Set m) → pullback (D→top top) ≃ cocone top
pullback-equiv-cocone top = (pullback-to-cocone top
, iso-is-eq _
(cocone-to-pullback top)
(λ c → ap (λ u → _ , _ , u) (happly-funext _))
(λ p → ap (λ u → _ , _ , u) (funext-happly _)))
compose-cocone-map : (D E : Set m) (Dcocone : cocone D)
→ ((f : D → E) → cocone E)
compose-cocone-map D E (A→top , B→top , h) f =
((f ◯ A→top) , (f ◯ B→top) , (λ c → ap f (h c)))
is-pushout : (D : Set m) ⦃ PD : P D ⦄ (Dcocone : cocone D) → Set _
is-pushout D Dcocone = (E : Set m) ⦃ PE : P E ⦄
→ is-equiv (compose-cocone-map D E Dcocone)
compose-cocone-map-compose : (D E F : Set m) (Dcocone : cocone D) (f : D → E)
(g : E → F)
→ compose-cocone-map E F (compose-cocone-map D E Dcocone f) g
≡ compose-cocone-map D F Dcocone (g ◯ f)
compose-cocone-map-compose D E F Dcocone f g =
ap (λ u → ((g ◯ (f ◯ cocone.A→top Dcocone))
, (g ◯ (f ◯ cocone.B→top Dcocone)) , u))
(funext (λ c → compose-ap g f (cocone.h Dcocone c)))
module _ (D : Set m) ⦃ PD : P D ⦄ (Dcocone : cocone D)
(Dpushout : is-pushout D Dcocone) (E : Set m) ⦃ PE : P E ⦄
(Ecocone : cocone E) (Epushout : is-pushout E Ecocone) where
private
DE-eq : (D → E) ≃ cocone E
DE-eq = (compose-cocone-map D E Dcocone , Dpushout E)
ED-eq : (E → D) ≃ cocone D
ED-eq = (compose-cocone-map E D Ecocone , Epushout D)
DD-eq : (D → D) ≃ cocone D
DD-eq = (compose-cocone-map D D Dcocone , Dpushout D)
EE-eq : (E → E) ≃ cocone E
EE-eq = (compose-cocone-map E E Ecocone , Epushout E)
D→E : D → E
D→E = (DE-eq ⁻¹) ☆ Ecocone
E→D : E → D
E→D = (ED-eq ⁻¹) ☆ Dcocone
abstract
D→E→D : (λ x → E→D (D→E x)) ≡ (λ x → x)
D→E→D = equiv-is-inj (compose-cocone-map D D Dcocone , Dpushout D) _ _
(! (compose-cocone-map-compose D E D Dcocone D→E E→D)
∘ (ap (λ u → compose-cocone-map E D u E→D)
(inverse-right-inverse DE-eq Ecocone)
∘ (inverse-right-inverse ED-eq Dcocone
∘ ap (λ u → _ , _ , u) (funext (λ c → ! (ap-id _))))))
E→D→E : (λ x → D→E (E→D x)) ≡ (λ x → x)
E→D→E = equiv-is-inj (compose-cocone-map E E Ecocone , Epushout E) _ _
(! (compose-cocone-map-compose E D E Ecocone E→D D→E)
∘ (ap (λ u → compose-cocone-map D E u D→E)
(inverse-right-inverse ED-eq Dcocone)
∘ (inverse-right-inverse DE-eq Ecocone
∘ ap (λ u → _ , _ , u) (funext (λ c → ! (ap-id _))))))
pushout-equiv-pushout : D ≃ E
pushout-equiv-pushout = (D→E , iso-is-eq _ E→D (happly E→D→E) (happly D→E→D))
| 36.427419
| 79
| 0.537304
|
a0e67bbd192bb558320ca44429fd85a6d2353867
| 813
|
agda
|
Agda
|
test/Fail/Issue829.agda
|
mdimjasevic/agda
|
8fb548356b275c7a1e79b768b64511ae937c738b
|
[
"BSD-3-Clause"
] | 1,989
|
2015-01-09T23:51:16.000Z
|
2022-03-30T18:20:48.000Z
|
test/Fail/Issue829.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 4,066
|
2015-01-10T11:24:51.000Z
|
2022-03-31T21:14:49.000Z
|
test/Fail/Issue829.agda
|
Seanpm2001-languages/agda
|
9911f73061e21a87fad76c662463257afe02c861
|
[
"BSD-2-Clause"
] | 371
|
2015-01-03T14:04:08.000Z
|
2022-03-30T19:00:30.000Z
|
-- {-# OPTIONS -v tc.cover.splittree:10 -v tc.cc:30 #-}
module Issue829 where
record ⊤ : Set where
constructor tt
data ⊥ : Set where
postulate
P : ⊥ → Set
data D : (A : Set) → A → Set where
c : ⊥ → (x : ⊤) → D ⊤ x
f : {A : Set} {x : A} → D A x → ⊥
f (c () .tt)
g : (x : ⊥) → P x
g ()
h : (A : Set) (x : A) (d : D A x) → P (f d)
h .⊤ tt (c x .tt) = g x
-- Bug.agda:21,21-24
-- Incomplete pattern matching when applying Bug.f
-- when checking that the expression g x has type P (f (c x tt))
-- Agda 2.3.2 gives the following more reasonable error message:
--
-- Bug.agda:21,21-24
-- x != f (c x tt) of type ⊥
-- when checking that the expression g x has type P (f (c x tt))
-- This regression is caused by the patch "Fixed issue 827 : incomplete
-- case tree caused by record pattern translation".
| 22.583333
| 72
| 0.590406
|
3fe4b4160617a829882086902167c3fa13377ff9
| 6,101
|
agda
|
Agda
|
theorems/cw/DegreeByProjection.agda
|
timjb/HoTT-Agda
|
66f800adef943afdf08c17b8ecfba67340fead5e
|
[
"MIT"
] | null | null | null |
theorems/cw/DegreeByProjection.agda
|
timjb/HoTT-Agda
|
66f800adef943afdf08c17b8ecfba67340fead5e
|
[
"MIT"
] | null | null | null |
theorems/cw/DegreeByProjection.agda
|
timjb/HoTT-Agda
|
66f800adef943afdf08c17b8ecfba67340fead5e
|
[
"MIT"
] | null | null | null |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.Bouquet
open import homotopy.SphereEndomorphism
open import groups.SphereEndomorphism
open import groups.CoefficientExtensionality
open import cw.CW
open import cw.WedgeOfCells
module cw.DegreeByProjection {i} where
module DegreeAboveOne {n : ℕ} (skel : Skeleton {i} (S (S n)))
(dec : has-cells-with-dec-eq skel)
-- the cells at the upper and lower dimensions
(upper : cells-last skel)
(lower : cells-last (cw-init skel))
where
private
lower-skel = cw-init skel
lower-cells = cells-nth lteS skel
lower-dec = cells-nth-has-dec-eq lteS skel dec
degree-map : Sphere (S n) → Sphere (S n)
degree-map = bwproj lower-dec lower
∘ <– (Bouquet-equiv-Xₙ/Xₙ₋₁ lower-skel)
∘ cfcod
∘ attaching-last skel upper
degree : ℤ
degree = Trunc-⊙SphereS-endo-degree n (Trunc-⊙SphereS-endo-in n [ degree-map ])
module DegreeAtOne (skel : Skeleton {i} 1)
(dec : has-cells-with-dec-eq skel)
-- the cells at the upper and lower dimensions
(line : cells-last skel)
(point : cells-last (cw-init skel)) where
private
points-dec-eq = cells-nth-has-dec-eq (inr ltS) skel dec
endpoint = attaching-last skel
-- When [true] matches, [true] will be sent to [false],
-- which is bad.
degree-true : ℤ
degree-true with points-dec-eq point (endpoint line true)
degree-true | inl _ = -1
degree-true | inr _ = 0
-- When [false] matches, [false] will be sent to [false],
-- which is good.
degree-false : ℤ
degree-false with points-dec-eq point (endpoint line false)
degree-false | inl _ = 1
degree-false | inr _ = 0
degree : ℤ
degree = degree-true ℤ+ degree-false
degree-last : ∀ {n} (skel : Skeleton {i} (S n))
→ has-cells-with-dec-eq skel
→ cells-last skel → cells-last (cw-init skel) → ℤ
degree-last {n = O} = DegreeAtOne.degree
degree-last {n = S _} = DegreeAboveOne.degree
degree-nth : ∀ {m n} (Sm≤n : S m ≤ n) (skel : Skeleton {i} n)
→ has-cells-with-dec-eq skel
→ cells-nth Sm≤n skel → cells-last (cw-init (cw-take Sm≤n skel)) → ℤ
degree-nth Sm≤n skel dec = degree-last (cw-take Sm≤n skel) (take-has-cells-with-dec-eq Sm≤n skel dec)
has-degrees-with-finite-support : ∀ {n} (skel : Skeleton {i} n)
→ has-cells-with-dec-eq skel → Type i
has-degrees-with-finite-support {n = O} _ _ = Lift ⊤
has-degrees-with-finite-support {n = S n} skel dec =
has-degrees-with-finite-support (cw-init skel) (init-has-cells-with-dec-eq skel dec) ×
∀ upper → has-finite-support (cells-nth-has-dec-eq (inr ltS) skel dec) (degree-last skel dec upper)
init-has-degrees-with-finite-support : ∀ {n} (skel : Skeleton {i} (S n)) dec
→ has-degrees-with-finite-support skel dec
→ has-degrees-with-finite-support (cw-init skel) (init-has-cells-with-dec-eq skel dec)
init-has-degrees-with-finite-support skel dec fin-sup = fst fin-sup
take-has-degrees-with-finite-support : ∀ {m n} (m≤n : m ≤ n) (skel : Skeleton {i} n) dec
→ has-degrees-with-finite-support skel dec
→ has-degrees-with-finite-support (cw-take m≤n skel) (take-has-cells-with-dec-eq m≤n skel dec)
take-has-degrees-with-finite-support (inl idp) skel dec fin-sup = fin-sup
take-has-degrees-with-finite-support (inr ltS) skel dec fin-sup =
init-has-degrees-with-finite-support skel dec fin-sup
take-has-degrees-with-finite-support (inr (ltSR lt)) skel dec fin-sup =
take-has-degrees-with-finite-support (inr lt) (cw-init skel)
(init-has-cells-with-dec-eq skel dec)
(init-has-degrees-with-finite-support skel dec fin-sup)
degree-last-has-finite-support : ∀ {n} (skel : Skeleton {i} (S n)) dec
→ has-degrees-with-finite-support skel dec
→ ∀ upper → has-finite-support
(cells-last-has-dec-eq (cw-init skel) (init-has-cells-with-dec-eq skel dec))
(degree-last skel dec upper)
degree-last-has-finite-support skel dec fin-sup = snd fin-sup
degree-nth-has-finite-support : ∀ {m n} (Sm≤n : S m ≤ n) (skel : Skeleton {i} n) dec
→ has-degrees-with-finite-support skel dec
→ ∀ upper → has-finite-support
(cells-last-has-dec-eq
(cw-init (cw-take Sm≤n skel))
(init-has-cells-with-dec-eq (cw-take Sm≤n skel) (take-has-cells-with-dec-eq Sm≤n skel dec)))
(degree-nth Sm≤n skel dec upper)
degree-nth-has-finite-support Sm≤n skel dec fin-sup =
degree-last-has-finite-support (cw-take Sm≤n skel)
(take-has-cells-with-dec-eq Sm≤n skel dec)
(take-has-degrees-with-finite-support Sm≤n skel dec fin-sup)
-- the following are named [boundary'] because it is not extended to the free groups
boundary'-last : ∀ {n} (skel : Skeleton {i} (S n)) dec
→ has-degrees-with-finite-support skel dec
→ cells-last skel → FreeAbGroup.El (cells-last (cw-init skel))
boundary'-last skel dec fin-sup upper = fst ((snd fin-sup) upper)
boundary-last : ∀ {n} (skel : Skeleton {i} (S n)) dec
→ has-degrees-with-finite-support skel dec
→ FreeAbGroup.grp (cells-last skel) →ᴳ FreeAbGroup.grp (cells-last (cw-init skel))
boundary-last skel dec fin-sup =
FreeAbGroup-extend (FreeAbGroup (cells-last (cw-init skel))) (boundary'-last skel dec fin-sup)
boundary'-nth : ∀ {m n} (Sm≤n : S m ≤ n) (skel : Skeleton {i} n) dec
→ has-degrees-with-finite-support skel dec
→ cells-nth Sm≤n skel → FreeAbGroup.El (cells-last (cw-init (cw-take Sm≤n skel)))
boundary'-nth Sm≤n skel dec fin-sup =
boundary'-last (cw-take Sm≤n skel)
(take-has-cells-with-dec-eq Sm≤n skel dec)
(take-has-degrees-with-finite-support Sm≤n skel dec fin-sup)
boundary-nth : ∀ {m n} (Sm≤n : S m ≤ n) (skel : Skeleton {i} n) dec
→ has-degrees-with-finite-support skel dec
→ FreeAbGroup.grp (cells-nth Sm≤n skel)
→ᴳ FreeAbGroup.grp (cells-last (cw-init (cw-take Sm≤n skel)))
boundary-nth Sm≤n skel dec fin-sup =
FreeAbGroup-extend
(FreeAbGroup (cells-last (cw-init (cw-take Sm≤n skel))))
(boundary'-nth Sm≤n skel dec fin-sup)
| 42.664336
| 103
| 0.655302
|
3ff72daa13374862d2954b423c07c30cd80e7a18
| 112
|
agda
|
Agda
|
Float.agda
|
Lolirofle/stuff-in-agda
|
70f4fba849f2fd779c5aaa5af122ccb6a5b271ba
|
[
"MIT"
] | 6
|
2020-04-07T17:58:13.000Z
|
2022-02-05T06:53:22.000Z
|
Float.agda
|
Lolirofle/stuff-in-agda
|
70f4fba849f2fd779c5aaa5af122ccb6a5b271ba
|
[
"MIT"
] | null | null | null |
Float.agda
|
Lolirofle/stuff-in-agda
|
70f4fba849f2fd779c5aaa5af122ccb6a5b271ba
|
[
"MIT"
] | null | null | null |
module Float where
import Lvl
open import Type
postulate Float : Type{Lvl.𝟎}
{-# BUILTIN FLOAT Float #-}
| 14
| 29
| 0.696429
|
11fe5e9dc47346258cf0f72eb3c6b282ea84bc59
| 547
|
agda
|
Agda
|
src/Categories/Category/Construction/MonoidAsCategory.agda
|
jaykru/agda-categories
|
a4053cf700bcefdf73b857c3352f1eae29382a60
|
[
"MIT"
] | 279
|
2019-06-01T14:36:40.000Z
|
2022-03-22T00:40:14.000Z
|
src/Categories/Category/Construction/MonoidAsCategory.agda
|
jaykru/agda-categories
|
a4053cf700bcefdf73b857c3352f1eae29382a60
|
[
"MIT"
] | 236
|
2019-06-01T14:53:54.000Z
|
2022-03-28T14:31:43.000Z
|
src/Categories/Category/Construction/MonoidAsCategory.agda
|
jaykru/agda-categories
|
a4053cf700bcefdf73b857c3352f1eae29382a60
|
[
"MIT"
] | 64
|
2019-06-02T16:58:15.000Z
|
2022-03-14T02:00:59.000Z
|
open import Algebra.Bundles using (Monoid)
module Categories.Category.Construction.MonoidAsCategory o {c ℓ} (M : Monoid c ℓ) where
open import Data.Unit.Polymorphic
open import Level
open import Categories.Category.Core
open Monoid M
-- A monoid is a category with one object
MonoidAsCategory : Category o c ℓ
MonoidAsCategory = record
{ Obj = ⊤
; assoc = assoc _ _ _
; sym-assoc = sym (assoc _ _ _)
; identityˡ = identityˡ _
; identityʳ = identityʳ _
; identity² = identityˡ _
; equiv = isEquivalence
; ∘-resp-≈ = ∙-cong
}
| 22.791667
| 87
| 0.711152
|
cc2139e5ae38f66c4457a5b6469fc1c5e17c87f8
| 194
|
agda
|
Agda
|
test/Issue73.agda
|
jespercockx/agda2hs
|
703c66db29023f5538eaa841f38dc34e89473a3e
|
[
"MIT"
] | 55
|
2020-10-20T13:36:25.000Z
|
2022-03-26T21:57:56.000Z
|
test/Issue73.agda
|
SNU-2D/agda2hs
|
160478a51bc78b0fdab07b968464420439f9fed6
|
[
"MIT"
] | 63
|
2020-10-22T05:19:27.000Z
|
2022-02-25T15:47:30.000Z
|
test/Issue73.agda
|
SNU-2D/agda2hs
|
160478a51bc78b0fdab07b968464420439f9fed6
|
[
"MIT"
] | 18
|
2020-10-21T22:19:09.000Z
|
2022-03-12T11:42:52.000Z
|
module Issue73 where
record ImplicitField (a : Set) : Set where
field
aField : a
{anImplicitField} : a
open ImplicitField public
{-# COMPILE AGDA2HS ImplicitField class #-}
| 21.555556
| 43
| 0.680412
|
Subsets and Splits
HTML Code Excluding Scripts
The query retrieves a limited set of HTML content entries that are longer than 8 characters and do not contain script tags, offering only basic filtering with minimal analytical value.