Search is not available for this dataset
text
string | meta
dict |
|---|---|
------------------------------------------------------------------------
-- Representation-independent results for non-dependent lenses
------------------------------------------------------------------------
{-# OPTIONS --cubical --safe #-}
import Equality.Path as P
module Lens.Non-dependent
{e⁺} (eq : ∀ {a p} → P.Equality-with-paths a p e⁺) where
open P.Derived-definitions-and-properties eq
open import Logical-equivalence using (_⇔_)
open import Prelude
open import Bijection equality-with-J as Bij using (module _↔_)
open import Equivalence equality-with-J using (_≃_)
open import Erased.Cubical eq
open import Function-universe equality-with-J as F hiding (_∘_)
open import H-level equality-with-J as H-level
open import H-level.Closure equality-with-J
open import Surjection equality-with-J using (_↠_)
private
variable
a b c c₁ c₂ c₃ : Level
A B : Set a
Lens₁ Lens₂ Lens₃ : Set a → Set b → Set c
------------------------------------------------------------------------
-- An existence result
-- There is, in general, no lens for the first projection from a
-- Σ-type, assuming that lenses with contractible domains have
-- contractible codomains.
no-first-projection-lens :
(Lens : Set (a ⊔ b) → Set a → Set c) →
@0 (∀ {A B} → Lens A B → Contractible A → Contractible B) →
∃ λ (A : Set a) → ∃ λ (B : A → Set b) →
¬ Lens (Σ A B) A
no-first-projection-lens {b = b} _ contractible-to-contractible =
↑ _ Bool ,
(λ b → ↑ _ (lower b ≡ true)) ,
λ l → $⟨ singleton-contractible _ ⟩
Contractible (Singleton true) ↝⟨ H-level.respects-surjection surj 0 ⟩
Contractible (∃ λ b → ↑ _ (lower b ≡ true)) ↝⟨ (λ hyp → [ contractible-to-contractible l hyp ]) ⟩
Erased (Contractible (↑ _ Bool)) ↝⟨ Erased-cong (H-level.respects-surjection (_↔_.surjection Bij.↑↔) 0) ⟩
Erased (Contractible Bool) ↝⟨ Erased-cong (mono₁ 0) ⟩
Erased (Is-proposition Bool) ↝⟨ inverse-ext? ¬-Erased↔¬ _ ¬-Bool-propositional ⟩□
⊥ □
where
surj : Singleton true ↠ ∃ λ b → ↑ _ (lower b ≡ true)
surj = record
{ logical-equivalence = record
{ to = λ { (b , b≡true) → lift b , lift b≡true }
; from = λ { (lift b , lift b≡true) → b , b≡true }
}
; right-inverse-of = refl
}
------------------------------------------------------------------------
-- Statements of preservation results, and some related lemmas
-- Lens-like things with getters and setters.
record Has-getter-and-setter
(Lens : Set a → Set b → Set c) :
Set (lsuc (a ⊔ b ⊔ c)) where
field
-- Getter.
get : {A : Set a} {B : Set b} → Lens A B → A → B
-- Setter.
set : {A : Set a} {B : Set b} → Lens A B → A → B → A
-- A statement of what it means for two lenses to have the same getter
-- and setter.
Same-getter-and-setter :
{Lens₁ : Set a → Set b → Set c₁}
{Lens₂ : Set a → Set b → Set c₂}
⦃ L₁ : Has-getter-and-setter Lens₁ ⦄
⦃ L₂ : Has-getter-and-setter Lens₂ ⦄
{A : Set a} {B : Set b} →
Lens₁ A B → Lens₂ A B → Set (a ⊔ b)
Same-getter-and-setter ⦃ L₁ = L₁ ⦄ ⦃ L₂ = L₂ ⦄ l₁ l₂ =
get L₁ l₁ ≡ get L₂ l₂ ×
set L₁ l₁ ≡ set L₂ l₂
where
open Has-getter-and-setter
-- A statement of what it means for a function to preserve getters and
-- setters for all inputs.
Preserves-getters-and-setters-→ :
{Lens₁ : Set a → Set b → Set c₁}
{Lens₂ : Set a → Set b → Set c₂}
⦃ L₁ : Has-getter-and-setter Lens₁ ⦄
⦃ L₂ : Has-getter-and-setter Lens₂ ⦄
(A : Set a) (B : Set b) →
(Lens₁ A B → Lens₂ A B) →
Set (a ⊔ b ⊔ c₁)
Preserves-getters-and-setters-→ {Lens₁ = Lens₁} A B f =
(l : Lens₁ A B) → Same-getter-and-setter (f l) l
-- A statement of what it means for a logical equivalence to preserve
-- getters and setters.
Preserves-getters-and-setters-⇔ :
{Lens₁ : Set a → Set b → Set c₁}
{Lens₂ : Set a → Set b → Set c₂}
⦃ L₁ : Has-getter-and-setter Lens₁ ⦄
⦃ L₂ : Has-getter-and-setter Lens₂ ⦄
(A : Set a) (B : Set b) →
(Lens₁ A B ⇔ Lens₂ A B) →
Set (a ⊔ b ⊔ c₁ ⊔ c₂)
Preserves-getters-and-setters-⇔ A B eq =
Preserves-getters-and-setters-→ A B (_⇔_.to eq) ×
Preserves-getters-and-setters-→ A B (_⇔_.from eq)
-- Composition preserves Preserves-getters-and-setters-→.
Preserves-getters-and-setters-→-∘ :
⦃ L₁ : Has-getter-and-setter Lens₁ ⦄
⦃ L₂ : Has-getter-and-setter Lens₂ ⦄
⦃ L₃ : Has-getter-and-setter Lens₃ ⦄
{f : Lens₂ A B → Lens₃ A B}
{g : Lens₁ A B → Lens₂ A B} →
Preserves-getters-and-setters-→ A B f →
Preserves-getters-and-setters-→ A B g →
Preserves-getters-and-setters-→ A B (f ∘ g)
Preserves-getters-and-setters-→-∘ p-f p-g _ =
trans (proj₁ (p-f _)) (proj₁ (p-g _))
, trans (proj₂ (p-f _)) (proj₂ (p-g _))
-- Composition preserves Preserves-getters-and-setters-⇔.
Preserves-getters-and-setters-⇔-∘ :
⦃ L₁ : Has-getter-and-setter Lens₁ ⦄
⦃ L₂ : Has-getter-and-setter Lens₂ ⦄
⦃ L₃ : Has-getter-and-setter Lens₃ ⦄
{f : Lens₂ A B ⇔ Lens₃ A B}
{g : Lens₁ A B ⇔ Lens₂ A B} →
Preserves-getters-and-setters-⇔ A B f →
Preserves-getters-and-setters-⇔ A B g →
Preserves-getters-and-setters-⇔ A B (f F.∘ g)
Preserves-getters-and-setters-⇔-∘ p-f p-g =
Preserves-getters-and-setters-→-∘ (proj₁ p-f) (proj₁ p-g)
, Preserves-getters-and-setters-→-∘ (proj₂ p-g) (proj₂ p-f)
-- The function inverse preserves Preserves-getters-and-setters-⇔.
Preserves-getters-and-setters-⇔-inverse :
⦃ L₁ : Has-getter-and-setter Lens₁ ⦄
⦃ L₂ : Has-getter-and-setter Lens₂ ⦄
{f : Lens₁ A B ⇔ Lens₂ A B} →
Preserves-getters-and-setters-⇔ A B f →
Preserves-getters-and-setters-⇔ A B (inverse f)
Preserves-getters-and-setters-⇔-inverse = swap
-- If the forward direction of a split surjection preserves getters
-- and setters, then both directions do.
Preserves-getters-and-setters-→-↠-⇔ :
⦃ L₁ : Has-getter-and-setter Lens₁ ⦄
⦃ L₂ : Has-getter-and-setter Lens₂ ⦄
(f : Lens₁ A B ↠ Lens₂ A B) →
Preserves-getters-and-setters-→ A B (_↠_.to f) →
Preserves-getters-and-setters-⇔ A B (_↠_.logical-equivalence f)
Preserves-getters-and-setters-→-↠-⇔ ⦃ L₁ = L₁ ⦄ ⦃ L₂ = L₂ ⦄ f p =
p
, λ l →
(get L₁ (_↠_.from f l) ≡⟨ sym $ proj₁ $ p (_↠_.from f l) ⟩
get L₂ (_↠_.to f (_↠_.from f l)) ≡⟨ cong (get L₂) $ _↠_.right-inverse-of f _ ⟩∎
get L₂ l ∎)
, (set L₁ (_↠_.from f l) ≡⟨ sym $ proj₂ $ p (_↠_.from f l) ⟩
set L₂ (_↠_.to f (_↠_.from f l)) ≡⟨ cong (set L₂) $ _↠_.right-inverse-of f _ ⟩∎
set L₂ l ∎)
where
open Has-getter-and-setter
| {
"alphanum_fraction": 0.5769461078,
"avg_line_length": 36.5027322404,
"ext": "agda",
"hexsha": "2766a1d194b39475453c05edcdaeef3ad0315913",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b7921cc6b52858cd7d8a52c183c7a6544d1a4062",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Saizan/dependent-lenses",
"max_forks_repo_path": "src/Lens/Non-dependent.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b7921cc6b52858cd7d8a52c183c7a6544d1a4062",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Saizan/dependent-lenses",
"max_issues_repo_path": "src/Lens/Non-dependent.agda",
"max_line_length": 122,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "b7921cc6b52858cd7d8a52c183c7a6544d1a4062",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Saizan/dependent-lenses",
"max_stars_repo_path": "src/Lens/Non-dependent.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2372,
"size": 6680
} |
module _ where
open import Agda.Primitive
-- Named implicit parameters
data D₁ {a b} (A : Set a) (B : Set b) : Set (a ⊔ lsuc b)
data D₁ {b = c} X Y where
mkD₁ : Set c → D₁ X Y
-- Trailing implicit parameters
data D₂ {a} : Set a
data D₂ where
tt : D₂
| {
"alphanum_fraction": 0.6307692308,
"avg_line_length": 15.2941176471,
"ext": "agda",
"hexsha": "65d55851ce004e4aa10309acafc8ed68cf049acc",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Succeed/Issue1886.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Succeed/Issue1886.agda",
"max_line_length": 56,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Succeed/Issue1886.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 98,
"size": 260
} |
{-# OPTIONS --cubical --safe #-}
module Data.List where
open import Data.List.Base public
| {
"alphanum_fraction": 0.7065217391,
"avg_line_length": 15.3333333333,
"ext": "agda",
"hexsha": "fbc8ea7e669430b3d7b67852c7ad5023e9440d53",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-01-05T14:05:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-01-05T14:05:30.000Z",
"max_forks_repo_head_hexsha": "3c176d4690566d81611080e9378f5a178b39b851",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "oisdk/combinatorics-paper",
"max_forks_repo_path": "agda/Data/List.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "3c176d4690566d81611080e9378f5a178b39b851",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "oisdk/combinatorics-paper",
"max_issues_repo_path": "agda/Data/List.agda",
"max_line_length": 33,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "3c176d4690566d81611080e9378f5a178b39b851",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "oisdk/combinatorics-paper",
"max_stars_repo_path": "agda/Data/List.agda",
"max_stars_repo_stars_event_max_datetime": "2021-01-05T15:32:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-01-05T14:07:44.000Z",
"num_tokens": 21,
"size": 92
} |
module Data.Tuple.Function where
open import Data
open import Data.Tuple as Tuple using (_⨯_ ; _,_)
open import Functional
open import Type
module _ {ℓ₁ ℓ₂ ℓ₃} {T₁ : Type{ℓ₁}} {T₂ : Type{ℓ₂}} {T₃ : Type{ℓ₃}} where
_,⃝_ : (T₁ → T₂) → (T₁ → T₃) → (T₁ → (T₂ ⨯ T₃))
_,⃝_ f g x = (f(x) , g(x))
left : (T₁ → (T₂ ⨯ T₃)) → (T₁ → T₂)
left = Tuple.left ∘_
right : (T₁ → (T₂ ⨯ T₃)) → (T₁ → T₃)
right = Tuple.right ∘_
| {
"alphanum_fraction": 0.5589622642,
"avg_line_length": 24.9411764706,
"ext": "agda",
"hexsha": "f69aa2b754779555c0e837840366ea9be3038c4b",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Lolirofle/stuff-in-agda",
"max_forks_repo_path": "Data/Tuple/Function.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "Data/Tuple/Function.agda",
"max_line_length": 73,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Lolirofle/stuff-in-agda",
"max_stars_repo_path": "Data/Tuple/Function.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-05T06:53:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:58:13.000Z",
"num_tokens": 206,
"size": 424
} |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Data.Nat where
open import Cubical.Data.Nat.Base public
open import Cubical.Data.Nat.Properties public
| {
"alphanum_fraction": 0.7602339181,
"avg_line_length": 24.4285714286,
"ext": "agda",
"hexsha": "ebfce44d1dd01e9d02ef2fa848e8a31e5462b3b9",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-22T02:02:01.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-22T02:02:01.000Z",
"max_forks_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "dan-iel-lee/cubical",
"max_forks_repo_path": "Cubical/Data/Nat.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_issues_repo_issues_event_max_datetime": "2022-01-27T02:07:48.000Z",
"max_issues_repo_issues_event_min_datetime": "2022-01-27T02:07:48.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "dan-iel-lee/cubical",
"max_issues_repo_path": "Cubical/Data/Nat.agda",
"max_line_length": 50,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "dan-iel-lee/cubical",
"max_stars_repo_path": "Cubical/Data/Nat.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 42,
"size": 171
} |
-- The <local hints> in an ATP pragma <prove> can be data constructors.
module ATPLocalHints1 where
postulate
D : Set
zero : D
succ : D → D
data N : D → Set where
zN : N zero
sN : ∀ {n} → N n → N (succ n)
postulate
0-N : N zero
{-# ATP prove 0-N zN #-}
| {
"alphanum_fraction": 0.5629370629,
"avg_line_length": 16.8235294118,
"ext": "agda",
"hexsha": "d685e06145c6a96725c4ee0de142c48d1e6a0eb0",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2016-08-03T03:54:55.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-05-10T23:06:19.000Z",
"max_forks_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/apia",
"max_forks_repo_path": "examples/ATPLocalHints1.agda",
"max_issues_count": 121,
"max_issues_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_issues_repo_issues_event_max_datetime": "2018-04-22T06:01:44.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-25T13:22:12.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/apia",
"max_issues_repo_path": "examples/ATPLocalHints1.agda",
"max_line_length": 71,
"max_stars_count": 10,
"max_stars_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/apia",
"max_stars_repo_path": "examples/ATPLocalHints1.agda",
"max_stars_repo_stars_event_max_datetime": "2019-12-03T13:44:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:54:16.000Z",
"num_tokens": 100,
"size": 286
} |
module UselessAbstractAbstract where
A : Set₁
abstract
abstract
A = Set
| {
"alphanum_fraction": 0.746835443,
"avg_line_length": 11.2857142857,
"ext": "agda",
"hexsha": "4e8e17ed7947a09c62ffed9d59f496ff8a7e5391",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "masondesu/agda",
"max_forks_repo_path": "test/fail/UselessAbstractAbstract.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "masondesu/agda",
"max_issues_repo_path": "test/fail/UselessAbstractAbstract.agda",
"max_line_length": 36,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "redfish64/autonomic-agda",
"max_stars_repo_path": "test/Fail/UselessAbstractAbstract.agda",
"max_stars_repo_stars_event_max_datetime": "2015-12-07T20:14:00.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-03-28T14:51:03.000Z",
"num_tokens": 22,
"size": 79
} |
module Pair where
postulate
_,_ : Set → Set → Set
fst : {A B : Set} → (A , B) → A
snd : {A B : Set} → (A , B) → B
{-# COMPILE GHC _,_ = type (,) #-}
{-# COMPILE GHC fst = \ _ _ -> fst #-}
{-# COMPILE GHC snd = \ _ _ -> snd #-}
| {
"alphanum_fraction": 0.4638297872,
"avg_line_length": 21.3636363636,
"ext": "agda",
"hexsha": "21d8f94ce9d4fb09c6188bd7614f99c0991fad6e",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "c5ffd117f6d5a98f7c68a2a6b9be54a150c70945",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda-editor",
"max_forks_repo_path": "src/Pair.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c5ffd117f6d5a98f7c68a2a6b9be54a150c70945",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda-editor",
"max_issues_repo_path": "src/Pair.agda",
"max_line_length": 38,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "c5ffd117f6d5a98f7c68a2a6b9be54a150c70945",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda-editor",
"max_stars_repo_path": "src/Pair.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 88,
"size": 235
} |
-- Andreas, 2017-09-16, issue #2759
-- Allow empty declaration blocks in the parser.
open import Agda.Builtin.Nat
x0 = zero
mutual
x1 = suc x0
abstract
x2 = suc x1
private
x3 = suc x2
instance
x4 = suc x3
macro
x5 = suc x4
postulate
x6 = suc x5
-- Expected: 6 warnings about empty blocks
mutual
postulate
-- Empty postulate block.
abstract private instance macro
-- Empty macro block.
| {
"alphanum_fraction": 0.7284263959,
"avg_line_length": 13.1333333333,
"ext": "agda",
"hexsha": "f1ce56306fa33f8605e41dede245f9b0b8343128",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue2759.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "aac88412199dd4cbcb041aab499d8a6b7e3f4a2e",
"max_issues_repo_issues_event_max_datetime": "2019-04-01T19:39:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-11-14T15:31:44.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "hborum/agda",
"max_issues_repo_path": "test/Succeed/Issue2759.agda",
"max_line_length": 48,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "aac88412199dd4cbcb041aab499d8a6b7e3f4a2e",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "hborum/agda",
"max_stars_repo_path": "test/Succeed/Issue2759.agda",
"max_stars_repo_stars_event_max_datetime": "2020-09-20T00:28:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-10-29T09:40:30.000Z",
"num_tokens": 128,
"size": 394
} |
----------------------------------------------------------------------
-- Copyright: 2013, Jan Stolarek, Lodz University of Technology --
-- --
-- License: See LICENSE file in root of the repo --
-- Repo address: https://github.com/jstolarek/dep-typed-wbl-heaps --
-- --
-- Refl datatype and functions required for equational reasoning. --
----------------------------------------------------------------------
module Basics.Reasoning where
open import Basics.Nat hiding (_≥_)
open import Basics.Ordering
-- Basic definition we will need in our proofs is propositional
-- equality (known as refl). Unlike refl definition provided by Agda's
-- standard library the definition below is not universe
-- polymorphic. It works only on Set, but not on Set1 and higher Sets
-- - this will be perfectly sufficient for our purposes. This datatype
-- allows to express equality between types belonging to Set.
data _≡_ {S : Set} (s : S) : S → Set where
refl : s ≡ s
infixl 1 _≡_
-- Below we prove basic properties of relations: symmetry,
-- transitivity, congruence and substitution. If these proofs are not
-- familiar I encourage to take a look at tutorials on Agda Wiki. The
-- most useful source in my opinion are the online lecture notes for
-- the Computer Aided Formal Reasoning course by Thorsten Altenkirch:
--
-- http://www.cs.nott.ac.uk/~txa/g53cfr/
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 B : Set} (f : A → B) → ∀ {a b} → a ≡ b → f a ≡ f b
cong f refl = refl
subst : {A : Set}(P : A → Set) → {a b : A} → a ≡ b → P a → P b
subst prp refl p = p
-- We prove some basic properties of addition that we will need later
-- in more complex proofs. I assume that you had previous exposure to
-- these basic proofs, but nevertheless I provide extensive
-- explanations. Make sure you understand how these proofs work before
-- proceeding with rest of the paper.
-- Note [0 is right identity of addition]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- The fact that 0 is left identity of addition (ie. 0 + a ≡ a)
-- follows directly from our definition of _+_:
--
-- _+_ : Nat → Nat → Nat
-- zero + m = m
-- suc n + m = suc (n + m)
--
-- But we need a separate proof that 0 is also right identity of
-- addition, ie. a + 0 ≡ a. Proof proceeds by induction on a. If a is
-- zero then we have:
--
-- 0 + 0 = 0
--
-- And the proof follows from the definition of addition - hence we
-- use refl. In a recursive case we have:
--
-- (suc a) + zero ≡ (suc a)
--
-- Applying definition of addition to LHS we have:
--
-- suc (a + zero) ≡ suc a
--
-- Since we have suc on both sides of the equality, we use
-- congruence. This leaves us with a proof that equality holds for the
-- parameters of suc:
--
-- a + zero ≡ a
--
-- But that happens to be the equality we are proving at the
-- moment. We therefore make a recursive call to (+0 a), which is
-- equivalent of applying inductive hypothesis in an inductive proof.
--
-- ∎
+0 : (a : Nat) → a + zero ≡ a -- See Note [0 is right identity of addition]
+0 zero = refl
+0 (suc a) = cong suc (+0 a)
-- Note [1 + (a + b) equals a + (1 + b)]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- We will need this property surprisingly often. We proceed by
-- inductive proof on a. In the base case, when a = 0, we have:
--
-- suc (0 + b) ≡ 0 + (suc b)
--
-- Applying definition of + to both sides of equality we get:
--
-- suc b ≡ suc b
--
-- Which is true by definition, hence we use refl. In the recursive
-- case we have:
--
-- suc ((suc a) + b) ≡ (suc a) + (suc b)
--
-- We apply definition of + to both sides and get:
--
-- suc (suc (a + b)) ≡ suc (a + (suc b))
--
-- Again, since we have suc on both sides we use congruence and are
-- left with a proof:
--
-- suc (a + b) ≡ a + (suc b)
--
-- Which again is the equality we are proving. We appeal to inductive
-- hypothesis by making a recursive call.
--
-- ∎
+suc : (a b : Nat) → suc (a + b) ≡ a + (suc b)
+suc zero b = refl
+suc (suc a) b = cong suc (+suc a b)
-- Note [Commutativity of addition]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- Everyone knows that a + b ≡ b + a. But Agda won't take our word and
-- requires a formal proof. Let's proceed by induction on second
-- argument. In the base case we have:
--
-- a + 0 ≡ 0 + a
--
-- Right side reduces by the definition of + which leaves us with
--
-- a + 0 ≡ a
--
-- We proved that earlier so we appeal to already existing proof. In
-- the inductive case we have:
--
-- a + suc b ≡ (suc b) + a [1]
--
-- Right hand side reduces by definition of + giving us:
--
-- a + suc b ≡ suc (b + a) [2]
--
-- [2] is therefore the equality we have to prove. From +suc we know
-- that
--
-- suc (a + b) ≡ a + (suc b) [3]
--
-- And we can use that to transform left hand side of [1]. Note
-- however that in order to apply [3] to left hand side of [1] we need
-- to reverse sides of the equality [3]:
--
-- a + (suc b) ≡ suc (a + b) [4]
--
-- We achieve this by using symmetry.
--
-- Looking at right hand sides of [2] and [4] we see they differ by
-- the order of arguments to +. We can prove them equal by using
-- congruence on suc and appealing to our inductive hypothesis of
-- commutativity of addition. This means we have proven two things:
--
-- a + (suc b) ≡ suc (a + b) [4, repeated], from symmetry of +suc
-- suc (a + b) ≡ suc (b + a) [5], from congruence on suc and
-- inductive hypothesis
--
-- Combining [4] and [5] using transitivity yields the proof of [2].
--
-- ∎
--
-- Here is a diagram, showing how code relates to the proof:
--
-- a + b ≡ b + a
-- ____|____
-- / \
-- trans (sym (+suc a b)) (cong suc (+comm a b))
-- ̲\_____________/ \__________________/
-- | |
-- a + (suc b) ≡ suc (a + b) |
-- suc (a + b) ≡ suc (b + a)
+comm : (a b : Nat) → a + b ≡ b + a
+comm a zero = +0 a
+comm a (suc b) = trans (sym (+suc a b)) (cong suc (+comm a b))
-- Note [Associativity of addition]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- We proceed by induction on the first parameter. In the base case we
-- have a = 0:
--
-- 0 + (b + c) ≡ (0 + b) + c
--
-- Both sides can be normalized using the definition of + giving us
--
-- b + c ≡ b + c
--
-- Since this is true by definition we use refl. In the inductive case
-- we have to prove:
--
-- suc a + (b + c) ≡ (suc a + b) + c
--
-- Again, Agda normalizes each side using definition of + :
--
-- LHS: suc a + (b + c) ≡ suc (a + (b + c))
-- RHS: (suc a + b) + c ≡ suc (a + b) + c ≡ suc ((a + b) + c)
--
-- This means we have to prove:
--
-- suc (a + (b + c)) ≡ suc ((a + b) + c)
--
-- We can use congruence to remove the outer suc on both sides which
-- leaves us with a proof of:
--
-- a + (b + c) ̄≡ (a + b) + c
--
-- Which happens to be our inductive hypothesis - hence a recursive
-- call to +assoc.
--
-- ∎
+assoc : (a b c : Nat) → a + (b + c) ≡ (a + b) + c
+assoc zero b c = refl
+assoc (suc a) b c = cong suc (+assoc a b c)
-- Note [If numbers are equal they are in the greater-equal relation]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- Finally, we need a proof that if a = b then a ≥ b. This property is
-- specific to our task, so you most likely haven't seen it other
-- tutorials. There are three interesting things in this proof:
--
-- 1) a value of type m ≥ n proves that m is greater-equal than n. We
-- therefore need to construct the value of this type.
--
-- 2) since refl is the only constructor of type ≡ we always use refl
-- when pattern matching on a value of ≡. We also always pass refl
-- as a value of ≡ in calls.
--
-- 3) we need to match on implicit parameters to construct a
-- proof. Note that although type signature specifies Nats m and
-- n, in the proof we require that these are always equal. This
-- requirement comes from the fact that m ≡ n, i.e. that m and n
-- are equal.
--
-- In the base case we need to construct a proof that 0 ≥ 0, which we
-- do by using ge0. Inductive case simply applies geS to result of
-- recursive call to ≥sym.
≥sym : {m n : Nat} → m ≡ n → m ≥ n
≥sym {zero} {zero} refl = ge0
≥sym {.(suc n)} {(suc n)} refl = geS (≥sym {n} {n} refl)
| {
"alphanum_fraction": 0.5716604824,
"avg_line_length": 33.5564202335,
"ext": "agda",
"hexsha": "291da66f49ad32ab1c3bd193766cfc0a7fa7e243",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "57db566cb840dc70331c29eb7bf3a0c849f8b27e",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "jstolarek/dep-typed-wbl-heaps",
"max_forks_repo_path": "src/Basics/Reasoning.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "57db566cb840dc70331c29eb7bf3a0c849f8b27e",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "jstolarek/dep-typed-wbl-heaps",
"max_issues_repo_path": "src/Basics/Reasoning.agda",
"max_line_length": 75,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "57db566cb840dc70331c29eb7bf3a0c849f8b27e",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "jstolarek/dep-typed-wbl-heaps",
"max_stars_repo_path": "src/Basics/Reasoning.agda",
"max_stars_repo_stars_event_max_datetime": "2018-05-02T21:48:43.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-05-02T21:48:43.000Z",
"num_tokens": 2531,
"size": 8624
} |
----------------------------------------------------------------------
-- This file contains constructions of new categories from existing --
-- categories. --
----------------------------------------------------------------------
module Category.CategoryCons where
open import Level
open import Data.Product
open import Setoid.Total
open import Category.Category
open SetoidFun
-- The product of two categories.
_●_ : {l₁ l₂ : Level} → (ℂ₁ : Cat {l₁}) → (ℂ₂ : Cat {l₂}) → Cat {l₁ ⊔ l₂}
ℂ₁ ● ℂ₂ = record {
Obj = (Obj ℂ₁) × (Obj ℂ₂);
Hom = λ A B → (Hom ℂ₁ (proj₁ A) (proj₁ B)) ●ₛ ((Hom ℂ₂ (proj₂ A) (proj₂ B)));
comp = λ {A} {B} {C} → (comp ℂ₁) ●b (comp ℂ₂);
id = λ {A} → (id ℂ₁) , (id ℂ₂);
assocPf = λ {A} {B} {C} {D} {f} {g} {h} → (assocPf ℂ₁) , (assocPf ℂ₂);
idPf = λ {A} {B} {f} → (idPf ℂ₁) , (idPf ℂ₂) }
| {
"alphanum_fraction": 0.4268943436,
"avg_line_length": 39.0416666667,
"ext": "agda",
"hexsha": "a0deb4f31d0034fe9edc3d0fe643432f9dbd2c56",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b33c6a59d664aed46cac8ef77d34313e148fecc2",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "heades/AUGL",
"max_forks_repo_path": "setoid-cats/Category/CategoryCons.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b33c6a59d664aed46cac8ef77d34313e148fecc2",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "heades/AUGL",
"max_issues_repo_path": "setoid-cats/Category/CategoryCons.agda",
"max_line_length": 89,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "b33c6a59d664aed46cac8ef77d34313e148fecc2",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "heades/AUGL",
"max_stars_repo_path": "setoid-cats/Category/CategoryCons.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 294,
"size": 937
} |
open import Data.Product renaming (_×_ to _∧_)
×-comm : {A B : Set} → (A ∧ B) → (B ∧ A)
×-comm (fst , snd) = snd , fst
id : {A : Set} → A → A
id a = a
K : {A B : Set} → A → B → A
K a b = a
app : {A B : Set} → (A → B) → A → B
app f a = f a
flip : {A B C : Set} → (A → B → C) → B → A → C
flip f b a = f a b
comp : {A B C : Set} → (A → B) → (B → C) → (A → C)
comp ab bc = λ x → bc (ab x)
S : {A B C : Set} → (A → B → C) → (A → B) → A → C
S g f = λ x → g x (f x)
proj1 : {A B : Set} → (A ∧ B) → A
proj1 (fst , snd) = fst
proj2 : {A B : Set} → (A ∧ B) → B
proj2 (fst , snd) = snd
diagonal : {A B : Set} → A → (A ∧ A)
diagonal a = a , a
commut : {A B : Set} → (A ∧ B) → (B ∧ A)
commut (fst , snd) = snd , fst
curry1 : {A B C : Set} → (A ∧ B → C) → (A → B → C)
curry1 f = λ x x₁ → f (x , x₁)
curry2 : {A B C : Set} → (A → B → C) → (A ∧ B → C)
curry2 f (fst , snd) = f fst snd
_↔_ : (A B : Set) → Set
A ↔ B = (A → B) ∧ (B → A)
currying : {A B C : Set} → (A ∧ B → C) ↔ (A → B → C)
currying = curry1 , curry2
distrib : {A B C : Set} → (A → (B ∧ C)) ↔ ((A → B) ∧ (A → C))
distrib = (λ x → (λ x₁ → proj1 (x x₁)) , λ x₁ → proj2 (x x₁)) , λ x x₁ → ((proj1 x) x₁) , ((proj2 x) x₁)
data _∨_ (A B : Set) : Set where
left : A → A ∨ B
right : B → A ∨ B
or-elim : {A B C : Set} → (A ∨ B) → (A → C) → (B → C) → C
or-elim (left x) = λ x₁ x₂ → x₁ x
or-elim (right x) = λ x₁ x₂ → x₂ x
or-comm : {A B : Set} → (A ∨ B) → (B ∨ A)
or-comm (left x) = right x
or-comm (right x) = left x
or-dist : {A B C : Set} → (A ∧ (B ∨ C)) → ((A ∧ B) ∨ (A ∧ C))
or-dist (fst , left x) = left (fst , x)
or-dist (fst , right x) = right (fst , x)
data ⊥ : Set where
⊥-elim : {A : Set} → ⊥ → A
⊥-elim ()
¬ : Set → Set
¬ A = A → ⊥
contr : {A B : Set} → (A → B) → (¬ B → ¬ A)
contr f = λ x x₁ → x (f x₁)
non-contr : {A : Set} → ¬ (A ∧ ¬ A)
non-contr (fst , snd) = snd fst
nni : {A : Set} → A → ¬ (¬ A)
nni a = λ x → x a
⊥-nne : ¬ (¬ ⊥) → ⊥
⊥-nne x = x ⊥-elim
¬-elim : {A B : Set} → ¬ A → A → B
¬-elim n a = ⊥-elim (n a)
nnlem : {A : Set} → ¬ (¬ (A ∨ ¬ A))
nnlem = (λ x → x (right λ y → x (left y)))
rp2 : {A : Set} → (A → ¬ A) → (¬ A → A) → ⊥
rp2 a na = nnlem (λ x → or-elim x (λ x₁ → a x₁ x₁) λ x₁ → x₁ (na x₁))
data ⊤ : Set where
tt : ⊤
ti : {A : Set} → (⊤ → A) → A
ti f = f tt
dmnt : ¬ ⊤ → ⊥
dmnt f = f tt
dmtn : ⊥ → ¬ ⊤
dmtn = λ x x₁ → x
lem : Set₁
lem = (A : Set) → A ∨ ¬ A
nne : Set₁
nne = (A : Set) → ¬ (¬ A) → A
nne-lem : nne → lem
nne-lem x A = x (A ∨ ¬ A) nnlem
lem-nne : lem → nne
lem-nne x A y = or-elim (x A) (λ x₁ → x₁) λ x₁ → ¬-elim y x₁
_↔₁_ : (A B : Set₁) → Set₁
A ↔₁ B = (A → B) ∧ (B → A)
peirce : Set₁
peirce = (A B : Set) → ((A → B) → A) → A
lem-peirce : lem ↔₁ peirce
lem-peirce = (λ x A B x₁ → or-elim (x A) id λ x₂ → x₁ λ x₃ → ¬-elim x₂ x₃) , λ x A → x (A ∨ ¬ A) ⊥ λ x₁ → right λ x₂ → x₁ (left x₂)
nne-peirce : nne ↔₁ peirce
nne-peirce = (λ x A B x₁ → x A λ x₂ → x₂ (x₁ λ x₃ → ¬-elim x₂ x₃)) , (λ x A x₁ → x A ⊥ λ x₂ → ¬-elim x₁ x₂)
| {
"alphanum_fraction": 0.4366767984,
"avg_line_length": 21.6131386861,
"ext": "agda",
"hexsha": "132ae92ab39ee68960d1d94d29d89d68fe1b52d5",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "9a0d4a3f97103550a67e5e9ecbc8322bf0a8be23",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "erwinkn/program-eq-proof",
"max_forks_repo_path": "TD5/prop.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "9a0d4a3f97103550a67e5e9ecbc8322bf0a8be23",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "erwinkn/program-eq-proof",
"max_issues_repo_path": "TD5/prop.agda",
"max_line_length": 131,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "9a0d4a3f97103550a67e5e9ecbc8322bf0a8be23",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "erwinkn/program-eq-proof",
"max_stars_repo_path": "TD5/prop.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1491,
"size": 2961
} |
------------------------------------------------------------------------
-- Contexts, variables, context morphisms, etc.
------------------------------------------------------------------------
-- Based on Conor McBride's "Outrageous but Meaningful Coincidences:
-- Dependent type-safe syntax and evaluation".
-- The contexts and variables are parametrised by a universe.
open import Data.Universe.Indexed
module deBruijn.Context.Basics
{i u e} (Uni : IndexedUniverse i u e) where
open IndexedUniverse Uni
open import Data.Product as Prod
open import Data.Unit
open import Function hiding (_∋_)
open import Level using (_⊔_; Lift)
open import Relation.Binary.PropositionalEquality as P using (_≡_)
open import Relation.Nullary
import Relation.Nullary.Decidable as Dec
open P.≡-Reasoning
------------------------------------------------------------------------
-- Contexts and "types"
mutual
-- Contexts.
infixl 5 _▻_
data Ctxt : Set (i ⊔ u ⊔ e) where
ε : Ctxt
_▻_ : (Γ : Ctxt) (σ : Type Γ) → Ctxt
-- Semantic types: maps from environments to universe codes. The
-- semantic types come in two flavours: indexed and unindexed
-- (paired up with an index).
IType : Ctxt → I → Set (u ⊔ e)
IType Γ i = Env Γ → U i
Type : Ctxt → Set (i ⊔ u ⊔ e)
Type Γ = ∃ λ i → IType Γ i
-- Extracts the index from an unindexed type.
index : ∀ {Γ} → Type Γ → I
index = proj₁
-- Converts a type to an indexed type.
indexed-type : ∀ {Γ} (σ : Type Γ) → IType Γ (index σ)
indexed-type = proj₂
-- Interpretation of contexts: environments.
Env : Ctxt → Set e
Env ε = Lift _ ⊤
Env (Γ ▻ σ) = Σ (Env Γ) λ γ → El (indexed-type σ γ)
-- Semantic values: maps from environments to universe values.
Value : (Γ : Ctxt) → Type Γ → Set _
Value Γ σ = (γ : Env Γ) → El (indexed-type σ γ)
------------------------------------------------------------------------
-- Context morphisms
-- Context morphisms or "semantic substitutions": maps from
-- environments to environments. Note the arrow's direction.
infixr 4 _⇨̂_
_⇨̂_ : Ctxt → Ctxt → Set _
Γ ⇨̂ Δ = Env Δ → Env Γ
-- The identity morphism.
îd : ∀ {Γ} → Γ ⇨̂ Γ
îd = id
-- If the context cannot be inferred the following variant can be used
-- instead.
îd[_] : ∀ Γ → Γ ⇨̂ Γ
îd[ _ ] = îd
-- Reverse composition of context morphisms.
infixl 9 _∘̂_
_∘̂_ : ∀ {Γ Δ Ε} → Γ ⇨̂ Δ → Δ ⇨̂ Ε → Γ ⇨̂ Ε
ρ̂₁ ∘̂ ρ̂₂ = ρ̂₁ ∘ ρ̂₂
-- Application of context morphisms to indexed types.
infixl 8 _/̂I_
_/̂I_ : ∀ {Γ Δ i} → IType Γ i → Γ ⇨̂ Δ → IType Δ i
σ /̂I ρ̂ = σ ∘ ρ̂
-- Application of context morphisms to types.
infixl 8 _/̂_
_/̂_ : ∀ {Γ Δ} → Type Γ → Γ ⇨̂ Δ → Type Δ
(i , σ) /̂ ρ̂ = (i , σ /̂I ρ̂)
-- Application of context morphisms to values.
infixl 8 _/̂Val_
_/̂Val_ : ∀ {Γ Δ σ} → Value Γ σ → (ρ̂ : Γ ⇨̂ Δ) → Value Δ (σ /̂ ρ̂)
v /̂Val ρ̂ = v ∘ ρ̂
-- Weakening.
ŵk : ∀ {Γ σ} → Γ ⇨̂ Γ ▻ σ
ŵk = proj₁
ŵk[_] : ∀ {Γ} σ → Γ ⇨̂ Γ ▻ σ
ŵk[ _ ] = ŵk
-- Empty context morphism.
ε̂ : ∀ {Δ} → ε ⇨̂ Δ
ε̂ = λ _ → _
ε̂[_] : ∀ Δ → ε ⇨̂ Δ
ε̂[ _ ] = ε̂
-- Extends a context morphism with another value.
infixl 5 _▻̂_ _▻̂[_]_
_▻̂_ : ∀ {Γ Δ σ} (ρ̂ : Γ ⇨̂ Δ) → Value Δ (σ /̂ ρ̂) → Γ ▻ σ ⇨̂ Δ
_▻̂_ = <_,_>
_▻̂[_]_ : ∀ {Γ Δ} (ρ̂ : Γ ⇨̂ Δ) σ → Value Δ (σ /̂ ρ̂) → Γ ▻ σ ⇨̂ Δ
ρ̂ ▻̂[ _ ] v = ρ̂ ▻̂ v
-- A context morphism which only modifies the last "variable".
ŝub : ∀ {Γ σ} → Value Γ σ → Γ ▻ σ ⇨̂ Γ
ŝub v = îd ▻̂ v
-- The "tail" of a "nonempty" context morphism.
t̂ail : ∀ {Γ Δ σ} → Γ ▻ σ ⇨̂ Δ → Γ ⇨̂ Δ
t̂ail ρ̂ = ŵk ∘̂ ρ̂
-- The "head" of a "nonempty" context morphism.
ĥead : ∀ {Γ Δ σ} (ρ̂ : Γ ▻ σ ⇨̂ Δ) → Value Δ (σ /̂ t̂ail ρ̂)
ĥead ρ̂ = proj₂ ∘ ρ̂
-- Lifting.
infixl 10 _↑̂_
infix 10 _↑̂
_↑̂_ : ∀ {Γ Δ} (ρ̂ : Γ ⇨̂ Δ) σ → Γ ▻ σ ⇨̂ Δ ▻ σ /̂ ρ̂
ρ̂ ↑̂ _ = Prod.map ρ̂ id
_↑̂ : ∀ {Γ Δ σ} (ρ̂ : Γ ⇨̂ Δ) → Γ ▻ σ ⇨̂ Δ ▻ σ /̂ ρ̂
ρ̂ ↑̂ = ρ̂ ↑̂ _
------------------------------------------------------------------------
-- Variables
-- Variables (de Bruijn indices).
infix 3 _∋_
data _∋_ : (Γ : Ctxt) → Type Γ → Set (i ⊔ u ⊔ e) where
zero : ∀ {Γ σ} → Γ ▻ σ ∋ σ /̂ ŵk
suc : ∀ {Γ σ τ} (x : Γ ∋ τ) → Γ ▻ σ ∋ τ /̂ ŵk
zero[_] : ∀ {Γ} σ → Γ ▻ σ ∋ σ /̂ ŵk
zero[ _ ] = zero
suc[_] : ∀ {Γ} σ {τ} → Γ ∋ τ → Γ ▻ σ ∋ τ /̂ ŵk
suc[ _ ] = suc
-- Interpretation of variables: a lookup function.
lookup : ∀ {Γ σ} → Γ ∋ σ → Value Γ σ
lookup zero (γ , v) = v
lookup (suc x) (γ , v) = lookup x γ
-- Application of context morphisms to variables.
infixl 8 _/̂∋_
_/̂∋_ : ∀ {Γ Δ σ} → Γ ∋ σ → (ρ̂ : Γ ⇨̂ Δ) → Value Δ (σ /̂ ρ̂)
x /̂∋ ρ̂ = lookup x /̂Val ρ̂
------------------------------------------------------------------------
-- Equality
infix 4 _≅-Ctxt_ _≅-Type_ _≅-IType_ _≅-Value_ _≅-⇨̂_ _≅-∋_
-- Equality of contexts.
_≅-Ctxt_ : Ctxt → Ctxt → Set _
Γ₁ ≅-Ctxt Γ₂ = Γ₁ ≡ Γ₂
-- Equality of types.
--
-- This library uses propositional equality, including the K rule.
--
-- Two types are defined to be equal if their corresponding telescopes
-- are equal. The constructor [_] turns a type into a telescope.
--
-- At first two types (or context morphisms, or…) were defined to be
-- equal if they were equal according to the heterogeneous equality.
-- However, this led to a problem. Consider the old and new
-- definitions of /̂-cong:
--
-- Old:
--
-- /̂-cong : ∀ {Γ₁ Δ₁ σ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁}
-- {Γ₂ Δ₂ σ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} →
-- Γ₁ ≡ Γ₂ → Δ₁ ≡ Δ₂ → σ₁ ≅ σ₂ → ρ̂₁ ≅ ρ̂₂ → σ₁ /̂ ρ̂₁ ≅ σ₂ /̂ ρ̂₂
-- /̂-cong P.refl P.refl H.refl H.refl = H.refl
--
-- New:
--
-- /̂-cong : ∀ {Γ₁ Δ₁ σ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁}
-- {Γ₂ Δ₂ σ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} →
-- σ₁ ≅-Type σ₂ → ρ̂₁ ≅-⇨̂ ρ̂₂ → σ₁ /̂ ρ̂₁ ≅-Type σ₂ /̂ ρ̂₂
-- /̂-cong P.refl P.refl = P.refl
--
-- Notice that the old definition required more assumptions than the
-- new one. This meant that proofs using various congruences became
-- unnecessarily large and complicated.
record [Type] : Set (i ⊔ u ⊔ e) where
constructor [_]
field
{Γ} : Ctxt
σ : Type Γ
_≅-Type_ : ∀ {Γ₁} (σ₁ : Type Γ₁)
{Γ₂} (σ₂ : Type Γ₂) → Set _
σ₁ ≅-Type σ₂ = [ σ₁ ] ≡ [ σ₂ ]
-- If the indices are equal, then _≅-Type_ coincides with _≡_.
≅-Type-⇒-≡ : ∀ {Γ} {σ₁ σ₂ : Type Γ} →
σ₁ ≅-Type σ₂ → σ₁ ≡ σ₂
≅-Type-⇒-≡ P.refl = P.refl
-- Certain uses of substitutivity can be removed.
drop-subst-Type : ∀ {a} {A : Set a} {x₁ x₂}
(f : A → Ctxt) {σ} (x₁≡x₂ : x₁ ≡ x₂) →
P.subst (λ x → Type (f x)) x₁≡x₂ σ ≅-Type σ
drop-subst-Type f P.refl = P.refl
-- TODO: Should functions like ≅-Type-⇒-≡ and drop-subst-Type be
-- included for all types?
record [IType] : Set (i ⊔ u ⊔ e) where
constructor [_]
field
{Γ} : Ctxt
{idx} : I
σ : IType Γ idx
_≅-IType_ : ∀ {Γ₁ i₁} (σ₁ : IType Γ₁ i₁)
{Γ₂ i₂} (σ₂ : IType Γ₂ i₂) → Set _
σ₁ ≅-IType σ₂ = _≡_ {A = [IType]} [ σ₁ ] [ σ₂ ]
-- If the indices are equal, then _≅-IType_ coincides with _≡_.
≅-IType-⇒-≡ : ∀ {Γ i} {σ₁ σ₂ : IType Γ i} →
σ₁ ≅-IType σ₂ → σ₁ ≡ σ₂
≅-IType-⇒-≡ P.refl = P.refl
-- Equality of values.
record [Value] : Set (i ⊔ u ⊔ e) where
constructor [_]
field
{Γ} : Ctxt
{σ} : Type Γ
v : Value Γ σ
_≅-Value_ : ∀ {Γ₁ σ₁} (v₁ : Value Γ₁ σ₁)
{Γ₂ σ₂} (v₂ : Value Γ₂ σ₂) → Set _
v₁ ≅-Value v₂ = _≡_ {A = [Value]} [ v₁ ] [ v₂ ]
≅-Value-⇒-≡ : ∀ {Γ σ} {v₁ v₂ : Value Γ σ} →
v₁ ≅-Value v₂ → v₁ ≡ v₂
≅-Value-⇒-≡ P.refl = P.refl
-- Equality of context morphisms.
record [⇨̂] : Set (i ⊔ u ⊔ e) where
constructor [_]
field
{Γ Δ} : Ctxt
ρ̂ : Γ ⇨̂ Δ
_≅-⇨̂_ : ∀ {Γ₁ Δ₁} (ρ̂₁ : Γ₁ ⇨̂ Δ₁)
{Γ₂ Δ₂} (ρ̂₂ : Γ₂ ⇨̂ Δ₂) → Set _
ρ̂₁ ≅-⇨̂ ρ̂₂ = _≡_ {A = [⇨̂]} [ ρ̂₁ ] [ ρ̂₂ ]
≅-⇨̂-⇒-≡ : ∀ {Γ Δ} {ρ̂₁ ρ̂₂ : Γ ⇨̂ Δ} →
ρ̂₁ ≅-⇨̂ ρ̂₂ → ρ̂₁ ≡ ρ̂₂
≅-⇨̂-⇒-≡ P.refl = P.refl
-- Equality of variables.
record [∋] : Set (i ⊔ u ⊔ e) where
constructor [_]
field
{Γ} : Ctxt
{σ} : Type Γ
x : Γ ∋ σ
_≅-∋_ : ∀ {Γ₁ σ₁} (x₁ : Γ₁ ∋ σ₁)
{Γ₂ σ₂} (x₂ : Γ₂ ∋ σ₂) → Set _
x₁ ≅-∋ x₂ = _≡_ {A = [∋]} [ x₁ ] [ x₂ ]
≅-∋-⇒-≡ : ∀ {Γ σ} {x₁ x₂ : Γ ∋ σ} →
x₁ ≅-∋ x₂ → x₁ ≡ x₂
≅-∋-⇒-≡ P.refl = P.refl
------------------------------------------------------------------------
-- Some congruence lemmas
▻-cong : ∀ {Γ₁ Γ₂ σ₁ σ₂} → σ₁ ≅-Type σ₂ → Γ₁ ▻ σ₁ ≅-Ctxt Γ₂ ▻ σ₂
▻-cong P.refl = P.refl
indexed-type-cong :
∀ {Γ₁} {σ₁ : Type Γ₁}
{Γ₂} {σ₂ : Type Γ₂} →
σ₁ ≅-Type σ₂ → indexed-type σ₁ ≅-IType indexed-type σ₂
indexed-type-cong P.refl = P.refl
îd-cong : ∀ {Γ₁ Γ₂} → Γ₁ ≅-Ctxt Γ₂ → îd[ Γ₁ ] ≅-⇨̂ îd[ Γ₂ ]
îd-cong P.refl = P.refl
∘̂-cong : ∀ {Γ₁ Δ₁ Ε₁} {ρ̂₁₁ : Γ₁ ⇨̂ Δ₁} {ρ̂₂₁ : Δ₁ ⇨̂ Ε₁}
{Γ₂ Δ₂ Ε₂} {ρ̂₁₂ : Γ₂ ⇨̂ Δ₂} {ρ̂₂₂ : Δ₂ ⇨̂ Ε₂} →
ρ̂₁₁ ≅-⇨̂ ρ̂₁₂ → ρ̂₂₁ ≅-⇨̂ ρ̂₂₂ → ρ̂₁₁ ∘̂ ρ̂₂₁ ≅-⇨̂ ρ̂₁₂ ∘̂ ρ̂₂₂
∘̂-cong P.refl P.refl = P.refl
/̂I-cong : ∀ {Γ₁ Δ₁ i₁} {σ₁ : IType Γ₁ i₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁}
{Γ₂ Δ₂ i₂} {σ₂ : IType Γ₂ i₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} →
σ₁ ≅-IType σ₂ → ρ̂₁ ≅-⇨̂ ρ̂₂ → σ₁ /̂I ρ̂₁ ≅-IType σ₂ /̂I ρ̂₂
/̂I-cong P.refl P.refl = P.refl
/̂-cong : ∀ {Γ₁ Δ₁ σ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁}
{Γ₂ Δ₂ σ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} →
σ₁ ≅-Type σ₂ → ρ̂₁ ≅-⇨̂ ρ̂₂ → σ₁ /̂ ρ̂₁ ≅-Type σ₂ /̂ ρ̂₂
/̂-cong P.refl P.refl = P.refl
/̂Val-cong : ∀ {Γ₁ Δ₁ σ₁} {v₁ : Value Γ₁ σ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁}
{Γ₂ Δ₂ σ₂} {v₂ : Value Γ₂ σ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} →
v₁ ≅-Value v₂ → ρ̂₁ ≅-⇨̂ ρ̂₂ → v₁ /̂Val ρ̂₁ ≅-Value v₂ /̂Val ρ̂₂
/̂Val-cong P.refl P.refl = P.refl
ŵk-cong : ∀ {Γ₁} {σ₁ : Type Γ₁} {Γ₂} {σ₂ : Type Γ₂} →
σ₁ ≅-Type σ₂ → ŵk[ σ₁ ] ≅-⇨̂ ŵk[ σ₂ ]
ŵk-cong P.refl = P.refl
ε̂-cong : ∀ {Δ₁ Δ₂} → Δ₁ ≅-Ctxt Δ₂ → ε̂[ Δ₁ ] ≅-⇨̂ ε̂[ Δ₂ ]
ε̂-cong P.refl = P.refl
▻̂-cong : ∀ {Γ₁ Δ₁ σ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} {v₁ : Value Δ₁ (σ₁ /̂ ρ̂₁)}
{Γ₂ Δ₂ σ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} {v₂ : Value Δ₂ (σ₂ /̂ ρ̂₂)} →
σ₁ ≅-Type σ₂ → ρ̂₁ ≅-⇨̂ ρ̂₂ → v₁ ≅-Value v₂ →
ρ̂₁ ▻̂[ σ₁ ] v₁ ≅-⇨̂ ρ̂₂ ▻̂[ σ₂ ] v₂
▻̂-cong P.refl P.refl P.refl = P.refl
ŝub-cong : ∀ {Γ₁ σ₁} {v₁ : Value Γ₁ σ₁} {Γ₂ σ₂} {v₂ : Value Γ₂ σ₂} →
v₁ ≅-Value v₂ → ŝub v₁ ≅-⇨̂ ŝub v₂
ŝub-cong P.refl = P.refl
t̂ail-cong : ∀ {Γ₁ Δ₁ σ₁} {ρ̂₁ : Γ₁ ▻ σ₁ ⇨̂ Δ₁}
{Γ₂ Δ₂ σ₂} {ρ̂₂ : Γ₂ ▻ σ₂ ⇨̂ Δ₂} →
ρ̂₁ ≅-⇨̂ ρ̂₂ → t̂ail ρ̂₁ ≅-⇨̂ t̂ail ρ̂₂
t̂ail-cong P.refl = P.refl
ĥead-cong : ∀ {Γ₁ Δ₁ σ₁} {ρ̂₁ : Γ₁ ▻ σ₁ ⇨̂ Δ₁}
{Γ₂ Δ₂ σ₂} {ρ̂₂ : Γ₂ ▻ σ₂ ⇨̂ Δ₂} →
ρ̂₁ ≅-⇨̂ ρ̂₂ → ĥead ρ̂₁ ≅-Value ĥead ρ̂₂
ĥead-cong P.refl = P.refl
↑̂-cong : ∀ {Γ₁ Δ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} {σ₁}
{Γ₂ Δ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} {σ₂} →
ρ̂₁ ≅-⇨̂ ρ̂₂ → σ₁ ≅-Type σ₂ → ρ̂₁ ↑̂ σ₁ ≅-⇨̂ ρ̂₂ ↑̂ σ₂
↑̂-cong P.refl P.refl = P.refl
zero-cong : ∀ {Γ₁} {σ₁ : Type Γ₁}
{Γ₂} {σ₂ : Type Γ₂} →
σ₁ ≅-Type σ₂ → zero[ σ₁ ] ≅-∋ zero[ σ₂ ]
zero-cong P.refl = P.refl
suc-cong :
∀ {Γ₁ σ₁ τ₁} {x₁ : Γ₁ ∋ τ₁}
{Γ₂ σ₂ τ₂} {x₂ : Γ₂ ∋ τ₂} →
σ₁ ≅-Type σ₂ → x₁ ≅-∋ x₂ → suc[ σ₁ ] x₁ ≅-∋ suc[ σ₂ ] x₂
suc-cong P.refl P.refl = P.refl
/̂∋-cong : ∀ {Γ₁ Δ₁ σ₁} {x₁ : Γ₁ ∋ σ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁}
{Γ₂ Δ₂ σ₂} {x₂ : Γ₂ ∋ σ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} →
x₁ ≅-∋ x₂ → ρ̂₁ ≅-⇨̂ ρ̂₂ → x₁ /̂∋ ρ̂₁ ≅-Value x₂ /̂∋ ρ̂₂
/̂∋-cong P.refl P.refl = P.refl
------------------------------------------------------------------------
-- Some properties, all of which hold definitionally
-- _/̂_ preserves the index.
index-/̂ : ∀ {Γ Δ} (σ : Type Γ) (ρ̂ : Γ ⇨̂ Δ) →
index (σ /̂ ρ̂) ≡ index σ
index-/̂ σ ρ̂ = P.refl
-- îd and _∘̂_ form a monoid.
îd-∘̂ : ∀ {Γ Δ} (ρ̂ : Γ ⇨̂ Δ) → ρ̂ ∘̂ îd ≅-⇨̂ ρ̂
îd-∘̂ ρ̂ = P.refl
∘̂-îd : ∀ {Γ Δ} (ρ̂ : Γ ⇨̂ Δ) → îd ∘̂ ρ̂ ≅-⇨̂ ρ̂
∘̂-îd ρ̂ = P.refl
∘̂-assoc : ∀ {Γ Δ Ε Ζ} (ρ̂₁ : Γ ⇨̂ Δ) (ρ̂₂ : Δ ⇨̂ Ε) (ρ̂₃ : Ε ⇨̂ Ζ) →
ρ̂₁ ∘̂ (ρ̂₂ ∘̂ ρ̂₃) ≅-⇨̂ (ρ̂₁ ∘̂ ρ̂₂) ∘̂ ρ̂₃
∘̂-assoc ρ̂₁ ρ̂₂ ρ̂₃ = P.refl
-- The lifting of the identity substitution is the identity
-- substitution.
îd-↑̂ : ∀ {Γ} (σ : Type Γ) → îd ↑̂ σ ≅-⇨̂ îd[ Γ ▻ σ ]
îd-↑̂ σ = P.refl
-- _↑̂ distributes over _∘̂_.
↑̂-distrib : ∀ {Γ Δ Ε} (ρ̂₁ : Γ ⇨̂ Δ) (ρ̂₂ : Δ ⇨̂ Ε) σ →
(ρ̂₁ ∘̂ ρ̂₂) ↑̂ σ ≅-⇨̂ ρ̂₁ ↑̂ σ ∘̂ ρ̂₂ ↑̂
↑̂-distrib ρ̂₁ ρ̂₂ σ = P.refl
-- ŵk is a left inverse of ŝub.
ŵk-∘̂-ŝub : ∀ {Γ σ} (v : Value Γ σ) → ŵk ∘̂ ŝub v ≅-⇨̂ îd
ŵk-∘̂-ŝub v = P.refl
-- First weakening under the head, and then replacing the head with
-- the new head, is the same as doing nothing.
ŵk-↑̂-∘̂-ŝub : ∀ {Γ} σ → ŵk ↑̂ ∘̂ ŝub proj₂ ≅-⇨̂ îd[ Γ ▻ σ ]
ŵk-↑̂-∘̂-ŝub σ = P.refl
-- ŵk commutes with arbitrary context morphisms (modulo lifting).
∘̂-ŵk : ∀ {Γ Δ} (ρ̂ : Γ ⇨̂ Δ) σ → ρ̂ ∘̂ ŵk[ σ /̂ ρ̂ ] ≅-⇨̂ ŵk[ σ ] ∘̂ ρ̂ ↑̂
∘̂-ŵk ρ̂ σ = P.refl
-- ŝub commutes with arbitrary context morphisms (modulo lifting).
ŝub-∘̂ : ∀ {Γ Δ σ} (ρ̂ : Γ ⇨̂ Δ) (v : Value Γ σ) →
ŝub v ∘̂ ρ̂ ≅-⇨̂ ρ̂ ↑̂ ∘̂ ŝub (v /̂Val ρ̂)
ŝub-∘̂ ρ̂ v = P.refl
-- Laws relating _▻̂_, ĥead and t̂ail.
ĥead-▻̂ : ∀ {Γ Δ σ} (ρ̂ : Γ ⇨̂ Δ) (v : Value Δ (σ /̂ ρ̂)) →
ĥead (ρ̂ ▻̂[ σ ] v) ≅-Value v
ĥead-▻̂ ρ̂ v = P.refl
t̂ail-▻̂ : ∀ {Γ Δ σ} (ρ̂ : Γ ⇨̂ Δ) (v : Value Δ (σ /̂ ρ̂)) →
t̂ail (ρ̂ ▻̂[ σ ] v) ≅-⇨̂ ρ̂
t̂ail-▻̂ ρ̂ v = P.refl
t̂ail-▻̂-ĥead : ∀ {Γ Δ σ} (ρ̂ : Γ ▻ σ ⇨̂ Δ) → t̂ail ρ̂ ▻̂ ĥead ρ̂ ≅-⇨̂ ρ̂
t̂ail-▻̂-ĥead ρ̂ = P.refl
-- Law relating _▻̂_ and _∘̂_.
▻̂-∘̂ : ∀ {Γ Δ Ε σ} (ρ̂₁ : Γ ⇨̂ Δ) (ρ̂₂ : Δ ⇨̂ Ε) (v : Value Δ (σ /̂ ρ̂₁)) →
(ρ̂₁ ▻̂[ σ ] v) ∘̂ ρ̂₂ ≅-⇨̂ (ρ̂₁ ∘̂ ρ̂₂) ▻̂ v /̂Val ρ̂₂
▻̂-∘̂ ρ̂₁ ρ̂₂ v = P.refl
-- The identity substitution has no effect.
/̂-îd : ∀ {Γ} (σ : Type Γ) → σ /̂ îd ≅-Type σ
/̂-îd σ = P.refl
/̂Val-îd : ∀ {Γ σ} (v : Value Γ σ) → v /̂Val îd ≅-Value v
/̂Val-îd v = P.refl
-- Applying two substitutions is equivalent to applying their
-- composition.
/̂-∘̂ : ∀ {Γ Δ Ε} (ρ̂₁ : Γ ⇨̂ Δ) (ρ̂₂ : Δ ⇨̂ Ε) σ →
σ /̂ ρ̂₁ ∘̂ ρ̂₂ ≅-Type σ /̂ ρ̂₁ /̂ ρ̂₂
/̂-∘̂ ρ̂₁ ρ̂₂ σ = P.refl
/̂Val-∘̂ : ∀ {Γ Δ Ε σ} (ρ̂₁ : Γ ⇨̂ Δ) (ρ̂₂ : Δ ⇨̂ Ε) (v : Value Γ σ) →
v /̂Val ρ̂₁ ∘̂ ρ̂₂ ≅-Value v /̂Val ρ̂₁ /̂Val ρ̂₂
/̂Val-∘̂ ρ̂₁ ρ̂₂ v = P.refl
------------------------------------------------------------------------
-- More properties
-- _▻_ is injective.
▻-injective : ∀ {Γ₁ σ₁ Γ₂ σ₂} →
Γ₁ ▻ σ₁ ≅-Ctxt Γ₂ ▻ σ₂ → Γ₁ ≅-Ctxt Γ₂ × σ₁ ≅-Type σ₂
▻-injective P.refl = P.refl , P.refl
-- Equality of variables is decidable (if they refer to the same
-- context).
infix 4 _≟-∋_
_≟-∋_ : ∀ {Γ σ₁} (x₁ : Γ ∋ σ₁) {σ₂} (x₂ : Γ ∋ σ₂) →
Dec (x₁ ≅-∋ x₂)
zero ≟-∋ zero = yes P.refl
zero ≟-∋ suc _ = no λ ()
suc _ ≟-∋ zero = no λ ()
suc x₁ ≟-∋ suc x₂ = Dec.map′ (suc-cong P.refl) helper (x₁ ≟-∋ x₂)
where
helper : ∀ {Γ₁ σ₁ τ₁} {x₁ : Γ₁ ∋ τ₁}
{Γ₂ σ₂ τ₂} {x₂ : Γ₂ ∋ τ₂} →
suc[ σ₁ ] x₁ ≅-∋ suc[ σ₂ ] x₂ → x₁ ≅-∋ x₂
helper P.refl = P.refl
| {
"alphanum_fraction": 0.4697890353,
"avg_line_length": 27.2756052142,
"ext": "agda",
"hexsha": "8fd8ae0dd75be532880ad93af794106ffdf92d27",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/dependently-typed-syntax",
"max_forks_repo_path": "deBruijn/Context/Basics.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/dependently-typed-syntax",
"max_issues_repo_path": "deBruijn/Context/Basics.agda",
"max_line_length": 78,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/dependently-typed-syntax",
"max_stars_repo_path": "deBruijn/Context/Basics.agda",
"max_stars_repo_stars_event_max_datetime": "2020-07-08T22:51:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-16T12:14:44.000Z",
"num_tokens": 7856,
"size": 14647
} |
{-# OPTIONS --without-K #-}
module Agda.Builtin.IO where
postulate IO : ∀ {a} → Set a → Set a
{-# BUILTIN IO IO #-}
{-# HASKELL type AgdaIO a b = IO b #-}
{-# COMPILED_TYPE IO MAlonzo.Code.Agda.Builtin.IO.AgdaIO #-}
| {
"alphanum_fraction": 0.6255707763,
"avg_line_length": 21.9,
"ext": "agda",
"hexsha": "cbc438889e740731d837f77c353d71de24c90c4d",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "pthariensflame/agda",
"max_forks_repo_path": "src/data/lib/prim/Agda/Builtin/IO.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "pthariensflame/agda",
"max_issues_repo_path": "src/data/lib/prim/Agda/Builtin/IO.agda",
"max_line_length": 60,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "pthariensflame/agda",
"max_stars_repo_path": "src/data/lib/prim/Agda/Builtin/IO.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 69,
"size": 219
} |
------------------------------------------------------------------------
-- Some character parsers
------------------------------------------------------------------------
-- This code also illustrates how a library can make use of another
-- library.
module RecursiveDescent.Inductive.Char where
open import Data.Unit
open import Data.Nat
open import Data.Bool
import Data.Char as C
open C using (Char; _==_)
open import Data.List
open import Data.Function hiding (_$_)
open import RecursiveDescent.Index
open import RecursiveDescent.Inductive
import RecursiveDescent.Inductive.Token
open import RecursiveDescent.Inductive.SimpleLib
import RecursiveDescent.Inductive.Lib as Lib
private
module L = Lib Char
-- Some parameterised parsers.
private
data NT (nt : ParserType₁) : ParserType₁ where
lib' : forall {i r} -> L.Nonterminal nt i r -> NT nt i r
digit' : NT nt _ ℕ
number' : NT nt _ ℕ
whitespace' : NT nt _ ⊤
Nonterminal : ParserType₁ -> ParserType₁
Nonterminal = NT
module Combinators
{nt} (lib : forall {i r} -> Nonterminal nt i r -> nt i r)
where
open L.Combinators (lib ∘₁ lib')
digit : Parser Char nt _ ℕ
digit = ! lib digit'
number : Parser Char nt _ ℕ
number = ! lib number'
whitespace : Parser Char nt _ ⊤
whitespace = ! lib whitespace'
open RecursiveDescent.Inductive.Token C.decSetoid
charLib : forall {i r} -> Nonterminal nt i r -> Parser Char nt i r
charLib (lib' p) = library p
charLib digit' = 0 <$ sym '0'
∣ 1 <$ sym '1'
∣ 2 <$ sym '2'
∣ 3 <$ sym '3'
∣ 4 <$ sym '4'
∣ 5 <$ sym '5'
∣ 6 <$ sym '6'
∣ 7 <$ sym '7'
∣ 8 <$ sym '8'
∣ 9 <$ sym '9'
charLib number' = toNum <$> digit +
where toNum = foldr (\n x -> 10 * x + n) 0 ∘ reverse
-- whitespace recognises an incomplete but useful list of whitespace
-- characters.
charLib whitespace' = sat' isSpace
where
isSpace = \c ->
(c == ' ') ∨ (c == '\t') ∨ (c == '\n') ∨ (c == '\r')
| {
"alphanum_fraction": 0.5478424015,
"avg_line_length": 28.4266666667,
"ext": "agda",
"hexsha": "704e00dfd7932df053d687f2e70d398935cdc570",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "76774f54f466cfe943debf2da731074fe0c33644",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/parser-combinators",
"max_forks_repo_path": "misc/RecursiveDescent/Inductive/Char.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "76774f54f466cfe943debf2da731074fe0c33644",
"max_issues_repo_issues_event_max_datetime": "2018-01-24T16:39:37.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-01-22T22:21:41.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/parser-combinators",
"max_issues_repo_path": "misc/RecursiveDescent/Inductive/Char.agda",
"max_line_length": 72,
"max_stars_count": 7,
"max_stars_repo_head_hexsha": "b396d35cc2cb7e8aea50b982429ee385f001aa88",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "yurrriq/parser-combinators",
"max_stars_repo_path": "misc/RecursiveDescent/Inductive/Char.agda",
"max_stars_repo_stars_event_max_datetime": "2021-06-22T05:35:31.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-12-13T05:23:14.000Z",
"num_tokens": 578,
"size": 2132
} |
------------------------------------------------------------------------
-- A map function for the substitutions
------------------------------------------------------------------------
open import Data.Universe.Indexed
module deBruijn.Substitution.Data.Map
{i u e} {Uni : IndexedUniverse i u e} where
import deBruijn.Context; open deBruijn.Context Uni
open import deBruijn.Substitution.Data.Basics
open import Function using (_$_)
import Relation.Binary.PropositionalEquality as P
open P.≡-Reasoning
private
module Dummy
{t₁} {T₁ : Term-like t₁}
{t₂} {T₂ : Term-like t₂}
where
open Term-like T₁ using ()
renaming (_⊢_ to _⊢₁_; _≅-⊢_ to _≅-⊢₁_; [_] to [_]₁)
open Term-like T₂ using () renaming (_≅-⊢_ to _≅-⊢₂_; [_] to [_]₂)
-- Map.
map : ∀ {Γ Δ Ε} {ρ̂₁ : Γ ⇨̂ Δ} {ρ̂₂ : Δ ⇨̂ Ε} →
[ T₁ ⟶ T₂ ] ρ̂₂ → Sub T₁ ρ̂₁ → Sub T₂ (ρ̂₁ ∘̂ ρ̂₂)
map f ε = ε
map {ρ̂₂ = ρ̂₂} f (ρ₁ ▻ t) =
P.subst (λ v → Sub T₂ (⟦ ρ₁ ⟧⇨ ∘̂ ρ̂₂ ▻̂ v))
(≅-Value-⇒-≡ $ P.sym $ corresponds f t)
(map f ρ₁ ▻ f · t)
abstract
-- An unfolding lemma.
map-▻ :
∀ {Γ Δ Ε} {ρ̂₁ : Γ ⇨̂ Δ} {ρ̂₂ : Δ ⇨̂ Ε} {σ}
(f : [ T₁ ⟶ T₂ ] ρ̂₂) (ρ : Sub T₁ ρ̂₁) t →
map f (ρ ▻⇨[ σ ] t) ≅-⇨ map f ρ ▻⇨[ σ ] f · t
map-▻ {ρ̂₂ = ρ̂₂} f ρ t =
drop-subst-Sub (λ v → ⟦ ρ ⟧⇨ ∘̂ ρ̂₂ ▻̂ v)
(≅-Value-⇒-≡ $ P.sym $ corresponds f t)
-- A congruence lemma.
map-cong : ∀ {Γ₁ Δ₁ Ε₁} {ρ̂₁₁ : Γ₁ ⇨̂ Δ₁} {ρ̂₂₁ : Δ₁ ⇨̂ Ε₁}
{f₁ : [ T₁ ⟶ T₂ ] ρ̂₂₁} {ρ₁ : Sub T₁ ρ̂₁₁}
{Γ₂ Δ₂ Ε₂} {ρ̂₁₂ : Γ₂ ⇨̂ Δ₂} {ρ̂₂₂ : Δ₂ ⇨̂ Ε₂}
{f₂ : [ T₁ ⟶ T₂ ] ρ̂₂₂} {ρ₂ : Sub T₁ ρ̂₁₂} →
f₁ ≅-⟶ f₂ → ρ₁ ≅-⇨ ρ₂ → map f₁ ρ₁ ≅-⇨ map f₂ ρ₂
map-cong {f₁ = _ , _} {f₂ = ._ , _} {ρ₂ = ε} [ P.refl ] P.refl =
P.refl
map-cong {f₁ = f₁} {f₂ = f₂} {ρ₂ = ρ ▻ t} f₁≅f₂ P.refl = begin
[ map f₁ (ρ ▻ t) ] ≡⟨ map-▻ f₁ ρ t ⟩
[ map f₁ ρ ▻ f₁ · t ] ≡⟨ ▻⇨-cong P.refl
(map-cong f₁≅f₂ (P.refl {x = [ ρ ]}))
(·-cong f₁≅f₂ (P.refl {x = [ t ]₁})) ⟩
[ map f₂ ρ ▻ f₂ · t ] ≡⟨ P.sym $ map-▻ f₂ ρ t ⟩
[ map f₂ (ρ ▻ t) ] ∎
-- Variants which only require that the functions are
-- extensionally equal.
map-cong-ext₁ : ∀ {Γ₁ Δ Ε₁} {ρ̂₁₁ : Γ₁ ⇨̂ Δ} {ρ̂₂₁ : Δ ⇨̂ Ε₁}
{f₁ : [ T₁ ⟶ T₂ ] ρ̂₂₁} {ρ₁ : Sub T₁ ρ̂₁₁}
{Γ₂ Ε₂} {ρ̂₁₂ : Γ₂ ⇨̂ Δ} {ρ̂₂₂ : Δ ⇨̂ Ε₂}
{f₂ : [ T₁ ⟶ T₂ ] ρ̂₂₂} {ρ₂ : Sub T₁ ρ̂₁₂} →
Ε₁ ≅-Ctxt Ε₂ →
(∀ {σ} (t : Δ ⊢₁ σ) → f₁ · t ≅-⊢₂ f₂ · t) →
ρ₁ ≅-⇨ ρ₂ → map f₁ ρ₁ ≅-⇨ map f₂ ρ₂
map-cong-ext₁ {Δ = Δ} {f₁ = f₁} {f₂ = f₂} {ρ₂ = ρ}
Ε₁≅Ε₂ f₁≅f₂ P.refl = helper ρ
where
helper : ∀ {Γ} {ρ̂ : Γ ⇨̂ Δ} (ρ : Sub T₁ ρ̂) → map f₁ ρ ≅-⇨ map f₂ ρ
helper ε = ε⇨-cong Ε₁≅Ε₂
helper (ρ ▻ t) = begin
[ map f₁ (ρ ▻ t) ] ≡⟨ map-▻ f₁ ρ t ⟩
[ map f₁ ρ ▻ f₁ · t ] ≡⟨ ▻⇨-cong P.refl (helper ρ) (f₁≅f₂ t) ⟩
[ map f₂ ρ ▻ f₂ · t ] ≡⟨ P.sym $ map-▻ f₂ ρ t ⟩
[ map f₂ (ρ ▻ t) ] ∎
map-cong-ext₂ : ∀ {Γ₁ Δ₁ Ε₁} {ρ̂₁₁ : Γ₁ ⇨̂ Δ₁} {ρ̂₂₁ : Δ₁ ⇨̂ Ε₁}
{f₁ : [ T₁ ⟶ T₂ ] ρ̂₂₁} {ρ₁ : Sub T₁ ρ̂₁₁}
{Γ₂ Δ₂ Ε₂} {ρ̂₁₂ : Γ₂ ⇨̂ Δ₂} {ρ̂₂₂ : Δ₂ ⇨̂ Ε₂}
{f₂ : [ T₁ ⟶ T₂ ] ρ̂₂₂} {ρ₂ : Sub T₁ ρ̂₁₂} →
Δ₁ ≅-Ctxt Δ₂ → Ε₁ ≅-Ctxt Ε₂ →
(∀ {σ₁ σ₂} {t₁ : Δ₁ ⊢₁ σ₁} {t₂ : Δ₂ ⊢₁ σ₂} →
t₁ ≅-⊢₁ t₂ → f₁ · t₁ ≅-⊢₂ f₂ · t₂) →
ρ₁ ≅-⇨ ρ₂ → map f₁ ρ₁ ≅-⇨ map f₂ ρ₂
map-cong-ext₂ P.refl Ε₁≅Ε₂ f₁≅f₂ ρ₁≅ρ₂ =
map-cong-ext₁ Ε₁≅Ε₂ (λ t → f₁≅f₂ (P.refl {x = [ t ]₁})) ρ₁≅ρ₂
private
-- A helper lemma.
/∋-map-▻ :
∀ {Γ Δ Ε σ τ} {ρ̂₁ : Γ ⇨̂ Δ} {ρ̂₂ : Δ ⇨̂ Ε} {t} →
(x : Γ ▻ σ ∋ τ) (f : [ T₁ ⟶ T₂ ] ρ̂₂) (ρ : Sub T₁ ρ̂₁) →
x /∋ map f (ρ ▻ t) ≅-⊢₂ x /∋ (map f ρ ▻ f · t)
/∋-map-▻ {t = t} x f ρ =
/∋-cong (P.refl {x = [ x ]}) (map-▻ f ρ t)
-- Some sort of naturality statement for _/∋_.
/∋-map : ∀ {Γ Δ Ε σ} {ρ̂₁ : Γ ⇨̂ Δ} {ρ̂₂ : Δ ⇨̂ Ε} →
(x : Γ ∋ σ) (f : [ T₁ ⟶ T₂ ] ρ̂₂) (ρ : Sub T₁ ρ̂₁) →
x /∋ map f ρ ≅-⊢₂ f · (x /∋ ρ)
/∋-map (zero {σ = σ}) f (ρ ▻ t) = begin
[ zero[ σ ] /∋ map f (ρ ▻ t) ]₂ ≡⟨ /∋-map-▻ zero[ σ ] f ρ ⟩
[ zero[ σ ] /∋ (map f ρ ▻ f · t) ]₂ ≡⟨ P.refl ⟩
[ f · t ]₂ ∎
/∋-map (suc {σ = σ} x) f (ρ ▻ t) = begin
[ suc x /∋ map f (ρ ▻ t) ]₂ ≡⟨ /∋-map-▻ (suc x) f ρ ⟩
[ suc[ σ ] x /∋ (map f ρ ▻ f · t) ]₂ ≡⟨ P.refl ⟩
[ x /∋ map f ρ ]₂ ≡⟨ /∋-map x f ρ ⟩
[ f · (x /∋ ρ) ]₂ ∎
open Dummy public
abstract
-- Map is functorial.
map-[id] : ∀ {t} {T : Term-like t} {Γ Δ} {ρ̂ : Γ ⇨̂ Δ}
(ρ : Sub T ρ̂) → map ([id] {T = T}) ρ ≅-⇨ ρ
map-[id] ε = P.refl
map-[id] (ρ ▻ t) = ▻⇨-cong P.refl (map-[id] ρ) P.refl
map-[∘] :
∀ {t₁} {T₁ : Term-like t₁}
{t₂} {T₂ : Term-like t₂}
{t₃} {T₃ : Term-like t₃}
{Γ Δ Ε Ζ} {ρ̂₁ : Γ ⇨̂ Δ} {ρ̂₂ : Δ ⇨̂ Ε} {ρ̂₃ : Ε ⇨̂ Ζ}
(f₂ : [ T₂ ⟶ T₃ ] ρ̂₃) (f₁ : [ T₁ ⟶ T₂ ] ρ̂₂)
(ρ : Sub T₁ ρ̂₁) →
map (f₂ [∘] f₁) ρ ≅-⇨ map f₂ (map f₁ ρ)
map-[∘] f₂ f₁ ε = P.refl
map-[∘] f₂ f₁ (ρ ▻ t) = begin
[ map (f₂ [∘] f₁) (ρ ▻ t) ] ≡⟨ map-▻ (f₂ [∘] f₁) ρ t ⟩
[ map (f₂ [∘] f₁) ρ ▻ f₂ · (f₁ · t) ] ≡⟨ ▻⇨-cong P.refl (map-[∘] f₂ f₁ ρ) P.refl ⟩
[ map f₂ (map f₁ ρ) ▻ f₂ · (f₁ · t) ] ≡⟨ P.sym $ map-▻ f₂ (map f₁ ρ) (f₁ · t) ⟩
[ map f₂ (map f₁ ρ ▻ f₁ · t) ] ≡⟨ map-cong (f₂ ∎-⟶) (P.sym $ map-▻ f₁ ρ t) ⟩
[ map f₂ (map f₁ (ρ ▻ t)) ] ∎
| {
"alphanum_fraction": 0.3731012118,
"avg_line_length": 39.06,
"ext": "agda",
"hexsha": "9b6acfe46608be5a5055fe9351a3c0f497f50839",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/dependently-typed-syntax",
"max_forks_repo_path": "deBruijn/Substitution/Data/Map.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/dependently-typed-syntax",
"max_issues_repo_path": "deBruijn/Substitution/Data/Map.agda",
"max_line_length": 88,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/dependently-typed-syntax",
"max_stars_repo_path": "deBruijn/Substitution/Data/Map.agda",
"max_stars_repo_stars_event_max_datetime": "2020-07-08T22:51:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-16T12:14:44.000Z",
"num_tokens": 3120,
"size": 5859
} |
{-# OPTIONS --without-K --safe #-}
module Categories.Comonad where
open import Level
open import Categories.Category using (Category)
open import Categories.Functor using (Functor; Endofunctor; _∘F_) renaming (id to idF)
open import Categories.NaturalTransformation renaming (id to idN)
open import Categories.NaturalTransformation.NaturalIsomorphism hiding (_≃_)
open import Categories.NaturalTransformation.Equivalence
open NaturalIsomorphism
record Comonad {o ℓ e} (C : Category o ℓ e) : Set (o ⊔ ℓ ⊔ e) where
field
F : Endofunctor C
ε : NaturalTransformation F idF
δ : NaturalTransformation F (F ∘F F)
module F = Functor F
module ε = NaturalTransformation ε
module δ = NaturalTransformation δ
open Category C
open Functor F
field
assoc : ∀ {X : Obj} → δ.η (F₀ X) ∘ δ.η X ≈ F₁ (δ.η X) ∘ δ.η X
sym-assoc : ∀ {X : Obj} → F₁ (δ.η X) ∘ δ.η X ≈ δ.η (F₀ X) ∘ δ.η X
identityˡ : ∀ {X : Obj} → F₁ (ε.η X) ∘ δ.η X ≈ id
identityʳ : ∀ {X : Obj} → ε.η (F₀ X) ∘ δ.η X ≈ id
| {
"alphanum_fraction": 0.6696252465,
"avg_line_length": 32.7096774194,
"ext": "agda",
"hexsha": "b682e545dc7af6545389d5c0d524396c2146187a",
"lang": "Agda",
"max_forks_count": 64,
"max_forks_repo_forks_event_max_datetime": "2022-03-14T02:00:59.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-06-02T16:58:15.000Z",
"max_forks_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Code-distancing/agda-categories",
"max_forks_repo_path": "src/Categories/Comonad.agda",
"max_issues_count": 236,
"max_issues_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_issues_repo_issues_event_max_datetime": "2022-03-28T14:31:43.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-06-01T14:53:54.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Code-distancing/agda-categories",
"max_issues_repo_path": "src/Categories/Comonad.agda",
"max_line_length": 86,
"max_stars_count": 279,
"max_stars_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Trebor-Huang/agda-categories",
"max_stars_repo_path": "src/Categories/Comonad.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-22T00:40:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-06-01T14:36:40.000Z",
"num_tokens": 348,
"size": 1014
} |
-- {-# OPTIONS -v tc.mod.apply:80 #-}
module Issue1985 where
module Def where
postulate A : Set
module Par (X : Set₁) where
postulate B : Set
open Def public
-- module Works where
-- module Ren B = Par B
-- module App = Ren Set
module Fails where
module RenP (X : Set₁) = Par X
module Ren = Par
-- Like RenP, Ren should contain
-- A : (B : Set) → Set
-- A B = Par.A B
-- but it incorrectly contained
-- A : Set
-- A = Par.A
A₁ A₂ B₁ B₂ : Set₁ → Set
A₁ = RenP.A
A₂ = Ren.A
B₁ = RenP.B
B₂ = Ren.B
module App = Ren Set
A₃ B₃ : Set
A₃ = App.A
B₃ = App.B
| {
"alphanum_fraction": 0.5761047463,
"avg_line_length": 16.0789473684,
"ext": "agda",
"hexsha": "5d5ecb642910402d6517d631c176e70d0b49faa2",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Succeed/Issue1985.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Succeed/Issue1985.agda",
"max_line_length": 37,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Succeed/Issue1985.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 232,
"size": 611
} |
{-# OPTIONS --allow-unsolved-metas #-}
open import Agda.Primitive
postulate
A : Set
F : ∀ {ℓ} (XF : Set ℓ) → Set ℓ
record R (Q : ∀ {ℓ} (XQ : Set ℓ) → Set ℓ) ℓ : Set (lsuc ℓ) where
field
f : {A : Set ℓ} (fa : F A) → Q A
open R
module M (X : Set₁) where
postulate
G : ∀ {ℓ} (XG : Set ℓ) → Set ℓ
module N (Y : Set) where
open M Set
variable
z : F A
postulate
P : (p : G A) → Set
fails : P (f _ z)
| {
"alphanum_fraction": 0.5136363636,
"avg_line_length": 15.7142857143,
"ext": "agda",
"hexsha": "9cacde3f4ed19f4bead8db794c56aaae8f96f06e",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue4149.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue4149.agda",
"max_line_length": 64,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue4149.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 190,
"size": 440
} |
module Imports.StaleMetaLiteral where
open import Common.Prelude hiding (_>>=_)
open import Common.Reflection
open import Common.Equality
macro
metaLit : Tactic
metaLit hole =
checkType unknown (def (quote Nat) []) >>= λ
{ (meta m args) →
unify hole (lit (meta m)) >>= λ _ →
unify (meta m args) (lit (nat 42))
; _ → typeError (strErr "not a meta" ∷ []) }
staleMeta : Meta
staleMeta = metaLit
| {
"alphanum_fraction": 0.6485849057,
"avg_line_length": 22.3157894737,
"ext": "agda",
"hexsha": "bd239141148ea6fb617d9a684197a7a6f48c45b4",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Fail/Imports/StaleMetaLiteral.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Fail/Imports/StaleMetaLiteral.agda",
"max_line_length": 48,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Fail/Imports/StaleMetaLiteral.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 126,
"size": 424
} |
module Verifier where
open import Definitions
open import NatEquality using (_≟_ ; equality-disjoint)
check1 : (m n : ℕ) → Equal? m n
check1 = _≟_
check2 : (m n : ℕ) → m ≡ n → m ≢ n → ⊥
check2 = equality-disjoint
| {
"alphanum_fraction": 0.6589861751,
"avg_line_length": 18.0833333333,
"ext": "agda",
"hexsha": "dd5f327ee64ca7ee2db177706147e01c06629842",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "ece25bed081a24f02e9f85056d05933eae2afabf",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "danr/agder",
"max_forks_repo_path": "problems/NatEquality/Verifier.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "ece25bed081a24f02e9f85056d05933eae2afabf",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "danr/agder",
"max_issues_repo_path": "problems/NatEquality/Verifier.agda",
"max_line_length": 55,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "ece25bed081a24f02e9f85056d05933eae2afabf",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "danr/agder",
"max_stars_repo_path": "problems/NatEquality/Verifier.agda",
"max_stars_repo_stars_event_max_datetime": "2021-05-17T12:07:03.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-05-17T12:07:03.000Z",
"num_tokens": 75,
"size": 217
} |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.MappingCones.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Unit
open import Cubical.Data.Sum
open import Cubical.HITs.Pushout
open import Cubical.HITs.MappingCones.Base
private
variable
ℓ ℓ' ℓ'' : Level
PushoutUnit-iso-Cone : ∀ {X : Type ℓ} {Y : Type ℓ'} (f : X → Y) → Iso (Pushout (const tt) f) (Cone f)
Iso.fun (PushoutUnit-iso-Cone f) (inl tt) = hub
Iso.fun (PushoutUnit-iso-Cone f) (inr x) = inj x
Iso.fun (PushoutUnit-iso-Cone f) (push x i) = spoke x i
Iso.inv (PushoutUnit-iso-Cone f) (inj x) = inr x
Iso.inv (PushoutUnit-iso-Cone f) hub = inl tt
Iso.inv (PushoutUnit-iso-Cone f) (spoke x i) = push x i
Iso.rightInv (PushoutUnit-iso-Cone f) (inj x) = refl
Iso.rightInv (PushoutUnit-iso-Cone f) hub = refl
Iso.rightInv (PushoutUnit-iso-Cone f) (spoke x i) = refl
Iso.leftInv (PushoutUnit-iso-Cone f) (inl tt) = refl
Iso.leftInv (PushoutUnit-iso-Cone f) (inr x) = refl
Iso.leftInv (PushoutUnit-iso-Cone f) (push x i) = refl
PushoutUnit≡Cone : ∀ {X : Type ℓ} {Y : Type ℓ'} (f : X → Y) → Pushout (const tt) f ≡ Cone f
PushoutUnit≡Cone f = isoToPath (PushoutUnit-iso-Cone f)
ConesUnit-iso-Cone : ∀ {X : Type ℓ} {Y : Type ℓ'} (f : X → Y) → Iso (Cones Unit (λ { tt → f })) (Cone f)
Iso.fun (ConesUnit-iso-Cone f) (inj x) = inj x
Iso.fun (ConesUnit-iso-Cone f) (hub tt) = hub
Iso.fun (ConesUnit-iso-Cone f) (spoke tt x i) = spoke x i
Iso.inv (ConesUnit-iso-Cone f) (inj x) = inj x
Iso.inv (ConesUnit-iso-Cone f) hub = hub tt
Iso.inv (ConesUnit-iso-Cone f) (spoke x i) = spoke tt x i
Iso.rightInv (ConesUnit-iso-Cone f) (inj x) = refl
Iso.rightInv (ConesUnit-iso-Cone f) hub = refl
Iso.rightInv (ConesUnit-iso-Cone f) (spoke x i) = refl
Iso.leftInv (ConesUnit-iso-Cone f) (inj x) = refl
Iso.leftInv (ConesUnit-iso-Cone f) (hub x) = refl
Iso.leftInv (ConesUnit-iso-Cone f) (spoke a x i) = refl
ConesUnit≡Cone : ∀ {X : Type ℓ} {Y : Type ℓ'} (f : X → Y) → (Cones Unit (λ { tt → f })) ≡ (Cone f)
ConesUnit≡Cone f = isoToPath (ConesUnit-iso-Cone f)
| {
"alphanum_fraction": 0.6620099144,
"avg_line_length": 42.6730769231,
"ext": "agda",
"hexsha": "4af0d01466e4690c5ba23edd5e399a3acca3ad93",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-22T02:02:01.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-22T02:02:01.000Z",
"max_forks_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "dan-iel-lee/cubical",
"max_forks_repo_path": "Cubical/HITs/MappingCones/Properties.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_issues_repo_issues_event_max_datetime": "2022-01-27T02:07:48.000Z",
"max_issues_repo_issues_event_min_datetime": "2022-01-27T02:07:48.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "dan-iel-lee/cubical",
"max_issues_repo_path": "Cubical/HITs/MappingCones/Properties.agda",
"max_line_length": 104,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "dan-iel-lee/cubical",
"max_stars_repo_path": "Cubical/HITs/MappingCones/Properties.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 852,
"size": 2219
} |
{-
This second-order term syntax was created from the following second-order syntax description:
syntax PCF
type
N : 0-ary
_↣_ : 2-ary | r30
B : 0-ary
term
app : α ↣ β α -> β | _$_ l20
lam : α.β -> α ↣ β | ƛ_ r10
tr : B
fl : B
ze : N
su : N -> N
pr : N -> N
iz : N -> B | 0?
if : B α α -> α
fix : α.α -> α
theory
(ƛβ) b : α.β a : α |> app (lam(x.b[x]), a) = b[a]
(ƛη) f : α ↣ β |> lam (x. app(f, x)) = f
(zz) |> iz (ze) = tr
(zs) n : N |> iz (su (n)) = fl
(ps) n : N |> pr (su (n)) = n
(ift) t f : α |> if (tr, t, f) = t
(iff) t f : α |> if (fl, t, f) = f
(fix) t : α.α |> fix (x.t[x]) = t[fix (x.t[x])]
-}
module PCF.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 PCF.Signature
private
variable
Γ Δ Π : Ctx
α β : PCFT
𝔛 : Familyₛ
-- Inductive term declaration
module PCF:Terms (𝔛 : Familyₛ) where
data PCF : Familyₛ where
var : ℐ ⇾̣ PCF
mvar : 𝔛 α Π → Sub PCF Π Γ → PCF α Γ
_$_ : PCF (α ↣ β) Γ → PCF α Γ → PCF β Γ
ƛ_ : PCF β (α ∙ Γ) → PCF (α ↣ β) Γ
tr : PCF B Γ
fl : PCF B Γ
ze : PCF N Γ
su : PCF N Γ → PCF N Γ
pr : PCF N Γ → PCF N Γ
0? : PCF N Γ → PCF B Γ
if : PCF B Γ → PCF α Γ → PCF α Γ → PCF α Γ
fix : PCF α (α ∙ Γ) → PCF α Γ
infixl 20 _$_
infixr 10 ƛ_
open import SOAS.Metatheory.MetaAlgebra ⅀F 𝔛
PCFᵃ : MetaAlg PCF
PCFᵃ = record
{ 𝑎𝑙𝑔 = λ where
(appₒ ⋮ a , b) → _$_ a b
(lamₒ ⋮ a) → ƛ_ a
(trₒ ⋮ _) → tr
(flₒ ⋮ _) → fl
(zeₒ ⋮ _) → ze
(suₒ ⋮ a) → su a
(prₒ ⋮ a) → pr a
(izₒ ⋮ a) → 0? a
(ifₒ ⋮ a , b , c) → if a b c
(fixₒ ⋮ a) → fix a
; 𝑣𝑎𝑟 = var ; 𝑚𝑣𝑎𝑟 = λ 𝔪 mε → mvar 𝔪 (tabulate mε) }
module PCFᵃ = MetaAlg PCFᵃ
module _ {𝒜 : Familyₛ}(𝒜ᵃ : MetaAlg 𝒜) where
open MetaAlg 𝒜ᵃ
𝕤𝕖𝕞 : PCF ⇾̣ 𝒜
𝕊 : Sub PCF Π Γ → Π ~[ 𝒜 ]↝ Γ
𝕊 (t ◂ σ) new = 𝕤𝕖𝕞 t
𝕊 (t ◂ σ) (old v) = 𝕊 σ v
𝕤𝕖𝕞 (mvar 𝔪 mε) = 𝑚𝑣𝑎𝑟 𝔪 (𝕊 mε)
𝕤𝕖𝕞 (var v) = 𝑣𝑎𝑟 v
𝕤𝕖𝕞 (_$_ a b) = 𝑎𝑙𝑔 (appₒ ⋮ 𝕤𝕖𝕞 a , 𝕤𝕖𝕞 b)
𝕤𝕖𝕞 (ƛ_ a) = 𝑎𝑙𝑔 (lamₒ ⋮ 𝕤𝕖𝕞 a)
𝕤𝕖𝕞 tr = 𝑎𝑙𝑔 (trₒ ⋮ tt)
𝕤𝕖𝕞 fl = 𝑎𝑙𝑔 (flₒ ⋮ tt)
𝕤𝕖𝕞 ze = 𝑎𝑙𝑔 (zeₒ ⋮ tt)
𝕤𝕖𝕞 (su a) = 𝑎𝑙𝑔 (suₒ ⋮ 𝕤𝕖𝕞 a)
𝕤𝕖𝕞 (pr a) = 𝑎𝑙𝑔 (prₒ ⋮ 𝕤𝕖𝕞 a)
𝕤𝕖𝕞 (0? a) = 𝑎𝑙𝑔 (izₒ ⋮ 𝕤𝕖𝕞 a)
𝕤𝕖𝕞 (if a b c) = 𝑎𝑙𝑔 (ifₒ ⋮ 𝕤𝕖𝕞 a , 𝕤𝕖𝕞 b , 𝕤𝕖𝕞 c)
𝕤𝕖𝕞 (fix a) = 𝑎𝑙𝑔 (fixₒ ⋮ 𝕤𝕖𝕞 a)
𝕤𝕖𝕞ᵃ⇒ : MetaAlg⇒ PCFᵃ 𝒜ᵃ 𝕤𝕖𝕞
𝕤𝕖𝕞ᵃ⇒ = record
{ ⟨𝑎𝑙𝑔⟩ = λ{ {t = t} → ⟨𝑎𝑙𝑔⟩ t }
; ⟨𝑣𝑎𝑟⟩ = refl
; ⟨𝑚𝑣𝑎𝑟⟩ = λ{ {𝔪 = 𝔪}{mε} → cong (𝑚𝑣𝑎𝑟 𝔪) (dext (𝕊-tab mε)) } }
where
open ≡-Reasoning
⟨𝑎𝑙𝑔⟩ : (t : ⅀ PCF α Γ) → 𝕤𝕖𝕞 (PCFᵃ.𝑎𝑙𝑔 t) ≡ 𝑎𝑙𝑔 (⅀₁ 𝕤𝕖𝕞 t)
⟨𝑎𝑙𝑔⟩ (appₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (lamₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (trₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (flₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (zeₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (suₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (prₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (izₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (ifₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (fixₒ ⋮ _) = refl
𝕊-tab : (mε : Π ~[ PCF ]↝ Γ)(v : ℐ α Π) → 𝕊 (tabulate mε) v ≡ 𝕤𝕖𝕞 (mε v)
𝕊-tab mε new = refl
𝕊-tab mε (old v) = 𝕊-tab (mε ∘ old) v
module _ (g : PCF ⇾̣ 𝒜)(gᵃ⇒ : MetaAlg⇒ PCFᵃ 𝒜ᵃ g) where
open MetaAlg⇒ gᵃ⇒
𝕤𝕖𝕞! : (t : PCF α Γ) → 𝕤𝕖𝕞 t ≡ g t
𝕊-ix : (mε : Sub PCF Π Γ)(v : ℐ α Π) → 𝕊 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 ⟨𝑣𝑎𝑟⟩
𝕤𝕖𝕞! (_$_ a b) rewrite 𝕤𝕖𝕞! a | 𝕤𝕖𝕞! b = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (ƛ_ a) rewrite 𝕤𝕖𝕞! a = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! tr = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! fl = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! ze = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (su a) rewrite 𝕤𝕖𝕞! a = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (pr a) rewrite 𝕤𝕖𝕞! a = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (0? a) rewrite 𝕤𝕖𝕞! a = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (if a b c) rewrite 𝕤𝕖𝕞! a | 𝕤𝕖𝕞! b | 𝕤𝕖𝕞! c = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (fix a) rewrite 𝕤𝕖𝕞! a = sym ⟨𝑎𝑙𝑔⟩
-- Syntax instance for the signature
PCF:Syn : Syntax
PCF:Syn = record
{ ⅀F = ⅀F
; ⅀:CS = ⅀:CompatStr
; mvarᵢ = PCF:Terms.mvar
; 𝕋:Init = λ 𝔛 → let open PCF:Terms 𝔛 in record
{ ⊥ = PCF ⋉ PCFᵃ
; ⊥-is-initial = record { ! = λ{ {𝒜 ⋉ 𝒜ᵃ} → 𝕤𝕖𝕞 𝒜ᵃ ⋉ 𝕤𝕖𝕞ᵃ⇒ 𝒜ᵃ }
; !-unique = λ{ {𝒜 ⋉ 𝒜ᵃ} (f ⋉ fᵃ⇒) {x = t} → 𝕤𝕖𝕞! 𝒜ᵃ f fᵃ⇒ t } } } }
-- Instantiation of the syntax and metatheory
open Syntax PCF:Syn public
open PCF:Terms public
open import SOAS.Families.Build public
open import SOAS.Syntax.Shorthands PCFᵃ public
open import SOAS.Metatheory PCF:Syn public
| {
"alphanum_fraction": 0.4786079836,
"avg_line_length": 27.1388888889,
"ext": "agda",
"hexsha": "e3ac035a4f420048ea1414ab385eda646fefcbbf",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2022-01-24T12:49:17.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-09T20:39:59.000Z",
"max_forks_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "JoeyEremondi/agda-soas",
"max_forks_repo_path": "out/PCF/Syntax.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_issues_repo_issues_event_max_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "JoeyEremondi/agda-soas",
"max_issues_repo_path": "out/PCF/Syntax.agda",
"max_line_length": 93,
"max_stars_count": 39,
"max_stars_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "JoeyEremondi/agda-soas",
"max_stars_repo_path": "out/PCF/Syntax.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-19T17:33:12.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-11-09T20:39:55.000Z",
"num_tokens": 3247,
"size": 4885
} |
{- An agda file contains a single module. The module name should correspond to
the name and path of the file. The path is relative to the project root. In
this case the project root is the root of Agda II. Modules can be
parameterised, but in this case we choose not to parameterise the top-level
module.
-}
module examples.syntax.Syntax where
-- It is recommended that the body of the top-level module is indented by a
-- small amount, but this is not enforced in the syntax.
-- You can have modules inside modules. The name of a sub-module isn't
-- qualified.
module Expressions (X : Set)(x1, x2 : X) where
-- There are three forms of sorts. Set = Set0.
postulate A1 : Set
A2 : Set3
A3 : Prop
-- Independent function space.
fun1 : X -> X
fun1 x = x
-- Implicit independent function space. This is mostly included for
-- symmetry, I can't come up with an example when this would be useful.
fun2 : {X} -> X
fun2 {x} = x
-- Dependent function space.
fun3 : (A:Set) -> A -> A
fun3 A x = x
-- Implicit dependent function space. 'A' is implicit so we don't have to
-- write it out in the function definition.
fun4 : {A:Set} -> A -> A
fun4 x = x
-- You can also write independent functions using the dependent function
-- space syntax. Not that you'd ever want to.
fun5 : (_:X) -> X
fun5 x = x
-- Lambdas can be domain free.
const1 : {A, B : Set} -> A -> B -> A
const1 = \x y -> x
-- Or completely typed.
const2 = \{A:Set}{B:Set}(x:A)(y:B) -> x -- inferable, no type needed
-- You cannot mix typed and untyped arguments in the same lambda.
const3 : {A, B : Set} -> A -> B -> A
const3 = \{A}{B} -> \(x:A)(y:B) -> x
-- You can have wildcards in lambdas
const4 : {A, B : Set} -> A -> B -> A
const4 = \x _ -> x
-- Implicit arguments can be omitted in applications.
x = const1 x1 x2
-- Or made explicit.
x' = const1 {X} {X} x1 x2
-- Infix operators can be bound by lambdas. See ComplexDeclarations for
-- more information about infix operators.
dup : {A:Set} -> (A -> A -> A) -> A -> A
dup = \(+) x -> x + x
-- The two basic declarations are function definitions and datatype
-- declarations.
module BasicDeclarations (X : Set) where
-- The most common declaration is the function definition. It consists of
-- two parts; a type signature and a set of function clauses. Type
-- signatures have the form 'id : type', no telescopes are allowed at this
-- point. This can be discussed.
id : X -> X
id x = x
-- You can omit the type signature if the type can be inferred.
id' = id
-- Datatypes are introduced with the data keyword.
data Bool : Set where
false : Bool
true : Bool
-- The parameters to the datatype (A in this case) are in scope in the
-- types of the constructors. At the moment inductive families are not
-- supported.
data List (A : Set) : Set where
nil : List A
(::) : A -> List A -> List A
-- When using a constructor as a function, the parameters are hidden
-- arguments.
singleton : X -> List X
singleton x = x :: nil
singleton' : X -> List X
singleton' x = (::) {X} x (nil {X})
-- You can pattern match over elements of a datatype when defining
-- functions (and only then).
null : (A : Set) -> List A -> Bool
null A nil = true
null A (x::xs) = false
-- Patterns can be nested (and functions can be recursive).
and : List Bool -> Bool
and nil = true
and (true::xs) = and xs
and (false::xs) = false
-- Functions can be defined in an infix style. When doing this it must be
-- clear what name is being defined without looking at fixities. Hence we
-- could never remove the parenthesis around x::xs in the second clause.
(++) : List X -> List X -> List X
nil ++ ys = ys
(x::xs) ++ ys = x :: (xs ++ ys)
-- You can also use a combination of infix and prefix.
(@) : {A, B, C : Set} -> (B -> C) -> (A -> B) -> A -> C
(f @ g) x = f (g x)
-- Declarations can appear in many different contexts and not all
-- declarations are allowed everywhere.
module ComplexDeclarations (X : Set) where
-- You can introduce new constants with the postulate declaration. A
-- postulate declaration takes a list of type signatures.
postulate A : Set
a : A
-- Let's introduce some datatypes so we have something to work with. At the
-- same time we illustrate that layout is optional.
data Nat : Set where { zero : Nat; suc : Nat -> Nat }
data Bool : Set where { false : Bool; true : Bool }
{- We can declare the fixity of infix symbols. The fixity is tied to a
particular binding of a name. The binding doesn't have to be in scope
directly (as in the example below), but it should be possible to bring
it into scope by moving the fixity declaration further down in the
current block (but never inside things).
The following wouldn't be allowed:
infixl 15 +
mutual
(+) : Nat -> Nat -> Nat
..
There are three forms: infix, infixl and infixr, for non-associative,
left associative and right associative respectively. The number is the
precedence level.
-}
infixl 15 +, `plus`
(+) : Nat -> Nat -> Nat
n + zero = zero
n + suc m = suc (n + m)
plus = (+)
-- The following code is to stress test the handling of infix applications.
infixl 10 @
infixl 11 @@
infixr 10 #
infixr 11 ##
postulate
(@) : Nat -> Nat -> Nat
(#) : Nat -> Nat -> Nat
(@@) : Nat -> Nat -> Nat
(##) : Nat -> Nat -> Nat
z = zero
test1 = z @ (z # z)
test2 = (z @ z) # z
test3 = z # (z @ z)
test4 = (z # z) @ z
test5 = z ## z # z ## z # z
test6 = z @@ z @ z @@ z @ z
test7 = z # z @@ z @@ z # z
-- Mutually recursive definition are introduced using the 'mutual' keyword.
-- A mutual block can contain function definitions, datatypes
-- (induction-recursion) and fixity declarations.
mutual
even : Nat -> Bool
even zero = true
even (suc n) = odd n
odd : Nat -> Bool
odd zero = false
odd (suc n) = even n
-- If a function is declared abstract the definition of the function is not
-- visible outside the module. For an abstract datatype the constructors
-- are hidden. Definitions that can appear in an abstract block are:
-- function definitions, data declarations, fixity declarations, mutual
-- blocks, open and name space declarations (see NameSpaces).
abstract
data Stack : Set where
nil : Stack
cons : A -> Stack -> Stack
empty : Stack
empty = nil
push : A -> Stack -> Stack
push = cons
-- Local declarations are introduces either with a let or in a where
-- clause. A where clause is attached to a function clause. Everything that
-- can appear in an abstract block can appear in a local declaration, plus
-- abstract blocks. Local functions can be recursive.
foo : (A : Set) -> A -> A
foo A x = let f : Local -> A
f (local y) = y
in f (local x)
where
data Local : Set where
local : A -> Local
-- You can declare things to be private to the current module. This means
-- that they cannot be accessed outside the module (but they're still
-- visible inside the module and its submodules). The only things that
-- cannot appear in a private block are other private blocks and import
-- statements.
private
bar : X -> X
bar x = x
-- Private declarations can go inside mutual and abstract blocks.
mutual
private f : Nat -> Nat
f zero = zero
f (suc n) = g n
g : Nat -> Nat
g n = f n
abstract
Nat' : Set
Nat' = Nat
private h : Nat' -> Nat
h n = n
-- A name space is something that contains names. You can create new
-- name spaces and bring names from a name space into scope.
module NameSpaces where
-- To access definitions from a module in a different file, you have to
-- 'import' this module. Only top-level modules (which have their own
-- files) can be imported.
-- If the imported module is not parameterised a name space with the same
-- name as the module is created.
import examples.syntax.ModuleA
-- We can now refer to things from ModuleA using the created name
-- space. Note that no unqualified names were brought into scope
-- (except, perhaps, the name of the name space). [To bring
-- unqualified names into scope we have to use the 'open'
-- declaration.]
FunnyNat = examples.syntax.ModuleA.Nat
-- If the name of an imported module clashes with a local module we might
-- have to rename the module we are importing
import examples.syntax.ModuleA as A
import examples.syntax.ModuleA as A' using (Nat)
Nat1 = A.Nat
Nat2 = A'.Nat
{- You can't project from a parameterised module. It has to be
instantiated first. The only thing that happens when importing
is that the module name 'examples.syntax.ModuleB' is brought
into scope (and the type checker goes away and type checks this
module).
-}
import examples.syntax.ModuleB
-- To instantiate ModuleB we need something to instantiate it with.
postulate X : Set
(==) : X -> X -> Prop
refl : (x : X) -> x == x
-- To instantiate a module you create a new module and define it as the
-- instantiation in question.
module B = examples.syntax.ModuleB X (==) refl
-- Now the module B contains all the names from ModuleB.
XList = B.List
And = B./\ -- qualified operators are not infix symbols
dummyX = B.SubModule.dummy -- submodules of ModuleB are also in scope
-- This of course works for non-parameterised modules as well.
module B' = B
-- And you can create parameterised modules this way.
module BX ((==) : X -> X -> Prop)(refl : (x : X) -> x == x) = B X (==) refl
-- To bring names from a module into scope you use an open declaration.
open examples.syntax.ModuleA
two : FunnyNat
two = eval (plus (suc zero) (suc zero))
{- In all three declarations (import, module instantiation and open) you
can give modifiers that affect the names which are imported. There are
three modifiers:
using (x1;..;xn) only import x1,..,xn
hiding (x1;..;xn) import everything but x1,..,xn
renaming (x1 to y1;..;xn to yn) import x1,..,xn but call them y1,..,yn
Restrictions:
- a modifier can appear only once
- 'using' and 'hiding' cannot appear together
- imported names must be distinct (e.g. you cannot rename to a name
that is already being imported).
-}
-- B1 only contains True and False
module B1 = B using (True; False)
-- B2 contains True, False and And where And = B./\
module B2 = B using (True; False) renaming (/\ to And)
-- B3 contains everything from B except reflEqList and eqList, plus ===
-- where (===) = B.eqList.
module B3 = B hiding (reflEqList) renaming (eqList to ===)
-- When referring to sub modules you have to be explicitly about it being
-- a module
module B4 = B renaming (module SubModule to Sub)
dummy : X
dummy = B4.Sub.dummy
-- There are two kinds of meta variables; question marks and underscores.
-- Question marks are used for interaction and underscores for implicit
-- arguments.
module MetaVariables where
postulate X : Set
x : X
-- There are two ways of writing a question mark: ? and {! ... !}
-- The type checker will not complain about unsolved question marks (unless
-- you claim you are done).
incomplete : {A:Set} -> A -> A
incomplete x = ?
incomplete' : {A:Set} -> A -> A
incomplete' x = {! you can put anything in here,
even {! nested holes !}
!}
-- Underscores should always be solvable locally. Internally underscores
-- are inserted for implicit arguments, but there are cases where you would
-- like to write them explicitly. For instance, if you want to give one but
-- not all implicit arguments to a function explicitly.
underscore : ({A,B,C:Set} -> (A -> A) -> B -> C) -> X
underscore f = f {_} {X} {_} (\y -> y) x
-- Note that '_' is not an identifier character. The current use of
-- underscore is not the real reason for this. The idea is rather that
-- underscore will be used for subscripts.
id : (A : Set) -> A -> A
id A x = x
x' = id_x -- this means id _ x
-- The parser supports four types of literals. The syntax is the same as in
-- Haskell (since that meant I could steal the lexer for them from ghc).
module Literals where
-- We haven't decided how to handle built-in types.
postulate Integer : Set
Char : Set
String : Set
Float : Set
fortyTwo : Integer
fortyTwo = 42
helloWorld : String
helloWorld = "Hello World!"
escape : Char
escape = '\ESC'
pi : Float
pi = 3.141592
-- There are few things that the parser doesn't implement.
{- Fancy case. I haven't been able to come up with a nice syntax for the
fancy case statement. The difficulty is that we should make it clear
what arguments to the elimination rule will appear as patterns (the
targets). Suggestions are welcome.
Also I'm not sure that we want the fancy case. It would be better to
have a good way of doing actual pattern matching on inductive families.
-}
{- Relative imports. You might want to be able to say
import .ModuleA
to import the module 'current.directory.ModuleA'. Easy to implement but
I'm not sure it's that painful to write the complete name (not a problem
in Haskell for instance). Drawbacks: it looks kind of funny and it adds
an extra bit of syntax to remember.
-}
| {
"alphanum_fraction": 0.6268888575,
"avg_line_length": 33.0887850467,
"ext": "agda",
"hexsha": "e27bbd3df5156540e97133ab72acbe0573e432a2",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "masondesu/agda",
"max_forks_repo_path": "examples/outdated-and-incorrect/syntax/Syntax.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "masondesu/agda",
"max_issues_repo_path": "examples/outdated-and-incorrect/syntax/Syntax.agda",
"max_line_length": 79,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/agda-kanso",
"max_stars_repo_path": "examples/outdated-and-incorrect/syntax/Syntax.agda",
"max_stars_repo_stars_event_max_datetime": "2019-11-27T04:41:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-11-27T04:41:05.000Z",
"num_tokens": 3745,
"size": 14162
} |
module LitDistinct where
{-# BUILTIN STRING String #-}
data _==_ {A : Set}(x : A) : A -> Set where
refl : x == x
data False : Set where
foo : "bar" == "baz" -> False
foo ()
| {
"alphanum_fraction": 0.5635359116,
"avg_line_length": 12.9285714286,
"ext": "agda",
"hexsha": "9c6f04dce7b11c37308a27152b2a830f8f668627",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "alhassy/agda",
"max_forks_repo_path": "test/Succeed/LitDistinct.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "alhassy/agda",
"max_issues_repo_path": "test/Succeed/LitDistinct.agda",
"max_line_length": 43,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "alhassy/agda",
"max_stars_repo_path": "test/Succeed/LitDistinct.agda",
"max_stars_repo_stars_event_max_datetime": "2021-07-07T10:49:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-07-07T10:49:57.000Z",
"num_tokens": 58,
"size": 181
} |
open import Data.List hiding ([_]) renaming (_∷_ to _∷ₗ_)
open import Data.Maybe
open import Data.Product
open import AEff
open import EffectAnnotations
open import Renamings
open import Substitutions
open import Types
open import Relation.Binary.PropositionalEquality hiding ([_])
open import Relation.Nullary
module Preservation where
-- BINDING CONTEXTS
BCtx = List VType
-- WELL-TYPED EVALUATION CONTEXTS
data _⊢E[_]⦂_ (Γ : Ctx) : (Δ : BCtx) → CType → Set where
[-] : {C : CType} →
-------------
Γ ⊢E[ [] ]⦂ C
let=_`in_ : {Δ : BCtx}
{X Y : VType}
{o : O}
{i : I} →
Γ ⊢E[ Δ ]⦂ X ! (o , i) →
Γ ∷ X ⊢M⦂ Y ! (o , i) →
------------------------
Γ ⊢E[ Δ ]⦂ Y ! (o , i)
↑ : {Δ : BCtx}
{X : VType}
{o : O}
{i : I} →
(op : Σₛ) →
op ∈ₒ o →
Γ ⊢V⦂ ``(payload op) →
Γ ⊢E[ Δ ]⦂ X ! (o , i) →
------------------------
Γ ⊢E[ Δ ]⦂ X ! (o , i)
↓ : {Δ : BCtx}
{X : VType}
{o : O}
{i : I}
(op : Σₛ) →
Γ ⊢V⦂ ``(payload op) →
Γ ⊢E[ Δ ]⦂ X ! (o , i) →
---------------------------
Γ ⊢E[ Δ ]⦂ X ! op ↓ₑ (o , i)
promise_∣_↦_`in_ : {Δ : BCtx}
{X Y : VType}
{o o' : O}
{i i' : I} →
(op : Σₛ) →
lkpᵢ op i ≡ just (o' , i') →
Γ ∷ ``(payload op) ⊢M⦂ ⟨ X ⟩ ! (o' , i') →
Γ ∷ ⟨ X ⟩ ⊢E[ Δ ]⦂ Y ! (o , i) →
------------------------------------------
Γ ⊢E[ X ∷ₗ Δ ]⦂ Y ! (o , i)
coerce : {Δ : BCtx}
{X : VType}
{o o' : O}
{i i' : I} →
o ⊑ₒ o' →
i ⊑ᵢ i' →
Γ ⊢E[ Δ ]⦂ X ! (o , i) →
------------------------
Γ ⊢E[ Δ ]⦂ X ! (o' , i')
-- MERGING AN ORDINARY CONTEXT AND A BINDING CONTEXT
infix 30 _⋈_
_⋈_ : Ctx → BCtx → Ctx
Γ ⋈ [] = Γ
Γ ⋈ (X ∷ₗ Δ) = (Γ ∷ ⟨ X ⟩) ⋈ Δ
-- FINDING THE TYPE OF THE HOLE OF A WELL-TYPED EVALUATION CONTEXT
hole-ty-e : {Γ : Ctx} {Δ : BCtx} {C : CType} → Γ ⊢E[ Δ ]⦂ C → CType
hole-ty-e {_} {_} {C} [-] =
C
hole-ty-e (let= E `in M) =
hole-ty-e E
hole-ty-e (↑ op p V E) =
hole-ty-e E
hole-ty-e (↓ op V E) =
hole-ty-e E
hole-ty-e (promise op ∣ p ↦ M `in E) =
hole-ty-e E
hole-ty-e (coerce p q E) =
hole-ty-e E
-- FILLING A WELL-TYPED EVALUATION CONTEXT
{- LEMMA 3.5 -}
infix 30 _[_]
_[_] : {Γ : Ctx} {Δ : BCtx} {C : CType} → (E : Γ ⊢E[ Δ ]⦂ C) → Γ ⋈ Δ ⊢M⦂ (hole-ty-e E) → Γ ⊢M⦂ C
[-] [ M ] =
M
(let= E `in N) [ M ] =
let= (E [ M ]) `in N
↑ op p V E [ M ] =
↑ op p V (E [ M ])
↓ op V E [ M ] =
↓ op V (E [ M ])
(promise op ∣ p ↦ N `in E) [ M ] =
promise op ∣ p ↦ N `in (E [ M ])
coerce p q E [ M ] =
coerce p q (E [ M ])
-- STRENGTHENING OF GROUND VALUES WRT BOUND PROMISES
strengthen-var : {Γ : Ctx} → (Δ : BCtx) → {A : BType} → `` A ∈ Γ ⋈ Δ → `` A ∈ Γ
strengthen-var [] x = x
strengthen-var (y ∷ₗ Δ) x with strengthen-var Δ x
... | Tl p = p
strengthen-val : {Γ : Ctx} {Δ : BCtx} {A : BType} → Γ ⋈ Δ ⊢V⦂ `` A → Γ ⊢V⦂ `` A
strengthen-val {_} {Δ} (` x) =
` strengthen-var Δ x
strengthen-val (``_ c) =
``_ c
strengthen-val-[] : {Γ : Ctx}
{A : BType} →
(V : Γ ⋈ [] ⊢V⦂ `` A) →
--------------------
strengthen-val {Δ = []} V ≡ V
strengthen-val-[] (` x) =
refl
strengthen-val-[] (``_ c) =
refl
-- SMALL-STEP OPERATIONAL SEMANTICS FOR WELL-TYPED COMPUTATIONS
-- (ADDITIONALLY SERVES AS THE PRESERVATION THEOREM)
{- THEOREM 3.6 -}
infix 10 _↝_
data _↝_ {Γ : Ctx} : {C : CType} → Γ ⊢M⦂ C → Γ ⊢M⦂ C → Set where
-- COMPUTATIONAL RULES
apply : {X : VType}
{C : CType} →
(M : Γ ∷ X ⊢M⦂ C) →
(V : Γ ⊢V⦂ X) →
----------------------
(ƛ M) · V
↝
M [ id-subst [ V ]s ]m
let-return : {X Y : VType}
{o : O}
{i : I} →
(V : Γ ⊢V⦂ X) →
(N : Γ ∷ X ⊢M⦂ Y ! (o , i)) →
-----------------------------
let= (return V) `in N
↝
N [ id-subst [ V ]s ]m
let-↑ : {X Y : VType}
{o : O}
{i : I}
{op : Σₛ} →
(p : op ∈ₒ o) →
(V : Γ ⊢V⦂ ``(payload op)) →
(M : Γ ⊢M⦂ X ! (o , i)) →
(N : Γ ∷ X ⊢M⦂ Y ! (o , i)) →
-----------------------------
let= (↑ op p V M) `in N
↝
↑ op p V (let= M `in N)
let-promise : {X Y Z : VType}
{o o' : O}
{i i' : I}
{op : Σₛ} →
(p : lkpᵢ op i ≡ just (o' , i')) →
(M₁ : Γ ∷ ``(payload op) ⊢M⦂ ⟨ X ⟩ ! (o' , i')) →
(M₂ : Γ ∷ ⟨ X ⟩ ⊢M⦂ Y ! (o , i)) →
(N : Γ ∷ Y ⊢M⦂ Z ! (o , i)) →
---------------------------------------------------------------------------
let= (promise op ∣ p ↦ M₁ `in M₂) `in N
↝
(promise op ∣ p ↦ M₁ `in (let= M₂ `in (M-rename (comp-ren exchange wk₁) N)))
letrec-unfold : {X : VType}
{C D : CType}
(M : Γ ∷ (X ⇒ C) ∷ X ⊢M⦂ C) →
(N : Γ ∷ (X ⇒ C) ⊢M⦂ D) →
----------------------------------------
(letrec M `in N)
↝
N [ id-subst [ ƛ (letrec M-rename wk₃ M `in M-rename exchange M) ]s ]m
promise-↑ : {X Y : VType}
{o o' : O}
{i i' : I}
{op op' : Σₛ} →
(p : lkpᵢ op i ≡ just (o' , i')) →
(q : op' ∈ₒ o) →
(V : Γ ∷ ⟨ X ⟩ ⊢V⦂ ``(payload op')) →
(M : Γ ∷ ``(payload op) ⊢M⦂ ⟨ X ⟩ ! (o' , i')) →
(N : Γ ∷ ⟨ X ⟩ ⊢M⦂ Y ! (o , i)) →
--------------------------------------------
(promise op ∣ p ↦ M `in (↑ op' q V N))
↝
↑ op' q (strengthen-val {Δ = X ∷ₗ []} V) (promise op ∣ p ↦ M `in N)
↓-return : {X : VType}
{o : O}
{i : I}
{op : Σₛ} →
(V : Γ ⊢V⦂ ``(payload op)) →
(W : Γ ⊢V⦂ X) →
----------------------------------------------------------------
↓ {o = o} {i = i} op V (return W)
↝
return {o = proj₁ (op ↓ₑ (o , i))} {i = proj₂ (op ↓ₑ (o , i))} W
↓-↑ : {X : VType}
{o : O}
{i : I}
{op : Σₛ}
{op' : Σₛ} →
(p : op' ∈ₒ o) →
(V : Γ ⊢V⦂ ``(payload op)) →
(W : Γ ⊢V⦂ ``(payload op')) →
(M : Γ ⊢M⦂ X ! (o , i)) →
-------------------------------
↓ op V (↑ op' p W M)
↝
↑ op' (↓ₑ-⊑ₒ op' p) W (↓ op V M)
↓-promise-op : {X Y : VType}
{o o' : O}
{i i' : I}
{op : Σₛ} →
(p : lkpᵢ op i ≡ just (o' , i')) →
(V : Γ ⊢V⦂ ``(payload op)) →
(M : Γ ∷ ``(payload op) ⊢M⦂ ⟨ X ⟩ ! (o' , i')) →
(N : Γ ∷ ⟨ X ⟩ ⊢M⦂ Y ! (o , i)) →
---------------------------------------------------------------------------------------
↓ op V (promise op ∣ p ↦ M `in N )
↝
(let= (coerce (↓ₑ-⊑ₒ-o' {o} p) (↓ₑ-⊑ₒ-i' {o} p) (M [ id-subst [ V ]s ]m)) `in
↓ op (V-rename wk₁ V) ((M-rename (comp-ren exchange wk₁) N) [ id-subst [ ` Hd ]s ]m))
↓-promise-op' : {X Y : VType}
{o o' : O}
{i i' : I}
{op op' : Σₛ} →
(p : ¬ op ≡ op') →
(q : lkpᵢ op' i ≡ just (o' , i')) →
(V : Γ ⊢V⦂ ``(payload op)) →
(M : Γ ∷ ``(payload op') ⊢M⦂ ⟨ X ⟩ ! (o' , i')) →
(N : Γ ∷ ⟨ X ⟩ ⊢M⦂ Y ! (o , i)) →
------------------------------------------------------------------------------------------
↓ op V (promise op' ∣ q ↦ M `in N )
↝
promise_∣_↦_`in_ {o' = proj₁ (lkpᵢ-↓ₑ-neq {o = o} {i = i} p q)}
{i' = proj₁ (proj₂ (lkpᵢ-↓ₑ-neq {o = o} {i = i} p q))}
op'
(proj₁ (proj₂ (proj₂ (lkpᵢ-↓ₑ-neq {o = o} {i = i} p q))))
(coerce (proj₁ (proj₂ (proj₂ (proj₂ (lkpᵢ-↓ₑ-neq {o = o} {i = i} p q)))))
(proj₂ (proj₂ (proj₂ (proj₂ (lkpᵢ-↓ₑ-neq {o = o} {i = i} p q)))))
M)
(↓ op (V-rename wk₁ V) N)
await-promise : {X : VType}
{C : CType} →
(V : Γ ⊢V⦂ X) →
(M : Γ ∷ X ⊢M⦂ C) →
--------------------
await ⟨ V ⟩ until M
↝
M [ id-subst [ V ]s ]m
-- EVALUATION CONTEXT RULE
context : {Δ : BCtx}
{C : CType} →
(E : Γ ⊢E[ Δ ]⦂ C) →
{M N : Γ ⋈ Δ ⊢M⦂ (hole-ty-e E)} →
M ↝ N →
-------------------------------
E [ M ] ↝ E [ N ]
-- COERCION RULES
-- (THE RESULT OF WORKING WITH WELL-TYPED SYNTAX AND MAKING SUBSUMPTION INTO AN EXPLICIT COERCION)
coerce-return : {X : VType}
{o o' : O}
{i i' : I}
{p : o ⊑ₒ o'}
{q : i ⊑ᵢ i'} →
(V : Γ ⊢V⦂ X) →
--------------------------------
coerce p q (return V) ↝ return V
coerce-↑ : {X : VType}
{o o' : O}
{i i' : I}
{p : o ⊑ₒ o'}
{q : i ⊑ᵢ i'}
{op : Σₛ} →
(r : op ∈ₒ o) →
(V : Γ ⊢V⦂ ``(payload op)) →
(M : Γ ⊢M⦂ X ! (o , i)) →
-------------------------------
coerce p q (↑ op r V M)
↝
↑ op (p op r) V (coerce p q M)
coerce-promise : {X Y : VType}
{o o' o'' : O}
{i i' i'' : I}
{p : o ⊑ₒ o'}
{q : i ⊑ᵢ i'}
{op : Σₛ} →
(r : lkpᵢ op i ≡ just (o'' , i''))
(M : Γ ∷ ``(payload op) ⊢M⦂ ⟨ X ⟩ ! (o'' , i'')) →
(N : Γ ∷ ⟨ X ⟩ ⊢M⦂ Y ! (o , i)) →
------------------------------------------------------------------
coerce p q (promise op ∣ r ↦ M `in N)
↝
promise_∣_↦_`in_ {o' = lkpᵢ-nextₒ q r}
{i' = lkpᵢ-nextᵢ q r}
op
(lkpᵢ-next-eq q r)
(coerce (lkpᵢ-next-⊑ₒ q r) (lkpᵢ-next-⊑ᵢ q r) M)
(coerce p q N)
| {
"alphanum_fraction": 0.2596823854,
"avg_line_length": 34.5714285714,
"ext": "agda",
"hexsha": "7c1a66f17b14de6ad54a98ed96dfb6612885bbac",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "71ebed9f90a3eb37ae6cd209457bae23a4d122d1",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "danelahman/aeff-agda",
"max_forks_repo_path": "Preservation.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "71ebed9f90a3eb37ae6cd209457bae23a4d122d1",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "danelahman/aeff-agda",
"max_issues_repo_path": "Preservation.agda",
"max_line_length": 110,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "71ebed9f90a3eb37ae6cd209457bae23a4d122d1",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "danelahman/aeff-agda",
"max_stars_repo_path": "Preservation.agda",
"max_stars_repo_stars_event_max_datetime": "2021-03-22T22:48:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-07-17T00:15:00.000Z",
"num_tokens": 3985,
"size": 12342
} |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
{- Proof that if [A] and [B] are two propositions, then so is [A * B]. -}
module homotopy.PropJoinProp
{i} {A : Type i} (pA : is-prop A)
{j} {B : Type j} (pB : is-prop B) where
contr-left : (a : A) → is-contr (A * B)
contr-left a = left a , Pushout-elim
(λ a' → ap left (prop-has-all-paths pA a a'))
(λ b' → glue (a , b'))
(λ {(a' , b') → ↓-cst=idf-in' $ ! $
↓-app=cst-out (apd (λ a → glue (a , b')) (prop-has-all-paths pA a a'))})
contr-right : (b : B) → is-contr (A * B)
contr-right b = right b , Pushout-elim
(λ a' → ! (glue (a' , b)))
(λ b' → ap right (prop-has-all-paths pB b b'))
(λ {(a' , b') → ↓-cst=idf-in' $
! (glue (a' , b)) ∙ glue (a' , b')
=⟨ ! (↓-cst=app-out' $ apd (λ b → glue (a' , b)) (prop-has-all-paths pB b b'))
|in-ctx ! (glue (a' , b)) ∙_ ⟩
! (glue (a' , b)) ∙ glue (a' , b) ∙ ap right (prop-has-all-paths pB b b')
=⟨ ! $ ∙-assoc (! (glue (a' , b))) (glue (a' , b)) (ap right (prop-has-all-paths pB b b')) ⟩
(! (glue (a' , b)) ∙ glue (a' , b)) ∙ ap right (prop-has-all-paths pB b b')
=⟨ !-inv-l (glue (a' , b)) |in-ctx _∙ ap right (prop-has-all-paths pB b b') ⟩
ap right (prop-has-all-paths pB b b')
=∎})
prop*prop-is-prop : is-prop (A * B)
prop*prop-is-prop = inhab-to-contr-is-prop $
Pushout-rec contr-left contr-right (λ _ → prop-has-all-paths is-contr-is-prop _ _)
| {
"alphanum_fraction": 0.5175561798,
"avg_line_length": 39.5555555556,
"ext": "agda",
"hexsha": "1c07c86a8cf521a3443549b005f3728f98836e00",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2018-12-26T21:31:57.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-12-26T21:31:57.000Z",
"max_forks_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "mikeshulman/HoTT-Agda",
"max_forks_repo_path": "theorems/homotopy/PropJoinProp.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "mikeshulman/HoTT-Agda",
"max_issues_repo_path": "theorems/homotopy/PropJoinProp.agda",
"max_line_length": 98,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "mikeshulman/HoTT-Agda",
"max_stars_repo_path": "theorems/homotopy/PropJoinProp.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 587,
"size": 1424
} |
module Categories.Comonad where
| {
"alphanum_fraction": 0.875,
"avg_line_length": 16,
"ext": "agda",
"hexsha": "ed3c45de4aabcb7200c9e5e9a66599f987477f90",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "p-pavel/categories",
"max_forks_repo_path": "Categories/Comonad.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "p-pavel/categories",
"max_issues_repo_path": "Categories/Comonad.agda",
"max_line_length": 31,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "p-pavel/categories",
"max_stars_repo_path": "Categories/Comonad.agda",
"max_stars_repo_stars_event_max_datetime": "2018-12-29T21:51:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-12-29T21:51:57.000Z",
"num_tokens": 7,
"size": 32
} |
{-# OPTIONS --cubical --safe --postfix-projections #-}
module Data.Binary.Skew where
open import Prelude
open import Data.Nat
open import Data.List
𝔹 : Type
𝔹 = List ℕ
inc : 𝔹 → 𝔹
inc [] = zero ∷ []
inc (x ∷ []) = zero ∷ x ∷ []
inc (x₁ ∷ zero ∷ xs) = suc x₁ ∷ xs
inc (x₁ ∷ suc x₂ ∷ xs) = zero ∷ x₁ ∷ x₂ ∷ xs
⟦_⇑⟧ : ℕ → 𝔹
⟦ zero ⇑⟧ = []
⟦ suc n ⇑⟧ = inc ⟦ n ⇑⟧
skew : ℕ → ℕ
skew n = suc (n + n)
w : ℕ → ℕ → ℕ
w zero a = a
w (suc n) a = skew (w n a)
⟦_∷_⇓⟧^ : ℕ → (ℕ → ℕ) → ℕ → ℕ
⟦ x ∷ xs ⇓⟧^ a = let a′ = w x a in a′ + xs (skew a′)
⟦_⇓⟧ : 𝔹 → ℕ
⟦ [] ⇓⟧ = zero
⟦ x ∷ xs ⇓⟧ = let a = w x 1 in a + foldr ⟦_∷_⇓⟧^ (const zero) xs a
-- open import Path.Reasoning
-- import Data.Nat.Properties as ℕ
-- inc-suc : ∀ x → ⟦ inc x ⇓⟧ ≡ suc ⟦ x ⇓⟧
-- inc-suc [] = refl
-- inc-suc (x ∷ []) = refl
-- inc-suc (x ∷ zero ∷ xs) = cong suc (ℕ.+-assoc (w x 1) (w x 1) _)
-- inc-suc (x₁ ∷ suc x₂ ∷ xs) = cong suc (cong (w x₁ 1 +_) {!!})
-- 𝔹-rightInv : ∀ x → ⟦ ⟦ x ⇑⟧ ⇓⟧ ≡ x
-- 𝔹-rightInv zero = refl
-- 𝔹-rightInv (suc x) = {!!}
-- 𝔹-leftInv : ∀ x → ⟦ ⟦ x ⇓⟧ ⇑⟧ ≡ x
-- 𝔹-leftInv [] = refl
-- 𝔹-leftInv (x ∷ xs) = {!!}
-- 𝔹⇔ℕ : 𝔹 ⇔ ℕ
-- 𝔹⇔ℕ .fun = ⟦_⇓⟧
-- 𝔹⇔ℕ .inv = ⟦_⇑⟧
-- 𝔹⇔ℕ .rightInv x = {!!}
-- 𝔹⇔ℕ .leftInv = {!!}
| {
"alphanum_fraction": 0.464811784,
"avg_line_length": 21.0689655172,
"ext": "agda",
"hexsha": "4c5d793527841ccde9a8623e522dd6a853f76bd6",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "oisdk/agda-playground",
"max_forks_repo_path": "Data/Binary/Skew.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "oisdk/agda-playground",
"max_issues_repo_path": "Data/Binary/Skew.agda",
"max_line_length": 70,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "oisdk/agda-playground",
"max_stars_repo_path": "Data/Binary/Skew.agda",
"max_stars_repo_stars_event_max_datetime": "2021-11-16T08:11:34.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-09-11T17:45:41.000Z",
"num_tokens": 668,
"size": 1222
} |
-- Andreas, 2011-05-30
-- {-# OPTIONS -v tc.lhs.unify:50 #-}
module Issue292c where
data ⊥ : Set where
infix 3 ¬_
¬_ : Set → Set
¬ P = P → ⊥
infix 4 _≅_
data _≅_ {A : Set} (x : A) : ∀ {B : Set} → B → Set where
refl : x ≅ x
record Σ (A : Set) (B : A → Set) : Set where
constructor _,_
field
proj₁ : A
proj₂ : B proj₁
open Σ public
data Bool : Set where true false : Bool
data Unit1 : Set where unit1 : Unit1
data Unit2 : Set where unit2 : Unit2
D : Bool -> Set
D true = Unit1
D false = Unit2
P : Set -> Set
P S = Σ S (\s → s ≅ unit1)
pbool : P (D true)
pbool = unit1 , refl
¬pbool2 : ¬ P (D false)
¬pbool2 ( unit2 , () )
{- expected error
unit2 ≅ unit1 should be empty, but that's not obvious to me
when checking that the clause ¬pbool2 (unit2 , ()) has type
¬ P (D false)
-}
| {
"alphanum_fraction": 0.5957711443,
"avg_line_length": 16.75,
"ext": "agda",
"hexsha": "bd804f61a4fc6d49cdb9e2a0c408753ec75904da",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Fail/Issue292c.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Fail/Issue292c.agda",
"max_line_length": 59,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Fail/Issue292c.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 306,
"size": 804
} |
{-
This second-order term syntax was created from the following second-order syntax description:
syntax FOL
type
* : 0-ary
N : 0-ary
term
false : * | ⊥
or : * * -> * | _∨_ l20
true : * | ⊤
and : * * -> * | _∧_ l20
not : * -> * | ¬_ r50
eq : N N -> * | _≟_ l20
all : N.* -> * | ∀′
ex : N.* -> * | ∃′
theory
(⊥U∨ᴸ) a |> or (false, a) = a
(⊥U∨ᴿ) a |> or (a, false) = a
(∨A) a b c |> or (or(a, b), c) = or (a, or(b, c))
(∨C) a b |> or(a, b) = or(b, a)
(⊤U∧ᴸ) a |> and (true, a) = a
(⊤U∧ᴿ) a |> and (a, true) = a
(∧A) a b c |> and (and(a, b), c) = and (a, and(b, c))
(∧D∨ᴸ) a b c |> and (a, or (b, c)) = or (and(a, b), and(a, c))
(∧D∨ᴿ) a b c |> and (or (a, b), c) = or (and(a, c), and(b, c))
(∨B∧ᴸ) a b |> or (and (a, b), a) = a
(∨B∧ᴿ) a b |> or (a, and (a, b)) = a
(∧B∨ᴸ) a b |> and (or (a, b), a) = a
(∧B∨ᴿ) a b |> and (a, or (a, b)) = a
(⊥X∧ᴸ) a |> and (false, a) = false
(⊥X∧ᴿ) a |> and (a, false) = false
(¬N∨ᴸ) a |> or (not (a), a) = false
(¬N∨ᴿ) a |> or (a, not (a)) = false
(∧C) a b |> and(a, b) = and(b, a)
(∨I) a |> or(a, a) = a
(∧I) a |> and(a, a) = a
(¬²) a |> not(not (a)) = a
(∨D∧ᴸ) a b c |> or (a, and (b, c)) = and (or(a, b), or(a, c))
(∨D∧ᴿ) a b c |> or (and (a, b), c) = and (or(a, c), or(b, c))
(⊤X∨ᴸ) a |> or (true, a) = true
(⊤X∨ᴿ) a |> or (a, true) = true
(¬N∧ᴸ) a |> and (not (a), a) = false
(¬N∧ᴿ) a |> and (a, not (a)) = false
(DM∧) a b |> not (and (a, b)) = or (not(a), not(b))
(DM∨) a b |> not (or (a, b)) = and (not(a), not(b))
(DM∀) p : N.* |> not (all (x. p[x])) = ex (x. not(p[x]))
(DM∃) p : N.* |> not (ex (x. p[x])) = all (x. not(p[x]))
(∀D∧) p q : N.* |> all (x. and(p[x], q[x])) = and (all(x.p[x]), all(x.q[x]))
(∃D∨) p q : N.* |> ex (x. or(p[x], q[x])) = or (ex(x.p[x]), ex(x.q[x]))
(∧P∀ᴸ) p : * q : N.* |> and (p, all(x.q[x])) = all (x. and(p, q[x]))
(∧P∃ᴸ) p : * q : N.* |> and (p, ex (x.q[x])) = ex (x. and(p, q[x]))
(∨P∀ᴸ) p : * q : N.* |> or (p, all(x.q[x])) = all (x. or (p, q[x]))
(∨P∃ᴸ) p : * q : N.* |> or (p, ex (x.q[x])) = ex (x. or (p, q[x]))
(∧P∀ᴿ) p : N.* q : * |> and (all(x.p[x]), q) = all (x. and(p[x], q))
(∧P∃ᴿ) p : N.* q : * |> and (ex (x.p[x]), q) = ex (x. and(p[x], q))
(∨P∀ᴿ) p : N.* q : * |> or (all(x.p[x]), q) = all (x. or (p[x], q))
(∨P∃ᴿ) p : N.* q : * |> or (ex (x.p[x]), q) = ex (x. or (p[x], q))
(∀Eᴸ) p : N.* n : N |> all (x.p[x]) = and (p[n], all(x.p[x]))
(∃Eᴸ) p : N.* n : N |> ex (x.p[x]) = or (p[n], ex (x.p[x]))
(∀Eᴿ) p : N.* n : N |> all (x.p[x]) = and (all(x.p[x]), p[n])
(∃Eᴿ) p : N.* n : N |> ex (x.p[x]) = or (ex (x.p[x]), p[n])
(∃⟹) p : N.* q : * |> imp (ex (x.p[x]), q) = all (x. imp(p[x], q))
(∀⟹) p : N.* q : * |> imp (all(x.p[x]), q) = ex (x. imp(p[x], q))
-}
module FOL.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 FOL.Signature
private
variable
Γ Δ Π : Ctx
α : FOLT
𝔛 : Familyₛ
-- Inductive term declaration
module FOL:Terms (𝔛 : Familyₛ) where
data FOL : Familyₛ where
var : ℐ ⇾̣ FOL
mvar : 𝔛 α Π → Sub FOL Π Γ → FOL α Γ
⊥ : FOL * Γ
_∨_ : FOL * Γ → FOL * Γ → FOL * Γ
⊤ : FOL * Γ
_∧_ : FOL * Γ → FOL * Γ → FOL * Γ
¬_ : FOL * Γ → FOL * Γ
_≟_ : FOL N Γ → FOL N Γ → FOL * Γ
∀′ : FOL * (N ∙ Γ) → FOL * Γ
∃′ : FOL * (N ∙ Γ) → FOL * Γ
infixl 20 _∨_
infixl 20 _∧_
infixr 50 ¬_
infixl 20 _≟_
open import SOAS.Metatheory.MetaAlgebra ⅀F 𝔛
FOLᵃ : MetaAlg FOL
FOLᵃ = record
{ 𝑎𝑙𝑔 = λ where
(falseₒ ⋮ _) → ⊥
(orₒ ⋮ a , b) → _∨_ a b
(trueₒ ⋮ _) → ⊤
(andₒ ⋮ a , b) → _∧_ a b
(notₒ ⋮ a) → ¬_ a
(eqₒ ⋮ a , b) → _≟_ a b
(allₒ ⋮ a) → ∀′ a
(exₒ ⋮ a) → ∃′ a
; 𝑣𝑎𝑟 = var ; 𝑚𝑣𝑎𝑟 = λ 𝔪 mε → mvar 𝔪 (tabulate mε) }
module FOLᵃ = MetaAlg FOLᵃ
module _ {𝒜 : Familyₛ}(𝒜ᵃ : MetaAlg 𝒜) where
open MetaAlg 𝒜ᵃ
𝕤𝕖𝕞 : FOL ⇾̣ 𝒜
𝕊 : Sub FOL Π Γ → Π ~[ 𝒜 ]↝ Γ
𝕊 (t ◂ σ) new = 𝕤𝕖𝕞 t
𝕊 (t ◂ σ) (old v) = 𝕊 σ v
𝕤𝕖𝕞 (mvar 𝔪 mε) = 𝑚𝑣𝑎𝑟 𝔪 (𝕊 mε)
𝕤𝕖𝕞 (var v) = 𝑣𝑎𝑟 v
𝕤𝕖𝕞 ⊥ = 𝑎𝑙𝑔 (falseₒ ⋮ tt)
𝕤𝕖𝕞 (_∨_ a b) = 𝑎𝑙𝑔 (orₒ ⋮ 𝕤𝕖𝕞 a , 𝕤𝕖𝕞 b)
𝕤𝕖𝕞 ⊤ = 𝑎𝑙𝑔 (trueₒ ⋮ tt)
𝕤𝕖𝕞 (_∧_ a b) = 𝑎𝑙𝑔 (andₒ ⋮ 𝕤𝕖𝕞 a , 𝕤𝕖𝕞 b)
𝕤𝕖𝕞 (¬_ a) = 𝑎𝑙𝑔 (notₒ ⋮ 𝕤𝕖𝕞 a)
𝕤𝕖𝕞 (_≟_ a b) = 𝑎𝑙𝑔 (eqₒ ⋮ 𝕤𝕖𝕞 a , 𝕤𝕖𝕞 b)
𝕤𝕖𝕞 (∀′ a) = 𝑎𝑙𝑔 (allₒ ⋮ 𝕤𝕖𝕞 a)
𝕤𝕖𝕞 (∃′ a) = 𝑎𝑙𝑔 (exₒ ⋮ 𝕤𝕖𝕞 a)
𝕤𝕖𝕞ᵃ⇒ : MetaAlg⇒ FOLᵃ 𝒜ᵃ 𝕤𝕖𝕞
𝕤𝕖𝕞ᵃ⇒ = record
{ ⟨𝑎𝑙𝑔⟩ = λ{ {t = t} → ⟨𝑎𝑙𝑔⟩ t }
; ⟨𝑣𝑎𝑟⟩ = refl
; ⟨𝑚𝑣𝑎𝑟⟩ = λ{ {𝔪 = 𝔪}{mε} → cong (𝑚𝑣𝑎𝑟 𝔪) (dext (𝕊-tab mε)) } }
where
open ≡-Reasoning
⟨𝑎𝑙𝑔⟩ : (t : ⅀ FOL α Γ) → 𝕤𝕖𝕞 (FOLᵃ.𝑎𝑙𝑔 t) ≡ 𝑎𝑙𝑔 (⅀₁ 𝕤𝕖𝕞 t)
⟨𝑎𝑙𝑔⟩ (falseₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (orₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (trueₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (andₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (notₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (eqₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (allₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (exₒ ⋮ _) = refl
𝕊-tab : (mε : Π ~[ FOL ]↝ Γ)(v : ℐ α Π) → 𝕊 (tabulate mε) v ≡ 𝕤𝕖𝕞 (mε v)
𝕊-tab mε new = refl
𝕊-tab mε (old v) = 𝕊-tab (mε ∘ old) v
module _ (g : FOL ⇾̣ 𝒜)(gᵃ⇒ : MetaAlg⇒ FOLᵃ 𝒜ᵃ g) where
open MetaAlg⇒ gᵃ⇒
𝕤𝕖𝕞! : (t : FOL α Γ) → 𝕤𝕖𝕞 t ≡ g t
𝕊-ix : (mε : Sub FOL Π Γ)(v : ℐ α Π) → 𝕊 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 ⟨𝑣𝑎𝑟⟩
𝕤𝕖𝕞! ⊥ = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (_∨_ a b) rewrite 𝕤𝕖𝕞! a | 𝕤𝕖𝕞! b = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! ⊤ = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (_∧_ a b) rewrite 𝕤𝕖𝕞! a | 𝕤𝕖𝕞! b = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (¬_ a) rewrite 𝕤𝕖𝕞! a = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (_≟_ a b) rewrite 𝕤𝕖𝕞! a | 𝕤𝕖𝕞! b = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (∀′ a) rewrite 𝕤𝕖𝕞! a = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (∃′ a) rewrite 𝕤𝕖𝕞! a = sym ⟨𝑎𝑙𝑔⟩
-- Syntax instance for the signature
FOL:Syn : Syntax
FOL:Syn = record
{ ⅀F = ⅀F
; ⅀:CS = ⅀:CompatStr
; mvarᵢ = FOL:Terms.mvar
; 𝕋:Init = λ 𝔛 → let open FOL:Terms 𝔛 in record
{ ⊥ = FOL ⋉ FOLᵃ
; ⊥-is-initial = record { ! = λ{ {𝒜 ⋉ 𝒜ᵃ} → 𝕤𝕖𝕞 𝒜ᵃ ⋉ 𝕤𝕖𝕞ᵃ⇒ 𝒜ᵃ }
; !-unique = λ{ {𝒜 ⋉ 𝒜ᵃ} (f ⋉ fᵃ⇒) {x = t} → 𝕤𝕖𝕞! 𝒜ᵃ f fᵃ⇒ t } } } }
-- Instantiation of the syntax and metatheory
open Syntax FOL:Syn public
open FOL:Terms public
open import SOAS.Families.Build public
open import SOAS.Syntax.Shorthands FOLᵃ public
open import SOAS.Metatheory FOL:Syn public
-- Derived operations
_⟹_ : FOL 𝔛 * Γ → FOL 𝔛 * Γ → FOL 𝔛 * Γ
p ⟹ q = ¬ p ∨ q
| {
"alphanum_fraction": 0.4391971665,
"avg_line_length": 31.9622641509,
"ext": "agda",
"hexsha": "32ffae3d9a781766a9e7b2a399ef7807739d1b44",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2022-01-24T12:49:17.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-09T20:39:59.000Z",
"max_forks_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "JoeyEremondi/agda-soas",
"max_forks_repo_path": "out/FOL/Syntax.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_issues_repo_issues_event_max_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "JoeyEremondi/agda-soas",
"max_issues_repo_path": "out/FOL/Syntax.agda",
"max_line_length": 93,
"max_stars_count": 39,
"max_stars_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "JoeyEremondi/agda-soas",
"max_stars_repo_path": "out/FOL/Syntax.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-19T17:33:12.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-11-09T20:39:55.000Z",
"num_tokens": 4295,
"size": 6776
} |
open import Agda.Builtin.Equality
data ⊥ : Set where
cong : {A B : Set} (f : A → B) {x y : A} → x ≡ y → f x ≡ f y
cong f refl = refl
postulate
funExt : ∀ {A B : Set} {f g : A → B}
→ (∀ x → f x ≡ g x) → f ≡ g
data D : Set where
c1 : D → ⊥ → D
c2 : (⊥ → D) → D
cycle : ∀ {n} → c2 (c1 n) ≡ n → ⊥
cycle ()
d : D
d = c2 λ ()
only-one-D : (x : D) → x ≡ d
only-one-D (c2 x) = cong c2 (funExt (λ ()))
boom : ⊥
boom = cycle (only-one-D (c2 (c1 d)))
| {
"alphanum_fraction": 0.4578833693,
"avg_line_length": 17.1481481481,
"ext": "agda",
"hexsha": "79559c4e1098f340f0daa4049e151cb0be8e0fef",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Fail/Issue4995-UnderappliedConstructor.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Fail/Issue4995-UnderappliedConstructor.agda",
"max_line_length": 60,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Fail/Issue4995-UnderappliedConstructor.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 217,
"size": 463
} |
open import Data.List
open import Data.List.Any
open import Data.Nat as ℕ
data capn-kind : Set where
cKStruct : capn-kind
ckInter : capn-kind
open import Relation.Binary.PropositionalEquality
open Membership (setoid capn-kind)
capn-ctx = List capn-kind
data capn-τ : {Γ : capn-ctx} → Set
data capn-field : {Γ : capn-ctx} → Set
data capn-method : {Γ : capn-ctx} → Set
--While the actual capnp schema supports declaration of structs in any order / arbitrary recursion,
--I am limiting this to reference to structs-declared-so-far. This makes the model simpler, without
--removing any of the power (I think), though it would be less convenient to write code for.
data capn-τ where
cVoid : ∀ {Γ} → capn-τ {Γ}
cBool : ∀ {Γ} → capn-τ {Γ}
cInt8 : ∀ {Γ} → capn-τ {Γ}
cInt16 : ∀ {Γ} → capn-τ {Γ}
cInt32 : ∀ {Γ} → capn-τ {Γ}
cInt64 : ∀ {Γ} → capn-τ {Γ}
cUInt8 : ∀ {Γ} → capn-τ {Γ}
cUInt16 : ∀ {Γ} → capn-τ {Γ}
cUInt32 : ∀ {Γ} → capn-τ {Γ}
cUInt64 : ∀ {Γ} → capn-τ {Γ}
cFloat32 : ∀ {Γ} → capn-τ {Γ}
cFloat64 : ∀ {Γ} → capn-τ {Γ}
cData : ∀ {Γ} → capn-τ {Γ}
cText : ∀ {Γ} → capn-τ {Γ}
cList : ∀ {Γ} → capn-τ {Γ} → capn-τ {Γ}
cStruct : ∀ {Γ} → List (capn-field {cKStruct ∷ Γ}) → capn-τ {cKStruct ∷ Γ}
cEnum : ∀ {Γ} → ℕ → capn-τ {Γ}
cVar : ∀ {Γ k} → (k ∈ Γ) → capn-τ {Γ}
cInterface : ∀ {Γ} → List (capn-method {ckInter ∷ Γ}) → capn-τ {ckInter ∷ Γ}
--I'm ignoring field names, because fields can be indexed by list position, which is enough for proofs
--I'm also ignoring groups, since they are just an addressing convenience
data capn-field where
cField : ∀ {Γ} → capn-τ {Γ} → capn-field {Γ}
cUnion : ∀ {Γ} → List (capn-field {Γ})→ capn-field {Γ}
cAny : ∀ {Γ} → capn-field {Γ}
data capn-method where
cMeth : ∀ {Γ} → List (capn-τ {Γ}) → List (capn-τ {Γ}) → capn-method {Γ}
| {
"alphanum_fraction": 0.587276551,
"avg_line_length": 39.625,
"ext": "agda",
"hexsha": "e0027a2aeb8650b6b3e3bdb54dc3d2f5327fca4e",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2019-03-18T13:51:18.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-01-12T23:35:10.000Z",
"max_forks_repo_head_hexsha": "0348b702860f1252458e657001989c154030f03c",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "maurer/holmes",
"max_forks_repo_path": "formal/capnproto.agda",
"max_issues_count": 21,
"max_issues_repo_head_hexsha": "0348b702860f1252458e657001989c154030f03c",
"max_issues_repo_issues_event_max_datetime": "2017-12-08T02:45:23.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-12-13T11:15:04.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "maurer/holmes",
"max_issues_repo_path": "formal/capnproto.agda",
"max_line_length": 102,
"max_stars_count": 27,
"max_stars_repo_head_hexsha": "0348b702860f1252458e657001989c154030f03c",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "maurer/holmes",
"max_stars_repo_path": "formal/capnproto.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-14T22:21:39.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-11-24T18:04:01.000Z",
"num_tokens": 788,
"size": 1902
} |
{- This file contains a direct proof that the Brunerie number (the
number n s.t. π₄(S³)≅ℤ/nℤ) is 2, not relying on any of the more
advanced constructions in chapters 4-6 in Brunerie's thesis (but still
using chapters 1-3 for the construction). The Brunerie number is defined via
S³ ≃ S¹ * S¹ -ᵂ→ S² ∨ S² -ᶠᵒˡᵈ→ S²
where * denotes the join, ∨ denotes the wedge sum, W is the Whitehead
map (see joinTo⋁ in Cubical.Homotopy.Whitehead) and the final map is
just the folding map. η := ∣ fold ∘ W ∣₀ defines an element of π₃(S²).
The (absolute value) of the Brunerie number is given by the absolute
value of ϕ(η) for any iso π₃(S²)≅ℤ. The reason it's hard to prove
ϕ(η) = ± 2 directly is mainly because the equivalence S³ ≃ S¹ * S¹
complicates things. In this file, we try to work around this problem.
The proof goes as follows.
1. Define π₃*(A) := ∥ S¹ * S¹ →∙ A ∥₀ and define explicitly an
addition on this type. Prove that the equivalence π₃(A) ≃ π₃*(A) is
structure preserving, thereby giving a group structure on π₃*(A) and a
group iso π₃*(A) ≅ π₃(A)
2. Under this iso, η gets mapped to η₁ (by construction) defined by
S¹ * S¹ -ᵂ→ S² ∨ S² -ᶠᵒˡᵈ→ S²
which is much easier to work with.
3. Define a sequence of equivalences
π₃*(S²) ≅ π₃*(S¹ * S¹) ≅ π₃*(S³) ≅ π₃(S³) ≅ ℤ
and trace η₁ in each step, proving that it ends up at -2. It turns out
that that the iso S³ ≃ S¹ * S¹, which has been relatively explicitly
defined in Cubical.HITs.Sphere.Properties, kills off a good deal of
``annoying'' terms on the way, making the proof rather straightforward.
4. Conclude that π₄(S³) ≅ ℤ/2ℤ.
-}
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Homotopy.Group.Pi4S3.QuickProof where
open import Cubical.Homotopy.Loopspace
open import Cubical.Homotopy.Group.Base
open import Cubical.Homotopy.Group.Pi3S2
open import Cubical.Homotopy.Group.PinSn
open import Cubical.Homotopy.Hopf
open import Cubical.Homotopy.Whitehead using (joinTo⋁)
open import Cubical.Homotopy.Connected
open import Cubical.Homotopy.HopfInvariant.HopfMap using (hopfMap≡HopfMap')
-- Only imports a simple equality of two constructions of the Hopf map.
open import Cubical.Homotopy.Group.Pi4S3.BrunerieNumber
using (fold∘W ; coFib-fold∘W∙ ; π₄S³≅π₃coFib-fold∘W∙ ; S³→S²→Pushout→Unit)
-- Only imports definitions/proofs from chapter 1-3 in Brunerie's thesis
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.GroupoidLaws renaming (assoc to ∙assoc)
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Function
open import Cubical.Data.Sigma
open import Cubical.Data.Nat
open import Cubical.Data.Int
renaming (ℤ to Z ; _·_ to _·Z_ ; _+_ to _+Z_)
open import Cubical.HITs.S1 renaming (_·_ to _*_)
open import Cubical.HITs.Sn
open import Cubical.HITs.Susp renaming (toSusp to σ)
open import Cubical.HITs.Join hiding (joinS¹S¹→S³)
open import Cubical.HITs.Wedge
open import Cubical.HITs.Pushout
open import Cubical.HITs.SetTruncation
renaming (rec2 to sRec2 ; elim to sElim ; elim2 to sElim2 ; map to sMap)
open import Cubical.HITs.Truncation renaming (rec to trRec)
open import Cubical.Algebra.Group
open import Cubical.Algebra.Group.Exact
open import Cubical.Algebra.Group.ZAction
open import Cubical.Algebra.Group.Instances.IntMod
open S¹Hopf
open Iso
open GroupStr
private
variable
ℓ : Level
A B : Pointed ℓ
-- Some abbreviations and simple lemmas
private
σ₁ = σ (S₊∙ 1)
σ₂ = σ (S₊∙ 2)
σ-filler : ∀ {ℓ} {A : Type ℓ} (x y : A) (i j : I) → Susp A
σ-filler x y i j = compPath-filler (merid x) (sym (merid y)) i j
to3ConnectedId : {f g : A →∙ B}
→ (isConnected 3 (typ B)) → fst f ≡ fst g → ∣ f ∣₂ ≡ ∣ g ∣₂
to3ConnectedId {f = f} {g = g} con p =
trRec (squash₂ _ _)
(λ q → cong ∣_∣₂ (ΣPathP (p , q)))
(fst (isConnectedPathP 1 (isConnectedPath 2 con _ _) (snd f) (snd g)))
connS³ : isConnected 3 (S₊ 3)
connS³ =
isConnectedSubtr 3 1 (sphereConnected 3)
con-joinS¹S¹ : isConnected 3 (join S¹ S¹)
con-joinS¹S¹ =
(isConnectedRetractFromIso 3
(IsoSphereJoin 1 1)
(isConnectedSubtr 3 1 (sphereConnected 3)))
-- Key goal: prove that the following element of π₃(S²) gets mapped to -2
η : π' 3 (S₊∙ 2)
η = fst (π'∘∙Hom 2 (fold∘W , refl)) ∣ id∙ (S₊∙ 3) ∣₂
{- Step 1. Define an addition on π₃*(A) := ∥ S¹ * S¹ →∙ A ∥₀ -}
-- On the underlying function spaces.
_+join_ : (f g : (join S¹ S¹ , inl base) →∙ A)
→ (join S¹ S¹ , inl base) →∙ A
fst (f +join g) (inl x) = fst f (inl x)
fst (f +join g) (inr x) = fst g (inr x)
fst (f +join g) (push a b i) =
(cong (fst f) (push a b ∙ sym (push base b))
∙∙ snd f ∙ sym (snd g)
∙∙ cong (fst g) (push base base ∙∙ sym (push a base) ∙∙ push a b)) i
snd (f +join g) = snd f
-- Homotopy group version
_π₃*+_ : (f g : ∥ (join S¹ S¹ , inl base) →∙ S₊∙ 2 ∥₂)
→ ∥ (join S¹ S¹ , inl base) →∙ S₊∙ 2 ∥₂
_π₃*+_ = sRec2 squash₂ λ x y → ∣ x +join y ∣₂
-- transferring between π₃ and π₃*
-- (homotopy groups defined in terms of S¹ * S¹)
joinify : S₊∙ 3 →∙ A → (join S¹ S¹ , inl base) →∙ A
fst (joinify f) x = fst f (joinS¹S¹→S³ x)
snd (joinify f) = snd f
disjoin : (join S¹ S¹ , inl base) →∙ A → S₊∙ 3 →∙ A
fst (disjoin f) = λ x → fst f (Iso.inv (IsoSphereJoin 1 1) x)
snd (disjoin f) = snd f
-- joinify is structure preserving
+join≡∙Π : (f g : S₊∙ 3 →∙ A)
→ joinify (∙Π f g)
≡ (joinify f +join joinify g)
+join≡∙Π f' g' =
ΣPathP ((funExt (λ { (inl x) → sym fp
; (inr x) → sym gp ∙ cong g (merid north)
; (push a b i) j → main a b j i}))
, λ i j → fp (j ∨ ~ i))
where
f = fst f'
g = fst g'
fp = snd f'
gp = snd g'
path-lem : ∀ {ℓ} {A : Type ℓ} {x y z w u : A}
(p : x ≡ y) (q : y ≡ z) (r : z ≡ w) (s : w ≡ u)
→ (refl ∙∙ p ∙∙ q) ∙ (r ∙∙ s ∙∙ refl)
≡ (p ∙∙ (q ∙ r) ∙∙ s)
path-lem p q r s =
cong ((p ∙ q) ∙_) (sym (compPath≡compPath' r s))
∙∙ sym (∙assoc p q (r ∙ s))
∙∙ cong (p ∙_) (∙assoc q r s)
∙ sym (doubleCompPath≡compPath p (q ∙ r) s)
main-helper : (a b : S¹)
→ Square ((refl ∙∙ cong f (σ₂ (S¹×S¹→S² a b)) ∙∙ fp)
∙ (sym gp ∙∙ cong g (σ₂ (S¹×S¹→S² a b)) ∙∙ refl))
((cong f (merid (S¹×S¹→S² a b))
∙ sym (cong f (merid north)))
∙∙ (fp ∙ sym gp)
∙∙ cong g (merid (S¹×S¹→S² a b)))
(λ _ → f north)
(cong g (merid north))
main-helper a b =
path-lem (cong f (σ₂ (S¹×S¹→S² a b))) fp (sym gp)
(cong g (σ₂ (S¹×S¹→S² a b)))
◁ lem
where
lem : PathP (λ i → f north ≡ cong g (merid north) i)
((λ i → f (σ₂ (S¹×S¹→S² a b) i))
∙∙ fp ∙ (sym gp) ∙∙
(cong g (σ₂ (S¹×S¹→S² a b))))
((cong f (merid (S¹×S¹→S² a b)) ∙ sym (cong f (merid north)))
∙∙ fp ∙ sym gp
∙∙ cong g (merid (S¹×S¹→S² a b)))
lem i j =
hcomp (λ k → λ { (i = i0) →
(cong-∙ f (merid (S¹×S¹→S² a b))
(sym (merid north)) (~ k)
∙∙ fp ∙ sym gp
∙∙ (λ i → g (σ-filler (S¹×S¹→S² a b) north k i))) j
; (i = i1) → ((cong f (merid (S¹×S¹→S² a b))
∙ sym (cong f (merid north)))
∙∙ (fp ∙ sym gp)
∙∙ cong g (merid (S¹×S¹→S² a b))) j
; (j = i0) → f north
; (j = i1) → g (merid north (~ k ∨ i))})
(((cong f (merid (S¹×S¹→S² a b)) ∙ sym (cong f (merid north)))
∙∙ (fp ∙ sym gp)
∙∙ cong g (merid (S¹×S¹→S² a b))) j)
main-helper₂ : (a b : S¹)
→ cong (fst (joinify g')) (push base base ∙∙ sym (push a base) ∙∙ push a b)
≡ cong g (merid (S¹×S¹→S² a b))
main-helper₂ a b = cong-∙∙ (fst (joinify g'))
(push base base) (sym (push a base)) (push a b)
∙ cong (cong g (merid north) ∙∙_∙∙ cong g (merid (S¹×S¹→S² a b)))
(cong (cong g) (cong sym (cong merid (S¹×S¹→S²rUnit a))))
∙ ((λ i → (cong g (λ j → merid north (j ∧ ~ i)))
∙∙ (cong g (λ j → merid north (~ j ∧ ~ i)))
∙∙ cong g (merid (S¹×S¹→S² a b)))
∙ sym (lUnit (cong g (merid (S¹×S¹→S² a b)))))
main : (a b : S¹)
→ PathP (λ i → fp (~ i) ≡ (sym gp ∙ cong g (merid north)) i)
((sym fp ∙∙ cong f (σ₂ (S¹×S¹→S² a b)) ∙∙ fp)
∙ (sym gp ∙∙ cong g (σ₂ (S¹×S¹→S² a b)) ∙∙ gp))
((cong (fst (joinify f')) (push a b ∙ sym (push base b))
∙∙ fp ∙ sym gp
∙∙ cong (fst (joinify g'))
(push base base ∙∙ sym (push a base) ∙∙ push a b)))
main a b =
((λ i j → hcomp (λ k → λ {(i = i0) → (((λ j → fp (~ j ∧ k))
∙∙ cong f (σ₂ (S¹×S¹→S² a b))
∙∙ fp)
∙ (sym gp
∙∙ cong g (σ₂ (S¹×S¹→S² a b))
∙∙ λ j → gp (j ∧ k))) j
; (i = i1) → ((cong f (merid (S¹×S¹→S² a b))
∙ sym (cong f (merid north)))
∙∙ fp ∙ sym gp
∙∙ cong g (merid (S¹×S¹→S² a b))) j
; (j = i0) → fp (~ i ∧ k)
; (j = i1) → compPath-filler'
(sym gp) (cong g (merid north)) k i})
(main-helper a b i j)))
▷ λ i →
cong-∙ (fst (joinify f')) (push a b) (sym (push base b)) (~ i)
∙∙ fp ∙ sym gp
∙∙ main-helper₂ a b (~ i)
-- Group structure on π₃*
-- todo: remove connectivity assumption
module _ (A : Pointed ℓ) (con : (isConnected 3 (typ A))) where
π₃*Iso : Iso (typ (π'Gr 2 A)) ∥ (join S¹ S¹ , inl base) →∙ A ∥₂
fun π₃*Iso = sMap joinify
inv π₃*Iso = sMap disjoin
rightInv π₃*Iso =
sElim (λ _ → isSetPathImplicit)
λ f → to3ConnectedId
con (funExt λ x → cong (fst f) (Iso.leftInv (IsoSphereJoin 1 1) x))
leftInv π₃*Iso =
sElim (λ _ → isSetPathImplicit)
λ f → to3ConnectedId
con (funExt (λ x → cong (fst f) (Iso.rightInv (IsoSphereJoin 1 1) x)))
π₃* : Group ℓ
π₃* = InducedGroup (π'Gr 2 A) (sRec2 squash₂ (λ x y → ∣ x +join y ∣₂))
(isoToEquiv π₃*Iso)
(sElim2 (λ _ _ → isSetPathImplicit) (λ f g → cong ∣_∣₂ (+join≡∙Π f g)))
π₃≅π₃* : GroupEquiv (π'Gr 2 A) π₃*
π₃≅π₃* =
InducedGroupEquiv (π'Gr 2 A) (sRec2 squash₂ (λ x y → ∣ x +join y ∣₂))
(isoToEquiv π₃*Iso)
(sElim2 (λ _ _ → isSetPathImplicit) (λ f g → cong ∣_∣₂ (+join≡∙Π f g)))
-- Induced homomorphisms (A →∙ B) → (π₃*(A) → π₃*(B))
-- todo: remove connectivity assumptions
module _ (conA : (isConnected 3 (typ A))) (conB : (isConnected 3 (typ B)))
(f : A →∙ B) where
postCompπ₃* : GroupHom (π₃* A conA) (π₃* B conB)
fst postCompπ₃* = sMap (f ∘∙_)
snd postCompπ₃* =
makeIsGroupHom
(sElim2 (λ _ _ → isSetPathImplicit)
λ h g → to3ConnectedId conB
(funExt λ { (inl x) → refl
; (inr x) → refl
; (push a b i) j →
(cong-∙∙ (fst f)
(cong (fst h) ((push a b ∙ (sym (push base b)))))
(snd h ∙ (sym (snd g)))
(cong (fst g) ((push base base
∙∙ (sym (push a base))
∙∙ push a b)))
∙ cong (cong (fst f)
(cong (fst h) (push a b ∙ (sym (push base b))))
∙∙_∙∙
cong (fst f ∘ fst g)
((push base base ∙∙ (sym (push a base)) ∙∙ push a b)))
(cong-∙ (fst f) (snd h) (sym (snd g))
∙ λ j → compPath-filler (cong (fst f) (snd h)) (snd f) j
∙ sym (compPath-filler
(cong (fst f) (snd g)) (snd f) j))) j i}))
-- Induced iso (A ≃∙ B) → π₃*(A) ≅ π₃*(B)
-- todo: remove connectivity assumptions
module _ (conA : (isConnected 3 (typ A))) (conB : (isConnected 3 (typ B)))
(f : A ≃∙ B) where
postCompπ₃*Equiv : GroupEquiv (π₃* A conA) (π₃* B conB)
fst postCompπ₃*Equiv = isoToEquiv h
where
h : Iso (π₃* A conA .fst) (π₃* B conB .fst)
fun h = fst (postCompπ₃* conA conB (≃∙map f))
inv h = fst (postCompπ₃* conB conA (≃∙map (invEquiv∙ f)))
rightInv h =
sElim (λ _ → isSetPathImplicit)
λ g → to3ConnectedId conB (funExt λ x → secEq (fst f) (fst g x))
leftInv h =
sElim (λ _ → isSetPathImplicit)
λ g → to3ConnectedId conA (funExt λ x → retEq (fst f) (fst g x))
snd postCompπ₃*Equiv = snd (postCompπ₃* conA conB (≃∙map f))
-- The relevant groups (in order of the iso π₃(S²) ≅ ℤ)
π₃S² = π'Gr 2 (S₊∙ 2)
π₃*S² = π₃* (S₊∙ 2) (sphereConnected 2)
π₃*joinS¹S¹ = π₃* (join S¹ S¹ , inl base) con-joinS¹S¹
π₃*S³ = π₃* (S₊∙ 3) connS³
π₃S³ = π'Gr 2 (S₊∙ 3)
{- Goal now: Show that
(η : π₃(S²))
↦ (η₁ : π₃*(S²))
↦ (η₂ : π₃*(S¹ * S¹))
↦ (η₃ : π₃*(S³))
↦ (η₄ : π₃(S³))
↦ (-2 : ℤ)
for some terms η₁ ... η₄ by a sequence of isomorphisms
π₃(S²) ≅ π₃*(S²) ≅ π₃*(S¹ * S¹) ≅ π₃*(S³) ≅ π₃(S³) ≅ ℤ
Hence, there is an is an iso π₃(S²) ≅ ℤ taking η to
-2, from which we can conclude π₄(S³) ≅ ℤ/2ℤ.
-}
-- Underlying functions of (some of) the ηs
η₁-raw : (join S¹ S¹ , inl base) →∙ S₊∙ 2
fst η₁-raw (inl x) = north
fst η₁-raw (inr x) = north
fst η₁-raw (push a b i) = (σ₁ b ∙ σ₁ a) i
snd η₁-raw = refl
η₂-raw : (join S¹ S¹ , inl base) →∙ (join S¹ S¹ , inl base)
fst η₂-raw (inl x) = inr (invLooper x)
fst η₂-raw (inr x) = inr x
fst η₂-raw (push a b i) =
(sym (push (b * invLooper a) (invLooper a))
∙ push (b * invLooper a) b) i
snd η₂-raw = sym (push base base)
η₃-raw : (join S¹ S¹ , inl base) →∙ S₊∙ 3
fst η₃-raw (inl x) = north
fst η₃-raw (inr x) = north
fst η₃-raw (push a b i) =
(sym (σ₂ (S¹×S¹→S² a b)) ∙ sym (σ₂ (S¹×S¹→S² a b))) i
snd η₃-raw = refl
-- Homotopy group versions
η₁ : fst π₃*S²
η₁ = ∣ η₁-raw ∣₂
η₂ : fst (π₃*joinS¹S¹)
η₂ = ∣ η₂-raw ∣₂
η₃ : π₃*S³ .fst
η₃ = ∣ η₃-raw ∣₂
η₄ : fst π₃S³
η₄ = ·π' 2 (-π' 2 ∣ idfun∙ (S₊∙ 3) ∣₂) (-π' 2 ∣ idfun∙ (S₊∙ 3) ∣₂)
-- π₃S²≅π₃*S²
π₃S²→π₃*S² : GroupEquiv π₃S² π₃*S²
π₃S²→π₃*S² = π₃≅π₃* (S₊∙ 2) (sphereConnected 2)
-- Time for π₃*(S¹ * S¹) ≅ π₃*S².
-- We have this iso already, but slightly differently stated,
-- so the following proof becomes a bit technical.
-- We define it in terms a slight variation of the Hopf map
Hopfσ : join S¹ S¹ → S₊ 2
Hopfσ (inl x) = north
Hopfσ (inr x) = north
Hopfσ (push a b i) = σ₁ (invLooper a * b) i
π₃*joinS¹S¹→π₃*S² : GroupHom π₃*joinS¹S¹ π₃*S²
π₃*joinS¹S¹→π₃*S² =
postCompπ₃* con-joinS¹S¹ (sphereConnected 2)
(Hopfσ , refl)
π₃*joinS¹S¹≅π₃*S² : GroupEquiv π₃*joinS¹S¹ π₃*S²
fst (fst π₃*joinS¹S¹≅π₃*S²) = fst π₃*joinS¹S¹→π₃*S²
snd (fst π₃*joinS¹S¹≅π₃*S²) =
subst isEquiv idLem isEquivπ₃*joinS¹S¹→π₃*S²'
where
π₃*joinS¹S¹→π₃*S²' : GroupHom π₃*joinS¹S¹ π₃*S²
π₃*joinS¹S¹→π₃*S²' =
postCompπ₃* con-joinS¹S¹ (sphereConnected 2)
(fst ∘ JoinS¹S¹→TotalHopf , refl)
isEquivπ₃*joinS¹S¹→π₃*S²' : isEquiv (fst π₃*joinS¹S¹→π₃*S²')
isEquivπ₃*joinS¹S¹→π₃*S²' =
transport (λ i → isEquiv (fst (help (~ i))))
(snd (fst GrEq))
where
GrEq = compGroupEquiv (πS³≅πTotalHopf 2) π'₃S²≅π'₃TotalHopf
help : PathP
(λ i → GroupHom
(GroupPath π₃*joinS¹S¹ π₃S³ .fst
(compGroupEquiv
(invGroupEquiv (π₃≅π₃* (join S¹ S¹ , inl base) con-joinS¹S¹))
(π'Iso 2 (isoToEquiv (IsoSphereJoin 1 1) , refl))) i)
(GroupPath π₃*S² π₃S² .fst
(invGroupEquiv (π₃≅π₃* (S₊∙ 2) (sphereConnected 2))) i))
π₃*joinS¹S¹→π₃*S²'
(fst (fst GrEq) , snd GrEq)
help =
toPathP (Σ≡Prop (λ _ → isPropIsGroupHom _ _)
(funExt
λ f → (λ i
→ transportRefl
((invGroupEquiv (π₃≅π₃* (S₊∙ 2) (sphereConnected 2))) .fst .fst
(fst π₃*joinS¹S¹→π₃*S²' (
((fst (fst (π₃≅π₃* (join S¹ S¹ , inl base) con-joinS¹S¹)))
(invEq (fst (π'Iso 2 (isoToEquiv (IsoSphereJoin 1 1) , refl)))
(transportRefl f i)))))) i)
∙ main f))
where
main : (f : _) → invEquiv (fst (π₃≅π₃* (S₊∙ 2) (sphereConnected 2))) .fst
(fst π₃*joinS¹S¹→π₃*S²'
(invEq
(invEquiv (fst (π₃≅π₃* (join S¹ S¹ , inl base) con-joinS¹S¹)))
(invEq (fst (π'Iso 2 (isoToEquiv Iso-joinS¹S¹-S³ , (λ _ → north))))
f)))
≡ fst GrEq .fst f
main = sElim (λ _ → isSetPathImplicit)
λ f → to3ConnectedId (sphereConnected 2)
(funExt λ x
→ (λ i → fst (JoinS¹S¹→TotalHopf (Iso.inv (IsoSphereJoin 1 1)
(fst f (Iso.rightInv (IsoSphereJoin 1 1) x i)))))
∙ sym (funExt⁻ (sym (cong fst hopfMap≡HopfMap'))
(fst f x)))
idLem : fst π₃*joinS¹S¹→π₃*S²' ≡ fst π₃*joinS¹S¹→π₃*S²
idLem =
funExt (sElim (λ _ → isSetPathImplicit)
λ f → to3ConnectedId (sphereConnected 2)
(funExt λ x → lem (fst f x)))
where
lem : (x : _) → fst (JoinS¹S¹→TotalHopf x) ≡ Hopfσ x
lem (inl x) = refl
lem (inr x) = sym (merid base)
lem (push a b i) j =
compPath-filler (merid (invLooper a * b)) (sym (merid base)) j i
snd π₃*joinS¹S¹≅π₃*S² = snd π₃*joinS¹S¹→π₃*S²
-- π₃*(S³) ≅ π₃*(S¹ * S¹)
π₃*S³≅π₃*joinS¹S¹ : GroupEquiv π₃*S³ π₃*joinS¹S¹
π₃*S³≅π₃*joinS¹S¹ =
postCompπ₃*Equiv
connS³ con-joinS¹S¹
(isoToEquiv (invIso (IsoSphereJoin 1 1)) , refl)
-- π₃(S³)≅π₃*(S³)
π₃S³≅π₃*S³ : GroupEquiv π₃S³ π₃*S³
π₃S³≅π₃*S³ = π₃≅π₃* (S₊∙ 3) connS³
η↦η₁ : fst (fst π₃S²→π₃*S²) η ≡ η₁
η↦η₁ = to3ConnectedId (sphereConnected 2)
(funExt λ x → (funExt⁻ lem₁ x) ∙ sym (lem₂ x))
where
lem₁ : fold∘W ∘ joinS¹S¹→S³ ≡ fold⋁ ∘ (joinTo⋁ {A = S₊∙ 1} {B = S₊∙ 1})
lem₁ = funExt λ x
→ cong (fold⋁ ∘ (joinTo⋁ {A = S₊∙ 1} {B = S₊∙ 1}))
(leftInv (IsoSphereJoin 1 1) x)
lem₂ : (x : join S¹ S¹) → fst η₁-raw x ≡ (fold⋁ ∘ joinTo⋁) x
lem₂ (inl x) = refl
lem₂ (inr x) = refl
lem₂ (push a b i) j = help j i
where
help : (σ₁ b ∙ σ₁ a) ≡ cong (fold⋁ ∘ joinTo⋁) (push a b)
help = sym (cong-∙∙ fold⋁ (λ j → inr (σ₁ b j))
(sym (push tt)) (λ j → inl (σ₁ a j))
∙ λ i → (λ j → σ₁ b (j ∧ ~ i))
∙∙ (λ j → σ₁ b (j ∨ ~ i))
∙∙ σ₁ a)
-- We show that η₂ ↦ η₁ (this is easier than η₁ ↦ η₂)
η₂↦η₁ : fst (fst π₃*joinS¹S¹≅π₃*S²) η₂ ≡ η₁
η₂↦η₁ =
to3ConnectedId (sphereConnected 2)
(funExt λ { (inl x) → refl
; (inr x) → refl
; (push a b i) j → main a b j i})
where
lem : (a b : S¹)
→ (sym (σ₁ (invLooper (b * invLooper a) * invLooper a)) ≡ σ₁ b)
× (σ₁ (invLooper (b * invLooper a) * b) ≡ σ₁ a)
fst (lem a b) =
cong sym (cong σ₁ (sym (invLooperDistr (b * invLooper a) a))
∙ σ-invSphere 0 (b * invLooper a * a))
∙ cong σ₁ (sym (assocS¹ b (invLooper a) a)
∙ cong (b *_) (commS¹ _ _ ∙ sym (rCancelS¹ a))
∙ rUnitS¹ b)
snd (lem a b) =
cong σ₁ (cong (_* b) (invLooperDistr b (invLooper a)
∙ cong (invLooper b *_) (invSphere² 1 a)
∙ commS¹ (invLooper b) a)
∙ sym (assocS¹ a (invLooper b) b)
∙ cong (a *_) (commS¹ _ _ ∙ sym (rCancelS¹ b))
∙ rUnitS¹ a)
main : (a b : S¹)
→ cong Hopfσ ((sym (push (b * invLooper a) (invLooper a))
∙ push (b * invLooper a) b))
≡ σ₁ b ∙ σ₁ a
main a b =
cong-∙ Hopfσ (sym (push (b * invLooper a) (invLooper a)))
(push (b * invLooper a) b)
∙ cong₂ _∙_ (fst (lem a b)) (snd (lem a b))
-- We show that η₂ ↦ η₃
η₂↦η₃ : invEq (fst π₃*S³≅π₃*joinS¹S¹) η₂ ≡ η₃
η₂↦η₃ =
to3ConnectedId connS³
(funExt λ x → sym (joinS¹S¹→S³σ≡ (fst η₂-raw x))
∙ lem x)
where
joinS¹S¹→S³σ : join S¹ S¹ → S₊ 3
joinS¹S¹→S³σ (inl x) = north
joinS¹S¹→S³σ (inr x) = north
joinS¹S¹→S³σ (push a b i) = σ₂ (S¹×S¹→S² a b) i
joinS¹S¹→S³σ≡ : (x : _) → joinS¹S¹→S³σ x ≡ joinS¹S¹→S³ x
joinS¹S¹→S³σ≡ (inl x) = refl
joinS¹S¹→S³σ≡ (inr x) = merid north
joinS¹S¹→S³σ≡ (push a b i) j =
compPath-filler (merid (S¹×S¹→S² a b)) (sym (merid north)) (~ j) i
lem : (x : _) → joinS¹S¹→S³σ (fst η₂-raw x) ≡ fst η₃-raw x
lem (inl x) = refl
lem (inr x) = refl
lem (push a b i) j = main j i
where
left-lem : σ₂ (S¹×S¹→S² (b * invLooper a) (invLooper a))
≡ σ₂ (S¹×S¹→S² a b)
left-lem = cong σ₂ (S¹×S¹→S²-Distr b (invLooper a)
∙ sym (S¹×S¹→S²-antiComm a b))
right-lem : σ₂ (S¹×S¹→S² (b * invLooper a) b) ≡ sym (σ₂ (S¹×S¹→S² a b))
right-lem =
cong σ₂ ((cong (λ x → S¹×S¹→S² x b) (commS¹ b (invLooper a))
∙ S¹×S¹→S²-Distr (invLooper a) b)
∙∙ S¹×S¹→S²-antiComm (invLooper a) b
∙∙ invSusp∘S¹×S¹→S² b (invLooper a))
∙∙ σ-invSphere 1 (S¹×S¹→S² b (invLooper a))
∙∙ cong (sym ∘ σ₂) (sym (S¹×S¹→S²-antiComm a b))
main : cong (joinS¹S¹→S³σ ∘ fst η₂-raw) (push a b)
≡ sym (σ₂ (S¹×S¹→S² a b)) ∙ sym (σ₂ (S¹×S¹→S² a b))
main = cong-∙ joinS¹S¹→S³σ
(sym (push (b * invLooper a) (invLooper a)))
(push (b * invLooper a) b)
∙ cong₂ _∙_ (cong sym left-lem) right-lem
-- We show that η₄ ↦ η₃ (this is easier than η₃ ↦ η₄)
η₄↦η₃ : fst (fst π₃S³≅π₃*S³) η₄ ≡ η₃
η₄↦η₃ = IsGroupHom.pres· (snd π₃S³≅π₃*S³)
(-π' 2 ∣ idfun∙ (S₊∙ 3) ∣₂) (-π' 2 ∣ idfun∙ (S₊∙ 3) ∣₂)
∙ cong₂ _+π₃*_ gen↦η₃/2 gen↦η₃/2
∙ η₃/2+η₃/2≡η₃
where
_+π₃*_ : fst π₃*S³ → fst π₃*S³ → fst π₃*S³
_+π₃*_ = GroupStr._·_ (snd π₃*S³)
η₃-raw/2 : (join S¹ S¹ , inl base) →∙ S₊∙ 3
fst η₃-raw/2 (inl x) = north
fst η₃-raw/2 (inr x) = north
fst η₃-raw/2 (push a b i) = σ₂ (S¹×S¹→S² a b) (~ i)
snd η₃-raw/2 = refl
η₃/2 : π₃*S³ .fst
η₃/2 = ∣ η₃-raw/2 ∣₂
gen↦η₃/2 : fst (fst π₃S³≅π₃*S³) (-π' 2 ∣ idfun∙ (S₊∙ 3) ∣₂) ≡ η₃/2
gen↦η₃/2 =
to3ConnectedId connS³
(funExt λ { (inl x) → refl
; (inr x) → refl
; (push a b i) → refl})
η₃/2+η₃/2≡η₃ : η₃/2 +π₃* η₃/2 ≡ η₃
η₃/2+η₃/2≡η₃ =
to3ConnectedId connS³
(funExt λ { (inl x) → refl
; (inr x) → refl
; (push a b i) → λ j → lem a b j i})
where
lem : (a b : S¹) → cong (fst (η₃-raw/2 +join η₃-raw/2)) (push a b)
≡ cong (fst η₃-raw) (push a b)
lem a b = (λ i → cong-∙ (fst η₃-raw/2) (push a b) (sym (push base b)) i
∙∙ rUnit refl (~ i)
∙∙ cong-∙∙ (fst η₃-raw/2)
(push base base) (sym (push a base)) (push a b) i)
∙∙ (λ i → (sym (σ₂ (S¹×S¹→S² a b)) ∙ rCancel (merid north) i)
∙∙ refl
∙∙ (sym (rCancel (merid north) i)
∙∙ (cong σ₂ (S¹×S¹→S²rUnit a) ∙ rCancel (merid north)) i
∙∙ sym (σ₂ (S¹×S¹→S² a b))))
∙∙ ((λ i → rUnit (sym (σ₂ (S¹×S¹→S² a b))) (~ i)
∙∙ refl
∙∙ lUnit (sym (σ₂ (S¹×S¹→S² a b))) (~ i))
∙ λ i → (λ j → σ₂ (S¹×S¹→S² a b) (i ∨ ~ j))
∙∙ (λ j → σ₂ (S¹×S¹→S² a b) (i ∧ ~ j))
∙∙ sym (σ₂ (S¹×S¹→S² a b)))
-- Agda is very keen on expanding things, so we make an abstract
-- summary of the main lemmas above
abstract
π₃S²≅π₃*S²-abs : GroupEquiv π₃S² π₃*S²
π₃S²≅π₃*S²-abs = π₃S²→π₃*S²
π₃*S²≅π₃*joinS¹S¹-abs : GroupEquiv π₃*S² π₃*joinS¹S¹
π₃*S²≅π₃*joinS¹S¹-abs = invGroupEquiv π₃*joinS¹S¹≅π₃*S²
π₃*joinS¹S¹≅π₃*S³-abs : GroupEquiv π₃*joinS¹S¹ π₃*S³
π₃*joinS¹S¹≅π₃*S³-abs = invGroupEquiv π₃*S³≅π₃*joinS¹S¹
π₃*S³≅π₃*S³-abs : GroupEquiv π₃*S³ π₃S³
π₃*S³≅π₃*S³-abs = invGroupEquiv π₃S³≅π₃*S³
-- stated in terms of (n : ℕ) to prevent normalisation
π₃'S³≅ℤ-abs : (n : ℕ) → GroupEquiv (π'Gr n (S₊∙ (suc n))) ℤ
π₃'S³≅ℤ-abs n = GroupIso→GroupEquiv (πₙ'Sⁿ≅ℤ n)
η↦η₁-abs : fst (fst π₃S²≅π₃*S²-abs) η ≡ η₁
η↦η₁-abs = η↦η₁
η₁↦η₂-abs : fst (fst π₃*S²≅π₃*joinS¹S¹-abs) η₁ ≡ η₂
η₁↦η₂-abs = cong (fst (fst π₃*S²≅π₃*joinS¹S¹-abs)) (sym η₂↦η₁)
∙ secEq (fst π₃*S²≅π₃*joinS¹S¹-abs) η₂
η₂↦η₃-abs : fst (fst π₃*joinS¹S¹≅π₃*S³-abs) η₂ ≡ η₃
η₂↦η₃-abs = η₂↦η₃
η₃↦η₄-abs : fst (fst π₃*S³≅π₃*S³-abs) η₃ ≡ η₄
η₃↦η₄-abs = cong (invEq (fst π₃S³≅π₃*S³)) (sym η₄↦η₃)
∙ retEq (fst π₃S³≅π₃*S³) η₄
gen↦1 : (n : ℕ) → fst (fst (π₃'S³≅ℤ-abs n)) ∣ idfun∙ (S₊∙ (suc n)) ∣₂ ≡ 1
gen↦1 = πₙ'Sⁿ≅ℤ-idfun∙
-- We finally prove that η₄ ↦ -2
abstract
η₄↦-2 : fst (fst (π₃'S³≅ℤ-abs 2)) η₄ ≡ -2
η₄↦-2 = speedUp (∣ idfun∙ (S₊∙ 3) ∣₂) (gen↦1 2)
where
speedUp : (x : _)
→ fst (fst (π₃'S³≅ℤ-abs (suc (suc zero)))) x ≡ (pos (suc zero))
→ (fst (fst (π₃'S³≅ℤ-abs 2))) (·π' 2 (-π' 2 x) (-π' 2 x)) ≡ -2
speedUp x p =
IsGroupHom.pres· (π₃'S³≅ℤ-abs 2 .snd)
(-π' 2 x) (-π' 2 x)
∙ cong (λ x → x +Z x)
(IsGroupHom.presinv (π₃'S³≅ℤ-abs 2 .snd) x ∙ cong (inv (ℤ .snd)) p)
-- Puting it all together, we get our group iso π₃(S²) ≅ ℤ
π₃'S²≅ℤ : GroupEquiv (π'Gr 2 (S₊∙ 2)) ℤ
π₃'S²≅ℤ =
compGroupEquiv
π₃S²≅π₃*S²-abs
(compGroupEquiv
π₃*S²≅π₃*joinS¹S¹-abs
(compGroupEquiv
π₃*joinS¹S¹≅π₃*S³-abs
(compGroupEquiv π₃*S³≅π₃*S³-abs
(π₃'S³≅ℤ-abs 2))))
-- ... which takes η to -2
η↦-2 : fst (fst π₃'S²≅ℤ) η ≡ - 2
η↦-2 =
cong (fst (fst (π₃'S³≅ℤ-abs 2)))
(cong (fst π₃*S³≅π₃*S³-abs .fst)
(cong (fst π₃*joinS¹S¹≅π₃*S³-abs .fst)
(cong (fst (fst π₃*S²≅π₃*joinS¹S¹-abs))
η↦η₁-abs
∙ η₁↦η₂-abs)
∙ η₂↦η₃-abs)
∙ η₃↦η₄-abs)
∙ η₄↦-2
-- We combine this with the rest of the main conclusions of chapters
-- 1-3 in Brunerie's thesis
BrunerieIso : GroupEquiv (π'Gr 3 (S₊∙ 3)) (ℤ/ 2)
BrunerieIso =
compGroupEquiv
(compGroupEquiv π₄S³≅π₃coFib-fold∘W∙
(invGroupEquiv
(GroupEquiv-abstractℤ/abs-gen
(π'Gr 2 (S₊∙ 3)) (π'Gr 2 (S₊∙ 2)) (π'Gr 2 coFib-fold∘W∙)
(invGroupEquiv (π₃'S³≅ℤ-abs 2))
(invGroupEquiv π₃'S²≅ℤ)
(π'∘∙Hom 2 (fold∘W , refl))
_
S³→S²→Pushout→Unit 2
(cong abs (cong (invEq (invEquiv (fst π₃'S²≅ℤ))
∘ sMap (_∘∙_ (fold∘W , refl)))
(sym (cong (invEq (fst (π₃'S³≅ℤ-abs 2))) (gen↦1 2))
∙ retEq (fst (π₃'S³≅ℤ-abs 2)) ∣ idfun∙ (S₊∙ 3) ∣₂))
∙ cong abs η↦-2))))
(abstractℤ/≅ℤ 2)
| {
"alphanum_fraction": 0.5307304315,
"avg_line_length": 36.514324693,
"ext": "agda",
"hexsha": "7ea2b1714dc694e9a366e2c556a9c23427f37c73",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "howsiyu/cubical",
"max_forks_repo_path": "Cubical/Homotopy/Group/Pi4S3/QuickProof.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "howsiyu/cubical",
"max_issues_repo_path": "Cubical/Homotopy/Group/Pi4S3/QuickProof.agda",
"max_line_length": 81,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "howsiyu/cubical",
"max_stars_repo_path": "Cubical/Homotopy/Group/Pi4S3/QuickProof.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 12068,
"size": 26765
} |
-- Basic intuitionistic propositional calculus, without ∨ or ⊥.
-- Kripke-style semantics with contexts as concrete worlds, and glueing for α and ▻.
-- Hilbert-style syntax.
module BasicIPC.Semantics.KripkeConcreteGluedHilbert where
open import BasicIPC.Syntax.Common public
open import Common.Semantics public
open ConcreteWorlds (Ty) public
-- Partial intuitionistic Kripke models with explicit syntax.
record Model : Set₁ where
infix 3 _⊩ᵅ_ _[⊢]_
field
-- Forcing for atomic propositions; monotonic.
_⊩ᵅ_ : World → Atom → Set
mono⊩ᵅ : ∀ {P w w′} → w ≤ w′ → w ⊩ᵅ P → w′ ⊩ᵅ P
-- Hilbert-style syntax representation; monotonic.
_[⊢]_ : Cx Ty → Ty → Set
mono[⊢] : ∀ {A Γ Γ′} → Γ ⊆ Γ′ → Γ [⊢] A → Γ′ [⊢] A
[var] : ∀ {A Γ} → A ∈ Γ → Γ [⊢] A
[app] : ∀ {A B Γ} → Γ [⊢] A ▻ B → Γ [⊢] A → Γ [⊢] B
[ci] : ∀ {A Γ} → Γ [⊢] A ▻ A
[ck] : ∀ {A B Γ} → Γ [⊢] A ▻ B ▻ A
[cs] : ∀ {A B C Γ} → Γ [⊢] (A ▻ B ▻ C) ▻ (A ▻ B) ▻ A ▻ C
[cpair] : ∀ {A B Γ} → Γ [⊢] A ▻ B ▻ A ∧ B
[cfst] : ∀ {A B Γ} → Γ [⊢] A ∧ B ▻ A
[csnd] : ∀ {A B Γ} → Γ [⊢] A ∧ B ▻ B
[unit] : ∀ {Γ} → Γ [⊢] ⊤
-- NOTE: [lam] is necessary to give meaning to Gentzen-style syntax.
[lam] : ∀ {A B Γ} → Γ , A [⊢] B → Γ [⊢] A ▻ B
infix 3 _[⊢]⋆_
_[⊢]⋆_ : Cx Ty → Cx Ty → Set
Γ [⊢]⋆ ∅ = 𝟙
Γ [⊢]⋆ Ξ , A = Γ [⊢]⋆ Ξ × Γ [⊢] A
open Model {{…}} public
-- Forcing in a particular world of a particular model.
module _ {{_ : Model}} where
infix 3 _⊩_
_⊩_ : World → Ty → Set
w ⊩ α P = Glue (unwrap w [⊢] α P) (w ⊩ᵅ P)
w ⊩ A ▻ B = Glue (unwrap w [⊢] (A ▻ B)) (∀ {w′} → w ≤ w′ → w′ ⊩ A → w′ ⊩ B)
w ⊩ A ∧ B = w ⊩ A × w ⊩ B
w ⊩ ⊤ = 𝟙
infix 3 _⊩⋆_
_⊩⋆_ : World → Cx Ty → Set
w ⊩⋆ ∅ = 𝟙
w ⊩⋆ Ξ , A = w ⊩⋆ Ξ × w ⊩ A
-- Monotonicity with respect to context inclusion.
module _ {{_ : Model}} where
mono⊩ : ∀ {A w w′} → w ≤ w′ → w ⊩ A → w′ ⊩ A
mono⊩ {α P} ξ s = mono[⊢] (unwrap≤ ξ) (syn s) ⅋ mono⊩ᵅ ξ (sem s)
mono⊩ {A ▻ B} ξ s = mono[⊢] (unwrap≤ ξ) (syn s) ⅋ λ ξ′ → sem s (trans≤ ξ ξ′)
mono⊩ {A ∧ B} ξ s = mono⊩ {A} ξ (π₁ s) , mono⊩ {B} ξ (π₂ s)
mono⊩ {⊤} ξ s = ∙
mono⊩⋆ : ∀ {Ξ w w′} → w ≤ w′ → w ⊩⋆ Ξ → w′ ⊩⋆ Ξ
mono⊩⋆ {∅} ξ ∙ = ∙
mono⊩⋆ {Ξ , A} ξ (ts , t) = mono⊩⋆ {Ξ} ξ ts , mono⊩ {A} ξ t
-- Extraction of syntax representation in a particular model.
module _ {{_ : Model}} where
reifyʳ : ∀ {A w} → w ⊩ A → unwrap w [⊢] A
reifyʳ {α P} s = syn s
reifyʳ {A ▻ B} s = syn s
reifyʳ {A ∧ B} s = [app] ([app] [cpair] (reifyʳ {A} (π₁ s))) (reifyʳ {B} (π₂ s))
reifyʳ {⊤} s = [unit]
reifyʳ⋆ : ∀ {Ξ w} → w ⊩⋆ Ξ → unwrap w [⊢]⋆ Ξ
reifyʳ⋆ {∅} ∙ = ∙
reifyʳ⋆ {Ξ , A} (ts , t) = reifyʳ⋆ ts , reifyʳ t
-- Useful theorems in functional form.
module _ {{_ : Model}} where
[multicut] : ∀ {Ξ A Γ} → Γ [⊢]⋆ Ξ → Ξ [⊢] A → Γ [⊢] A
[multicut] {∅} ∙ u = mono[⊢] bot⊆ u
[multicut] {Ξ , B} (ts , t) u = [app] ([multicut] ts ([lam] u)) t
[pair] : ∀ {A B Γ} → Γ [⊢] A → Γ [⊢] B → Γ [⊢] A ∧ B
[pair] t u = [app] ([app] [cpair] t) u
[fst] : ∀ {A B Γ} → Γ [⊢] A ∧ B → Γ [⊢] A
[fst] t = [app] [cfst] t
[snd] : ∀ {A B Γ} → Γ [⊢] A ∧ B → Γ [⊢] B
[snd] t = [app] [csnd] t
-- Additional useful equipment.
module _ {{_ : Model}} where
_⟪$⟫_ : ∀ {A B w} → w ⊩ A ▻ B → w ⊩ A → w ⊩ B
s ⟪$⟫ a = sem s refl≤ a
⟪K⟫ : ∀ {A B w} → w ⊩ A → w ⊩ B ▻ A
⟪K⟫ {A} a = [app] [ck] (reifyʳ a) ⅋ λ ξ →
K (mono⊩ {A} ξ a)
⟪S⟫ : ∀ {A B C w} → w ⊩ A ▻ B ▻ C → w ⊩ A ▻ B → w ⊩ A → w ⊩ C
⟪S⟫ s₁ s₂ a = (s₁ ⟪$⟫ a) ⟪$⟫ (s₂ ⟪$⟫ a)
⟪S⟫′ : ∀ {A B C w} → w ⊩ A ▻ B ▻ C → w ⊩ (A ▻ B) ▻ A ▻ C
⟪S⟫′ {A} {B} {C} s₁ = [app] [cs] (syn s₁) ⅋ λ ξ s₂ →
[app] ([app] [cs] (mono[⊢] (unwrap≤ ξ) (syn s₁))) (syn s₂) ⅋ λ ξ′ →
⟪S⟫ (mono⊩ {A ▻ B ▻ C} (trans≤ ξ ξ′) s₁) (mono⊩ {A ▻ B} ξ′ s₂)
_⟪,⟫′_ : ∀ {A B w} → w ⊩ A → w ⊩ B ▻ A ∧ B
_⟪,⟫′_ {A} a = [app] [cpair] (reifyʳ a) ⅋ λ ξ →
_,_ (mono⊩ {A} ξ a)
-- Forcing in a particular world of a particular model, for sequents.
module _ {{_ : Model}} where
infix 3 _⊩_⇒_
_⊩_⇒_ : World → Cx Ty → Ty → Set
w ⊩ Γ ⇒ A = w ⊩⋆ Γ → w ⊩ A
infix 3 _⊩_⇒⋆_
_⊩_⇒⋆_ : World → Cx Ty → Cx Ty → Set
w ⊩ Γ ⇒⋆ Ξ = w ⊩⋆ Γ → w ⊩⋆ Ξ
-- Entailment, or forcing in all worlds of all models, for sequents.
infix 3 _⊨_
_⊨_ : Cx Ty → Ty → Set₁
Γ ⊨ A = ∀ {{_ : Model}} {w : World} → w ⊩ Γ ⇒ A
infix 3 _⊨⋆_
_⊨⋆_ : Cx Ty → Cx Ty → Set₁
Γ ⊨⋆ Ξ = ∀ {{_ : Model}} {w : World} → w ⊩ Γ ⇒⋆ Ξ
-- Additional useful equipment, for sequents.
module _ {{_ : Model}} where
lookup : ∀ {A Γ w} → A ∈ Γ → w ⊩ Γ ⇒ A
lookup top (γ , a) = a
lookup (pop i) (γ , b) = lookup i γ
_⟦$⟧_ : ∀ {A B Γ w} → w ⊩ Γ ⇒ A ▻ B → w ⊩ Γ ⇒ A → w ⊩ Γ ⇒ B
(s₁ ⟦$⟧ s₂) γ = s₁ γ ⟪$⟫ s₂ γ
⟦K⟧ : ∀ {A B Γ w} → w ⊩ Γ ⇒ A → w ⊩ Γ ⇒ B ▻ A
⟦K⟧ {A} {B} a γ = ⟪K⟫ {A} {B} (a γ)
⟦S⟧ : ∀ {A B C Γ w} → w ⊩ Γ ⇒ A ▻ B ▻ C → w ⊩ Γ ⇒ A ▻ B → w ⊩ Γ ⇒ A → w ⊩ Γ ⇒ C
⟦S⟧ s₁ s₂ a γ = ⟪S⟫ (s₁ γ) (s₂ γ) (a γ)
_⟦,⟧_ : ∀ {A B Γ w} → w ⊩ Γ ⇒ A → w ⊩ Γ ⇒ B → w ⊩ Γ ⇒ A ∧ B
(a ⟦,⟧ b) γ = a γ , b γ
⟦π₁⟧ : ∀ {A B Γ w} → w ⊩ Γ ⇒ A ∧ B → w ⊩ Γ ⇒ A
⟦π₁⟧ s γ = π₁ (s γ)
⟦π₂⟧ : ∀ {A B Γ w} → w ⊩ Γ ⇒ A ∧ B → w ⊩ Γ ⇒ B
⟦π₂⟧ s γ = π₂ (s γ)
| {
"alphanum_fraction": 0.4285443877,
"avg_line_length": 29.8474576271,
"ext": "agda",
"hexsha": "fc00fa545979712d2d7479ca459e53c119de023f",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "fcd187db70f0a39b894fe44fad0107f61849405c",
"max_forks_repo_licenses": [
"X11"
],
"max_forks_repo_name": "mietek/hilbert-gentzen",
"max_forks_repo_path": "BasicIPC/Semantics/KripkeConcreteGluedHilbert.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "fcd187db70f0a39b894fe44fad0107f61849405c",
"max_issues_repo_issues_event_max_datetime": "2018-06-10T09:11:22.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-06-10T09:11:22.000Z",
"max_issues_repo_licenses": [
"X11"
],
"max_issues_repo_name": "mietek/hilbert-gentzen",
"max_issues_repo_path": "BasicIPC/Semantics/KripkeConcreteGluedHilbert.agda",
"max_line_length": 93,
"max_stars_count": 29,
"max_stars_repo_head_hexsha": "fcd187db70f0a39b894fe44fad0107f61849405c",
"max_stars_repo_licenses": [
"X11"
],
"max_stars_repo_name": "mietek/hilbert-gentzen",
"max_stars_repo_path": "BasicIPC/Semantics/KripkeConcreteGluedHilbert.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-01T10:29:18.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-07-03T18:51:56.000Z",
"num_tokens": 2925,
"size": 5283
} |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import cohomology.Theory
{- Ordinary cohomology groups of the n-torus Tⁿ = (S¹)ⁿ.
- We have Cᵏ(Tⁿ) == C⁰(S⁰)^(n choose' k) where _choose'_ defined as below.
- This argument could give Cᵏ((Sᵐ)ⁿ) with a little more work. -}
module cohomology.Torus {i} (OT : OrdinaryTheory i) where
open OrdinaryTheory OT
open import cohomology.Sphere OT
open import cohomology.SphereProduct cohomology-theory
{- Almost n choose k, but with n choose' O = 0 for any n. -}
_choose'_ : ℕ → ℤ → ℕ
n choose' negsucc _ = 0
n choose' pos O = 0
n choose' pos (S O) = n
O choose' pos (S (S k)) = 0
S n choose' pos (S (S k)) = (n choose' (pos (S (S k)))) + (n choose' (pos (S k)))
_-⊙Torus : ℕ → Ptd₀
O -⊙Torus = ⊙Unit
(S n) -⊙Torus = ⊙S¹ ⊙× (n -⊙Torus)
C-nTorus : (k : ℤ) (n : ℕ)
→ C k (⊙Lift (n -⊙Torus)) ≃ᴳ C 0 (⊙Lift ⊙S⁰) ^ᴳ (n choose' k)
C-nTorus (negsucc k) O = lift-iso ∘eᴳ trivial-iso-0ᴳ (C-Unit (negsucc k))
C-nTorus (negsucc k) (S n) =
C (negsucc k) (⊙Lift (S n -⊙Torus))
≃ᴳ⟨ C-emap (negsucc k) (⊙lift-equiv ⊙∘e ⊙×-emap (⊙ide _) ⊙lower-equiv) ⟩
C (negsucc k) (⊙S¹ ⊙× ⊙Lift (n -⊙Torus))
≃ᴳ⟨ C-Sphere× (negsucc k) 1 (⊙Lift (n -⊙Torus)) ⟩
C (negsucc k) (⊙Lift ⊙S¹) ×ᴳ (C (negsucc k) (⊙Lift (n -⊙Torus)) ×ᴳ C (negsucc k) (⊙Susp (⊙Lift (n -⊙Torus))))
≃ᴳ⟨ ×ᴳ-emap (trivial-iso-0ᴳ (C-Sphere-≠-is-trivial (negsucc k) 1 (ℤ-negsucc≠pos _ _))) (idiso _) ⟩
0ᴳ ×ᴳ (C (negsucc k) (⊙Lift (n -⊙Torus)) ×ᴳ C (negsucc k) (⊙Susp (⊙Lift (n -⊙Torus))))
≃ᴳ⟨ ×ᴳ-unit-l _ ⟩
C (negsucc k) (⊙Lift (n -⊙Torus)) ×ᴳ C (negsucc k) (⊙Susp (⊙Lift (n -⊙Torus)))
≃ᴳ⟨ ×ᴳ-emap
(lower-iso ∘eᴳ C-nTorus (negsucc k) n)
(C-nTorus (negsucc (S k)) n ∘eᴳ C-Susp (negsucc (S k)) (⊙Lift (n -⊙Torus))) ⟩
0ᴳ ×ᴳ Lift-group 0ᴳ
≃ᴳ⟨ ×ᴳ-unit-l (Lift-group 0ᴳ) ⟩
Lift-group 0ᴳ
≃ᴳ∎
C-nTorus (pos O) O = lift-iso ∘eᴳ trivial-iso-0ᴳ (C-Unit 0)
C-nTorus (pos O) (S n) =
C 0 (⊙Lift (S n -⊙Torus))
≃ᴳ⟨ C-emap 0 (⊙lift-equiv ⊙∘e ⊙×-emap (⊙ide _) ⊙lower-equiv) ⟩
C 0 (⊙S¹ ⊙× ⊙Lift (n -⊙Torus))
≃ᴳ⟨ C-Sphere× 0 1 (⊙Lift (n -⊙Torus)) ⟩
C 0 (⊙Lift ⊙S¹) ×ᴳ (C 0 (⊙Lift (n -⊙Torus)) ×ᴳ C 0 (⊙Susp (⊙Lift (n -⊙Torus))))
≃ᴳ⟨ ×ᴳ-emap (trivial-iso-0ᴳ (C-Sphere-≠-is-trivial 0 1 (pos-≠ (ℕ-O≠S _)))) (idiso _) ⟩
0ᴳ ×ᴳ (C 0 (⊙Lift (n -⊙Torus)) ×ᴳ C 0 (⊙Susp (⊙Lift (n -⊙Torus))))
≃ᴳ⟨ ×ᴳ-unit-l _ ⟩
C 0 (⊙Lift (n -⊙Torus)) ×ᴳ C 0 (⊙Susp (⊙Lift (n -⊙Torus)))
≃ᴳ⟨ ×ᴳ-emap
(lower-iso ∘eᴳ C-nTorus 0 n)
(C-nTorus -1 n ∘eᴳ C-Susp -1 (⊙Lift (n -⊙Torus))) ⟩
0ᴳ ×ᴳ Lift-group 0ᴳ
≃ᴳ⟨ ×ᴳ-unit-l _ ⟩
Lift-group 0ᴳ
≃ᴳ∎
C-nTorus (pos (S O)) O = lift-iso ∘eᴳ trivial-iso-0ᴳ (C-Unit 1)
C-nTorus (pos (S O)) (S n) =
C 1 (⊙Lift (S n -⊙Torus))
≃ᴳ⟨ C-emap 1 (⊙lift-equiv ⊙∘e ⊙×-emap (⊙ide _) ⊙lower-equiv) ⟩
C 1 (⊙S¹ ⊙× ⊙Lift (n -⊙Torus))
≃ᴳ⟨ C-Sphere× 1 1 (⊙Lift (n -⊙Torus)) ⟩
C 1 (⊙Lift ⊙S¹) ×ᴳ (C 1 (⊙Lift (n -⊙Torus)) ×ᴳ C 1 (⊙Susp (⊙Lift (n -⊙Torus))))
≃ᴳ⟨ ×ᴳ-emap (C-Sphere-diag 1)
( ×ᴳ-unit-r _
∘eᴳ ×ᴳ-emap
(C-nTorus 1 n)
(lower-iso
∘eᴳ C-nTorus 0 n
∘eᴳ C-Susp 0 (⊙Lift (n -⊙Torus)))) ⟩
C 0 (⊙Lift ⊙S⁰) ×ᴳ (C 0 (⊙Lift ⊙S⁰) ^ᴳ n)
≃ᴳ∎
C-nTorus (pos (S (S k))) O = lift-iso ∘eᴳ trivial-iso-0ᴳ (C-Unit (pos (S (S k))))
C-nTorus (pos (S (S k))) (S n) =
C (pos (S (S k))) (⊙Lift (S n -⊙Torus))
≃ᴳ⟨ C-emap (pos (S (S k))) (⊙lift-equiv ⊙∘e ⊙×-emap (⊙ide _) ⊙lower-equiv) ⟩
C (pos (S (S k))) (⊙S¹ ⊙× ⊙Lift (n -⊙Torus))
≃ᴳ⟨ C-Sphere× (pos (S (S k))) 1 (⊙Lift (n -⊙Torus)) ⟩
C (pos (S (S k))) (⊙Lift ⊙S¹) ×ᴳ (C (pos (S (S k))) (⊙Lift (n -⊙Torus)) ×ᴳ C (pos (S (S k))) (⊙Susp (⊙Lift (n -⊙Torus))))
≃ᴳ⟨ ×ᴳ-emap (trivial-iso-0ᴳ (C-Sphere-≠-is-trivial (pos (S (S k))) 1 (pos-≠ (ℕ-S-≠ (ℕ-S≠O k))))) (idiso _) ⟩
0ᴳ ×ᴳ (C (pos (S (S k))) (⊙Lift (n -⊙Torus)) ×ᴳ C (pos (S (S k))) (⊙Susp (⊙Lift (n -⊙Torus))))
≃ᴳ⟨ ×ᴳ-unit-l _ ⟩
C (pos (S (S k))) (⊙Lift (n -⊙Torus)) ×ᴳ C (pos (S (S k))) (⊙Susp (⊙Lift (n -⊙Torus)))
≃ᴳ⟨ ×ᴳ-emap
(C-nTorus (pos (S (S k))) n)
(C-nTorus (pos (S k)) n ∘eᴳ C-Susp (pos (S k)) (⊙Lift (n -⊙Torus))) ⟩
(C 0 (⊙Lift ⊙S⁰) ^ᴳ (n choose' pos (S (S k)))) ×ᴳ (C 0 (⊙Lift ⊙S⁰) ^ᴳ (n choose' pos (S k)))
≃ᴳ⟨ ^ᴳ-+ (C 0 (⊙Lift ⊙S⁰)) (n choose' pos (S (S k))) (n choose' pos (S k)) ⁻¹ᴳ ⟩
C 0 (⊙Lift ⊙S⁰) ^ᴳ (S n choose' pos (S (S k)))
≃ᴳ∎
| {
"alphanum_fraction": 0.5097816197,
"avg_line_length": 39.25,
"ext": "agda",
"hexsha": "8b7def68136f17fd31fe3f5045f376c3d4e44cf3",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2018-12-26T21:31:57.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-12-26T21:31:57.000Z",
"max_forks_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "timjb/HoTT-Agda",
"max_forks_repo_path": "theorems/cohomology/Torus.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "timjb/HoTT-Agda",
"max_issues_repo_path": "theorems/cohomology/Torus.agda",
"max_line_length": 123,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "timjb/HoTT-Agda",
"max_stars_repo_path": "theorems/cohomology/Torus.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2664,
"size": 4396
} |
------------------------------------------------------------------------
-- Some derivable properties
------------------------------------------------------------------------
open import Algebra
module Algebra.Props.Lattice (l : Lattice) where
open Lattice l
open import Algebra.Structures
import Algebra.FunctionProperties as P; open P _≈_
import Relation.Binary.EqReasoning as EqR; open EqR setoid
open import Data.Function
open import Data.Product
∧-idempotent : Idempotent _∧_
∧-idempotent x = begin
x ∧ x ≈⟨ refl ⟨ ∧-pres-≈ ⟩ sym (proj₁ absorptive _ _) ⟩
x ∧ (x ∨ x ∧ x) ≈⟨ proj₂ absorptive _ _ ⟩
x ∎
∨-idempotent : Idempotent _∨_
∨-idempotent x = begin
x ∨ x ≈⟨ refl ⟨ ∨-pres-≈ ⟩ sym (∧-idempotent _) ⟩
x ∨ x ∧ x ≈⟨ proj₁ absorptive _ _ ⟩
x ∎
-- The dual construction is also a lattice.
∧-∨-isLattice : IsLattice _≈_ _∧_ _∨_
∧-∨-isLattice = record
{ isEquivalence = isEquivalence
; ∨-comm = ∧-comm
; ∨-assoc = ∧-assoc
; ∨-pres-≈ = ∧-pres-≈
; ∧-comm = ∨-comm
; ∧-assoc = ∨-assoc
; ∧-pres-≈ = ∨-pres-≈
; absorptive = swap absorptive
}
∧-∨-lattice : Lattice
∧-∨-lattice = record
{ _∧_ = _∨_
; _∨_ = _∧_
; isLattice = ∧-∨-isLattice
}
| {
"alphanum_fraction": 0.5098039216,
"avg_line_length": 26.5625,
"ext": "agda",
"hexsha": "2ece1a28a6a9bb3c73d74caf5f3d91cbea890943",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:54:10.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-07-21T16:37:58.000Z",
"max_forks_repo_head_hexsha": "8ef786b40e4a9ab274c6103dc697dcb658cf3db3",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "isabella232/Lemmachine",
"max_forks_repo_path": "vendor/stdlib/src/Algebra/Props/Lattice.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "8ef786b40e4a9ab274c6103dc697dcb658cf3db3",
"max_issues_repo_issues_event_max_datetime": "2022-03-12T12:17:51.000Z",
"max_issues_repo_issues_event_min_datetime": "2022-03-12T12:17:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "larrytheliquid/Lemmachine",
"max_issues_repo_path": "vendor/stdlib/src/Algebra/Props/Lattice.agda",
"max_line_length": 72,
"max_stars_count": 56,
"max_stars_repo_head_hexsha": "8ef786b40e4a9ab274c6103dc697dcb658cf3db3",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "isabella232/Lemmachine",
"max_stars_repo_path": "vendor/stdlib/src/Algebra/Props/Lattice.agda",
"max_stars_repo_stars_event_max_datetime": "2021-12-21T17:02:19.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-20T02:11:42.000Z",
"num_tokens": 463,
"size": 1275
} |
------------------------------------------------------------------------
-- Code related to the paper "Bag Equivalence via a Proof-Relevant
-- Membership Relation"
--
-- Nils Anders Danielsson
------------------------------------------------------------------------
-- Note that the code does not follow the paper exactly. For instance,
-- many definitions are universe-polymorphic, and in some cases where
-- the paper contains both a specialised and a more general definition
-- the code only contains the more general one. The code has also been
-- changed after the paper was published.
{-# OPTIONS --without-K --safe #-}
module README.Bag-equivalence where
------------------------------------------------------------------------
-- 2: Brief Introduction to Agda
-- The prelude, containing List, ℕ, Fin, ⊥, ⊤, _⊎_ (written as _+_ in
-- the paper), ∃, and _×_.
import Prelude
-- Some list functions: length and index (called lookup in the paper).
import List
-- Logical equivalences: _⇔_.
import Logical-equivalence
-- Bijections: _↔_.
import Bijection
-- Equality: _≡_.
import Equality.Propositional
-- The K rule, and a proof showing that it implies proof-irrelevance.
import Equality
-- Bijectional reasoning combinators (more general than those in the
-- paper): inverse (written as sym in the paper), _□, and _↔⟨_⟩_.
import Function-universe
------------------------------------------------------------------------
-- 3: Bag Equivalence for Lists
-- Any, _∈_, and the two definitions of bag equivalence.
import Bag-equivalence
------------------------------------------------------------------------
-- 4: Bijectional Reasoning
-- Definitions of map, concat and _>>=_ (the latter as part of a monad
-- instance).
import List
-- Algebraic properties of type constructors (like ⊥ ⊎ A ↔ A).
import Function-universe
import Fin
-- All the main lemmas from this section, including
-- >>=-left-distributive.
import Bag-equivalence
------------------------------------------------------------------------
-- 5: The Definitions Are Equivalent
-- The equivalence proof.
import Bag-equivalence
-- There are infinitely many proofs of ℕ ≡ ℕ in homotopy type theory.
import Univalence-axiom
------------------------------------------------------------------------
-- 6: Bag Equivalence for Arbitrary Containers
-- Containers, including Any, _∈_, the two definitions of bag
-- equivalence, and a proof showing that the two definitions are
-- logically equivalent.
--
-- There is also a proof which shows that the definitions are
-- isomorphic (assuming extensionality), if "bijection" is replaced by
-- the logically equivalent concept of "(weak) equivalence" in the
-- definitions of bag equivalence.
import Container
import Equivalence
-- The List, Stream and Tree containers. It is shown that the general
-- definition of bag equivalence for containers, instantiated with the
-- List container, is equivalent (in a certain sense) to the list-only
-- definition given above.
import Container.List
import Container.Stream
import Container.Tree
------------------------------------------------------------------------
-- 7: More Bijectional Reasoning
-- Three implementations of tree sort are provided.
-- 1) An implementation of tree sort, formally proved to return a
-- permutation of the input.
import Tree-sort.Partial
import Tree-sort.Examples
-- 2) An implementation of tree sort, formally proved to return a
-- /sorted/ permutation of the input.
import Tree-sort.Full
import Tree-sort.Examples
-- 3) An implementation of tree sort which uses containers to
-- represent trees and lists.
--
-- In the module Tree-sort.Full indexed types are used to enforce
-- sortedness, but this development uses non-indexed containers, so
-- sortedness is not enforced.
--
-- The implementation using containers has the advantage of uniform
-- definitions of Any/membership/bag equivalence, but the other
-- implementations use more direct definitions and are perhaps a
-- bit "leaner".
import Container.Tree
import Container.Tree-sort
import Container.Tree-sort.Example
------------------------------------------------------------------------
-- 8: Set Equivalence, Subsets and Subbags
-- Injections: _↣_.
import Injection
-- The general definition of set and bag equivalence and the subset
-- and subbag preorders, as well as preservation lemmas such as
-- >>=-cong.
import Bag-equivalence
------------------------------------------------------------------------
-- 9: Related Work
-- One of the definitions of bag equivalence from Coq's standard
-- library has been replicated, and shown to be sound with respect to
-- the other ones.
import Bag-equivalence
------------------------------------------------------------------------
-- 10: Conclusions
-- Two proofs showing that cons is left cancellative, using different
-- definitions of bag equivalence.
import Bag-equivalence
| {
"alphanum_fraction": 0.6265643924,
"avg_line_length": 28.6358381503,
"ext": "agda",
"hexsha": "77a3836ddb9de81cbce69806a4970ebd2cb4ac98",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/equality",
"max_forks_repo_path": "README/Bag-equivalence.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/equality",
"max_issues_repo_path": "README/Bag-equivalence.agda",
"max_line_length": 72,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/equality",
"max_stars_repo_path": "README/Bag-equivalence.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-02T17:18:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-05-21T22:58:50.000Z",
"num_tokens": 1011,
"size": 4954
} |
{-# OPTIONS --without-K --safe #-}
module Cham.Label where
open import Cham.Name
data Label : Set where
_⁺ : Name → Label
_⁻ : Name → Label
| {
"alphanum_fraction": 0.6351351351,
"avg_line_length": 13.4545454545,
"ext": "agda",
"hexsha": "3c70f751d13cab5d1ce3783d365a5b3fe3eb6b16",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "292023fc36fa67ca4a81cff9a875a325a79b9d6f",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "riz0id/chemical-abstract-machine",
"max_forks_repo_path": "agda/Cham/Label.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "292023fc36fa67ca4a81cff9a875a325a79b9d6f",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "riz0id/chemical-abstract-machine",
"max_issues_repo_path": "agda/Cham/Label.agda",
"max_line_length": 34,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "292023fc36fa67ca4a81cff9a875a325a79b9d6f",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "riz0id/chemical-abstract-machine",
"max_stars_repo_path": "agda/Cham/Label.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 42,
"size": 148
} |
module prelude where
open import Function using (id; _∘_) public
open import Data.Sum renaming (inj₁ to Σ₁; inj₂ to Σ₂) using (_⊎_) public
open import Data.Product renaming (proj₁ to π₁; proj₂ to π₂) using (Σ; _×_; _,_; ∃; Σ-syntax) public
open import Agda.Builtin.Unit using (⊤; tt) public
open import Data.Empty using (⊥) public
open import Data.Nat as Nat renaming (suc to ℕs; zero to ℕz; _+_ to _ℕ+_) using (ℕ) public
open import Relation.Binary.PropositionalEquality.Core as Eq using (_≡_; _≢_; refl; sym; trans; subst) renaming (cong to _⟨$⟩_) public
open Eq.≡-Reasoning using (_≡⟨⟩_; step-≡; _∎) public
postulate
extensionality : {A : Set} {B : A → Set} {f g : (x : A) → B x}
→ (∀ x → f x ≡ g x) → f ≡ g
extensionality2 : {A : Set} {B : A → Set} {C : (x : A) → B x → Set} {f g : (x : A) (y : B x) → C x y }
→ (∀ x y → f x y ≡ g x y) → f ≡ g
extensionality2 λλf≡g = extensionality λ x → extensionality λ y → λλf≡g x y
trans-refl : {A : Set} {x y : A} (p : x ≡ y) → trans p refl ≡ p
trans-refl p rewrite p = refl
subst⋯ : {A : Set} {x y z : A} (P : A → Set) (p : x ≡ y) (q : y ≡ z) (Px : P x)
→ subst P (trans p q) Px ≡ subst P q (subst P p Px)
subst⋯ _ p _ _ rewrite p = refl
_×⁼_ : {A X : Set} {a b : A} {x y : X} → a ≡ b → x ≡ y → (a , x) ≡ (b , y)
_×⁼_ refl refl = refl
_⨄_ : {A B : Set} → (A → Set) → (B → Set) → A ⊎ B → Set
(F ⨄ G) (Σ₁ x) = F x
(F ⨄ G) (Σ₂ y) = G y
_⨃_ _⨉_ : {A B : Set} → (A → Set) → (B → Set) → A × B → Set
F ⨃ G = λ (a , b) → F a ⊎ G b
F ⨉ G = λ (a , b) → F a × G b
_$₁_ : ∀ {A B X : Set} (f : A → B) → A × X → B × X
f $₁ (a , x) = f a , x
_⁻¹ : {A B : Set} → (A → B) → B → Set
_⁻¹ {A} {B} f b = Σ[ a ∈ A ] (f a ≡ b)
uncurry : {a b c : Set} → (a → b → c) → (a × b) → c
uncurry f (a , b) = f a b
| {
"alphanum_fraction": 0.5154755205,
"avg_line_length": 41.3255813953,
"ext": "agda",
"hexsha": "73c441936290d98e0457fa72ca1f6adc2a8b993b",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2022-01-30T11:45:57.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-07-10T17:19:37.000Z",
"max_forks_repo_head_hexsha": "425de958985aacbd3284d3057fe21fd682e315ea",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "dspivak/poly",
"max_forks_repo_path": "code-examples/agda/prelude.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "425de958985aacbd3284d3057fe21fd682e315ea",
"max_issues_repo_issues_event_max_datetime": "2022-01-12T10:06:32.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-09-02T02:29:39.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "dspivak/poly",
"max_issues_repo_path": "code-examples/agda/prelude.agda",
"max_line_length": 134,
"max_stars_count": 53,
"max_stars_repo_head_hexsha": "425de958985aacbd3284d3057fe21fd682e315ea",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "mstone/poly",
"max_stars_repo_path": "code-examples/agda/prelude.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-22T23:08:27.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-02-18T16:31:04.000Z",
"num_tokens": 815,
"size": 1777
} |
module Data.Vec.Membership.Propositional.Distinct.Properties where
open import Data.Fin as Fin
open import Relation.Binary.PropositionalEquality as P
open import Data.Vec as Vec using (Vec; [] ; _∷_ ; _++_)
open import Data.Vec.Any
open import Data.Vec.Membership.Propositional.Distinct
open import Data.Vec.Membership.Propositional.Disjoint renaming (Disjoint to _⋈_)
open import Data.Vec.Membership.Propositional.Properties
open import Data.Vec.Membership.Propositional
open import Data.Product
open import Data.Empty using (⊥-elim)
open import Function using (_∘_)
open import Function.Equivalence using (_⇔_; equivalence)
distinct-++ˡ : ∀ {a}{A : Set a}{m n} (xs : Vec A m){ys : Vec A n} → Distinct (xs ++ ys) → Distinct xs
distinct-++ˡ [] dis = distinct-[]
distinct-++ˡ (x ∷ xs) (.x distinct-∷ dis by x∉xsys) = x distinct-∷ distinct-++ˡ xs dis by λ x∈xs → x∉xsys (∈-++⁺ˡ x∈xs)
distinct-++ʳ : ∀ {a}{A : Set a}{m n} (xs : Vec A m) {ys : Vec A n} → Distinct (xs ++ ys) → Distinct ys
distinct-++ʳ [] dys = dys
distinct-++ʳ (x ∷ xs) (.x distinct-∷ dxsys by _) = distinct-++ʳ xs dxsys
distinct-++→disjoint : ∀ {a}{A : Set a}{m n} (xs : Vec A m) {ys : Vec A n} → Distinct (xs ++ ys) → xs ⋈ ys
distinct-++→disjoint [] dxsys {z} () z∈ys
distinct-++→disjoint (x ∷ xs) (.x distinct-∷ dxsys by x∉xsys) {.x} (here refl) x∈ys = x∉xsys (∈-++⁺ʳ xs x∈ys)
distinct-++→disjoint (x ∷ xs) (.x distinct-∷ dxsys by x₁) {z} (there z∈xs) z∈ys = distinct-++→disjoint xs dxsys z∈xs z∈ys
⋈→distinct-++ : ∀ {a}{A : Set a}{m n}{xs : Vec A m}{ys : Vec A n} → Distinct xs → Distinct ys → xs ⋈ ys → Distinct (xs ++ ys)
⋈→distinct-++ {xs = []} _ dys _ = dys
⋈→distinct-++ {xs = x ∷ xs} (.x distinct-∷ dxs by x∉xs) dys xxs⋈ys = x distinct-∷ ⋈→distinct-++ dxs dys (xxs⋈ys ∘ there)
by λ x∈xs++ys → xxs⋈ys (here P.refl) (x∈xs++ys→x∉xs→x∈ys xs x∈xs++ys x∉xs)
where
x∈xs++ys→x∉xs→x∈ys : ∀ {a} {A : Set a} {m n} (xs : Vec A m){ys : Vec A n} →
∀ {x} → x ∈ xs ++ ys → x ∉ xs → x ∈ ys
x∈xs++ys→x∉xs→x∈ys [] x∈ys _ = x∈ys
x∈xs++ys→x∉xs→x∈ys (x ∷ xs) (here refl) x∉xs = ⊥-elim (x∉xs (here refl))
x∈xs++ys→x∉xs→x∈ys (x ∷ xs) (there x∈xsys) x∉xs = x∈xs++ys→x∉xs→x∈ys xs x∈xsys (x∉xs ∘ there)
distinct-++⇔⋈ : ∀ {a}{A : Set a}{m n} {xs : Vec A m}{ys : Vec A n} →
Distinct (xs ++ ys) ⇔ (Distinct xs × Distinct ys × xs ⋈ ys)
distinct-++⇔⋈ = equivalence to from
where
open import Data.Nat.Properties
to : ∀ {a}{A : Set a} {m n} {xs : Vec A m}{ys : Vec A n} →
Distinct (xs ++ ys) → (Distinct xs × Distinct ys × xs ⋈ ys)
to {xs = xs} dxsys = distinct-++ˡ xs dxsys , distinct-++ʳ xs dxsys , distinct-++→disjoint xs dxsys
from : ∀ {a}{A : Set a} {m n} {xs : Vec A m}{ ys : Vec A n} →
(Distinct xs × Distinct ys × xs ⋈ ys) → Distinct (xs ++ ys)
from (dxs , dys , xs⋈ys) = ⋈→distinct-++ dxs dys xs⋈ys
private
lookup-∈ : ∀ {a n}{A : Set a} i (xs : Vec A n) → Vec.lookup i xs ∈ xs
lookup-∈ () []
lookup-∈ zero (x ∷ xs) = here P.refl
lookup-∈ (suc i) (x ∷ xs) = there (lookup-∈ i xs)
lookup-injective : ∀ {a n}{A : Set a} {xs : Vec A n}{i j} →
Distinct xs → Vec.lookup i xs ≡ Vec.lookup j xs → i ≡ j
lookup-injective {i = ()} {j} distinct-[] _
lookup-injective {i = zero} {zero} (x distinct-∷ dxs by x∉xs) eq = P.refl
lookup-injective {i = suc i} {suc j} (x distinct-∷ dxs by x∉xs) eq = P.cong Fin.suc (lookup-injective dxs eq)
lookup-injective {xs = _ ∷ xs} {i = zero} {suc j} (x distinct-∷ dxs by x∉xs) eq rewrite eq =
⊥-elim (x∉xs (lookup-∈ j xs))
lookup-injective {xs = _ ∷ xs} {i = suc i} {zero} (x distinct-∷ dxs by x∉xs) eq rewrite P.sym eq = ⊥-elim (x∉xs (lookup-∈ i xs))
| {
"alphanum_fraction": 0.5897365532,
"avg_line_length": 54.3880597015,
"ext": "agda",
"hexsha": "d1c108ee6a750c4ee99c7a159b7494d34c16309f",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "d4cd2a3442a9b58e6139499d16a2b31268f27f80",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "tizmd/agda-distinct-disjoint",
"max_forks_repo_path": "src/Data/Vec/Membership/Propositional/Distinct/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "d4cd2a3442a9b58e6139499d16a2b31268f27f80",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "tizmd/agda-distinct-disjoint",
"max_issues_repo_path": "src/Data/Vec/Membership/Propositional/Distinct/Properties.agda",
"max_line_length": 129,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "d4cd2a3442a9b58e6139499d16a2b31268f27f80",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "tizmd/agda-distinct-disjoint",
"max_stars_repo_path": "src/Data/Vec/Membership/Propositional/Distinct/Properties.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1546,
"size": 3644
} |
module Utils where
open import Data.Fin using (Fin)
import Data.Fin as F
open import Data.Nat
data Fromℕ (n : ℕ) : ℕ → Set where
yes : (m : Fin n) → Fromℕ n (F.toℕ m)
no : (m : ℕ) → Fromℕ n (n + m)
fromℕ : ∀ n m → Fromℕ n m
fromℕ zero m = no m
fromℕ (suc n) zero = yes F.zero
fromℕ (suc n) (suc m) with fromℕ n m
fromℕ (suc n) (suc .(F.toℕ m)) | yes m = yes (F.suc m)
fromℕ (suc n) (suc .(n + m)) | no m = no m
| {
"alphanum_fraction": 0.5707656613,
"avg_line_length": 25.3529411765,
"ext": "agda",
"hexsha": "fddda83d2b6d4d807dfec3b6a272a3786d56cb3c",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "6f3df71dcd958c6a1d1bf4f175dc16c220d42124",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "bens/hwlc",
"max_forks_repo_path": "Utils.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "6f3df71dcd958c6a1d1bf4f175dc16c220d42124",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "bens/hwlc",
"max_issues_repo_path": "Utils.agda",
"max_line_length": 54,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "6f3df71dcd958c6a1d1bf4f175dc16c220d42124",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "bens/hwlc",
"max_stars_repo_path": "Utils.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 196,
"size": 431
} |
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Fundamental {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.LogicalRelation
open import Definition.LogicalRelation.Irrelevance
open import Definition.LogicalRelation.Properties
open import Definition.LogicalRelation.Substitution
open import Definition.LogicalRelation.Substitution.Properties
open import Definition.LogicalRelation.Substitution.Conversion
open import Definition.LogicalRelation.Substitution.Reduction
open import Definition.LogicalRelation.Substitution.Reflexivity
open import Definition.LogicalRelation.Substitution.Introductions
import Definition.LogicalRelation.Substitution.Irrelevance as S
open import Agda.Primitive
open import Tools.Product
open import Tools.Unit
open import Tools.Nat
import Tools.PropositionalEquality as PE
mutual
-- Fundamental theorem for contexts.
valid : ∀ {Γ} → ⊢ Γ → ⊩ᵛ Γ
valid ε = ε′
valid (⊢Γ ∙ A) = let [Γ] , [A] = fundamental A in [Γ] ∙′ [A]
-- Fundamental theorem for types.
fundamental : ∀ {Γ A} (⊢A : Γ ⊢ A) → Σω₄ (⊩ᵛ Γ) (λ [Γ] → Γ ⊩ᵛ⟨ ¹ ⟩ A / [Γ])
fundamental (ℕⱼ x) = valid x , ℕᵛ (valid x)
fundamental (Uⱼ x) = valid x , Uᵛ (valid x)
fundamental (Πⱼ_▹_ {F} {G} ⊢F ⊢G) with fundamental ⊢F | fundamental ⊢G
fundamental (Πⱼ_▹_ {F} {G} ⊢F ⊢G) | [Γ] , [F] | [Γ∙F] , [G] =
[Γ] , Πᵛ {F} {G} [Γ] [F] (S.irrelevance {A = G} [Γ∙F] ([Γ] ∙′ [F]) [G])
fundamental (univ {A} ⊢A) with fundamentalTerm ⊢A
fundamental (univ {A} ⊢A) | [Γ] , [U] , [A] =
[Γ] , univᵛ {A} [Γ] [U] [A]
-- Fundamental theorem for type equality.
fundamentalEq : ∀{Γ A B} → Γ ⊢ A ≡ B
→ ∃ω₄ λ ([Γ] : ⊩ᵛ Γ)
→ ∃ω₃² λ ([A] : Γ ⊩ᵛ⟨ ¹ ⟩ A / [Γ]) ([B] : Γ ⊩ᵛ⟨ ¹ ⟩ B / [Γ])
→ Γ ⊩ᵛ⟨ ¹ ⟩ A ≡ B / [Γ] / [A]
fundamentalEq (univ {A} {B} x) with fundamentalTermEq x
fundamentalEq (univ {A} {B} x) | [Γ] , modelsTermEq [U] [t] [u] [t≡u] =
let [A] = univᵛ {A} [Γ] [U] [t]
[B] = univᵛ {B} [Γ] [U] [u]
in [Γ] , [A] , [B]
, (λ ⊢Δ [σ] → univEqEq (proj₁ ([U] ⊢Δ [σ]))
(proj₁ ([A] ⊢Δ [σ]))
([t≡u] ⊢Δ [σ]))
fundamentalEq (refl D) =
let [Γ] , [B] = fundamental D
in [Γ] , [B] , [B] , (λ ⊢Δ [σ] → reflEq (proj₁ ([B] ⊢Δ [σ])))
fundamentalEq (sym A≡B) with fundamentalEq A≡B
fundamentalEq (sym A≡B) | [Γ] , [B] , [A] , [B≡A] =
[Γ] , [A] , [B]
, (λ ⊢Δ [σ] → symEq (proj₁ ([B] ⊢Δ [σ]))
(proj₁ ([A] ⊢Δ [σ]))
([B≡A] ⊢Δ [σ]))
fundamentalEq (trans {A} {B₁} {B} A≡B₁ B₁≡B)
with fundamentalEq A≡B₁ | fundamentalEq B₁≡B
fundamentalEq (trans {A} {B₁} {B} A≡B B≡C) | [Γ] , [A] , [B₁] , [A≡B₁]
| [Γ]₁ , [B₁]₁ , [B] , [B₁≡B] =
[Γ] , [A] , S.irrelevance {A = B} [Γ]₁ [Γ] [B]
, (λ ⊢Δ [σ] →
let [σ]′ = S.irrelevanceSubst [Γ] [Γ]₁ ⊢Δ ⊢Δ [σ]
in transEq (proj₁ ([A] ⊢Δ [σ])) (proj₁ ([B₁] ⊢Δ [σ]))
(proj₁ ([B] ⊢Δ [σ]′)) ([A≡B₁] ⊢Δ [σ])
(irrelevanceEq (proj₁ ([B₁]₁ ⊢Δ [σ]′))
(proj₁ ([B₁] ⊢Δ [σ]))
([B₁≡B] ⊢Δ [σ]′)))
fundamentalEq (Π-cong {F} {H} {G} {E} ⊢F A≡B A≡B₁)
with fundamentalEq A≡B | fundamentalEq A≡B₁
fundamentalEq (Π-cong {F} {H} {G} {E} ⊢F A≡B A≡B₁) | [Γ] , [F] , [H] , [F≡H]
| [Γ]₁ , [G] , [E] , [G≡E] =
let [G]′ = S.irrelevance {A = G} [Γ]₁ ([Γ] ∙′ [F]) [G]
[E]′ = S.irrelevanceLift {A = E} {F = F} {H = H} [Γ] [F] [H] [F≡H]
(S.irrelevance {A = E} [Γ]₁ ([Γ] ∙′ [F]) [E])
[G≡E]′ = S.irrelevanceEq {A = G} {B = E} [Γ]₁
([Γ] ∙′ [F]) [G] [G]′ [G≡E]
in [Γ]
, Πᵛ {F} {G} [Γ] [F] [G]′
, Πᵛ {H} {E} [Γ] [H] [E]′
, Π-congᵛ {F} {G} {H} {E} [Γ] [F] [G]′ [H] [E]′ [F≡H] [G≡E]′
-- Fundamental theorem for variables.
fundamentalVar : ∀ {Γ A x}
→ x ∷ A ∈ Γ
→ ([Γ] : ⊩ᵛ Γ)
→ ∃ω₃ λ ([A] : Γ ⊩ᵛ⟨ ¹ ⟩ A / [Γ])
→ Γ ⊩ᵛ⟨ ¹ ⟩ var x ∷ A / [Γ] / [A]
fundamentalVar here (VPack _ _ (V∙ {A = A} {l = l} [Γ] [A])) =
(λ ⊢Δ [σ] →
let [σA] = proj₁ ([A] ⊢Δ (proj₁ [σ]))
[σA′] = maybeEmb (irrelevance′ (PE.sym (subst-wk A)) [σA])
in [σA′]
, (λ [σ′] [σ≡σ′] →
irrelevanceEq″ (PE.sym (subst-wk A)) (PE.sym (subst-wk A))
[σA] [σA′] (proj₂ ([A] ⊢Δ (proj₁ [σ]))
(proj₁ [σ′]) (proj₁ [σ≡σ′]))))
, (λ ⊢Δ [σ] →
let [σA] = proj₁ ([A] ⊢Δ (proj₁ [σ]))
[σA′] = maybeEmb (irrelevance′ (PE.sym (subst-wk A)) [σA])
in irrelevanceTerm′ (PE.sym (subst-wk A)) [σA] [σA′] (proj₂ [σ])
, (λ [σ′] [σ≡σ′] → irrelevanceEqTerm′ (PE.sym (subst-wk A))
[σA] [σA′] (proj₂ [σ≡σ′])))
fundamentalVar (there {A = A} h) ([Γ] ∙′ [B]) =
(λ ⊢Δ [σ] →
let [h] = proj₁ (fundamentalVar h [Γ]) ⊢Δ (proj₁ [σ])
[σA] = proj₁ [h]
[σA′] = irrelevance′ (PE.sym (subst-wk A)) [σA]
in [σA′]
, (λ [σ′] [σ≡σ′] →
irrelevanceEq″ (PE.sym (subst-wk A)) (PE.sym (subst-wk A))
[σA] [σA′]
(proj₂ [h] (proj₁ [σ′]) (proj₁ [σ≡σ′]))))
, (λ ⊢Δ [σ] →
let [h] = (proj₁ (fundamentalVar h [Γ])) ⊢Δ (proj₁ [σ])
[σA] = proj₁ [h]
[σA′] = irrelevance′ (PE.sym (subst-wk A)) [σA]
[h′] = (proj₂ (fundamentalVar h [Γ])) ⊢Δ (proj₁ [σ])
in irrelevanceTerm′ (PE.sym (subst-wk A)) [σA] [σA′] (proj₁ [h′])
, (λ [σ′] [σ≡σ′] →
irrelevanceEqTerm′ (PE.sym (subst-wk A)) [σA] [σA′]
(proj₂ [h′] (proj₁ [σ′]) (proj₁ [σ≡σ′]))))
-- Fundamental theorem for terms.
fundamentalTerm : ∀{Γ A t} → Γ ⊢ t ∷ A
→ ∃ω₄ λ ([Γ] : ⊩ᵛ Γ)
→ ∃ω₃ λ ([A] : Γ ⊩ᵛ⟨ ¹ ⟩ A / [Γ])
→ Γ ⊩ᵛ⟨ ¹ ⟩ t ∷ A / [Γ] / [A]
fundamentalTerm (ℕⱼ x) = valid x , Uᵛ (valid x) , ℕᵗᵛ (valid x)
fundamentalTerm (Πⱼ_▹_ {F} {G} ⊢F ⊢G)
with fundamentalTerm ⊢F | fundamentalTerm ⊢G
... | [Γ] , [U] , [F]ₜ | [Γ]₁ , [U]₁ , [G]ₜ =
let [F] = univᵛ {F} [Γ] [U] [F]ₜ
[U]′ = S.irrelevance {A = U} [Γ]₁ ([Γ] ∙′ [F]) [U]₁
[F]ₜ′ = S.irrelevanceTerm {A = U} {t = F} [Γ] [Γ] [U] (Uᵛ [Γ]) [F]ₜ
[G]ₜ′ = S.irrelevanceTerm {A = U} {t = G} [Γ]₁ ([Γ] ∙′ [F]) [U]₁
(λ {Δ} {σ} → [U]′ {Δ} {σ}) [G]ₜ
in [Γ] , [U]
, S.irrelevanceTerm {A = U} {t = Π F ▹ G} [Γ] [Γ] (Uᵛ [Γ]) [U]
(Πᵗᵛ {F} {G} [Γ] [F] (λ {Δ} {σ} → [U]′ {Δ} {σ})
[F]ₜ′ [G]ₜ′)
fundamentalTerm (var ⊢Γ x∷A) = valid ⊢Γ , fundamentalVar x∷A (valid ⊢Γ)
fundamentalTerm (lamⱼ {F} {G} {t} ⊢F ⊢t)
with fundamental ⊢F | fundamentalTerm ⊢t
... | [Γ] , [F] | [Γ]₁ , [G] , [t] =
let [G]′ = S.irrelevance {A = G} [Γ]₁ ([Γ] ∙′ [F]) [G]
[t]′ = S.irrelevanceTerm {A = G} {t = t} [Γ]₁ ([Γ] ∙′ [F]) [G] [G]′ [t]
in [Γ] , Πᵛ {F} {G} [Γ] [F] [G]′
, lamᵛ {F} {G} {t} [Γ] [F] [G]′ [t]′
fundamentalTerm (_∘ⱼ_ {g} {a} {F} {G} Dt Du)
with fundamentalTerm Dt | fundamentalTerm Du
... | [Γ] , [ΠFG] , [t] | [Γ]₁ , [F] , [u] =
let [ΠFG]′ = S.irrelevance {A = Π F ▹ G} [Γ] [Γ]₁ [ΠFG]
[t]′ = S.irrelevanceTerm {A = Π F ▹ G} {t = g} [Γ] [Γ]₁ [ΠFG] [ΠFG]′ [t]
[G[t]] = substSΠ {F} {G} {a} [Γ]₁ [F] [ΠFG]′ [u]
[t∘u] = appᵛ {F} {G} {g} {a} [Γ]₁ [F] [ΠFG]′ [t]′ [u]
in [Γ]₁ , [G[t]] , [t∘u]
fundamentalTerm (zeroⱼ x) = valid x , ℕᵛ (valid x) , zeroᵛ {l = ¹} (valid x)
fundamentalTerm (sucⱼ {n} t) with fundamentalTerm t
fundamentalTerm (sucⱼ {n} t) | [Γ] , [ℕ] , [n] =
[Γ] , [ℕ] , sucᵛ {n = n} [Γ] [ℕ] [n]
fundamentalTerm (natrecⱼ {G} {s} {z} {n} ⊢G ⊢z ⊢s ⊢n)
with fundamental ⊢G | fundamentalTerm ⊢z | fundamentalTerm ⊢s
| fundamentalTerm ⊢n
... | [Γ] , [G] | [Γ]₁ , [G₀] , [z] | [Γ]₂ , [G₊] , [s] | [Γ]₃ , [ℕ] , [n] =
let sType = Π ℕ ▹ (G ▹▹ G [ suc (var 0) ]↑)
[Γ]′ = [Γ]₃
[G]′ = S.irrelevance {A = G} [Γ] ([Γ]′ ∙′ [ℕ]) [G]
[G₀]′ = S.irrelevance {A = G [ zero ]} [Γ]₁ [Γ]′ [G₀]
[G₊]′ = S.irrelevance {A = sType} [Γ]₂ [Γ]′ [G₊]
[Gₙ]′ = substS {F = ℕ} {G = G} {t = n} [Γ]′ [ℕ] [G]′ [n]
[z]′ = S.irrelevanceTerm {A = G [ zero ]} {t = z} [Γ]₁ [Γ]′
[G₀] [G₀]′ [z]
[s]′ = S.irrelevanceTerm {A = sType} {t = s} [Γ]₂ [Γ]′ [G₊] [G₊]′ [s]
in [Γ]′ , [Gₙ]′
, natrecᵛ {G} {z} {s} {n} [Γ]′ [ℕ] [G]′ [G₀]′ [G₊]′ [Gₙ]′ [z]′ [s]′ [n]
fundamentalTerm (conv {t} {A} {B} ⊢t A′≡A)
with fundamentalTerm ⊢t | fundamentalEq A′≡A
fundamentalTerm (conv {t} {A} {B} ⊢t A′≡A) | [Γ] , [A′] , [t]
| [Γ]₁ , [A′]₁ , [A] , [A′≡A] =
let [Γ]′ = [Γ]₁
[t]′ = S.irrelevanceTerm {A = A} {t = t} [Γ] [Γ]′ [A′] [A′]₁ [t]
in [Γ]′ , [A]
, convᵛ {t} {A} {B} [Γ]′ [A′]₁ [A] [A′≡A] [t]′
-- Fundamental theorem for term equality.
fundamentalTermEq : ∀{Γ A t t′} → Γ ⊢ t ≡ t′ ∷ A
→ ∃ω₄ λ ([Γ] : ⊩ᵛ Γ)
→ [ Γ ⊩ᵛ⟨ ¹ ⟩ t ≡ t′ ∷ A / [Γ] ]
fundamentalTermEq (refl D) with fundamentalTerm D
... | [Γ] , [A] , [t] =
[Γ] , modelsTermEq [A] [t] [t]
(λ ⊢Δ [σ] → reflEqTerm (proj₁ ([A] ⊢Δ [σ]))
(proj₁ ([t] ⊢Δ [σ])))
fundamentalTermEq (sym D) with fundamentalTermEq D
fundamentalTermEq (sym D) | [Γ] , modelsTermEq [A] [t′] [t] [t′≡t] =
[Γ] , modelsTermEq [A] [t] [t′]
(λ ⊢Δ [σ] → symEqTerm (proj₁ ([A] ⊢Δ [σ]))
([t′≡t] ⊢Δ [σ]))
fundamentalTermEq (trans {t} {u} {r} {A} t≡u u≡t′)
with fundamentalTermEq t≡u | fundamentalTermEq u≡t′
fundamentalTermEq (trans {t} {u} {r} {A} t≡u u≡t′)
| [Γ] , modelsTermEq [A] [t] [u] [t≡u]
| [Γ]₁ , modelsTermEq [A]₁ [t]₁ [u]₁ [t≡u]₁ =
let [r]′ = S.irrelevanceTerm {A = A} {t = r} [Γ]₁ [Γ] [A]₁ [A] [u]₁
in [Γ] , modelsTermEq [A] [t] [r]′
(λ ⊢Δ [σ] →
let [σ]′ = S.irrelevanceSubst [Γ] [Γ]₁ ⊢Δ ⊢Δ [σ]
[t≡u]₁′ = irrelevanceEqTerm (proj₁ ([A]₁ ⊢Δ [σ]′))
(proj₁ ([A] ⊢Δ [σ]))
([t≡u]₁ ⊢Δ [σ]′)
in transEqTerm (proj₁ ([A] ⊢Δ [σ]))
([t≡u] ⊢Δ [σ]) [t≡u]₁′)
fundamentalTermEq (conv {A} {B} {t} {u} t≡u A′≡A)
with fundamentalTermEq t≡u | fundamentalEq A′≡A
fundamentalTermEq (conv {A} {B} {t} {u} t≡u A′≡A)
| [Γ] , modelsTermEq [A′] [t] [u] [t≡u] | [Γ]₁ , [A′]₁ , [A] , [A′≡A] =
let [t]′ = S.irrelevanceTerm {A = A} {t = t} [Γ] [Γ]₁ [A′] [A′]₁ [t]
[u]′ = S.irrelevanceTerm {A = A} {t = u} [Γ] [Γ]₁ [A′] [A′]₁ [u]
[t]″ = convᵛ {t} {A} {B} [Γ]₁ [A′]₁ [A] [A′≡A] [t]′
[u]″ = convᵛ {u} {A} {B} [Γ]₁ [A′]₁ [A] [A′≡A] [u]′
in [Γ]₁
, modelsTermEq [A] [t]″ [u]″
(λ ⊢Δ [σ] →
let [σ]′ = S.irrelevanceSubst [Γ]₁ [Γ] ⊢Δ ⊢Δ [σ]
[t≡u]′ = irrelevanceEqTerm (proj₁ ([A′] ⊢Δ [σ]′))
(proj₁ ([A′]₁ ⊢Δ [σ]))
([t≡u] ⊢Δ [σ]′)
in convEqTerm₁ (proj₁ ([A′]₁ ⊢Δ [σ])) (proj₁ ([A] ⊢Δ [σ]))
([A′≡A] ⊢Δ [σ]) [t≡u]′)
fundamentalTermEq (Π-cong {E} {F} {G} {H} ⊢F F≡H G≡E)
with fundamental ⊢F | fundamentalTermEq F≡H | fundamentalTermEq G≡E
... | [Γ] , [F] | [Γ]₁ , modelsTermEq [U] [F]ₜ [H]ₜ [F≡H]ₜ
| [Γ]₂ , modelsTermEq [U]₁ [G]ₜ [E]ₜ [G≡E]ₜ =
let [U]′ = Uᵛ [Γ]
[F]ₜ′ = S.irrelevanceTerm {A = U} {t = F} [Γ]₁ [Γ] [U] [U]′ [F]ₜ
[H]ₜ′ = S.irrelevanceTerm {A = U} {t = H} [Γ]₁ [Γ] [U] [U]′ [H]ₜ
[F]′ = S.irrelevance {A = F} [Γ] [Γ]₁ [F]
[H] = univᵛ {A = H} [Γ] [U]′ [H]ₜ′
[F≡H] = S.irrelevanceEq {A = F} {B = H} [Γ]₁ [Γ] [F]′ [F]
(univEqᵛ {F} {H} [Γ]₁ [U] [F]′ [F≡H]ₜ)
[U]₁′ = Uᵛ (VPack _ _ (V∙ {A = F} [Γ] [F]))
[U]₂′ = Uᵛ (VPack _ _ (V∙ {A = H} [Γ] [H]))
[G]ₜ′ = S.irrelevanceTerm {A = U} {t = G} [Γ]₂ ([Γ] ∙′ [F])
[U]₁ (λ {Δ} {σ} → [U]₁′ {Δ} {σ}) [G]ₜ
[E]ₜ′ = S.irrelevanceTermLift {A = U} {F = F} {H = H} {t = E}
[Γ] [F] [H] [F≡H]
(λ {Δ} {σ} → [U]₁′ {Δ} {σ})
(S.irrelevanceTerm {A = U} {t = E} [Γ]₂ ([Γ] ∙′ [F])
[U]₁ (λ {Δ} {σ} → [U]₁′ {Δ} {σ}) [E]ₜ)
[F≡H]ₜ′ = S.irrelevanceEqTerm {A = U} {t = F} {u = H}
[Γ]₁ [Γ] [U] (Uᵛ [Γ]) [F≡H]ₜ
[G≡E]ₜ′ = S.irrelevanceEqTerm {A = U} {t = G} {u = E} [Γ]₂
(VPack _ _ (V∙ {A = F} [Γ] [F])) [U]₁
(λ {Δ} {σ} → [U]₁′ {Δ} {σ}) [G≡E]ₜ
in [Γ]
, modelsTermEq
[U]′
(Πᵗᵛ {F} {G} [Γ] [F] (λ {Δ} {σ} → [U]₁′ {Δ} {σ}) [F]ₜ′ [G]ₜ′)
(Πᵗᵛ {H} {E} [Γ] [H] (λ {Δ} {σ} → [U]₂′ {Δ} {σ}) [H]ₜ′ [E]ₜ′)
(Π-congᵗᵛ {F} {G} {H} {E} [Γ] [F] [H]
(λ {Δ} {σ} → [U]₁′ {Δ} {σ}) (λ {Δ} {σ} → [U]₂′ {Δ} {σ})
[F]ₜ′ [G]ₜ′ [H]ₜ′ [E]ₜ′ [F≡H]ₜ′ [G≡E]ₜ′)
fundamentalTermEq (app-cong {a} {b} {f} {g} {F} {G} f≡g a≡b)
with fundamentalTermEq f≡g | fundamentalTermEq a≡b
... | [Γ] , modelsTermEq [ΠFG] [f] [g] [f≡g]
| [Γ]₁ , modelsTermEq [F] [a] [b] [a≡b] =
let [ΠFG]′ = S.irrelevance {A = Π F ▹ G} [Γ] [Γ]₁ [ΠFG]
[f]′ = S.irrelevanceTerm {A = Π F ▹ G} {t = f} [Γ] [Γ]₁ [ΠFG] [ΠFG]′ [f]
[g]′ = S.irrelevanceTerm {A = Π F ▹ G} {t = g} [Γ] [Γ]₁ [ΠFG] [ΠFG]′ [g]
[f≡g]′ = S.irrelevanceEqTerm {A = Π F ▹ G} {t = f} {u = g}
[Γ] [Γ]₁ [ΠFG] [ΠFG]′ [f≡g]
[G[a]] = substSΠ {F} {G} {a} [Γ]₁ [F] [ΠFG]′ [a]
[G[b]] = substSΠ {F} {G} {b} [Γ]₁ [F] [ΠFG]′ [b]
[G[a]≡G[b]] = substSΠEq {F} {G} {F} {G} {a} {b} [Γ]₁ [F] [F] [ΠFG]′
[ΠFG]′ (reflᵛ {Π F ▹ G} [Γ]₁ [ΠFG]′) [a] [b] [a≡b]
in [Γ]₁ , modelsTermEq [G[a]]
(appᵛ {F} {G} {f} {a} [Γ]₁ [F] [ΠFG]′ [f]′ [a])
(conv₂ᵛ {g ∘ b} {G [ a ]} {G [ b ]} [Γ]₁
[G[a]] [G[b]] [G[a]≡G[b]]
(appᵛ {F} {G} {g} {b}
[Γ]₁ [F] [ΠFG]′ [g]′ [b]))
(app-congᵛ {F} {G} {f} {g} {a} {b}
[Γ]₁ [F] [ΠFG]′ [f≡g]′ [a] [b] [a≡b])
fundamentalTermEq (β-red {a} {b} {F} {G} ⊢F ⊢b ⊢a)
with fundamental ⊢F | fundamentalTerm ⊢b | fundamentalTerm ⊢a
... | [Γ] , [F] | [Γ]₁ , [G] , [b] | [Γ]₂ , [F]₁ , [a] =
let [G]′ = S.irrelevance {A = G} [Γ]₁ ([Γ]₂ ∙′ [F]₁) [G]
[b]′ = S.irrelevanceTerm {A = G} {t = b} [Γ]₁ ([Γ]₂ ∙′ [F]₁) [G] [G]′ [b]
[G[a]] = substS {F} {G} {a} [Γ]₂ [F]₁ [G]′ [a]
[b[a]] = substSTerm {F} {G} {a} {b} [Γ]₂ [F]₁ [G]′ [b]′ [a]
[lam] , [eq] =
redSubstTermᵛ {G [ a ]} {(lam b) ∘ a} {b [ a ]} [Γ]₂
(λ {Δ} {σ} ⊢Δ [σ] →
let [liftσ] = liftSubstS {F = F} [Γ]₂ ⊢Δ [F]₁ [σ]
⊢σF = escape (proj₁ ([F]₁ ⊢Δ [σ]))
⊢σb = escapeTerm (proj₁ ([G]′ (⊢Δ ∙ ⊢σF) [liftσ]))
(proj₁ ([b]′ (⊢Δ ∙ ⊢σF) [liftσ]))
⊢σa = escapeTerm (proj₁ ([F]₁ ⊢Δ [σ]))
(proj₁ ([a] ⊢Δ [σ]))
in PE.subst₂ (λ x y → _ ⊢ (lam (subst (liftSubst σ) b))
∘ (subst σ a) ⇒ x ∷ y)
(PE.sym (singleSubstLift b a))
(PE.sym (singleSubstLift G a))
(β-red ⊢σF ⊢σb ⊢σa))
[G[a]] [b[a]]
in [Γ]₂ , modelsTermEq [G[a]] [lam] [b[a]] [eq]
fundamentalTermEq (η-eq {f} {g} {F} {G} ⊢F ⊢t ⊢t′ t≡t′) with
fundamental ⊢F | fundamentalTerm ⊢t |
fundamentalTerm ⊢t′ | fundamentalTermEq t≡t′
... | [Γ] , [F] | [Γ]₁ , [ΠFG] , [t] | [Γ]₂ , [ΠFG]₁ , [t′]
| [Γ]₃ , modelsTermEq [G] [t0] [t′0] [t0≡t′0] =
let [F]′ = S.irrelevance {A = F} [Γ] [Γ]₁ [F]
[G]′ = S.irrelevance {A = G} [Γ]₃ ([Γ]₁ ∙′ [F]′) [G]
[t′]′ = S.irrelevanceTerm {A = Π F ▹ G} {t = g}
[Γ]₂ [Γ]₁ [ΠFG]₁ [ΠFG] [t′]
[ΠFG]″ = Πᵛ {F} {G} [Γ]₁ [F]′ [G]′
[t]″ = S.irrelevanceTerm {A = Π F ▹ G} {t = f}
[Γ]₁ [Γ]₁ [ΠFG] [ΠFG]″ [t]
[t′]″ = S.irrelevanceTerm {A = Π F ▹ G} {t = g}
[Γ]₂ [Γ]₁ [ΠFG]₁ [ΠFG]″ [t′]
[t0≡t′0]′ = S.irrelevanceEqTerm {A = G} {t = wk1 f ∘ var 0}
{u = wk1 g ∘ var 0}
[Γ]₃ ([Γ]₁ ∙′ [F]′) [G] [G]′ [t0≡t′0]
[t≡t′] = η-eqᵛ {f} {g} {F} {G} [Γ]₁ [F]′ [G]′ [t]″ [t′]″ [t0≡t′0]′
[t≡t′]′ = S.irrelevanceEqTerm {A = Π F ▹ G} {t = f} {u = g}
[Γ]₁ [Γ]₁ [ΠFG]″ [ΠFG] [t≡t′]
in [Γ]₁ , modelsTermEq [ΠFG] [t] [t′]′ [t≡t′]′
fundamentalTermEq (suc-cong x) with fundamentalTermEq x
fundamentalTermEq (suc-cong {t} {u} x)
| [Γ] , modelsTermEq [A] [t] [u] [t≡u] =
let [suct] = sucᵛ {n = t} [Γ] [A] [t]
[sucu] = sucᵛ {n = u} [Γ] [A] [u]
in [Γ] , modelsTermEq [A] [suct] [sucu]
(λ ⊢Δ [σ] →
sucEqTerm (proj₁ ([A] ⊢Δ [σ])) ([t≡u] ⊢Δ [σ]))
fundamentalTermEq (natrec-cong {z} {z′} {s} {s′} {n} {n′} {F} {F′}
F≡F′ z≡z′ s≡s′ n≡n′)
with fundamentalEq F≡F′ |
fundamentalTermEq z≡z′ |
fundamentalTermEq s≡s′ |
fundamentalTermEq n≡n′
fundamentalTermEq (natrec-cong {z} {z′} {s} {s′} {n} {n′} {F} {F′}
F≡F′ z≡z′ s≡s′ n≡n′) |
[Γ] , [F] , [F′] , [F≡F′] |
[Γ]₁ , modelsTermEq [F₀] [z] [z′] [z≡z′] |
[Γ]₂ , modelsTermEq [F₊] [s] [s′] [s≡s′] |
[Γ]₃ , modelsTermEq [ℕ] [n] [n′] [n≡n′] =
let sType = Π ℕ ▹ (F ▹▹ F [ suc (var 0) ]↑)
s′Type = Π ℕ ▹ (F′ ▹▹ F′ [ suc (var 0) ]↑)
[0] = S.irrelevanceTerm {l = ¹} {A = ℕ} {t = zero}
[Γ]₃ [Γ]₃ (ℕᵛ [Γ]₃) [ℕ] (zeroᵛ {l = ¹} [Γ]₃)
[F]′ = S.irrelevance {A = F} [Γ] ([Γ]₃ ∙′ [ℕ]) [F]
[F₀]′ = S.irrelevance {A = F [ zero ]} [Γ]₁ [Γ]₃ [F₀]
[F₊]′ = S.irrelevance {A = sType} [Γ]₂ [Γ]₃ [F₊]
[Fₙ]′ = substS {ℕ} {F} {n} [Γ]₃ [ℕ] [F]′ [n]
[F′]′ = S.irrelevance {A = F′} [Γ] ([Γ]₃ ∙′ [ℕ]) [F′]
[F₀]″ = substS {ℕ} {F} {zero} [Γ]₃ [ℕ] [F]′ [0]
[F′₀]′ = substS {ℕ} {F′} {zero} [Γ]₃ [ℕ] [F′]′ [0]
[F′₊]′ = sucCase {F′} [Γ]₃ [ℕ] [F′]′
[F′ₙ′]′ = substS {ℕ} {F′} {n′} [Γ]₃ [ℕ] [F′]′ [n′]
[ℕ≡ℕ] = reflᵛ {ℕ} [Γ]₃ [ℕ]
[0≡0] = reflᵗᵛ {ℕ} {zero} [Γ]₃ [ℕ] [0]
[F≡F′]′ = S.irrelevanceEq {A = F} {B = F′}
[Γ] ([Γ]₃ ∙′ [ℕ]) [F] [F]′ [F≡F′]
[F₀≡F′₀] = substSEq {ℕ} {ℕ} {F} {F′} {zero} {zero}
[Γ]₃ [ℕ] [ℕ] [ℕ≡ℕ]
[F]′ [F′]′ [F≡F′]′ [0] [0] [0≡0]
[F₀≡F′₀]′ = S.irrelevanceEq {A = F [ zero ]} {B = F′ [ zero ]}
[Γ]₃ [Γ]₃ [F₀]″ [F₀]′ [F₀≡F′₀]
[F₊≡F′₊] = sucCaseCong {F} {F′} [Γ]₃ [ℕ] [F]′ [F′]′ [F≡F′]′
[F₊≡F′₊]′ = S.irrelevanceEq {A = sType} {B = s′Type}
[Γ]₃ [Γ]₃ (sucCase {F} [Γ]₃ [ℕ] [F]′)
[F₊]′ [F₊≡F′₊]
[Fₙ≡F′ₙ′]′ = substSEq {ℕ} {ℕ} {F} {F′} {n} {n′}
[Γ]₃ [ℕ] [ℕ] [ℕ≡ℕ] [F]′ [F′]′ [F≡F′]′
[n] [n′] [n≡n′]
[z]′ = S.irrelevanceTerm {A = F [ zero ]} {t = z}
[Γ]₁ [Γ]₃ [F₀] [F₀]′ [z]
[z′]′ = convᵛ {z′} {F [ zero ]} {F′ [ zero ]}
[Γ]₃ [F₀]′ [F′₀]′ [F₀≡F′₀]′
(S.irrelevanceTerm {A = F [ zero ]} {t = z′}
[Γ]₁ [Γ]₃ [F₀] [F₀]′ [z′])
[z≡z′]′ = S.irrelevanceEqTerm {A = F [ zero ]} {t = z} {u = z′}
[Γ]₁ [Γ]₃ [F₀] [F₀]′ [z≡z′]
[s]′ = S.irrelevanceTerm {A = sType} {t = s} [Γ]₂ [Γ]₃ [F₊] [F₊]′ [s]
[s′]′ = convᵛ {s′} {sType} {s′Type} [Γ]₃ [F₊]′ [F′₊]′ [F₊≡F′₊]′
(S.irrelevanceTerm {A = sType} {t = s′}
[Γ]₂ [Γ]₃ [F₊] [F₊]′ [s′])
[s≡s′]′ = S.irrelevanceEqTerm {A = sType} {t = s} {u = s′}
[Γ]₂ [Γ]₃ [F₊] [F₊]′ [s≡s′]
in [Γ]₃
, modelsTermEq [Fₙ]′
(natrecᵛ {F} {z} {s} {n}
[Γ]₃ [ℕ] [F]′ [F₀]′ [F₊]′ [Fₙ]′ [z]′ [s]′ [n])
(conv₂ᵛ {natrec F′ z′ s′ n′} {F [ n ]} {F′ [ n′ ]}
[Γ]₃ [Fₙ]′ [F′ₙ′]′ [Fₙ≡F′ₙ′]′
(natrecᵛ {F′} {z′} {s′} {n′}
[Γ]₃ [ℕ] [F′]′ [F′₀]′ [F′₊]′ [F′ₙ′]′
[z′]′ [s′]′ [n′]))
(natrec-congᵛ {F} {F′} {z} {z′} {s} {s′} {n} {n′}
[Γ]₃ [ℕ] [F]′ [F′]′ [F≡F′]′
[F₀]′ [F′₀]′ [F₀≡F′₀]′
[F₊]′ [F′₊]′ [F₊≡F′₊]′ [Fₙ]′
[z]′ [z′]′ [z≡z′]′
[s]′ [s′]′ [s≡s′]′ [n] [n′] [n≡n′])
fundamentalTermEq (natrec-zero {z} {s} {F} ⊢F ⊢z ⊢s)
with fundamental ⊢F | fundamentalTerm ⊢z | fundamentalTerm ⊢s
fundamentalTermEq (natrec-zero {z} {s} {F} ⊢F ⊢z ⊢s) | [Γ] , [F]
| [Γ]₁ , [F₀] , [z] | [Γ]₂ , [F₊] , [s] =
let sType = Π ℕ ▹ (F ▹▹ F [ suc (var 0) ]↑)
[Γ]′ = [Γ]₁
[ℕ]′ = ℕᵛ {l = ¹} [Γ]′
[F₊]′ = S.irrelevance {A = sType} [Γ]₂ [Γ]′ [F₊]
[s]′ = S.irrelevanceTerm {A = sType} {t = s} [Γ]₂ [Γ]′ [F₊] [F₊]′ [s]
[F]′ = S.irrelevance {A = F} [Γ] ([Γ]′ ∙′ [ℕ]′) [F]
d , r =
redSubstTermᵛ {F [ zero ]} {natrec F z s zero} {z} [Γ]′
(λ {Δ} {σ} ⊢Δ [σ] →
let ⊢ℕ = escape (proj₁ ([ℕ]′ ⊢Δ [σ]))
⊢F = escape (proj₁ ([F]′ (⊢Δ ∙ ⊢ℕ)
(liftSubstS {F = ℕ}
[Γ]′ ⊢Δ [ℕ]′ [σ])))
⊢z = PE.subst (λ x → Δ ⊢ subst σ z ∷ x)
(singleSubstLift F zero)
(escapeTerm (proj₁ ([F₀] ⊢Δ [σ]))
(proj₁ ([z] ⊢Δ [σ])))
⊢s = PE.subst (λ x → Δ ⊢ subst σ s ∷ x)
(natrecSucCase σ F)
(escapeTerm (proj₁ ([F₊]′ ⊢Δ [σ]))
(proj₁ ([s]′ ⊢Δ [σ])))
in PE.subst (λ x → Δ ⊢ subst σ (natrec F z s zero)
⇒ subst σ z ∷ x)
(PE.sym (singleSubstLift F zero))
(natrec-zero ⊢F ⊢z ⊢s))
[F₀] [z]
in [Γ]′ , modelsTermEq [F₀] d [z] r
fundamentalTermEq (natrec-suc {n} {z} {s} {F} ⊢n ⊢F ⊢z ⊢s)
with fundamentalTerm ⊢n | fundamental ⊢F
| fundamentalTerm ⊢z | fundamentalTerm ⊢s
... | [Γ] , [ℕ] , [n] | [Γ]₁ , [F] | [Γ]₂ , [F₀] , [z] | [Γ]₃ , [F₊] , [s] =
let [ℕ]′ = S.irrelevance {A = ℕ} [Γ] [Γ]₃ [ℕ]
[n]′ = S.irrelevanceTerm {A = ℕ} {t = n} [Γ] [Γ]₃ [ℕ] [ℕ]′ [n]
[sucn] = sucᵛ {n = n} [Γ]₃ [ℕ]′ [n]′
[F₀]′ = S.irrelevance {A = F [ zero ]} [Γ]₂ [Γ]₃ [F₀]
[z]′ = S.irrelevanceTerm {A = F [ zero ]} {t = z}
[Γ]₂ [Γ]₃ [F₀] [F₀]′ [z]
[F]′ = S.irrelevance {A = F} [Γ]₁ ([Γ]₃ ∙′ [ℕ]′) [F]
[F[sucn]] = substS {ℕ} {F} {suc n} [Γ]₃ [ℕ]′ [F]′ [sucn]
[Fₙ]′ = substS {ℕ} {F} {n} [Γ]₃ [ℕ]′ [F]′ [n]′
[natrecₙ] = natrecᵛ {F} {z} {s} {n}
[Γ]₃ [ℕ]′ [F]′ [F₀]′ [F₊] [Fₙ]′ [z]′ [s] [n]′
t = (s ∘ n) ∘ (natrec F z s n)
q = subst (liftSubst (sgSubst n))
(wk1 (F [ suc (var 0) ]↑))
y = S.irrelevanceTerm′
{A = q [ natrec F z s n ]} {A′ = F [ suc n ]} {t = t}
(natrecIrrelevantSubst′ F z s n) [Γ]₃ [Γ]₃
(substSΠ {F [ n ]} {q} {natrec F z s n} [Γ]₃
(substS {ℕ} {F} {n} [Γ]₃ [ℕ]′ [F]′ [n]′)
(substSΠ {ℕ} {F ▹▹ F [ suc (var 0) ]↑} {n}
[Γ]₃ [ℕ]′ [F₊] [n]′)
[natrecₙ])
[F[sucn]]
(appᵛ {F [ n ]} {q} {s ∘ n} {natrec F z s n} [Γ]₃ [Fₙ]′
(substSΠ {ℕ} {F ▹▹ F [ suc (var 0) ]↑} {n}
[Γ]₃ [ℕ]′ [F₊] [n]′)
(appᵛ {ℕ} {F ▹▹ F [ suc (var 0) ]↑} {s} {n}
[Γ]₃ [ℕ]′ [F₊] [s] [n]′)
[natrecₙ])
d , r =
redSubstTermᵛ {F [ suc n ]} {natrec F z s (suc n)} {t } {¹} {_} [Γ]₃
(λ {Δ} {σ} ⊢Δ [σ] →
let ⊢n = escapeTerm (proj₁ ([ℕ]′ ⊢Δ [σ]))
(proj₁ ([n]′ ⊢Δ [σ]))
⊢ℕ = escape (proj₁ ([ℕ]′ ⊢Δ [σ]))
⊢F = escape (proj₁ ([F]′ (⊢Δ ∙ ⊢ℕ)
(liftSubstS {F = ℕ}
[Γ]₃ ⊢Δ [ℕ]′ [σ])))
⊢z = PE.subst (λ x → Δ ⊢ subst σ z ∷ x)
(singleSubstLift F zero)
(escapeTerm (proj₁ ([F₀]′ ⊢Δ [σ]))
(proj₁ ([z]′ ⊢Δ [σ])))
⊢s = PE.subst (λ x → Δ ⊢ subst σ s ∷ x)
(natrecSucCase σ F)
(escapeTerm (proj₁ ([F₊] ⊢Δ [σ]))
(proj₁ ([s] ⊢Δ [σ])))
r = _⊢_⇒_∷_.natrec-suc {n = subst σ n}
{z = subst σ z} {s = subst σ s}
{F = subst (liftSubst σ) F}
⊢n ⊢F ⊢z ⊢s
in PE.subst (λ x → Δ ⊢ subst σ (natrec F z s (suc n))
⇒ (subst σ t) ∷ x)
(PE.trans (PE.trans (substCompEq F)
(substVar-to-subst (λ { 0 → PE.refl
; (1+ x) → PE.trans (subst-wk (σ x))
(subst-id (σ x))
})
F))
(PE.sym (substCompEq F)))
r)
[F[sucn]] y
in [Γ]₃ , modelsTermEq [F[sucn]] d y r
-- Fundamental theorem for substitutions.
fundamentalSubst : ∀ {Γ Δ σ} (⊢Γ : ⊢ Γ) (⊢Δ : ⊢ Δ)
→ Δ ⊢ˢ σ ∷ Γ
→ ∃ω₄ λ [Γ] → Δ ⊩ˢ σ ∷ Γ / [Γ] / ⊢Δ
fundamentalSubst ε ⊢Δ [σ] = ε′ , tt
fundamentalSubst (⊢Γ ∙ ⊢A) ⊢Δ ([tailσ] , [headσ]) =
let [Γ] , [A] = fundamental ⊢A
[Δ] , [A]′ , [t] = fundamentalTerm [headσ]
[Γ]′ , [σ] = fundamentalSubst ⊢Γ ⊢Δ [tailσ]
[tailσ]′ = S.irrelevanceSubst [Γ]′ [Γ] ⊢Δ ⊢Δ [σ]
[idA] = proj₁ ([A]′ (soundContext [Δ]) (idSubstS [Δ]))
[idA]′ = proj₁ ([A] ⊢Δ [tailσ]′)
[idt] = proj₁ ([t] (soundContext [Δ]) (idSubstS [Δ]))
in [Γ] ∙′ [A] , ([tailσ]′
, irrelevanceTerm″ (subst-id _) (subst-id _) [idA] [idA]′ [idt])
-- Fundamental theorem for substitution equality.
fundamentalSubstEq : ∀ {Γ Δ σ σ′} (⊢Γ : ⊢ Γ) (⊢Δ : ⊢ Δ)
→ Δ ⊢ˢ σ ≡ σ′ ∷ Γ
→ ∃ω₄ λ [Γ]
→ ∃ω₃² λ [σ] ([σ′] : Δ ⊩ˢ σ′ ∷ Γ / [Γ] / ⊢Δ)
→ Δ ⊩ˢ σ ≡ σ′ ∷ Γ / [Γ] / ⊢Δ / [σ]
fundamentalSubstEq ε ⊢Δ σ = ε′ , tt , tt , tt
fundamentalSubstEq (⊢Γ ∙ ⊢A) ⊢Δ (tailσ≡σ′ , headσ≡σ′) =
let [Γ] , [A] = fundamental ⊢A
[Γ]′ , [tailσ] , [tailσ′] , [tailσ≡σ′] = fundamentalSubstEq ⊢Γ ⊢Δ tailσ≡σ′
[Δ] , modelsTermEq [A]′ [t] [t′] [t≡t′] = fundamentalTermEq headσ≡σ′
[tailσ]′ = S.irrelevanceSubst [Γ]′ [Γ] ⊢Δ ⊢Δ [tailσ]
[tailσ′]′ = S.irrelevanceSubst [Γ]′ [Γ] ⊢Δ ⊢Δ [tailσ′]
[tailσ≡σ′]′ = S.irrelevanceSubstEq [Γ]′ [Γ] ⊢Δ ⊢Δ [tailσ] [tailσ]′ [tailσ≡σ′]
[idA] = proj₁ ([A]′ (soundContext [Δ]) (idSubstS [Δ]))
[idA]′ = proj₁ ([A] ⊢Δ [tailσ]′)
[idA]″ = proj₁ ([A] ⊢Δ [tailσ′]′)
[idt] = proj₁ ([t] (soundContext [Δ]) (idSubstS [Δ]))
[idt′] = proj₁ ([t′] (soundContext [Δ]) (idSubstS [Δ]))
[idt≡t′] = [t≡t′] (soundContext [Δ]) (idSubstS [Δ])
in [Γ] ∙′ [A]
, ([tailσ]′ , irrelevanceTerm″ (subst-id _) (subst-id _) [idA] [idA]′ [idt])
, ([tailσ′]′ , convTerm₁ [idA]′ [idA]″
(proj₂ ([A] ⊢Δ [tailσ]′) [tailσ′]′ [tailσ≡σ′]′)
(irrelevanceTerm″ (subst-id _) (subst-id _)
[idA] [idA]′ [idt′]))
, ([tailσ≡σ′]′ , irrelevanceEqTerm″ (subst-id _) (subst-id _) (subst-id _)
[idA] [idA]′ [idt≡t′])
| {
"alphanum_fraction": 0.3635415966,
"avg_line_length": 53.1035714286,
"ext": "agda",
"hexsha": "98a735e6a9712259b72ecaa266c639c52af8fe4b",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "2251b8da423be0c6fb916f2675d7bd8537e4cd96",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "loic-p/logrel-mltt",
"max_forks_repo_path": "Definition/LogicalRelation/Fundamental.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "2251b8da423be0c6fb916f2675d7bd8537e4cd96",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "loic-p/logrel-mltt",
"max_issues_repo_path": "Definition/LogicalRelation/Fundamental.agda",
"max_line_length": 83,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "2251b8da423be0c6fb916f2675d7bd8537e4cd96",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "loic-p/logrel-mltt",
"max_stars_repo_path": "Definition/LogicalRelation/Fundamental.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 13920,
"size": 29738
} |
------------------------------------------------------------------------
-- Some auxiliary operations and lemmas
------------------------------------------------------------------------
module BreadthFirst.Lemmas where
open import Codata.Musical.Notation
open import Codata.Musical.Colist as Colist
using (Colist; []; _∷_; concat; _++_)
open import Function
open import Data.List using ([]; _∷_)
open import Data.List.NonEmpty as List⁺ using (List⁺; [_]; _∷_; _⁺++⁺_)
import Data.Vec as Vec
open import Data.Product using (_,_)
open import Relation.Binary.PropositionalEquality as PropEq
using (_≡_) renaming (refl to ≡-refl)
open import BreadthFirst.Universe
open import BreadthFirst.Programs
open import Tree using (leaf; node; map)
open import Stream using (Stream; _≺_) renaming (_++_ to _++∞_)
------------------------------------------------------------------------
-- Some operations
zipWith : {A B : Set} (f : A → B → B) → Colist A → Stream B → Stream B
zipWith f [] ys = ys
zipWith f (x ∷ xs) (y ≺ ys) = f x y ≺ ♯ zipWith f (♭ xs) (♭ ys)
infixr 5 _⁺++_ _⁺++∞_
_⁺++∞_ : {A : Set} → List⁺ A → Stream A → Stream A
xs ⁺++∞ ys = Colist.fromList (Vec.toList $ List⁺.toVec xs) ++∞ ys
_⁺++_ : {A : Set} → List⁺ A → Colist A → Colist A
xs ⁺++ ys = Colist.fromList (Vec.toList $ List⁺.toVec xs) ++ ys
------------------------------------------------------------------------
-- Eq is an equivalence relation
refl : ∀ {a} x → Eq a x x
refl {a = tree a} leaf = leaf
refl {a = tree a} (node l x r) = node (♯ refl (♭ l)) (refl x) (♯ refl (♭ r))
refl {a = stream a} (x ≺ xs) = refl x ≺ ♯ refl (♭ xs)
refl {a = colist a} [] = []
refl {a = colist a} (x ∷ xs) = refl x ∷ ♯ refl (♭ xs)
refl {a = a ⊗ b} (x , y) = (refl x , refl y)
refl {a = ⌈ A ⌉} x = ⌈ PropEq.refl ⌉
sym : ∀ {a x y} → Eq a x y → Eq a y x
sym {a = tree a} leaf = leaf
sym {a = tree a} (node l≈l′ x≈x′ r≈r′) = node (♯ sym (♭ l≈l′)) (sym x≈x′) (♯ sym (♭ r≈r′))
sym {a = stream a} (x≈x′ ≺ xs≈xs′) = sym x≈x′ ≺ ♯ sym (♭ xs≈xs′)
sym {a = colist a} [] = []
sym {a = colist a} (x≈x′ ∷ xs≈xs′) = sym x≈x′ ∷ ♯ sym (♭ xs≈xs′)
sym {a = a ⊗ b} (x≈x′ , y≈y′) = (sym x≈x′ , sym y≈y′)
sym {a = ⌈ A ⌉} ⌈ x≡x′ ⌉ = ⌈ PropEq.sym x≡x′ ⌉
trans : ∀ {a x y z} → Eq a x y → Eq a y z → Eq a x z
trans {a = tree a} leaf leaf = leaf
trans {a = tree a} (node l≈l′ x≈x′ r≈r′)
(node l′≈l″ x′≈x″ r′≈r″) = node (♯ trans (♭ l≈l′) (♭ l′≈l″))
(trans x≈x′ x′≈x″)
(♯ trans (♭ r≈r′) (♭ r′≈r″))
trans {a = stream a} (x≈x′ ≺ xs≈xs′)
(x′≈x″ ≺ xs′≈xs″) = trans x≈x′ x′≈x″ ≺ ♯ trans (♭ xs≈xs′) (♭ xs′≈xs″)
trans {a = colist a} [] [] = []
trans {a = colist a} (x≈x′ ∷ xs≈xs′)
(x′≈x″ ∷ xs′≈xs″) = trans x≈x′ x′≈x″ ∷ ♯ trans (♭ xs≈xs′) (♭ xs′≈xs″)
trans {a = a ⊗ b} (x≈x′ , y≈y′)
(x′≈x″ , y′≈y″) = (trans x≈x′ x′≈x″ , trans y≈y′ y′≈y″)
trans {a = ⌈ A ⌉} ⌈ x≡x′ ⌉ ⌈ x′≡x″ ⌉ = ⌈ PropEq.trans x≡x′ x′≡x″ ⌉
------------------------------------------------------------------------
-- Productivity checker workaround for Eq
infixr 5 _≺_ _∷_
infixr 4 _,_
infix 3 _∎
infixr 2 _≈⟨_⟩_ _≊⟨_⟩_
data EqP : ∀ a → El a → El a → Set₁ where
leaf : ∀ {a} → EqP (tree a) leaf leaf
node : ∀ {a x x′ l l′ r r′}
(l≈l′ : ∞ (EqP (tree a) (♭ l) (♭ l′)))
(x≈x′ : Eq a x x′ )
(r≈r′ : ∞ (EqP (tree a) (♭ r) (♭ r′))) →
EqP (tree a) (node l x r) (node l′ x′ r′)
_≺_ : ∀ {a x x′ xs xs′}
(x≈x′ : Eq a x x′ )
(xs≈xs′ : ∞ (EqP (stream a) (♭ xs) (♭ xs′))) →
EqP (stream a) (x ≺ xs) (x′ ≺ xs′)
[] : ∀ {a} → EqP (colist a) [] []
_∷_ : ∀ {a x x′ xs xs′}
(x≈x′ : Eq a x x′ )
(xs≈xs′ : ∞ (EqP (colist a) (♭ xs) (♭ xs′))) →
EqP (colist a) (x ∷ xs) (x′ ∷ xs′)
_,_ : ∀ {a b x x′ y y′}
(x≈x′ : Eq a x x′) (y≈y′ : Eq b y y′) →
EqP (a ⊗ b) (x , y) (x′ , y′)
⌈_⌉ : ∀ {A x x′} (x≡x′ : x ≡ x′) → EqP ⌈ A ⌉ x x′
_≊⟨_⟩_ : ∀ {a} x {y z}
(x≈y : EqP a x y) (y≈z : EqP a y z) → EqP a x z
zipWith-cong :
∀ {a b} {f : El a → El b → El b}
(cong : ∀ {x x′ y y′} →
Eq a x x′ → Eq b y y′ → Eq b (f x y) (f x′ y′))
{xs xs′ ys ys′}
(xs≈xs′ : EqP (colist a) xs xs′)
(ys≈ys′ : EqP (stream b) ys ys′) →
EqP (stream b) (zipWith f xs ys) (zipWith f xs′ ys′)
data EqW : ∀ a → El a → El a → Set₁ where
leaf : ∀ {a} → EqW (tree a) leaf leaf
node : ∀ {a x x′ l l′ r r′}
(l≈l′ : EqP (tree a) (♭ l) (♭ l′))
(x≈x′ : Eq a x x′ )
(r≈r′ : EqP (tree a) (♭ r) (♭ r′)) →
EqW (tree a) (node l x r) (node l′ x′ r′)
_≺_ : ∀ {a x x′ xs xs′}
(x≈x′ : Eq a x x′ )
(xs≈xs′ : EqP (stream a) (♭ xs) (♭ xs′)) →
EqW (stream a) (x ≺ xs) (x′ ≺ xs′)
[] : ∀ {a} → EqW (colist a) [] []
_∷_ : ∀ {a x x′ xs xs′}
(x≈x′ : Eq a x x′ )
(xs≈xs′ : EqP (colist a) (♭ xs) (♭ xs′)) →
EqW (colist a) (x ∷ xs) (x′ ∷ xs′)
_,_ : ∀ {a b x x′ y y′}
(x≈x′ : Eq a x x′) (y≈y′ : Eq b y y′) →
EqW (a ⊗ b) (x , y) (x′ , y′)
⌈_⌉ : ∀ {A x x′} (x≡x′ : x ≡ x′) → EqW ⌈ A ⌉ x x′
⟦_⟧≈⁻¹ : ∀ {a} {x y : El a} → Eq a x y → EqP a x y
⟦ leaf ⟧≈⁻¹ = leaf
⟦ node l≈l′ x≈x′ r≈r′ ⟧≈⁻¹ = node (♯ ⟦ ♭ l≈l′ ⟧≈⁻¹) x≈x′ (♯ ⟦ ♭ r≈r′ ⟧≈⁻¹)
⟦ x≈x′ ≺ xs≈xs′ ⟧≈⁻¹ = x≈x′ ≺ ♯ ⟦ ♭ xs≈xs′ ⟧≈⁻¹
⟦ [] ⟧≈⁻¹ = []
⟦ x≈x′ ∷ xs≈xs′ ⟧≈⁻¹ = x≈x′ ∷ ♯ ⟦ ♭ xs≈xs′ ⟧≈⁻¹
⟦ (x≈x′ , y≈y′) ⟧≈⁻¹ = (x≈x′ , y≈y′)
⟦ ⌈ x≡x′ ⌉ ⟧≈⁻¹ = ⌈ x≡x′ ⌉
whnf≈ : ∀ {a xs ys} → EqP a xs ys → EqW a xs ys
whnf≈ leaf = leaf
whnf≈ (node l≈l′ x≈x′ r≈r′) = node (♭ l≈l′) x≈x′ (♭ r≈r′)
whnf≈ (x≈x′ ≺ xs≈xs′) = x≈x′ ≺ ♭ xs≈xs′
whnf≈ [] = []
whnf≈ (x≈x′ ∷ xs≈xs′) = x≈x′ ∷ ♭ xs≈xs′
whnf≈ (x≈x′ , y≈y′) = (x≈x′ , y≈y′)
whnf≈ ⌈ x≡x′ ⌉ = ⌈ x≡x′ ⌉
whnf≈ ( _ ≊⟨ x≈y ⟩ y≈z) with whnf≈ x≈y | whnf≈ y≈z
whnf≈ (._ ≊⟨ x≈y ⟩ y≈z) | leaf | leaf = leaf
whnf≈ (._ ≊⟨ x≈y ⟩ y≈z) | node l≈l′ x≈x′ r≈r′
| node l′≈l″ x′≈x″ r′≈r″ = node (_ ≊⟨ l≈l′ ⟩ l′≈l″) (trans x≈x′ x′≈x″) (_ ≊⟨ r≈r′ ⟩ r′≈r″)
whnf≈ (._ ≊⟨ x≈y ⟩ y≈z) | [] | [] = []
whnf≈ (._ ≊⟨ x≈y ⟩ y≈z) | x≈y′ ∷ xs≈ys′ | y≈z′ ∷ ys≈zs′ = trans x≈y′ y≈z′ ∷ (_ ≊⟨ xs≈ys′ ⟩ ys≈zs′)
whnf≈ (._ ≊⟨ x≈y ⟩ y≈z) | x≈y′ ≺ xs≈ys′ | y≈z′ ≺ ys≈zs′ = trans x≈y′ y≈z′ ≺ (_ ≊⟨ xs≈ys′ ⟩ ys≈zs′)
whnf≈ (._ ≊⟨ x≈y ⟩ y≈z) | (x≈x′ , y≈y′) | (x′≈x″ , y′≈y″) = (trans x≈x′ x′≈x″ , trans y≈y′ y′≈y″)
whnf≈ ( _ ≊⟨ x≈y ⟩ y≈z) | ⌈ x≡x′ ⌉ | ⌈ x′≡x″ ⌉ = ⌈ PropEq.trans x≡x′ x′≡x″ ⌉
whnf≈ (zipWith-cong cong xs≈xs′ ys≈ys′) with whnf≈ xs≈xs′ | whnf≈ ys≈ys′
... | [] | ys≈ys″ = ys≈ys″
... | x≈x′ ∷ xs≈xs″ | y≈y′ ≺ ys≈ys″ =
cong x≈x′ y≈y′ ≺ zipWith-cong cong xs≈xs″ ys≈ys″
mutual
value≈ : ∀ {a xs ys} → EqW a xs ys → Eq a xs ys
value≈ leaf = leaf
value≈ (node l≈l′ x≈x′ r≈r′) = node (♯ ⟦ l≈l′ ⟧≈) x≈x′ (♯ ⟦ r≈r′ ⟧≈)
value≈ (x≈x′ ≺ xs≈xs′) = x≈x′ ≺ ♯ ⟦ xs≈xs′ ⟧≈
value≈ [] = []
value≈ (x≈x′ ∷ xs≈xs′) = x≈x′ ∷ ♯ ⟦ xs≈xs′ ⟧≈
value≈ (x≈x′ , y≈y′) = (x≈x′ , y≈y′)
value≈ ⌈ x≡x′ ⌉ = ⌈ x≡x′ ⌉
⟦_⟧≈ : ∀ {a xs ys} → EqP a xs ys → Eq a xs ys
⟦ xs≈ys ⟧≈ = value≈ (whnf≈ xs≈ys)
_≈⟨_⟩_ : ∀ {a} x {y z}
(x≈y : Eq a x y) (y≈z : EqP a y z) → EqP a x z
x ≈⟨ x≈y ⟩ y≈z = x ≊⟨ ⟦ x≈y ⟧≈⁻¹ ⟩ y≈z
_∎ : ∀ {a} x → EqP a x x
x ∎ = ⟦ refl x ⟧≈⁻¹
------------------------------------------------------------------------
-- Productivity checker workaround for PrefixOf
infixr 2 _≋⟨_⟩_ _⊑⟨_⟩_
data PrefixOfP (a : U) :
Colist (El a) → Stream (El a) → Set₁ where
[] : ∀ {ys} → PrefixOfP a [] ys
⁺++-mono : ∀ xs {ys ys′} (ys⊑ys′ : ∞ (PrefixOfP a ys ys′)) →
PrefixOfP a (xs ⁺++ ys) (xs ⁺++∞ ys′)
_≋⟨_⟩_ : ∀ xs {ys zs} (xs≈ys : Eq (colist a) xs ys)
(ys⊑zs : PrefixOfP a ys zs) → PrefixOfP a xs zs
_⊑⟨_⟩_ : ∀ xs {ys zs} (xs⊑ys : PrefixOfP a xs ys)
(ys≈zs : EqP (stream a) ys zs) → PrefixOfP a xs zs
data PrefixOfW (a : U) :
Colist (El a) → Stream (El a) → Set₁ where
[] : ∀ {ys} → PrefixOfW a [] ys
_∷_ : ∀ {x y xs ys}
(x≈y : Eq a x y) (p : PrefixOfP a (♭ xs) (♭ ys)) →
PrefixOfW a (x ∷ xs) (y ≺ ys)
whnf⊑ : ∀ {a xs ys} →
PrefixOfP a xs ys → PrefixOfW a xs ys
whnf⊑ [] = []
whnf⊑ (⁺++-mono (x ∷ []) ys⊑ys′) = refl x ∷ ♭ ys⊑ys′
whnf⊑ (⁺++-mono (x ∷ (x′ ∷ xs)) ys⊑ys′) =
refl x ∷ ⁺++-mono (x′ ∷ xs) ys⊑ys′
whnf⊑ (._ ≋⟨ [] ⟩ _ ) = []
whnf⊑ (._ ≋⟨ x≈y ∷ xs≈ys ⟩ ys⊑zs) with whnf⊑ ys⊑zs
... | y≈z ∷ ys⊑zs′ = trans x≈y y≈z ∷ (_ ≋⟨ ♭ xs≈ys ⟩ ys⊑zs′)
whnf⊑ (._ ⊑⟨ xs⊑ys ⟩ ys≈zs) with whnf⊑ xs⊑ys | whnf≈ ys≈zs
... | [] | _ = []
... | x≈y ∷ xs⊑ys′ | y≈z ≺ ys≈zs′ = trans x≈y y≈z ∷ (_ ⊑⟨ xs⊑ys′ ⟩ ys≈zs′)
mutual
value⊑ : ∀ {a xs ys} → PrefixOfW a xs ys → PrefixOf a xs ys
value⊑ [] = []
value⊑ (x≈y ∷ xs⊑ys) = x≈y ∷ ♯ ⟦ xs⊑ys ⟧⊑
⟦_⟧⊑ : ∀ {a xs ys} → PrefixOfP a xs ys → PrefixOf a xs ys
⟦ xs⊑ys ⟧⊑ = value⊑ (whnf⊑ xs⊑ys)
------------------------------------------------------------------------
-- More lemmas
⁺++∞-cong : ∀ {a xs xs′ ys ys′} →
Eq ⌈ List⁺ (El a) ⌉ xs xs′ →
Eq (stream a) ys ys′ →
Eq (stream a) (xs ⁺++∞ ys) (xs′ ⁺++∞ ys′)
⁺++∞-cong {xs = x ∷ []} ⌈ ≡-refl ⌉ ys≈ys′ = refl x ≺ ♯ ys≈ys′
⁺++∞-cong {xs = x ∷ (x′ ∷ xs)} ⌈ ≡-refl ⌉ ys≈ys′ =
refl x ≺ ♯ ⁺++∞-cong {xs = x′ ∷ xs} ⌈ ≡-refl ⌉ ys≈ys′
++-assoc : ∀ {a} xs ys zs →
Eq (stream a) (xs ⁺++∞ (ys ⁺++∞ zs)) ((xs ⁺++⁺ ys) ⁺++∞ zs)
++-assoc (x ∷ []) ys zs = refl x ≺ ♯ refl (ys ⁺++∞ zs)
++-assoc (x ∷ (x′ ∷ xs)) ys zs = refl x ≺ ♯ ++-assoc (x′ ∷ xs) ys zs
zip-++-assoc : ∀ {a} xss yss (zss : Stream (Stream (El a))) →
Eq (stream (stream a))
(zipWith _⁺++∞_ ⟦ xss ⟧ (zipWith _⁺++∞_ ⟦ yss ⟧ zss))
(zipWith _⁺++∞_ ⟦ longZipWith _⁺++⁺_ xss yss ⟧ zss)
zip-++-assoc xss yss (zs ≺ zss) with whnf xss | whnf yss
... | [] | [] = refl _
... | [] | ys ∷ yss′ = refl _
... | xs ∷ xss′ | [] = refl _
... | ⌈ xs ⌉ ∷ xss′ | ⌈ ys ⌉ ∷ yss′ =
++-assoc xs ys zs ≺ ♯ zip-++-assoc (♭ xss′) (♭ yss′) (♭ zss)
concat-lemma : ∀ {a} xs xss →
Eq (colist a) (concat (xs ∷ xss))
(xs ⁺++ concat (♭ xss))
concat-lemma (x ∷ []) xss = refl x ∷ ♯ refl (concat (♭ xss))
concat-lemma (x ∷ (x′ ∷ xs)) xss = refl x ∷ ♯ concat-lemma (x′ ∷ xs) xss
| {
"alphanum_fraction": 0.3796313196,
"avg_line_length": 40.7360594796,
"ext": "agda",
"hexsha": "05069d7b14a6490b11d7cb6dc73c7af1cc113bf5",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "1b90445566df0d3b4ba6e31bd0bac417b4c0eb0e",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/codata",
"max_forks_repo_path": "BreadthFirst/Lemmas.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "1b90445566df0d3b4ba6e31bd0bac417b4c0eb0e",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/codata",
"max_issues_repo_path": "BreadthFirst/Lemmas.agda",
"max_line_length": 114,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "1b90445566df0d3b4ba6e31bd0bac417b4c0eb0e",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/codata",
"max_stars_repo_path": "BreadthFirst/Lemmas.agda",
"max_stars_repo_stars_event_max_datetime": "2021-02-13T14:48:45.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-02-13T14:48:45.000Z",
"num_tokens": 5549,
"size": 10958
} |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.GroupoidQuotients where
open import Cubical.HITs.GroupoidQuotients.Base public
open import Cubical.HITs.GroupoidQuotients.Properties public
| {
"alphanum_fraction": 0.8075117371,
"avg_line_length": 35.5,
"ext": "agda",
"hexsha": "ef2758b565af43c9162683462eddff13ff6fa397",
"lang": "Agda",
"max_forks_count": 134,
"max_forks_repo_forks_event_max_datetime": "2022-03-23T16:22:13.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-11-16T06:11:03.000Z",
"max_forks_repo_head_hexsha": "53e159ec2e43d981b8fcb199e9db788e006af237",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "marcinjangrzybowski/cubical",
"max_forks_repo_path": "Cubical/HITs/GroupoidQuotients.agda",
"max_issues_count": 584,
"max_issues_repo_head_hexsha": "53e159ec2e43d981b8fcb199e9db788e006af237",
"max_issues_repo_issues_event_max_datetime": "2022-03-30T12:09:17.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-10-15T09:49:02.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "marcinjangrzybowski/cubical",
"max_issues_repo_path": "Cubical/HITs/GroupoidQuotients.agda",
"max_line_length": 60,
"max_stars_count": 301,
"max_stars_repo_head_hexsha": "53e159ec2e43d981b8fcb199e9db788e006af237",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "marcinjangrzybowski/cubical",
"max_stars_repo_path": "Cubical/HITs/GroupoidQuotients.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-24T02:10:47.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-10-17T18:00:24.000Z",
"num_tokens": 58,
"size": 213
} |
{-# OPTIONS --copatterns #-}
-- 2013-05-30 Andreas, Oury's counterexample to subject reduction in Coq
-- 2014-11-04 Andreas: simplified (removed force)
module MatchingOnCoinductiveRecord where
open import Common.Equality
record U : Set where
coinductive
constructor inn
field
out : U
open U
u : U
out u = u
eq : (x : U) → x ≡ inn (out x)
eq (inn y) = refl
-- should fail, as internally this is just
-- eq x = refl
-- and we do not have η for coinductive records
equ : u ≡ inn u
equ = eq u
-- normalizes to refl, which does not have type u ≡ inn u
| {
"alphanum_fraction": 0.6831858407,
"avg_line_length": 18.8333333333,
"ext": "agda",
"hexsha": "4ad2c3964e66a7d0ae1487946b55412b1078c169",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "alhassy/agda",
"max_forks_repo_path": "test/Fail/MatchingOnCoinductiveRecord.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "alhassy/agda",
"max_issues_repo_path": "test/Fail/MatchingOnCoinductiveRecord.agda",
"max_line_length": 72,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "alhassy/agda",
"max_stars_repo_path": "test/Fail/MatchingOnCoinductiveRecord.agda",
"max_stars_repo_stars_event_max_datetime": "2015-12-07T20:14:00.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-03-28T14:51:03.000Z",
"num_tokens": 178,
"size": 565
} |
{-# OPTIONS --cubical --safe #-}
module Cubical.Data.Sum.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Data.Empty
open import Cubical.Data.Nat
open import Cubical.Data.Sum.Base
-- Path space of sum type
module SumPath {ℓ ℓ'} {A : Type ℓ} {B : Type ℓ'} where
Cover : A ⊎ B → A ⊎ B → Type (ℓ-max ℓ ℓ')
Cover (inl a) (inl a') = Lift {j = ℓ-max ℓ ℓ'} (a ≡ a')
Cover (inl _) (inr _) = Lift ⊥
Cover (inr _) (inl _) = Lift ⊥
Cover (inr b) (inr b') = Lift {j = ℓ-max ℓ ℓ'} (b ≡ b')
reflCode : (c : A ⊎ B) → Cover c c
reflCode (inl a) = lift refl
reflCode (inr b) = lift 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 (inl a) (inl a') (lift p) = cong inl p
decode (inl a) (inr b') ()
decode (inr b) (inl a') ()
decode (inr b) (inr b') (lift q) = cong inr q
decodeRefl : ∀ c → decode c c (reflCode c) ≡ refl
decodeRefl (inl a) = refl
decodeRefl (inr b) = 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
→ isOfHLevel (suc (suc n)) B
→ ∀ c c' → isOfHLevel (suc n) (Cover c c')
isOfHLevelCover n p q (inl a) (inl a') = isOfHLevelLift (suc n) (p a a')
isOfHLevelCover n p q (inl a) (inr b') =
isOfHLevelLift (suc n)
(subst (λ m → isOfHLevel m ⊥) (+-comm n 1)
(hLevelLift n isProp⊥))
isOfHLevelCover n p q (inr b) (inl a') =
isOfHLevelLift (suc n)
(subst (λ m → isOfHLevel m ⊥) (+-comm n 1)
(hLevelLift n isProp⊥))
isOfHLevelCover n p q (inr b) (inr b') = isOfHLevelLift (suc n) (q b b')
isOfHLevelSum : ∀ {ℓ ℓ'} (n : ℕ) {A : Type ℓ} {B : Type ℓ'}
→ isOfHLevel (suc (suc n)) A
→ isOfHLevel (suc (suc n)) B
→ isOfHLevel (suc (suc n)) (A ⊎ B)
isOfHLevelSum n lA lB c c' =
retractIsOfHLevel (suc n)
(SumPath.encode c c')
(SumPath.decode c c')
(SumPath.decodeEncode c c')
(SumPath.isOfHLevelCover n lA lB c c')
| {
"alphanum_fraction": 0.5884368308,
"avg_line_length": 32.8873239437,
"ext": "agda",
"hexsha": "57c43e294ce34470bb3332fd678f5e7a3e3a358b",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cj-xu/cubical",
"max_forks_repo_path": "Cubical/Data/Sum/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cj-xu/cubical",
"max_issues_repo_path": "Cubical/Data/Sum/Properties.agda",
"max_line_length": 74,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cj-xu/cubical",
"max_stars_repo_path": "Cubical/Data/Sum/Properties.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 979,
"size": 2335
} |
module Sets.PredicateSet.Finite{ℓₗ}{ℓₒ} where
import Lvl
open import Functional
open import Logic.Propositional{ℓₗ Lvl.⊔ ℓₒ}
open import Logic.Predicate{ℓₗ}{ℓₒ}
open import Numeral.Finite
open import Numeral.Natural
import Relator.Equals
open import Sets.PredicateSet
open import Structure.Function.Domain
open import Type{ℓₒ}
{-
record Irrelevant∃ {X : Type} (Pred : X → Stmt) : Stmt where
field
witness : X
⦃ .proof ⦄ : Pred(witness)
record Finite {T} (S : PredSet{ℓₗ}{ℓₒ}(T)) : Stmt where
field
count : ℕ
bijection : 𝕟(count) → Irrelevant∃(x ↦ (x ∈ S))
proof : Bijective(bijection) -- TODO: Bijective must allow different levels
-}
| {
"alphanum_fraction": 0.6920821114,
"avg_line_length": 26.2307692308,
"ext": "agda",
"hexsha": "9b22cb344f9d4f27650f35f5ed79e0001364b146",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Lolirofle/stuff-in-agda",
"max_forks_repo_path": "old/Sets/PredicateSet/Finite.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "old/Sets/PredicateSet/Finite.agda",
"max_line_length": 83,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Lolirofle/stuff-in-agda",
"max_stars_repo_path": "old/Sets/PredicateSet/Finite.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-05T06:53:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:58:13.000Z",
"num_tokens": 233,
"size": 682
} |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Monad.Strong where
open import Categories.Category
open import Categories.Monoidal
open import Categories.Functor
renaming (id to idF; _∘_ to _∘F_; _≡_ to _≡F_)
open import Categories.Functor.Constant
open import Categories.NaturalTransformation
renaming (id to idN; _≡_ to _≡N_)
open import Categories.NaturalIsomorphism
using (module NaturalIsomorphism)
open import Categories.Monad
open import Categories.Product
open import Data.Fin using (Fin)
open import Function using (flip)
open import Data.Nat using ()
open import Data.Product using (_,_)
open import Data.Vec
using (Vec; _∷_; []; [_]; lookup)
open import Level
record Strength
{o ℓ e}(C : Category o ℓ e)
(monoidal : Monoidal C)
(M : Monad C)
: Set (o ⊔ ℓ ⊔ e) where
open Category C
open Monoidal monoidal
using (⊗)
renaming (id to idObj)
open NaturalIsomorphism (Monoidal.identityˡ monoidal) using () renaming (F⇒G to υˡ)
open NaturalIsomorphism (Monoidal.identityʳ monoidal) using () renaming (F⇒G to υʳ)
open NaturalIsomorphism (Monoidal.assoc monoidal) using ()
renaming (F⇒G to αʳ; F⇐G to αˡ)
module υˡ = NaturalTransformation υˡ
open Functor ⊗
using ()
renaming (F₀ to ⊗₀; F₁ to ⊗₁)
unitorˡ : ∀ A → ⊗₀ (idObj , A) ⇒ A
unitorˡ A = υˡ.η (flip lookup [ A ])
associatorʳ : ∀ A B C → ⊗₀ (⊗₀ (A , B) , C) ⇒ ⊗₀ (A , ⊗₀ (B , C))
associatorʳ A B C = NaturalTransformation.η αʳ (flip lookup (A ∷ B ∷ C ∷ []))
associatorˡ : ∀ A B C → ⊗₀ (A , ⊗₀ (B , C)) ⇒ ⊗₀ (⊗₀ (A , B) , C)
associatorˡ A B C = NaturalTransformation.η αˡ (flip lookup (A ∷ B ∷ C ∷ []))
module M = Monad M
open M using (F)
open Functor F
using (F₀; F₁)
open NaturalTransformation M.η
using (η)
open NaturalTransformation M.μ
using ()
renaming (η to μ)
field
σ : NaturalTransformation (⊗ ∘F (idF {C = C} ⁂ F)) (F ∘F ⊗)
module σ = NaturalTransformation σ
field
.identity₁ : ∀ {A}
→ F₁ (unitorˡ A) ∘ σ.η (idObj , A)
≡ unitorˡ (F₀ A)
.identity₂ : ∀ {A B}
→ σ.η (A , B) ∘ ⊗₁ (id , η B)
≡ η (⊗₀ (A , B))
α-assoc : ∀ {A B C}
→ F₁ (associatorʳ A B C) ∘ σ.η (⊗₀ (A , B) , C)
≡ σ.η (A , ⊗₀ (B , C)) ∘ ⊗₁ (id , σ.η (B , C)) ∘ associatorʳ A B (F₀ C)
μ-assoc : ∀ {A B}
→ μ (⊗₀ (A , B)) ∘ F₁ (σ.η (A , B)) ∘ σ.η (A , F₀ B)
≡ σ.η (A , B) ∘ ⊗₁ (id , μ B)
| {
"alphanum_fraction": 0.5951020408,
"avg_line_length": 27.8409090909,
"ext": "agda",
"hexsha": "cc69ecebe1af9d924b4828483f8b9cef8c191ba2",
"lang": "Agda",
"max_forks_count": 23,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T13:50:56.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-02-05T13:03:09.000Z",
"max_forks_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "p-pavel/categories",
"max_forks_repo_path": "Categories/Monad/Strong.agda",
"max_issues_count": 19,
"max_issues_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2",
"max_issues_repo_issues_event_max_datetime": "2019-08-09T16:31:40.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-05-23T06:47:10.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "p-pavel/categories",
"max_issues_repo_path": "Categories/Monad/Strong.agda",
"max_line_length": 85,
"max_stars_count": 98,
"max_stars_repo_head_hexsha": "36f4181d751e2ecb54db219911d8c69afe8ba892",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "copumpkin/categories",
"max_stars_repo_path": "Categories/Monad/Strong.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-08T05:20:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-04-15T14:57:33.000Z",
"num_tokens": 947,
"size": 2450
} |
module OTT.Prelude where
open import Level
renaming (Level to MetaLevel; zero to lzeroₘ; suc to lsucₘ; _⊔_ to _⊔ₘ_) using () public
open import Function public
open import Relation.Binary.PropositionalEquality as P using (_≡_)
renaming (refl to prefl; trans to ptrans; subst to psubst; cong to pcong; cong₂ to pcong₂) public
open import Data.Empty public
open import Data.Nat.Base hiding (_⊔_; _≟_; erase) public
open import Data.Maybe.Base using (Maybe; nothing; just) public
open import Data.Product hiding (,_) renaming (map to pmap) public
open import OTT.Lib.Heteroindexed public
open import OTT.Lib.Decidable public
open import Relation.Nullary
open import Relation.Binary
infix 4 ,_
pattern ,_ y = _ , y
record ⊤ {α} : Set α where
constructor tt
⊤₀ : Set
⊤₀ = ⊤
instance
iprefl : ∀ {α} {A : Set α} {x : A} -> x ≡ x
iprefl = prefl
,-inst : ∀ {α β} {A : Set α} {B : A -> Set β} {{x : A}} {{y : B x}} -> Σ A B
,-inst {{x}} {{y}} = x , y
pright : ∀ {α} {A : Set α} {x y z : A} -> x ≡ y -> x ≡ z -> y ≡ z
pright prefl prefl = prefl
hpcong₂ : ∀ {α β γ} {A : Set α} {B : A -> Set β} {C : Set γ} {x₁ x₂} {y₁ : B x₁} {y₂ : B x₂}
-> (f : ∀ x -> B x -> C) -> (q : x₁ ≡ x₂) -> psubst B q y₁ ≡ y₂ -> f x₁ y₁ ≡ f x₂ y₂
hpcong₂ f prefl prefl = prefl
record Apply {α β} {A : Set α} (B : A -> Set β) x : Set β where
constructor tag
field detag : B x
open Apply public
tag-inj : ∀ {α β} {A : Set α} {B : A -> Set β} {x} {y₁ y₂ : B x}
-> tag {B = B} y₁ ≡ tag y₂ -> y₁ ≡ y₂
tag-inj prefl = prefl
data Match {ι α} {I : Set ι} {i} (A : I -> Set α) (x : A i) : Set (ι ⊔ₘ α) where
matched : ∀ {j} -> (x′ : A j) -> [ A ] x ≅ x′ -> Match A x
match : ∀ {ι α} {I : Set ι} {i} -> (A : I -> Set α) -> (x : A i) -> Match A x
match A x = matched x irefl
data IMatch {ι α β} {I : Set ι} {i} (A : I -> Set α) {x : A i}
(B : ∀ {i} -> A i -> Set β) (y : B x) : Set (ι ⊔ₘ α ⊔ₘ β) where
imatched : ∀ {i} {x : A i} -> (y′ : B x) -> [ A ][ B ] y ≅ y′ -> IMatch A B y
imatch : ∀ {ι α β} {I : Set ι} {i}
-> (A : I -> Set α) {x : A i} -> (B : ∀ {i} -> A i -> Set β) -> (y : B x) -> IMatch A B y
imatch A B y = imatched y iirefl
module _ {α} {A : Set α} where
open import Relation.Nullary.Decidable
open import Data.Maybe
toPropEq : {a b : Maybe A} -> a ≡ b -> Eq _≡_ a b
toPropEq {a = nothing} prefl = nothing
toPropEq {a = just _ } prefl = just prefl
fromPropEq : {a b : Maybe A} -> Eq _≡_ a b -> a ≡ b
fromPropEq (just q) = pcong just q
fromPropEq nothing = prefl
fromDecPropEq : {a b : Maybe A} -> Dec (Eq _≡_ a b) -> Dec (a ≡ b)
fromDecPropEq = map′ fromPropEq toPropEq where
decideMaybe : Decidable (_≡_ {A = A}) -> Decidable (_≡_ {A = Maybe A})
decideMaybe D a b = fromDecPropEq (a ≟ b) where
open DecSetoid (decSetoid (P.decSetoid D))
Enum : ℕ -> Set
Enum 0 = ⊥
Enum 1 = ⊤
Enum (suc n) = Maybe (Enum n)
decEnum : ∀ n -> Decidable (_≡_ {A = Enum n})
decEnum 0 () ()
decEnum 1 tt tt = yes prefl
decEnum (suc (suc n)) e₁ e₂ = decideMaybe (decEnum (suc n)) e₁ e₂
| {
"alphanum_fraction": 0.5597790773,
"avg_line_length": 32.7446808511,
"ext": "agda",
"hexsha": "60d54777034f71a7f4e62a30fc9ac4af90350f83",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2022-01-06T19:34:26.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-11-13T12:44:41.000Z",
"max_forks_repo_head_hexsha": "34e2980af98ff2ded500619edce3e0907a6e9050",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "ajnavarro/language-dataset",
"max_forks_repo_path": "data/github.com/effectfully/OTT/3da2a48114dc7d02854049800cdf0f279ff3dd43/Prelude.agda",
"max_issues_count": 91,
"max_issues_repo_head_hexsha": "34e2980af98ff2ded500619edce3e0907a6e9050",
"max_issues_repo_issues_event_max_datetime": "2022-03-21T04:17:18.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-11-11T15:41:26.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "ajnavarro/language-dataset",
"max_issues_repo_path": "data/github.com/effectfully/OTT/3da2a48114dc7d02854049800cdf0f279ff3dd43/Prelude.agda",
"max_line_length": 99,
"max_stars_count": 9,
"max_stars_repo_head_hexsha": "34e2980af98ff2ded500619edce3e0907a6e9050",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "ajnavarro/language-dataset",
"max_stars_repo_path": "data/github.com/effectfully/OTT/3da2a48114dc7d02854049800cdf0f279ff3dd43/Prelude.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-11T09:48:45.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-08-07T11:54:33.000Z",
"num_tokens": 1258,
"size": 3078
} |
{-# OPTIONS --without-K --safe #-}
open import Algebra.Structures.Bundles.Field
import Algebra.Linear.Structures.Bundles.FiniteDimensional as FDB
module Algebra.Linear.Space.FiniteDimensional.Hom
{k ℓᵏ} (K : Field k ℓᵏ)
{p a₁ ℓ₁} (V₁-space : FDB.FiniteDimensional K a₁ ℓ₁ p)
{n a₂ ℓ₂} (V₂-space : FDB.FiniteDimensional K a₂ ℓ₂ n)
where
open import Algebra.Linear.Structures.VectorSpace K
open import Algebra.Linear.Structures.Bundles as VS
open import Algebra.Linear.Structures.FiniteDimensional K
open import Algebra.Linear.Morphism.Bundles K
open VectorSpaceField
open FDB.FiniteDimensional V₁-space
using ()
renaming
( Carrier to V₁
; _≈_ to _≈₁_
; isEquivalence to ≈₁-isEquiv
; refl to ≈₁-refl
; sym to ≈₁-sym
; trans to ≈₁-trans
; _+_ to _+₁_
; _∙_ to _∙₁_
; -_ to -₁_
; 0# to 0₁
; +-identityˡ to +₁-identityˡ
; +-identityʳ to +₁-identityʳ
; +-identity to +₁-identity
; +-cong to +₁-cong
; +-assoc to +₁-assoc
; +-comm to +₁-comm
; *ᵏ-∙-compat to *ᵏ-∙₁-compat
; ∙-+-distrib to ∙₁-+₁-distrib
; ∙-+ᵏ-distrib to ∙₁-+ᵏ-distrib
; ∙-cong to ∙₁-cong
; ∙-identity to ∙₁-identity
; ∙-absorbˡ to ∙₁-absorbˡ
; ∙-absorbʳ to ∙₁-absorbʳ
; -‿cong to -₁‿cong
; -‿inverseˡ to -₁‿inverseˡ
; -‿inverseʳ to -₁‿inverseʳ
; vectorSpace to vectorSpace₁
; embed to embed₁
)
open FDB.FiniteDimensional V₂-space
using ()
renaming
( Carrier to V₂
; _≈_ to _≈₂_
; isEquivalence to ≈₂-isEquiv
; refl to ≈₂-refl
; sym to ≈₂-sym
; trans to ≈₂-trans
; _+_ to _+₂_
; _∙_ to _∙₂_
; -_ to -₂_
; 0# to 0₂
; +-identityˡ to +₂-identityˡ
; +-identityʳ to +₂-identityʳ
; +-identity to +₂-identity
; +-cong to +₂-cong
; +-assoc to +₂-assoc
; +-comm to +₂-comm
; *ᵏ-∙-compat to *ᵏ-∙₂-compat
; ∙-+-distrib to ∙₂-+₂-distrib
; ∙-+ᵏ-distrib to ∙₂-+ᵏ-distrib
; ∙-cong to ∙₂-cong
; ∙-identity to ∙₂-identity
; ∙-absorbˡ to ∙₂-absorbˡ
; ∙-absorbʳ to ∙₂-absorbʳ
; -‿cong to -₂‿cong
; -‿inverseˡ to -₂‿inverseˡ
; -‿inverseʳ to -₂‿inverseʳ
; vectorSpace to vectorSpace₂
; embed to embed₂
)
open LinearIsomorphism embed₁
using ()
renaming
( ⟦_⟧ to ⟦_⟧₁
; ⟦⟧-cong to ⟦⟧₁-cong
; injective to ⟦⟧₁-injective
; surjective to ⟦⟧₁-surjective
; +-homo to +₁-homo
; ∙-homo to ∙₁-homo
; 0#-homo to 0₁-homo
)
open LinearIsomorphism embed₂
using ()
renaming
( ⟦_⟧ to ⟦_⟧₂
; ⟦⟧-cong to ⟦⟧₂-cong
; injective to ⟦⟧₂-injective
; surjective to ⟦⟧₂-surjective
; +-homo to +₂-homo
; ∙-homo to ∙₂-homo
; 0#-homo to 0₂-homo
)
import Algebra.Linear.Construct.HomSpace K vectorSpace₁ vectorSpace₂ as PS
open VS.VectorSpace PS.vectorSpace
renaming
( refl to ≈-refl
; sym to ≈-sym
; trans to ≈-trans
)
import Algebra.Linear.Construct.Vector as Vec
open Vec K
using
( ++-cong
; ++-identityˡ
; +-distrib-++
; ∙-distrib-++
; 0++0≈0
)
renaming
( _≈_ to _≈v_
; ≈-refl to ≈v-refl
; ≈-sym to ≈v-sym
; ≈-trans to ≈v-trans
; _+_ to _+v_
; _∙_ to _∙v_
; 0# to 0v
; +-cong to +v-cong
; setoid to vec-setoid
; vectorSpace to vector-vectorSpace
)
import Algebra.Linear.Construct.Matrix K as M
open import Data.Nat hiding (_+_) renaming (_*_ to _*ℕ_)
open import Relation.Binary.PropositionalEquality as P
using (_≡_; subst; subst-subst-sym)
renaming
( refl to ≡-refl
; sym to ≡-sym
; trans to ≡-trans
)
open import Data.Vec
open import Data.Product
open import Data.Fin
open import Function
δ : ∀ {n p} -> Fin n -> Fin p -> K'
δ zero zero = 1ᵏ
δ (suc n) zero = 0ᵏ
δ zero (suc p) = 0ᵏ
δ (suc n) (suc p) = δ n p
canonicalBasis : M.Matrix n p
canonicalBasis = M.tabulate δ
module _ where
open import Algebra.Morphism.Definitions (LinearMap vectorSpace₁ vectorSpace₂) (M.Matrix n p) M._≈_
open import Algebra.Linear.Morphism.Definitions K (LinearMap vectorSpace₁ vectorSpace₂) (M.Matrix n p) M._≈_
import Relation.Binary.Morphism.Definitions (LinearMap vectorSpace₁ vectorSpace₂) (M.Matrix n p) as R
open import Relation.Binary.EqReasoning (M.setoid {n} {p})
Mat : LinearMap vectorSpace₁ vectorSpace₂ -> M.Matrix n p
Mat f = M.mapCols (λ u -> embed₂ LinearIsomorphism.⟪$⟫ (f LinearMap.⟪$⟫ {! embed₁ ⁻¹ ⟪$⟫ u!}))
canonicalBasis
-- (λ u → embed₂ LinearIsomorphism.⟪$⟫ (proj₁ (⟦⟧₂-surjective u))) canonicalBasis
Mat-cong : R.Homomorphic₂ _≈_ M._≈_ Mat
Mat-cong {A} {B} f =
begin
Mat A
≈⟨ M.≈-reflexive (M.mapCols-cong (λ u → {!!}) canonicalBasis) ⟩
{!!}
≈⟨ {!!} ⟩
Mat B
∎
{-
Mat-cong : R.Homomorphic₂ PS._≈_ _≈v_ Mat
⟦⟧-cong (r₁ , r₂) = ++-cong (⟦⟧₁-cong r₁) (⟦⟧₂-cong r₂)
+-homo : Homomorphic₂ ⟦_⟧ _+_ _+v_
+-homo (x₁ , x₂) (y₁ , y₂) =
begin
⟦ (x₁ , x₂) + (y₁ , y₂) ⟧
≡⟨⟩
⟦ x₁ +₁ y₁ ⟧₁ ++ ⟦ x₂ +₂ y₂ ⟧₂
≈⟨ ++-cong (+₁-homo x₁ y₁) (+₂-homo x₂ y₂) ⟩
(⟦ x₁ ⟧₁ +v ⟦ y₁ ⟧₁) ++ (⟦ x₂ ⟧₂ +v ⟦ y₂ ⟧₂)
≈⟨ ≈v-sym (+-distrib-++ ⟦ x₁ ⟧₁ ⟦ x₂ ⟧₂ ⟦ y₁ ⟧₁ ⟦ y₂ ⟧₂) ⟩
(⟦ x₁ ⟧₁ ++ ⟦ x₂ ⟧₂) +v (⟦ y₁ ⟧₁ ++ ⟦ y₂ ⟧₂)
≈⟨ +v-cong ≈v-refl ≈v-refl ⟩
⟦ x₁ , x₂ ⟧ +v ⟦ y₁ , y₂ ⟧
∎
0#-homo : Homomorphic₀ ⟦_⟧ 0# 0v
0#-homo =
begin
⟦ 0# ⟧
≡⟨⟩
⟦ 0₁ ⟧₁ ++ ⟦ 0₂ ⟧₂
≈⟨ ++-cong 0₁-homo 0₂-homo ⟩
(0v {n}) ++ (0v {p})
≈⟨ 0++0≈0 {n} {p} ⟩
0v {n +ℕ p}
∎
∙-homo : ScalarHomomorphism ⟦_⟧ _∙_ _∙v_
∙-homo c (x₁ , x₂) =
begin
⟦ c ∙ (x₁ , x₂) ⟧
≈⟨ ++-cong (∙₁-homo c x₁) (∙₂-homo c x₂) ⟩
(c ∙v ⟦ x₁ ⟧₁) ++ (c ∙v ⟦ x₂ ⟧₂)
≈⟨ ≈v-sym (∙-distrib-++ c ⟦ x₁ ⟧₁ ⟦ x₂ ⟧₂) ⟩
c ∙v ⟦ x₁ , x₂ ⟧
∎
⟦⟧-injective : Injective ⟦_⟧
⟦⟧-injective {x₁ , x₂} {y₁ , y₂} r =
let (r₁ , r₂) = ++-split r
in ⟦⟧₁-injective r₁ , ⟦⟧₂-injective r₂
⟦⟧-surjective : Surjective ⟦_⟧
⟦⟧-surjective y =
let (x₁ , x₂) = splitAt' n p ≡-refl y
(u , r₁) = ⟦⟧₁-surjective x₁
(v , r₂) = ⟦⟧₂-surjective x₂
in (u , v) , ≈v-trans (++-cong r₁ r₂) (++-splitAt' {n} {p} y)
embed : LinearIsomorphism PS.vectorSpace (vector-vectorSpace {n +ℕ p})
embed = record
{ ⟦_⟧ = ⟦_⟧
; isLinearIsomorphism = record
{ isLinearMonomorphism = record
{ isLinearMap = record
{ isAbelianGroupMorphism = record
{ gp-homo = record
{ mn-homo = record
{ sm-homo = record
{ ⟦⟧-cong = ⟦⟧-cong
; ∙-homo = +-homo
}
; ε-homo = 0#-homo
}
}
}
; ∙-homo = ∙-homo
}
; injective = ⟦⟧-injective
}
; surjective = ⟦⟧-surjective
}
}
isFiniteDimensional : IsFiniteDimensional _≈_ _+_ _∙_ -_ 0# (n +ℕ p)
isFiniteDimensional = record
{ isVectorSpace = isVectorSpace
; embed = embed
}
-}
| {
"alphanum_fraction": 0.5386235955,
"avg_line_length": 26.0805860806,
"ext": "agda",
"hexsha": "53c126c22a0b665338636f2cd51c1559422b992a",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "d87c5a1eb5dd0569238272e67bce1899616b789a",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "felko/linear-algebra",
"max_forks_repo_path": "src/Algebra/Linear/Space/FiniteDimensional/Hom.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "d87c5a1eb5dd0569238272e67bce1899616b789a",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "felko/linear-algebra",
"max_issues_repo_path": "src/Algebra/Linear/Space/FiniteDimensional/Hom.agda",
"max_line_length": 110,
"max_stars_count": 15,
"max_stars_repo_head_hexsha": "d87c5a1eb5dd0569238272e67bce1899616b789a",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "felko/linear-algebra",
"max_stars_repo_path": "src/Algebra/Linear/Space/FiniteDimensional/Hom.agda",
"max_stars_repo_stars_event_max_datetime": "2020-12-30T06:18:08.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-11-02T14:11:00.000Z",
"num_tokens": 3094,
"size": 7120
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties satisfied by join semilattices
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary.Lattice
module Relation.Binary.Properties.JoinSemilattice
{c ℓ₁ ℓ₂} (J : JoinSemilattice c ℓ₁ ℓ₂) where
open JoinSemilattice J
import Algebra as Alg
import Algebra.Structures as Alg
import Algebra.FunctionProperties as P; open P _≈_
open import Data.Product
open import Function using (_∘_; flip)
open import Relation.Binary
open import Relation.Binary.Properties.Poset poset
import Relation.Binary.Reasoning.PartialOrder as PoR
-- The join operation is monotonic.
∨-monotonic : _∨_ Preserves₂ _≤_ ⟶ _≤_ ⟶ _≤_
∨-monotonic {x} {y} {u} {v} x≤y u≤v =
let _ , _ , least = supremum x u
y≤y∨v , v≤y∨v , _ = supremum y v
in least (y ∨ v) (trans x≤y y≤y∨v) (trans u≤v v≤y∨v)
∨-cong : _∨_ Preserves₂ _≈_ ⟶ _≈_ ⟶ _≈_
∨-cong x≈y u≈v = antisym (∨-monotonic (reflexive x≈y) (reflexive u≈v))
(∨-monotonic (reflexive (Eq.sym x≈y))
(reflexive (Eq.sym u≈v)))
-- The join operation is commutative, associative and idempotent.
∨-comm : Commutative _∨_
∨-comm x y =
let x≤x∨y , y≤x∨y , least = supremum x y
y≤y∨x , x≤y∨x , least′ = supremum y x
in antisym (least (y ∨ x) x≤y∨x y≤y∨x) (least′ (x ∨ y) y≤x∨y x≤x∨y)
∨-assoc : Associative _∨_
∨-assoc x y z =
let x∨y≤[x∨y]∨z , z≤[x∨y]∨z , least = supremum (x ∨ y) z
x≤x∨[y∨z] , y∨z≤x∨[y∨z] , least′ = supremum x (y ∨ z)
y≤y∨z , z≤y∨z , _ = supremum y z
x≤x∨y , y≤x∨y , _ = supremum x y
in antisym (least (x ∨ (y ∨ z)) (∨-monotonic refl y≤y∨z)
(trans z≤y∨z y∨z≤x∨[y∨z]))
(least′ ((x ∨ y) ∨ z) (trans x≤x∨y x∨y≤[x∨y]∨z)
(∨-monotonic y≤x∨y refl))
∨-idempotent : Idempotent _∨_
∨-idempotent x =
let x≤x∨x , _ , least = supremum x x
in antisym (least x refl refl) x≤x∨x
x≤y⇒x∨y≈y : ∀ {x y} → x ≤ y → x ∨ y ≈ y
x≤y⇒x∨y≈y {x} {y} x≤y = antisym
(begin x ∨ y ≤⟨ ∨-monotonic x≤y refl ⟩
y ∨ y ≈⟨ ∨-idempotent _ ⟩
y ∎)
(y≤x∨y _ _)
where open PoR poset
-- Every order-theoretic semilattice can be turned into an algebraic one.
isAlgSemilattice : Alg.IsSemilattice _≈_ _∨_
isAlgSemilattice = record
{ isBand = record
{ isSemigroup = record
{ isMagma = record
{ isEquivalence = isEquivalence
; ∙-cong = ∨-cong
}
; assoc = ∨-assoc
}
; idem = ∨-idempotent
}
; comm = ∨-comm
}
algSemilattice : Alg.Semilattice c ℓ₁
algSemilattice = record { isSemilattice = isAlgSemilattice }
-- The dual construction is a meet semilattice.
dualIsMeetSemilattice : IsMeetSemilattice _≈_ (flip _≤_) _∨_
dualIsMeetSemilattice = record
{ isPartialOrder = invIsPartialOrder
; infimum = supremum
}
dualMeetSemilattice : MeetSemilattice c ℓ₁ ℓ₂
dualMeetSemilattice = record
{ _∧_ = _∨_
; isMeetSemilattice = dualIsMeetSemilattice
}
| {
"alphanum_fraction": 0.562716127,
"avg_line_length": 30.5865384615,
"ext": "agda",
"hexsha": "3bc7b99ee3a5a9fcecc88f9cb54dd0766201622c",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "omega12345/agda-mode",
"max_forks_repo_path": "test/asset/agda-stdlib-1.0/Relation/Binary/Properties/JoinSemilattice.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "omega12345/agda-mode",
"max_issues_repo_path": "test/asset/agda-stdlib-1.0/Relation/Binary/Properties/JoinSemilattice.agda",
"max_line_length": 73,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "omega12345/agda-mode",
"max_stars_repo_path": "test/asset/agda-stdlib-1.0/Relation/Binary/Properties/JoinSemilattice.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1284,
"size": 3181
} |
open import Agda.Builtin.Nat
open import Agda.Builtin.Sigma
interleaved mutual
data Rec : Set
⟦_⟧ : Rec → Set
constructor `Nat : Rec
⟦ `Nat ⟧ = Nat
_ : Rec
_ = `Σ `Nat (λ _ → `Nat)
_ : Rec → Rec
_ = λ r → `Σ r (λ _ → `Nat)
constructor `Σ : (r : Rec) → (⟦ r ⟧ → Rec) → Rec
⟦ `Σ A B ⟧ = Σ ⟦ A ⟧ λ a → ⟦ B a ⟧
_+1-Nats : Nat → Rec
zero +1-Nats = `Nat
suc n +1-Nats = `Σ `Nat λ _ → n +1-Nats
Nats : Rec
Nats = `Σ `Nat _+1-Nats
[1] : ⟦ Nats ⟧
[1] = 0 , 1
[1⋯3] : ⟦ Nats ⟧
[1⋯3] = 2 , 1 , 2 , 3
| {
"alphanum_fraction": 0.4904214559,
"avg_line_length": 15.8181818182,
"ext": "agda",
"hexsha": "79f14d85f5157831b779cf18dc3824229f66fb5a",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "shlevy/agda",
"max_forks_repo_path": "test/Succeed/Issue2858-IR-record.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue2858-IR-record.agda",
"max_line_length": 50,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue2858-IR-record.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 271,
"size": 522
} |
{-# OPTIONS --without-K #-}
module Lecture4 where
import Lecture3
open Lecture3 public
-- the identity type on a type A, given a fixed basepoint x
data Id {i : Level} {A : UU i} (x : A) : A → UU i where
refl : Id x x
_==_ : {i : Level} {A : UU i} (x y : A) → UU i
x == y = Id x y
ind-Id : {i j : Level} {A : UU i} {x : A} (B : (y : A) (p : Id x y) → UU j) →
(B x refl) → (y : A) (p : Id x y) → B y p
ind-Id x b y refl = b
-- groupoid structure on identity types (a.k.a. paths)
inv : {i : Level} {A : UU i} {x y : A} → Id x y → Id y x
inv (refl) = refl
_⁻¹ : {i : Level} {A : UU i} {x y : A} → Id x y → Id y x
x ⁻¹ = inv x
concat : {i : Level} {A : UU i} {x z : A} (y : A) → Id x y → Id y z → Id x z
concat x refl q = q
_·_ : {i : Level} {A : UU i} {x z : A} {y : A} → Id x y → Id y z → Id x z
p · q = concat _ p q
-- equational reasoning (TODO: demonstrate this by reworking some of the proofs to use it)
infix 15 _==∎ -- \qed
infixr 10 _==⟨_⟩_ -- \< \>
_==∎ : ∀ {i : Level} {A : UU i} (a : A) → a == a
a ==∎ = refl
_==⟨_⟩_ : ∀ {i : Level} {A : UU i} (a : A) {b c : A} → a == b → b == c → a == c
a ==⟨ γ ⟩ η = γ · η
-- end equational reasoning
assoc : {i : Level} {A : UU i} {x y z w : A} (p : Id x y) (q : Id y z) (r : Id z w) → Id (concat _ p (concat _ q r)) (concat _ (concat _ p q) r)
assoc refl q r = refl
left-unit : {i : Level} {A : UU i} {x y : A} (p : Id x y) → Id (concat _ refl p) p
left-unit refl = refl
right-unit : {i : Level} {A : UU i} {x y : A} (p : Id x y) → Id (concat _ p refl) p
right-unit refl = refl
left-inv : {i : Level} {A : UU i} {x y : A} (p : Id x y) →
Id (concat _ (inv p) p) refl
left-inv refl = refl
right-inv : {i : Level} {A : UU i} {x y : A} (p : Id x y) →
Id (concat _ p (inv p)) refl
right-inv refl = refl
-- action on paths of a function
ap : {i j : Level} {A : UU i} {B : UU j} (f : A → B) {x y : A} (p : Id x y) → Id (f x) (f y)
ap f refl = refl
ap-id : {i : Level} {A : UU i} {x y : A} (p : Id x y) → Id (ap id p) p
ap-id refl = refl
ap-comp : {i j k : Level} {A : UU i} {B : UU j} {C : UU k} (g : B → C) (f : A → B) {x y : A} (p : Id x y) → Id (ap (comp g f) p) (ap g (ap f p))
ap-comp g f refl = refl
ap-refl : {i j : Level} {A : UU i} {B : UU j} (f : A → B) (x : A) →
Id (ap f (refl {_} {_} {x})) refl
ap-refl f x = refl
ap-concat : {i j : Level} {A : UU i} {B : UU j} (f : A → B) {x y z : A} (p : Id x y) (q : Id y z) → Id (ap f (concat _ p q)) (concat _ (ap f p) (ap f q))
ap-concat f refl q = refl
ap-inv : {i j : Level} {A : UU i} {B : UU j} (f : A → B) {x y : A} (p : Id x y) → Id (ap f (inv p)) (inv (ap f p))
ap-inv f refl = refl
tr : {i j : Level} {A : UU i} (B : A → UU j) {x y : A} (p : Id x y) (b : B x) → B y
tr B refl b = b
apd : {i j : Level} {A : UU i} {B : A → UU j} (f : (x : A) → B x) {x y : A} (p : Id x y) → Id (tr B p (f x)) (f y)
apd f refl = refl
-- Exercises below
-- Exercise 4.1 The composition of transports is the transport of the concatenation
tr-concat : {i j : Level} {A : UU i} (B : A → UU j) {x y z : A} (p : Id x y) (q : Id y z) (b : B x) → Id (tr B q (tr B p b)) (tr B (concat _ p q) b)
tr-concat B refl refl b = refl
-- Exercise 4.2 Taking the inverse distributes contravariantly over concatenation
inv-assoc : {i : Level} {A : UU i} {x y z : A} (p : Id x y) (q : Id y z) → Id (inv (concat _ p q)) (concat _ (inv q) (inv p))
inv-assoc refl refl = refl
-- Exercise 4.3 If B is a weakened family over A (trivial bundle, not dependent), then tr is refl
tr-triv : {i j : Level} {A : UU i} {B : UU j} {x y : A} (p : Id x y) (b : B) → Id (tr (weaken A B) p b) b
tr-triv refl b = refl
-- Exercise 4.4 Transporting, using x=y and f:A → B, an identity between identities
tr-fib : {i j : Level} {A : UU i} {B : UU j} {f : A → B} {x y : A} (p : Id x y) (b : B) →
(q : Id (f x) b) → Id (tr (λ (a : A) → Id (f a) b) p q) (concat _ (inv (ap f p)) q)
tr-fib refl b q = refl
tr-fib' : {i j : Level} {A : UU i} {B : UU j} {f : A → B} {x y : A} (p : Id x y) (b : B) →
(q : Id b (f x)) → Id (tr (λ (a : A) → Id b (f a)) p q) (concat _ q (ap f p))
tr-fib' refl b refl = refl
-- Exercise 4.5
inv-con : {i : Level} {A : UU i} {x y z : A} (p : Id x y) (q : Id y z) (r : Id x z) → (Id (p · q) r) → (Id q ((inv p) · r))
inv-con refl refl r refl = refl
con-inv : {i : Level} {A : UU i} {x y z : A} (p : Id x y) (q : Id y z) (r : Id x z) → (Id (p · q) r) → (Id p (r · (inv q)))
con-inv refl refl r refl = refl
-- Exercise 4.6 Path lifting, from a path in the base A to a path in the total space Σ A B
lift : {i j : Level} {A : UU i} {B : A → UU j} {x y : A} (p : Id x y) (b : B x) → Id (dpair x b) (dpair y (tr B p b))
lift refl b = refl
-- Exercise 4.7 Some laws of arithmetic (follow-up from Remark 2.3.1)
right-unit-addN : (m : ℕ) → Id (m + Nzero) m
right-unit-addN Nzero = refl
right-unit-addN (Nsucc m) = ap Nsucc (right-unit-addN m)
left-unit-addN : (m : ℕ) → Id (Nzero + m) m
left-unit-addN m = refl
assoc-addN : (m n k : ℕ) → Id (m + (n + k)) ((m + n) + k)
assoc-addN Nzero n k = refl
assoc-addN (Nsucc m) n k = ap Nsucc (assoc-addN m n k)
right-succ-addN : (m n : ℕ) → Id (m + (Nsucc n)) (Nsucc (m + n))
right-succ-addN Nzero n = refl
right-succ-addN (Nsucc m) n = ap Nsucc (right-succ-addN m n)
comm-addN : (m n : ℕ) → Id (m + n) (n + m)
comm-addN Nzero Nzero = refl
comm-addN Nzero (Nsucc n) = ap Nsucc (comm-addN Nzero n)
comm-addN (Nsucc m) Nzero = ap Nsucc (comm-addN m Nzero)
comm-addN (Nsucc m) (Nsucc n) =
((Nsucc m) + (Nsucc n))
==⟨ ap Nsucc (comm-addN m (Nsucc n)) ⟩
(Nsucc ((Nsucc n) + m))
==⟨ inv (right-succ-addN (Nsucc n) m) ⟩
((Nsucc n) + (Nsucc m))
==∎
left-zero-mulN : (m : ℕ) → Id (Nzero ** m) Nzero
left-zero-mulN m = refl
right-zero-mulN : (m : ℕ) → Id (m ** Nzero) Nzero
right-zero-mulN Nzero = refl
right-zero-mulN (Nsucc m) = concat (m ** Nzero) (right-unit-addN _) (right-zero-mulN m)
left-unit-mulN : (m : ℕ) → Id ((Nsucc Nzero) ** m) m
left-unit-mulN m = refl
right-unit-mulN : (m : ℕ) → Id (m ** (Nsucc Nzero)) m
right-unit-mulN Nzero = refl
right-unit-mulN (Nsucc m) =
((Nsucc m) ** (Nsucc Nzero))
==⟨ comm-addN _ (Nsucc Nzero) ⟩
(Nsucc Nzero) + (m ** (Nsucc Nzero))
==⟨ ap Nsucc (right-unit-mulN m) ⟩
(Nsucc m)
==∎
distr-addN-mulN : (m n k : ℕ) → Id ((m + n) ** k) ((m ** k) + (n ** k))
distr-addN-mulN Nzero n k = refl
distr-addN-mulN (Nsucc m) n k =
((Nsucc m) + n) ** k
==⟨ refl ⟩
(Nsucc (m + n)) ** k
==⟨ refl ⟩
((m + n) ** k) + k
==⟨ ap (λ x → x + k) (distr-addN-mulN m n k) ⟩
((m ** k) + (n ** k)) + k
==⟨ inv (assoc-addN (m ** k) (n ** k) k) ⟩
(m ** k) + ((n ** k) + k)
==⟨ ap (λ x → (m ** k) + x) (comm-addN (n ** k) k) ⟩
(m ** k) + (k + (n ** k))
==⟨ assoc-addN (m ** k) k (n ** k) ⟩
((m ** k) + k) + (n ** k)
==⟨ refl ⟩
((Nsucc m) ** k) + (n ** k)
==∎
assoc-mulN : (m n k : ℕ) → Id (m ** (n ** k)) ((m ** n) ** k)
assoc-mulN Nzero n k = refl
assoc-mulN (Nsucc m) n k =
((Nsucc m) ** (n ** k))
==⟨ refl ⟩
(m ** (n ** k)) + (n ** k)
==⟨ ap (λ x → x + (n ** k)) (assoc-mulN m n k) ⟩
((m ** n) ** k) + (n ** k)
==⟨ inv (distr-addN-mulN (m ** n) n k) ⟩
((m ** n) + n) ** k
==⟨ refl ⟩
(Nsucc m ** n) ** k
==∎
| {
"alphanum_fraction": 0.4988922736,
"avg_line_length": 30.0916666667,
"ext": "agda",
"hexsha": "ecf206418537f9446c11c9e695e1cbaf1584b737",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2018-06-25T15:05:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-02-22T19:58:46.000Z",
"max_forks_repo_head_hexsha": "af64d808630f4f1498a75201b6ca4d74d662516b",
"max_forks_repo_licenses": [
"Unlicense"
],
"max_forks_repo_name": "glangmead/hott_cmu80818",
"max_forks_repo_path": "Lecture4.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "af64d808630f4f1498a75201b6ca4d74d662516b",
"max_issues_repo_issues_event_max_datetime": "2018-03-25T14:44:31.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-02-22T21:01:16.000Z",
"max_issues_repo_licenses": [
"Unlicense"
],
"max_issues_repo_name": "glangmead/hott_cmu80818",
"max_issues_repo_path": "Lecture4.agda",
"max_line_length": 153,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "af64d808630f4f1498a75201b6ca4d74d662516b",
"max_stars_repo_licenses": [
"Unlicense"
],
"max_stars_repo_name": "glangmead/hott_cmu80818",
"max_stars_repo_path": "Lecture4.agda",
"max_stars_repo_stars_event_max_datetime": "2018-09-04T02:52:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-05-03T20:32:19.000Z",
"num_tokens": 3219,
"size": 7222
} |
-- Testing how the pragmas are saved in the agda interface files (using
-- the program dump-agdai) when they are used from the command-line:
-- $ agda --no-termination-check OptionPragmaCommandLine.agda
-- 17 October 2012. Because the PragmaOption --no-termination-check
-- was used from the command-line it is *not* saved in the interface
-- file.
-- iPragmaOptions = []
module OptionPragmaCommandLine where
| {
"alphanum_fraction": 0.7578692494,
"avg_line_length": 31.7692307692,
"ext": "agda",
"hexsha": "106a7928cc93b598085d495cdc11a029bf37081a",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2016-08-03T03:54:55.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-05-10T23:06:19.000Z",
"max_forks_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/apia",
"max_forks_repo_path": "notes/agda-interface/OptionPragmaCommandLine.agda",
"max_issues_count": 121,
"max_issues_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_issues_repo_issues_event_max_datetime": "2018-04-22T06:01:44.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-25T13:22:12.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/apia",
"max_issues_repo_path": "notes/agda-interface/OptionPragmaCommandLine.agda",
"max_line_length": 71,
"max_stars_count": 10,
"max_stars_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/apia",
"max_stars_repo_path": "notes/agda-interface/OptionPragmaCommandLine.agda",
"max_stars_repo_stars_event_max_datetime": "2019-12-03T13:44:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:54:16.000Z",
"num_tokens": 100,
"size": 413
} |
{-# OPTIONS --cubical-compatible #-}
open import Agda.Builtin.Equality
subst :
{A : Set} {@0 x y : A}
(@0 P : A → Set) → x ≡ y → P x → P y
subst P refl p = p
| {
"alphanum_fraction": 0.5487804878,
"avg_line_length": 18.2222222222,
"ext": "agda",
"hexsha": "ffc6ebf8fd090c32e3fc651644921df10614bf00",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "KDr2/agda",
"max_forks_repo_path": "test/Fail/Issue5448-3.agda",
"max_issues_count": 6,
"max_issues_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_issues_repo_issues_event_max_datetime": "2021-11-24T08:31:10.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-10-18T08:12:24.000Z",
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "KDr2/agda",
"max_issues_repo_path": "test/Fail/Issue5448-3.agda",
"max_line_length": 38,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "KDr2/agda",
"max_stars_repo_path": "test/Fail/Issue5448-3.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 60,
"size": 164
} |
module Lists.Reverse where
open import Lists
open import Nats
open import Equality
open import Function
------------------------------------------------------------------------
-- internal stuffs
private
-- rev$v:a=a:rev$v : ∀ {n m} {A : Set n} (a : A) (v : List A m) →
-- rev (v ∷ʳ a) ≡ a ∷ rev v
-- rev$v:a=a:rev$v _ [] = refl
-- rev$v:a=a:rev$v a (_ ∷ xs) with rev (xs ∷ʳ a) | rev$v:a=a:rev$v a xs
-- ... | .(a ∷ rev xs) | refl = refl
rev$v:a=a:rev$v : ∀ {n} {A : Set n} (a : A) (v : List A) →
reverse (v ∷ʳ a) ≡ a ∷ reverse v
rev$v:a=a:rev$v _ [] = refl
rev$v:a=a:rev$v a (_ ∷ xs)
rewrite rev$v:a=a:rev$v a xs
= refl
rev∘rev=id : ∀ {n} {A : Set n} (v : List A) → reverse (reverse v) ≡ v
rev∘rev=id [] = refl
rev∘rev=id (x ∷ xs)
rewrite rev$v:a=a:rev$v x $ reverse xs
| rev∘rev=id xs
= refl
------------------------------------------------------------------------
-- public aliases
list-rev-rev-id : ∀ {n} {A : Set n} (v : List A) → reverse (reverse v) ≡ v
list-rev-rev-id = rev∘rev=id
| {
"alphanum_fraction": 0.4295900178,
"avg_line_length": 29.5263157895,
"ext": "agda",
"hexsha": "c9cfd97d3cc6bb361d6ca5caf45da14293a35497",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7dc0ea4782a5ff960fe31bdcb8718ce478eaddbc",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "ice1k/Theorems",
"max_forks_repo_path": "src/Lists/Reverse.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7dc0ea4782a5ff960fe31bdcb8718ce478eaddbc",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Apache-2.0"
],
"max_issues_repo_name": "ice1k/Theorems",
"max_issues_repo_path": "src/Lists/Reverse.agda",
"max_line_length": 74,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "7dc0ea4782a5ff960fe31bdcb8718ce478eaddbc",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "ice1k/Theorems",
"max_stars_repo_path": "src/Lists/Reverse.agda",
"max_stars_repo_stars_event_max_datetime": "2020-04-15T15:28:03.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-15T15:28:03.000Z",
"num_tokens": 381,
"size": 1122
} |
module Structure.Operator.Monoid.Monoids.Coset where
open import Functional
open import Function.Equals
open import Function.Equals.Proofs
import Lvl
open import Logic
open import Logic.Predicate
open import Logic.Predicate.Equiv
open import Sets.PredicateSet renaming (_≡_ to _≡ₛ_)
open import Structure.Function
open import Structure.Function.Domain
open import Structure.Function.Domain.Proofs
open import Structure.Function.Multi
open import Structure.Operator.Monoid
open import Structure.Operator.Monoid.Homomorphism
open import Structure.Operator.Monoid.Monoids.Function
open import Structure.Operator.Monoid.Submonoid
open import Structure.Operator.Properties
open import Structure.Operator
open import Structure.Relator.Properties
open import Structure.Setoid renaming (_≡_ to _≡ₑ_)
open import Syntax.Transitivity
open import Type
private variable ℓ ℓₑ : Lvl.Level
private variable T : Type{ℓ}
module _ ⦃ equiv : Equiv{ℓₑ}(T) ⦄ ⦃ function : ∀{f : T → T} → Function(f) ⦄ {_▫_ : T → T → T} (monoid : Monoid(_▫_)) where
cosetₗ-submonoid : Submonoid(function-monoid)(⊶(_▫_))
Submonoid.contains-identity cosetₗ-submonoid = [∃]-intro (_) ⦃ intro(identityₗ(_▫_)(_)) ⦄
Submonoid.operator-closure cosetₗ-submonoid {f}{g} ⦃ [∃]-intro a ⦃ pa ⦄ ⦄ ⦃ [∃]-intro b ⦃ pb ⦄ ⦄ =
[∃]-intro (a ▫ b) ⦃ intro (\{x} →
((a ▫ b) ▫ x) 🝖[ _≡ₑ_ ]-[ associativity(_▫_) ]
(a ▫ (b ▫ x)) 🝖[ _≡ₑ_ ]-[ _⊜_.proof pa ]
f(b ▫ x) 🝖[ _≡ₑ_ ]-[ congruence₁(f) (_⊜_.proof pb) ]
f(g(x)) 🝖[ _≡ₑ_ ]-[]
(f ∘ g)(x) 🝖-end
) ⦄
cosetᵣ-submonoid : Submonoid(function-monoid)(⊶(swap(_▫_)))
Submonoid.contains-identity cosetᵣ-submonoid = [∃]-intro (_) ⦃ intro(identityᵣ(_▫_)(_)) ⦄
Submonoid.operator-closure cosetᵣ-submonoid {f}{g} ⦃ [∃]-intro a ⦃ pa ⦄ ⦄ ⦃ [∃]-intro b ⦃ pb ⦄ ⦄ =
[∃]-intro (b ▫ a) ⦃ intro (\{x} →
(x ▫ (b ▫ a)) 🝖[ _≡ₑ_ ]-[ associativity(_▫_) ]-sym
((x ▫ b) ▫ a) 🝖[ _≡ₑ_ ]-[ _⊜_.proof pa ]
f(x ▫ b) 🝖[ _≡ₑ_ ]-[ congruence₁(f) (_⊜_.proof pb) ]
f(g(x)) 🝖[ _≡ₑ_ ]-[]
(f ∘ g)(x) 🝖-end
) ⦄
cosetₗ-homomorphism : ∃(Homomorphism monoid (Submonoid.monoid cosetₗ-submonoid))
∃.witness cosetₗ-homomorphism a = [∃]-intro (a ▫_) ⦃ [∃]-intro a ⦃ reflexivity(_≡ₑ_) {a ▫_} ⦄ ⦄
_⊜_.proof (Function.congruence (Homomorphism.function (∃.proof cosetₗ-homomorphism)) ab) {x} = congruence₂ₗ(_▫_)(x) ab
_⊜_.proof (Preserving.proof (Homomorphism.preserve-op (∃.proof cosetₗ-homomorphism)) {x}) = associativity(_▫_)
_⊜_.proof (Preserving.proof (Homomorphism.preserve-id (∃.proof cosetₗ-homomorphism))) {x} = identityₗ(_▫_)(_)
instance
cosetₗ-surjective : Surjective([∃]-witness cosetₗ-homomorphism)
Surjective.proof cosetₗ-surjective {[∃]-intro f ⦃ pf ⦄} = pf
instance
cosetₗ-injective : Injective([∃]-witness cosetₗ-homomorphism)
Injective.proof cosetₗ-injective {x} {y} (intro xy) =
x 🝖[ _≡ₑ_ ]-[ identityᵣ(_▫_)(_) ]-sym
x ▫ Monoid.id monoid 🝖[ _≡ₑ_ ]-[ xy {Monoid.id monoid} ]
y ▫ Monoid.id monoid 🝖[ _≡ₑ_ ]-[ identityᵣ(_▫_)(_) ]
y 🝖-end
instance
cosetₗ-bijective : Bijective([∃]-witness cosetₗ-homomorphism)
cosetₗ-bijective = injective-surjective-to-bijective([∃]-witness cosetₗ-homomorphism)
{-
cosetᵣ-homomorphism : ∃(Homomorphism monoid (Submonoid.monoid cosetᵣ-submonoid))
∃.witness cosetᵣ-homomorphism a = [∃]-intro (_▫ a) ⦃ [∃]-intro a ⦃ reflexivity(_≡ₑ_) {_▫ a} ⦄ ⦄
_⊜_.proof (Function.congruence (Homomorphism.function (∃.proof cosetᵣ-homomorphism)) ab) {x} = congruence₂ᵣ(_▫_)(x) ab
_⊜_.proof (Preserving.proof (Homomorphism.preserve-op (∃.proof cosetᵣ-homomorphism)) {a} {b}) {x} =
(x ▫ (a ▫ b)) 🝖[ _≡ₑ_ ]-[ {!!} ]
((x ▫ b) ▫ a) 🝖-end
_⊜_.proof (Preserving.proof (Homomorphism.preserve-id (∃.proof cosetᵣ-homomorphism))) {x} = identityᵣ(_▫_)(_)
-}
| {
"alphanum_fraction": 0.640298892,
"avg_line_length": 46.7590361446,
"ext": "agda",
"hexsha": "a78b047c7ddfc071b5ac35f08dc499d9c50159f5",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Lolirofle/stuff-in-agda",
"max_forks_repo_path": "Structure/Operator/Monoid/Monoids/Coset.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "Structure/Operator/Monoid/Monoids/Coset.agda",
"max_line_length": 122,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Lolirofle/stuff-in-agda",
"max_stars_repo_path": "Structure/Operator/Monoid/Monoids/Coset.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-05T06:53:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:58:13.000Z",
"num_tokens": 1614,
"size": 3881
} |
-- Exponentials and closed categories
module CategoryTheory.BCCCs.Closed where
open import CategoryTheory.Categories
open import CategoryTheory.BCCCs.Cartesian
module _ {n} {ℂ : Category n} (Cℂ : Cartesian ℂ) where
open Category ℂ
open Cartesian Cℂ
-- Exponential from two objects
record Exponential (A B : obj) : Set (lsuc n) where
field
-- | Data
-- Exponential object
A⇒B : obj
-- Evaluation map
eval : A⇒B ⊗ A ~> B
-- Canonical transposition morphism (currying)
Λ : ∀{E} -> (E ⊗ A ~> B) -> (E ~> A⇒B)
-- | Laws
Λ-comm : ∀{E} -> {e : E ⊗ A ~> B}
-> eval ∘ (Λ e * id) ≈ e
Λ-unique : ∀{E} -> {e : E ⊗ A ~> B} {m : E ~> A⇒B}
-> eval ∘ (m * id) ≈ e -> Λ e ≈ m
Λ-cong : ∀{E} {f g : E ⊗ A ~> B}
-> f ≈ g -> Λ f ≈ Λ g
-- Currying identity
Λ-*id : ∀{D E} {f : E ⊗ A ~> B} {g : D ~> E}
-> Λ (f ∘ (g * id)) ≈ Λ f ∘ g
Λ-*id {D}{E}{f}{g} =
begin
Λ (f ∘ (g * id))
≈⟨ Λ-cong (≈-cong-left (Λ-comm [sym]) ≈> ∘-assoc) ⟩
Λ (eval ∘ (Λ f * id) ∘ (g * id))
≈⟨ Λ-cong (≈-cong-right (*-idemp-dist-∘ id-left)) ⟩
Λ (eval ∘ (Λ f ∘ g) * id)
≈⟨ Λ-unique r≈ ⟩
Λ f ∘ g
∎
-- Type class for closed categories
-- definition using exponentials
record Closed {n} {ℂ : Category n} (Cℂ : Cartesian ℂ) : Set (lsuc n) where
open Category ℂ
field
-- Exponential object for each pair of objects
exp : ∀(A B : obj) -> Exponential Cℂ A B
open module E {A} {B} = Exponential (exp A B) public
-- Shorthand for exponential object
infixr 20 _⇒_
_⇒_ : (A B : obj) -> obj
A ⇒ B = A⇒B {A} {B}
| {
"alphanum_fraction": 0.448423303,
"avg_line_length": 31.1833333333,
"ext": "agda",
"hexsha": "8d4fdbaa77647407c07443b31645d38a7e04dcc6",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7d993ba55e502d5ef8707ca216519012121a08dd",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "DimaSamoz/temporal-type-systems",
"max_forks_repo_path": "src/CategoryTheory/BCCCs/Closed.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7d993ba55e502d5ef8707ca216519012121a08dd",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "DimaSamoz/temporal-type-systems",
"max_issues_repo_path": "src/CategoryTheory/BCCCs/Closed.agda",
"max_line_length": 74,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "7d993ba55e502d5ef8707ca216519012121a08dd",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "DimaSamoz/temporal-type-systems",
"max_stars_repo_path": "src/CategoryTheory/BCCCs/Closed.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-04T09:33:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-05-31T20:37:04.000Z",
"num_tokens": 676,
"size": 1871
} |
{-
Please do not move this file. Changes should only be made if
necessary.
This file contains benchmarks for the paper:
Synthetic Integral Cohomology in Cubical Agda
Guillaume Brunerie, Axel Ljungström, Anders Mörtberg
Computer Science Logic (CSL) 2022
Command to run the benchmarks and get timings:
agda -v profile.definitions:10 Benchmarks.agda
This assumes that there is no Benchmarks.agdai file. If there is one,
then it should be removed before the above command is run.
-}
{-# OPTIONS --safe #-}
module Cubical.Experiments.ZCohomology.Benchmarks where
open import Cubical.Foundations.Everything
open import Cubical.Data.Nat
open import Cubical.Data.Bool
open import Cubical.Data.Int
open import Cubical.HITs.Sn
open import Cubical.Algebra.Group hiding (ℤ ; Bool)
open import Cubical.ZCohomology.Base
open import Cubical.ZCohomology.Properties
open import Cubical.ZCohomology.GroupStructure hiding (_+ₕ_) renaming (_+'ₕ_ to _+ₕ_)
{- _+'ₕ_ is just (λ x y → (x +ₕ 0ₕ) +ₕ (y +ₕ 0ₕ))
For technical reason, this gives nicer reductions and computes better in
higher dimensions. -}
open import Cubical.ZCohomology.Groups.Sn
open import Cubical.ZCohomology.Groups.Wedge
open import Cubical.ZCohomology.Groups.Torus
open import Cubical.ZCohomology.Groups.KleinBottle
open import Cubical.ZCohomology.Groups.WedgeOfSpheres
open import Cubical.ZCohomology.Groups.RP2
open import Cubical.ZCohomology.Groups.CP2
open import Cubical.Data.Sigma
open import Cubical.HITs.KleinBottle
open import Cubical.HITs.RPn.Base
open import Cubical.HITs.SetTruncation
open import Cubical.HITs.Pushout
open import Cubical.HITs.Hopf
open import Cubical.HITs.Truncation
open import Cubical.HITs.Susp
open import Cubical.HITs.S1
open IsGroupHom
open Iso
-- S¹ (everything fast)
module S1-tests where
ϕ : coHom 1 (S₊ 1) → ℤ
ϕ = fun (fst (Hⁿ-Sⁿ≅ℤ 0))
ϕ⁻¹ : ℤ → coHom 1 (S₊ 1)
ϕ⁻¹ = inv (fst (Hⁿ-Sⁿ≅ℤ 0))
test₁ : ϕ (ϕ⁻¹ 0) ≡ 0 -- <10ms
test₁ = refl
test₂ : ϕ (ϕ⁻¹ 1) ≡ 1 -- <10ms
test₂ = refl
test₃ : ϕ (ϕ⁻¹ 0 +ₕ ϕ⁻¹ 0) ≡ 0 -- <10ms
test₃ = refl
test₄ : ϕ (ϕ⁻¹ 0 +ₕ ϕ⁻¹ 1) ≡ 1 -- 12ms
test₄ = refl
test₅ : ϕ (ϕ⁻¹ 1 +ₕ ϕ⁻¹ 0) ≡ 1 -- 13ms
test₅ = refl
test₆ : ϕ (ϕ⁻¹ -3 +ₕ ϕ⁻¹ 4) ≡ 1 -- 37ms
test₆ = refl
test₇ : ϕ (ϕ⁻¹ -5 +ₕ ϕ⁻¹ -2) ≡ -7 -- 38ms
test₇ = refl
-- S²
module S2-tests where
ϕ : coHom 2 (S₊ 2) → ℤ
ϕ = fun (fst (Hⁿ-Sⁿ≅ℤ 1))
ϕ⁻¹ : ℤ → coHom 2 (S₊ 2)
ϕ⁻¹ = inv (fst (Hⁿ-Sⁿ≅ℤ 1))
test₁ : ϕ (ϕ⁻¹ 0) ≡ 0 -- 13ms
test₁ = refl
test₂ : ϕ (ϕ⁻¹ 1) ≡ 1 -- 17ms
test₂ = refl
test₃ : ϕ (ϕ⁻¹ 0 +ₕ ϕ⁻¹ 0) ≡ 0 -- 1,152ms
test₃ = refl
test₄ : ϕ (ϕ⁻¹ 0 +ₕ ϕ⁻¹ 1) ≡ 1 -- 1,235ms
test₄ = refl
test₅ : ϕ (ϕ⁻¹ 1 +ₕ ϕ⁻¹ 0) ≡ 1 -- 1,208ms
test₅ = refl
test₆ : ϕ (ϕ⁻¹ 1 +ₕ ϕ⁻¹ 1) ≡ 2 -- 1,153ms
test₆ = refl
test₇ : ϕ (ϕ⁻¹ 2 +ₕ ϕ⁻¹ 4) ≡ 6 -- 1,365ms
test₇ = refl
-- S³
module S3-tests where
ϕ : coHom 3 (S₊ 3) → ℤ
ϕ = fun (fst (Hⁿ-Sⁿ≅ℤ 2))
ϕ⁻¹ : ℤ → coHom 3 (S₊ 3)
ϕ⁻¹ = inv (fst (Hⁿ-Sⁿ≅ℤ 2))
test₁ : ϕ (ϕ⁻¹ 0) ≡ 0 -- 228ms
test₁ = refl
test₂ : ϕ (ϕ⁻¹ 1) ≡ 1 -- 231ms
test₂ = refl
test₃ : ϕ (ϕ⁻¹ 3) ≡ 3 -- 325ms
test₃ = refl
{-
test₄ : ϕ (ϕ⁻¹ 0 +ₕ ϕ⁻¹ 0) ≡ 0 -- nope
test₄ = refl
test₅ : ϕ (ϕ⁻¹ 0 +ₕ ϕ⁻¹ 1) ≡ 1 -- nope
test₅ = refl
-}
-- S⁴
module S4-tests where
ϕ : coHom 4 (S₊ 4) → ℤ
ϕ = fun (fst (Hⁿ-Sⁿ≅ℤ 3))
ϕ⁻¹ : ℤ → coHom 4 (S₊ 4)
ϕ⁻¹ = inv (fst (Hⁿ-Sⁿ≅ℤ 3))
{- _+ₕ_ Fails already here...
test₁ : ϕ (ϕ⁻¹ 0) ≡ 0 -- nope
test₁ = refl
-}
-- ϕ can handle 0ₕ fast
test₂ : ϕ (0ₕ _) ≡ 0 -- < 10ms
test₂ = refl
{- It fails to map the generator to 1, however.
test₂ : ϕ (∣ ∣_∣ ∣₂) ≡ 1 -- nope
test₂ = refl
-}
module S1∨S1∨S2-tests₁ where -- everything fast
ϕ : coHom 1 S²⋁S¹⋁S¹ → ℤ × ℤ
ϕ = fun (fst H¹-S²⋁S¹⋁S¹)
ϕ⁻¹ : ℤ × ℤ → coHom 1 S²⋁S¹⋁S¹
ϕ⁻¹ = inv (fst H¹-S²⋁S¹⋁S¹)
test₁ : ϕ (ϕ⁻¹ (0 , 0)) ≡ (0 , 0) -- 11ms
test₁ = refl
test₂ : ϕ (ϕ⁻¹ (3 , 1)) ≡ (3 , 1) -- 23ms
test₂ = refl
test₃ : ϕ (ϕ⁻¹ (0 , 0) +ₕ ϕ⁻¹ (0 , 0)) ≡ (0 , 0) -- 19ms
test₃ = refl
test₄ : ϕ (ϕ⁻¹ (0 , 1) +ₕ ϕ⁻¹ (1 , 0)) ≡ (1 , 1) -- 26ms
test₄ = refl
test₅ : ϕ (ϕ⁻¹ (3 , 2) +ₕ ϕ⁻¹ (-1 , 5)) ≡ (2 , 7) -- 62ms
test₅ = refl
module S1∨S1∨S2-tests₂ where
ϕ : coHom 2 S²⋁S¹⋁S¹ → ℤ
ϕ = fun (fst H²-S²⋁S¹⋁S¹)
ϕ⁻¹ : ℤ → coHom 2 S²⋁S¹⋁S¹
ϕ⁻¹ = inv (fst H²-S²⋁S¹⋁S¹)
test₁ : ϕ (ϕ⁻¹ 0) ≡ 0 -- 106ms
test₁ = refl
test₂ : ϕ (ϕ⁻¹ 3) ≡ 3 -- 125ms
test₂ = refl
test₃ : ϕ (ϕ⁻¹ 0 +ₕ ϕ⁻¹ 0) ≡ 0 -- 9,689ms
test₃ = refl
test₄ : ϕ (ϕ⁻¹ 0 +ₕ ϕ⁻¹ 1) ≡ 1 -- 9,235ms
test₄ = refl
test₅ : ϕ (ϕ⁻¹ 1 +ₕ ϕ⁻¹ 0) ≡ 1 -- 9,748ms
test₅ = refl
test₆ : ϕ (ϕ⁻¹ 1 +ₕ ϕ⁻¹ 1) ≡ 2 -- 9,136ms
test₆ = refl
test₇ : ϕ (ϕ⁻¹ 2 +ₕ ϕ⁻¹ 4) ≡ 6 -- 9,557ms
test₇ = refl
module Torus-test₁ where -- fast
ϕ : coHom 1 (S₊ 1 × S₊ 1) → ℤ × ℤ
ϕ = fun (fst H¹-T²≅ℤ×ℤ)
ϕ⁻¹ : ℤ × ℤ → coHom 1 (S₊ 1 × S₊ 1)
ϕ⁻¹ = inv (fst H¹-T²≅ℤ×ℤ)
test₁ : ϕ (ϕ⁻¹ (0 , 0)) ≡ (0 , 0) -- 11ms
test₁ = refl
test₂ : ϕ (ϕ⁻¹ (3 , 1)) ≡ (3 , 1) -- 17ms
test₂ = refl
test₃ : ϕ (ϕ⁻¹ (0 , 0) +ₕ ϕ⁻¹ (0 , 0)) ≡ (0 , 0) -- 19ms
test₃ = refl
test₄ : ϕ (ϕ⁻¹ (0 , 1) +ₕ ϕ⁻¹ (1 , 0)) ≡ (1 , 1) -- 26ms
test₄ = refl
test₅ : ϕ (ϕ⁻¹ (-3 , 2) +ₕ ϕ⁻¹ (-1 , 5)) ≡ (-4 , 7) -- 61ms
test₅ = refl
module Torus-test₂ where
ϕ : coHom 2 (S₊ 1 × S₊ 1) → ℤ
ϕ = fun (fst H²-T²≅ℤ)
ϕ⁻¹ : ℤ → coHom 2 (S₊ 1 × S₊ 1)
ϕ⁻¹ = inv (fst H²-T²≅ℤ)
test₁ : ϕ (ϕ⁻¹ 0) ≡ 0 -- 136sm
test₁ = refl
test₂ : ϕ (ϕ⁻¹ 3) ≡ 3 -- 154ms
test₂ = refl
test₃ : ϕ (ϕ⁻¹ 0 +ₕ ϕ⁻¹ 0) ≡ 0 -- 12,790ms
test₃ = refl
test₄ : ϕ (ϕ⁻¹ 0 +ₕ ϕ⁻¹ 1) ≡ 1 -- 12,366ms
test₄ = refl
test₅ : ϕ (ϕ⁻¹ 1 +ₕ ϕ⁻¹ 0) ≡ 1 -- 12,257ms
test₅ = refl
test₆ : ϕ (ϕ⁻¹ 1 +ₕ ϕ⁻¹ 1) ≡ 2 -- 13,092ms
test₆ = refl
test₇ : ϕ (ϕ⁻¹ 2 +ₕ ϕ⁻¹ 4) ≡ 6 -- 12,528ms
test₇ = refl
module Klein-test₁ where -- fast
ϕ : coHom 1 KleinBottle → ℤ
ϕ = fun (fst H¹-𝕂²≅ℤ)
ϕ⁻¹ : ℤ → coHom 1 KleinBottle
ϕ⁻¹ = inv (fst H¹-𝕂²≅ℤ)
test₁ : ϕ (ϕ⁻¹ 0) ≡ 0 -- <10ms
test₁ = refl
test₂ : ϕ (ϕ⁻¹ 3) ≡ 3 -- 13ms
test₂ = refl
test₃ : ϕ (ϕ⁻¹ 0 +ₕ ϕ⁻¹ 0) ≡ 0 -- 10ms
test₃ = refl
test₄ : ϕ (ϕ⁻¹ 0 +ₕ ϕ⁻¹ 1) ≡ 1 -- 14ms
test₄ = refl
test₅ : ϕ (ϕ⁻¹ 1 +ₕ ϕ⁻¹ 0) ≡ 1 -- 14ms
test₅ = refl
test₆ : ϕ (ϕ⁻¹ -3 +ₕ ϕ⁻¹ 4) ≡ 1 -- 38ms
test₆ = refl
test₇ : ϕ (ϕ⁻¹ -5 +ₕ ϕ⁻¹ -2) ≡ -7 -- 38ms
test₇ = refl
-- The example in the paper:
test : ϕ (ϕ⁻¹ 1 +ₕ ϕ⁻¹ 2) ≡ 3 -- 22ms
test = refl
module Klein-test₂ where
ϕ : coHom 2 KleinBottle → Bool
ϕ = fun (fst H²-𝕂²≅Bool)
ϕ⁻¹ : Bool → coHom 2 KleinBottle
ϕ⁻¹ = inv (fst H²-𝕂²≅Bool)
{-
test₀ : ϕ (0ₕ _) ≡ true -- fails already here...
test₀ = refl
-}
module RP2-test₂ where
ϕ : coHom 2 RP² → Bool
ϕ = fun (fst H²-RP²≅Bool)
ϕ⁻¹ : Bool → coHom 2 RP²
ϕ⁻¹ = inv (fst H²-RP²≅Bool)
test₀ : ϕ (0ₕ _) ≡ true -- 1,328ms (unlike for Klein, this works)
test₀ = refl
{-
test₁ : ϕ (ϕ⁻¹ true) ≡ true -- nope
test₁ = refl
-}
module CP2-test₂ where
ϕ : coHom 2 CP² → ℤ
ϕ = fun (fst H²CP²≅ℤ)
ϕ⁻¹ : ℤ → coHom 2 CP²
ϕ⁻¹ = inv (fst H²CP²≅ℤ)
-- For explicitly constructed elements g : H²CP², ϕ works well
test₀ : ϕ (0ₕ _) ≡ 0 -- <10ms
test₀ = refl
generator : coHom 2 CP²
generator = ∣ (λ { (inl x) → ∣ x ∣ ; (inr x) → 0ₖ _ ; (push a i) → p a i}) ∣₂
where
ind : (B : TotalHopf → Type) → ((x : _) → isOfHLevel 3 (B x)) → B (north , base) → (x : _) → B x
ind =
transport (λ i → (B : isoToPath IsoS³TotalHopf i → Type)
→ ((x : _) → isOfHLevel 3 (B x))
→ B (transp (λ j → isoToPath IsoS³TotalHopf (i ∨ ~ j)) i (north , base)) → (x : _) → B x)
λ B hLev ind → sphereElim _ (λ _ → hLev _) ind
p : (a : TotalHopf) → ∣ fst a ∣ ≡ 0ₖ 2
p = ind _ (λ _ → isOfHLevelTrunc 4 _ _) refl
test₁ : ϕ generator ≡ 1 -- 24ms
test₁ = refl
-- For _+ₕ_ too
test₂ : ϕ (ϕ⁻¹ 0 +ₕ ϕ⁻¹ 0) ≡ 0 -- 1,343ms
test₂ = refl
test₃ : ϕ (ϕ⁻¹ 1 +ₕ ϕ⁻¹ 1) ≡ 2 -- 1,302ms
test₃ = refl
test₄ : ϕ (ϕ⁻¹ 2 +ₕ ϕ⁻¹ 2) ≡ 4 -- 1,410ms
test₄ = refl
module CP2-test₄ where
ϕ : coHom 4 CP² → ℤ
ϕ = fun (fst H⁴CP²≅ℤ)
ϕ⁻¹ : ℤ → coHom 4 CP²
ϕ⁻¹ = inv (fst H⁴CP²≅ℤ)
{-
test₀ : ϕ (0ₕ _) ≡ 0 -- fails already here...
test₀ = refl
-}
| {
"alphanum_fraction": 0.5518607443,
"avg_line_length": 21.4690721649,
"ext": "agda",
"hexsha": "61a2662f325ef9116e5c71352bcb424a66b06f7a",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "a1d2bb38c0794f3cb00610cd6061cf9b5410518d",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "lkstl/cubical",
"max_forks_repo_path": "Cubical/Experiments/ZCohomology/Benchmarks.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "a1d2bb38c0794f3cb00610cd6061cf9b5410518d",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "lkstl/cubical",
"max_issues_repo_path": "Cubical/Experiments/ZCohomology/Benchmarks.agda",
"max_line_length": 100,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "a1d2bb38c0794f3cb00610cd6061cf9b5410518d",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "lkstl/cubical",
"max_stars_repo_path": "Cubical/Experiments/ZCohomology/Benchmarks.agda",
"max_stars_repo_stars_event_max_datetime": "2021-10-20T11:56:18.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-10-20T11:56:18.000Z",
"num_tokens": 4546,
"size": 8330
} |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Definition
open import Numbers.Naturals.Naturals
open import Numbers.Integers.Integers
open import Groups.Groups
open import Groups.Definition
open import Groups.Lemmas
open import Rings.Definition
open import Rings.Orders.Total.Definition
open import Rings.Orders.Partial.Definition
open import Fields.Fields
open import Setoids.Setoids
open import Setoids.Orders.Partial.Definition
open import Setoids.Orders.Total.Definition
open import Functions.Definition
open import Sets.EquivalenceRelations
module Numbers.Rationals.Definition where
open import Fields.FieldOfFractions.Setoid ℤIntDom
open import Fields.FieldOfFractions.Addition ℤIntDom
open import Fields.FieldOfFractions.Multiplication ℤIntDom
open import Fields.FieldOfFractions.Ring ℤIntDom
open import Fields.FieldOfFractions.Field ℤIntDom
open import Fields.FieldOfFractions.Lemmas ℤIntDom
open import Fields.FieldOfFractions.Order ℤIntDom ℤOrderedRing
ℚ : Set
ℚ = fieldOfFractionsSet
ℚSetoid : Setoid ℚ
ℚSetoid = fieldOfFractionsSetoid
_+Q_ : ℚ → ℚ → ℚ
a +Q b = fieldOfFractionsPlus a b
_*Q_ : ℚ → ℚ → ℚ
a *Q b = fieldOfFractionsTimes a b
ℚRing : Ring fieldOfFractionsSetoid _+Q_ _*Q_
ℚRing = fieldOfFractionsRing
0Q : ℚ
0Q = Ring.0R ℚRing
injectionQ : ℤ → ℚ
injectionQ = embedIntoFieldOfFractions
injectionNQ : ℕ → ℚ
injectionNQ n = injectionQ (nonneg n)
injectionQInjective : Injection injectionQ
injectionQInjective {nonneg x} {nonneg .x} refl = refl
injectionQInjective {negSucc x} {negSucc .x} refl = refl
ℚField : Field ℚRing
ℚField = fieldOfFractions
_<Q_ : ℚ → ℚ → Set
_<Q_ = fieldOfFractionsComparison
_=Q_ : ℚ → ℚ → Set
a =Q b = Setoid._∼_ fieldOfFractionsSetoid a b
reflQ : {x : ℚ} → (x =Q x)
reflQ {x} = Equivalence.reflexive (Setoid.eq fieldOfFractionsSetoid) {x}
_≤Q_ : ℚ → ℚ → Set
a ≤Q b = (a <Q b) || (a =Q b)
negateQ : ℚ → ℚ
negateQ a = Group.inverse (Ring.additiveGroup ℚRing) a
_-Q_ : ℚ → ℚ → ℚ
a -Q b = a +Q negateQ b
a-A : (a : ℚ) → (a -Q a) =Q 0Q
a-A a = Group.invRight (Ring.additiveGroup ℚRing) {a}
ℚPartialOrder : SetoidPartialOrder fieldOfFractionsSetoid fieldOfFractionsComparison
ℚPartialOrder = fieldOfFractionsOrder
ℚTotalOrder : SetoidTotalOrder fieldOfFractionsOrder
ℚTotalOrder = fieldOfFractionsTotalOrder
ℚOrderInherited : (a b : ℤ) → a <Z b → injectionQ a <Q injectionQ b
ℚOrderInherited a b a<b = fieldOfFractionsOrderInherited a<b
open SetoidTotalOrder fieldOfFractionsTotalOrder
open SetoidPartialOrder partial
open Setoid fieldOfFractionsSetoid
negateQWellDefined : (a b : ℚ) → (a =Q b) → (negateQ a) =Q (negateQ b)
negateQWellDefined a b a=b = inverseWellDefined (Ring.additiveGroup ℚRing) {a} {b} a=b
ℚPOrdered : PartiallyOrderedRing ℚRing partial
ℚPOrdered = fieldOfFractionsPOrderedRing
ℚOrdered : TotallyOrderedRing ℚPOrdered
ℚOrdered = fieldOfFractionsOrderedRing
| {
"alphanum_fraction": 0.783161512,
"avg_line_length": 28.2524271845,
"ext": "agda",
"hexsha": "febd07c7eebc8e7138913ca255c79e768949f01a",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-29T13:23:07.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-29T13:23:07.000Z",
"max_forks_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Smaug123/agdaproofs",
"max_forks_repo_path": "Numbers/Rationals/Definition.agda",
"max_issues_count": 14,
"max_issues_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_issues_repo_issues_event_max_datetime": "2020-04-11T11:03:39.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-06T21:11:59.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Smaug123/agdaproofs",
"max_issues_repo_path": "Numbers/Rationals/Definition.agda",
"max_line_length": 86,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Smaug123/agdaproofs",
"max_stars_repo_path": "Numbers/Rationals/Definition.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-28T06:04:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-08-08T12:44:19.000Z",
"num_tokens": 974,
"size": 2910
} |
{-
This second-order term syntax was created from the following second-order syntax description:
syntax PropLog | PR
type
* : 0-ary
term
false : * | ⊥
or : * * -> * | _∨_ l20
true : * | ⊤
and : * * -> * | _∧_ l30
not : * -> * | ¬_ r50
theory
(⊥U∨ᴸ) a |> or (false, a) = a
(⊥U∨ᴿ) a |> or (a, false) = a
(∨A) a b c |> or (or(a, b), c) = or (a, or(b, c))
(∨C) a b |> or(a, b) = or(b, a)
(⊤U∧ᴸ) a |> and (true, a) = a
(⊤U∧ᴿ) a |> and (a, true) = a
(∧A) a b c |> and (and(a, b), c) = and (a, and(b, c))
(∧D∨ᴸ) a b c |> and (a, or (b, c)) = or (and(a, b), and(a, c))
(∧D∨ᴿ) a b c |> and (or (a, b), c) = or (and(a, c), and(b, c))
(⊥X∧ᴸ) a |> and (false, a) = false
(⊥X∧ᴿ) a |> and (a, false) = false
(¬N∨ᴸ) a |> or (not (a), a) = false
(¬N∨ᴿ) a |> or (a, not (a)) = false
(∧C) a b |> and(a, b) = and(b, a)
(∨I) a |> or(a, a) = a
(∧I) a |> and(a, a) = a
(¬²) a |> not(not (a)) = a
(∨D∧ᴸ) a b c |> or (a, and (b, c)) = and (or(a, b), or(a, c))
(∨D∧ᴿ) a b c |> or (and (a, b), c) = and (or(a, c), or(b, c))
(∨B∧ᴸ) a b |> or (and (a, b), a) = a
(∨B∧ᴿ) a b |> or (a, and (a, b)) = a
(∧B∨ᴸ) a b |> and (or (a, b), a) = a
(∧B∨ᴿ) a b |> and (a, or (a, b)) = a
(⊤X∨ᴸ) a |> or (true, a) = true
(⊤X∨ᴿ) a |> or (a, true) = true
(¬N∧ᴸ) a |> and (not (a), a) = false
(¬N∧ᴿ) a |> and (a, not (a)) = false
(DM∧) a b |> not (and (a, b)) = or (not(a), not(b))
(DM∨) a b |> not (or (a, b)) = and (not(a), not(b))
-}
module PropLog.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 PropLog.Signature
private
variable
Γ Δ Π : Ctx
α : *T
𝔛 : Familyₛ
-- Inductive term declaration
module PR:Terms (𝔛 : Familyₛ) where
data PR : Familyₛ where
var : ℐ ⇾̣ PR
mvar : 𝔛 α Π → Sub PR Π Γ → PR α Γ
⊥ : PR * Γ
_∨_ : PR * Γ → PR * Γ → PR * Γ
⊤ : PR * Γ
_∧_ : PR * Γ → PR * Γ → PR * Γ
¬_ : PR * Γ → PR * Γ
infixl 20 _∨_
infixl 30 _∧_
infixr 50 ¬_
open import SOAS.Metatheory.MetaAlgebra ⅀F 𝔛
PRᵃ : MetaAlg PR
PRᵃ = record
{ 𝑎𝑙𝑔 = λ where
(falseₒ ⋮ _) → ⊥
(orₒ ⋮ a , b) → _∨_ a b
(trueₒ ⋮ _) → ⊤
(andₒ ⋮ a , b) → _∧_ a b
(notₒ ⋮ a) → ¬_ a
; 𝑣𝑎𝑟 = var ; 𝑚𝑣𝑎𝑟 = λ 𝔪 mε → mvar 𝔪 (tabulate mε) }
module PRᵃ = MetaAlg PRᵃ
module _ {𝒜 : Familyₛ}(𝒜ᵃ : MetaAlg 𝒜) where
open MetaAlg 𝒜ᵃ
𝕤𝕖𝕞 : PR ⇾̣ 𝒜
𝕊 : Sub PR Π Γ → Π ~[ 𝒜 ]↝ Γ
𝕊 (t ◂ σ) new = 𝕤𝕖𝕞 t
𝕊 (t ◂ σ) (old v) = 𝕊 σ v
𝕤𝕖𝕞 (mvar 𝔪 mε) = 𝑚𝑣𝑎𝑟 𝔪 (𝕊 mε)
𝕤𝕖𝕞 (var v) = 𝑣𝑎𝑟 v
𝕤𝕖𝕞 ⊥ = 𝑎𝑙𝑔 (falseₒ ⋮ tt)
𝕤𝕖𝕞 (_∨_ a b) = 𝑎𝑙𝑔 (orₒ ⋮ 𝕤𝕖𝕞 a , 𝕤𝕖𝕞 b)
𝕤𝕖𝕞 ⊤ = 𝑎𝑙𝑔 (trueₒ ⋮ tt)
𝕤𝕖𝕞 (_∧_ a b) = 𝑎𝑙𝑔 (andₒ ⋮ 𝕤𝕖𝕞 a , 𝕤𝕖𝕞 b)
𝕤𝕖𝕞 (¬_ a) = 𝑎𝑙𝑔 (notₒ ⋮ 𝕤𝕖𝕞 a)
𝕤𝕖𝕞ᵃ⇒ : MetaAlg⇒ PRᵃ 𝒜ᵃ 𝕤𝕖𝕞
𝕤𝕖𝕞ᵃ⇒ = record
{ ⟨𝑎𝑙𝑔⟩ = λ{ {t = t} → ⟨𝑎𝑙𝑔⟩ t }
; ⟨𝑣𝑎𝑟⟩ = refl
; ⟨𝑚𝑣𝑎𝑟⟩ = λ{ {𝔪 = 𝔪}{mε} → cong (𝑚𝑣𝑎𝑟 𝔪) (dext (𝕊-tab mε)) } }
where
open ≡-Reasoning
⟨𝑎𝑙𝑔⟩ : (t : ⅀ PR α Γ) → 𝕤𝕖𝕞 (PRᵃ.𝑎𝑙𝑔 t) ≡ 𝑎𝑙𝑔 (⅀₁ 𝕤𝕖𝕞 t)
⟨𝑎𝑙𝑔⟩ (falseₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (orₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (trueₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (andₒ ⋮ _) = refl
⟨𝑎𝑙𝑔⟩ (notₒ ⋮ _) = refl
𝕊-tab : (mε : Π ~[ PR ]↝ Γ)(v : ℐ α Π) → 𝕊 (tabulate mε) v ≡ 𝕤𝕖𝕞 (mε v)
𝕊-tab mε new = refl
𝕊-tab mε (old v) = 𝕊-tab (mε ∘ old) v
module _ (g : PR ⇾̣ 𝒜)(gᵃ⇒ : MetaAlg⇒ PRᵃ 𝒜ᵃ g) where
open MetaAlg⇒ gᵃ⇒
𝕤𝕖𝕞! : (t : PR α Γ) → 𝕤𝕖𝕞 t ≡ g t
𝕊-ix : (mε : Sub PR Π Γ)(v : ℐ α Π) → 𝕊 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 ⟨𝑣𝑎𝑟⟩
𝕤𝕖𝕞! ⊥ = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (_∨_ a b) rewrite 𝕤𝕖𝕞! a | 𝕤𝕖𝕞! b = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! ⊤ = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (_∧_ a b) rewrite 𝕤𝕖𝕞! a | 𝕤𝕖𝕞! b = sym ⟨𝑎𝑙𝑔⟩
𝕤𝕖𝕞! (¬_ a) rewrite 𝕤𝕖𝕞! a = sym ⟨𝑎𝑙𝑔⟩
-- Syntax instance for the signature
PR:Syn : Syntax
PR:Syn = record
{ ⅀F = ⅀F
; ⅀:CS = ⅀:CompatStr
; mvarᵢ = PR:Terms.mvar
; 𝕋:Init = λ 𝔛 → let open PR:Terms 𝔛 in record
{ ⊥ = PR ⋉ PRᵃ
; ⊥-is-initial = record { ! = λ{ {𝒜 ⋉ 𝒜ᵃ} → 𝕤𝕖𝕞 𝒜ᵃ ⋉ 𝕤𝕖𝕞ᵃ⇒ 𝒜ᵃ }
; !-unique = λ{ {𝒜 ⋉ 𝒜ᵃ} (f ⋉ fᵃ⇒) {x = t} → 𝕤𝕖𝕞! 𝒜ᵃ f fᵃ⇒ t } } } }
-- Instantiation of the syntax and metatheory
open Syntax PR:Syn public
open PR:Terms public
open import SOAS.Families.Build public
open import SOAS.Syntax.Shorthands PRᵃ public
open import SOAS.Metatheory PR:Syn public
-- Derived operations
_⟹_ : PR 𝔛 * Γ → PR 𝔛 * Γ → PR 𝔛 * Γ
p ⟹ q = ¬ p ∨ q
| {
"alphanum_fraction": 0.4765267968,
"avg_line_length": 27.6666666667,
"ext": "agda",
"hexsha": "01eeb3ca531f42cf39430e8d70e0a25d27ccccc7",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2022-01-24T12:49:17.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-09T20:39:59.000Z",
"max_forks_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "JoeyEremondi/agda-soas",
"max_forks_repo_path": "out/PropLog/Syntax.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_issues_repo_issues_event_max_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "JoeyEremondi/agda-soas",
"max_issues_repo_path": "out/PropLog/Syntax.agda",
"max_line_length": 93,
"max_stars_count": 39,
"max_stars_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "JoeyEremondi/agda-soas",
"max_stars_repo_path": "out/PropLog/Syntax.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-19T17:33:12.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-11-09T20:39:55.000Z",
"num_tokens": 3034,
"size": 4814
} |
-- Andreas, 2015-11-18 Fixing de Bruijn indices in debug print for with.
{-# OPTIONS -v tc.with.top:25 #-} -- KEEP!
postulate
Trash A : Set
P : A → Set
provokeError : Trash
-- The trash arguments should not show up in the debug printing!
-- If they do, permutations or de Bruijn indices are messed up,
-- or the debug messages are printed in the wrong context.
test : (trash1 : Trash) (b : A) (trash2 : Trash) (f : ∀ x → P x) (trash3 : Trash) → Set
test trash1 b trash2 f trash3 with f b
... | p = provokeError
-- EXPECTED:
-- ...
-- vs = [f b]
-- as = [P b]
-- ...
-- with arguments [f b]
-- types [P b]
-- ...
-- checkWithFunction
-- ...
-- as = [P b]
-- vs = [f b]
-- ...
--
-- and then a type error message.
| {
"alphanum_fraction": 0.575,
"avg_line_length": 23.75,
"ext": "agda",
"hexsha": "1b50a59e5d4aa6d3494a8f9064d06291a2d7c5b4",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Fail/DebugWith.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Fail/DebugWith.agda",
"max_line_length": 87,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Fail/DebugWith.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 235,
"size": 760
} |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Category.Complete.Properties.Construction {o ℓ e} (C : Category o ℓ e) where
open import Level
open import Data.Product using (∃₂; _,_; -,_)
open import Categories.Category.Complete
open import Categories.Diagram.Equalizer C
open import Categories.Diagram.Limit as Lim
open import Categories.Object.Product.Indexed C
open import Categories.Functor
import Categories.Category.Construction.Cones as Co
import Categories.Morphism.Reasoning as MR
private
variable
o′ ℓ′ e′ o″ ℓ″ e″ : Level
module C = Category C
module _ (prods : AllProductsOf (o′ ⊔ ℓ′)) (equalizer : ∀ {A B} (f g : A C.⇒ B) → Equalizer f g) where
private
module Prods {I} (P : I → C.Obj) = IndexedProductOf (prods P)
open C.HomReasoning
module _ {J : Category o′ ℓ′ e′} (F : Functor J C) where
private
module J = Category J
open Functor F
open MR C
module OP = Prods {Lift ℓ′ J.Obj} (λ j → F₀ (lower j))
module MP = Prods {∃₂ J._⇒_} (λ { (_ , B , _) → F₀ B })
src : C.Obj
src = OP.X
dst : C.Obj
dst = MP.X
ϕ⇒ : (i : ∃₂ J._⇒_) → let (_ , B , _) = i in src C.⇒ F₀ B
ϕ⇒ (_ , B , _) = OP.π (lift B)
ϕ : src C.⇒ dst
ϕ = MP.⟨ ϕ⇒ ⟩
ψ⇒ : (i : ∃₂ J._⇒_) → let (_ , B , _) = i in src C.⇒ F₀ B
ψ⇒ (A , B , f) = F₁ f C.∘ OP.π (lift A)
ψ : src C.⇒ dst
ψ = MP.⟨ ψ⇒ ⟩
module eq = Equalizer (equalizer ϕ ψ)
⊤ : Co.Cone F
⊤ = record
{ N = eq.obj
; apex = record
{ ψ = λ X → OP.π (lift X) C.∘ eq.arr
; commute = λ {X Y} f → begin
F₁ f C.∘ OP.π (lift X) C.∘ eq.arr ≈˘⟨ pushˡ (MP.commute ψ⇒ _) ⟩
(MP.π (-, -, f) C.∘ ψ) C.∘ eq.arr ≈˘⟨ pushʳ eq.equality ⟩
MP.π (-, -, f) C.∘ ϕ C.∘ eq.arr ≈⟨ pullˡ (MP.commute ϕ⇒ _ ) ⟩
OP.π (lift Y) C.∘ eq.arr ∎
}
}
module _ {K : Co.Cone F} where
private
module K = Co.Cone F K
K⇒ : K.N C.⇒ src
K⇒ = OP.⟨ (λ j → K.ψ (lower j)) ⟩
Keq : (i : ∃₂ J._⇒_) → ϕ⇒ i C.∘ K⇒ C.≈ ψ⇒ i C.∘ K⇒
Keq i@(A , B , f) = begin
ϕ⇒ i C.∘ K⇒ ≈⟨ OP.commute _ _ ⟩
K.ψ B ≈˘⟨ K.commute _ ⟩
F₁ f C.∘ K.ψ A ≈˘⟨ pullʳ (OP.commute _ _) ⟩
ψ⇒ i C.∘ K⇒ ∎
!-eq : ϕ C.∘ K⇒ C.≈ ψ C.∘ K⇒
!-eq = begin
ϕ C.∘ K⇒ ≈⟨ MP.⟨⟩∘ _ _ ⟩
MP.⟨ (λ i → ϕ⇒ i C.∘ K⇒) ⟩ ≈⟨ MP.⟨⟩-cong _ _ Keq ⟩
MP.⟨ (λ i → ψ⇒ i C.∘ K⇒) ⟩ ≈˘⟨ MP.⟨⟩∘ _ _ ⟩
ψ C.∘ K⇒ ∎
! : Co.Cones F [ K , ⊤ ]
! = record
{ arr = eq.equalize {h = K⇒} !-eq
; commute = λ {j} → begin
(OP.π (lift j) C.∘ eq.arr) C.∘ eq.equalize !-eq ≈˘⟨ pushʳ eq.universal ⟩
OP.π (lift j) C.∘ K⇒ ≈⟨ OP.commute _ _ ⟩
K.ψ j ∎
}
!-unique : (f : Co.Cones F [ K , ⊤ ]) → Co.Cones F [ ! ≈ f ]
!-unique f = ⟺ (eq.unique eq)
where module f = Co.Cone⇒ F f
eq : K⇒ C.≈ eq.arr C.∘ f.arr
eq = OP.unique′ _ _ λ i → begin
OP.π i C.∘ K⇒ ≈⟨ OP.commute _ _ ⟩
K.ψ (lower i) ≈˘⟨ f.commute ⟩
(OP.π i C.∘ eq.arr) C.∘ f.arr ≈⟨ C.assoc ⟩
OP.π i C.∘ eq.arr C.∘ f.arr ∎
complete : Limit F
complete = record
{ terminal = record
{ ⊤ = ⊤
; ⊤-is-terminal = record
{ ! = !
; !-unique = !-unique
}
}
}
AllProducts×Equalizer⇒Complete : Complete o′ ℓ′ e′ C
AllProducts×Equalizer⇒Complete = complete
| {
"alphanum_fraction": 0.4317237799,
"avg_line_length": 31.3170731707,
"ext": "agda",
"hexsha": "ef6bb8c0c8515f336d707650864af97ac55fa4a4",
"lang": "Agda",
"max_forks_count": 64,
"max_forks_repo_forks_event_max_datetime": "2022-03-14T02:00:59.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-06-02T16:58:15.000Z",
"max_forks_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Code-distancing/agda-categories",
"max_forks_repo_path": "src/Categories/Category/Complete/Properties/Construction.agda",
"max_issues_count": 236,
"max_issues_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_issues_repo_issues_event_max_datetime": "2022-03-28T14:31:43.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-06-01T14:53:54.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Code-distancing/agda-categories",
"max_issues_repo_path": "src/Categories/Category/Complete/Properties/Construction.agda",
"max_line_length": 102,
"max_stars_count": 279,
"max_stars_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Trebor-Huang/agda-categories",
"max_stars_repo_path": "src/Categories/Category/Complete/Properties/Construction.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-22T00:40:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-06-01T14:36:40.000Z",
"num_tokens": 1565,
"size": 3852
} |
{-# OPTIONS --without-K #-}
module Leftovers.Utils where
open import Data.String using (String)
open import Data.List as List
-- open import Reflection
open import Leftovers.Monad
open import Reflection.Term
open import Reflection.Pattern as P
-- open import Reflection.TypeChecking.Monad.Instances
open import Data.Nat
open import Data.Product
open import Data.Unit
open import Function using (_$_)
import Data.List.Categorical
open import Level
open Data.List.Categorical.TraversableM {m = Level.zero} leftoversMonad
case_of_ : ∀ {A B : Set} → A → (A → B) → B
case x of f = f x
λv_↦_ λh_↦_ : String → Term → Term
λv x ↦ body = lam visible (abs x body)
λh x ↦ body = lam hidden (abs x body)
identity : ∀ {ℓ} { X : Set ℓ} → X → X
identity x = x
the : ∀ {ℓ} → (T : Set ℓ) → T → T
the _ = identity
_⦂_ : Term → Type → Term
t ⦂ T = def (quote the) (vArg T ∷ vArg t ∷ [])
app : Term → Term → Term
app f x = def (quote _$_) (vArg f ∷ vArg x ∷ [])
returnTypeFor : Type → Term → Leftovers Type
returnTypeFor (pi (arg _ dom) cod) x = do
debugPrint "returnTypeFor" 2 (strErr "Checking pattern " ∷ termErr x ∷ strErr " against type " ∷ termErr dom ∷ [])
checkType x dom
pure (app (lam visible cod) x)
returnTypeFor t x = do
ldom ← freshMeta (quoteTerm Level)
lcod ← freshMeta (quoteTerm Level)
dom ← freshMeta (sort (set ldom))
cod ← extendContext (vArg dom) (freshMeta (sort (set lcod)))
unify t (pi (vArg dom) (abs "x" cod))
pure (app (lam visible (abs "x" cod)) x)
--Try an action (usually unification) but continue without it
-- if it fails
try : Leftovers ⊤ → Leftovers ⊤
try x = catchLeftovers x (pure tt)
tryUnify : Term → Term → Leftovers ⊤
tryUnify x y = try (unify x y)
{- Syntactic sugar for trying a computation, if it fails then try the other one -}
-- try-fun : ∀ {a} {A : Set a} → Leftovers A → Leftovers A → Leftovers A
-- try-fun = catchLeftovers
-- syntax try-fun t f = try t or-else f
constructors : Definition → List Name
constructors (data-type pars cs) = cs
constructors _ = []
import Reflection.Show
record CtorArg : Set where
constructor mkCtorArg
field
pat : Arg Pattern
term : Arg Term
type : Arg Type
-- Given a name, get its type
-- and generate fresh metas for each argument
-- e.g. turn (a -> b -> c -> d) into [_ , _ , _]
fully-applied-pattern : Name → Leftovers (List (CtorArg))
fully-applied-pattern nm =
do
nmType ← getType nm
-- debugPrint "full-app" 2 (strErr "fullApp " ∷ nameErr nm ∷ termErr nmType ∷ [])
pure (full-app-type nmType 0)
where
full-app-type : Type → ℕ → List (CtorArg)
full-app-type (pi (arg info dom) (abs s x)) pos =
(mkCtorArg
(arg info (P.var pos))
(arg info (var pos []))
(arg info unknown)) ∷ full-app-type x (1 + pos)
-- ((arg info (P.var pos) , arg info (var pos [])) ∷ full-app-type x (1 + pos))
full-app-type t pos = []
| {
"alphanum_fraction": 0.6522790055,
"avg_line_length": 28.6732673267,
"ext": "agda",
"hexsha": "8e4ab7689a1eeeac4efb0bd7c044867f1d9abb68",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "01b60b405009feaada181af175f019ceb89e42b2",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "JoeyEremondi/AgdaLeftovers",
"max_forks_repo_path": "src/Leftovers/Utils.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "01b60b405009feaada181af175f019ceb89e42b2",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "JoeyEremondi/AgdaLeftovers",
"max_issues_repo_path": "src/Leftovers/Utils.agda",
"max_line_length": 118,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "01b60b405009feaada181af175f019ceb89e42b2",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "JoeyEremondi/AgdaLeftovers",
"max_stars_repo_path": "src/Leftovers/Utils.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 916,
"size": 2896
} |
open import Nat
open import Prelude
open import contexts
open import core
open import dynamics-core
open import lemmas-gcomplete
open import disjointness
open import dom-eq
open import holes-disjoint-checks
open import lemmas-disjointness
open import lemmas-freshness
open import finality
open import focus-formation
open import ground-decidable
open import grounding
open import lemmas-subst-ta
open import htype-decidable
open import lemmas-consistency
open import lemmas-ground
open import lemmas-matching
open import synth-unicity
open import elaborability
open import elaboration-generality
open import elaboration-unicity
open import type-assignment-unicity
open import typed-elaboration
open import canonical-boxed-forms
open import canonical-indeterminate-forms
open import canonical-value-forms
open import lemmas-progress-checks
open import preservation
open import progress
open import progress-checks
open import cast-inert
open import complete-elaboration
open import complete-preservation
open import complete-progress
open import lemmas-complete
open import contraction
open import exchange
open import weakening
open import binders-disjoint-checks
| {
"alphanum_fraction": 0.8504672897,
"avg_line_length": 21.4,
"ext": "agda",
"hexsha": "c1af2b934d41b2da705e3f849ff13985f481ee91",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "a3640d7b0f76cdac193afd382694197729ed6d57",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "hazelgrove/hazelnut-agda",
"max_forks_repo_path": "dynamics-all.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "a3640d7b0f76cdac193afd382694197729ed6d57",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "hazelgrove/hazelnut-agda",
"max_issues_repo_path": "dynamics-all.agda",
"max_line_length": 41,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "a3640d7b0f76cdac193afd382694197729ed6d57",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "hazelgrove/hazelnut-agda",
"max_stars_repo_path": "dynamics-all.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 262,
"size": 1177
} |
{-# OPTIONS --without-K --rewriting #-}
module lib.PathSeq where
open import lib.path-seq.Ap public
open import lib.path-seq.Concat public
open import lib.path-seq.Inversion public
open import lib.path-seq.Reasoning public
open import lib.path-seq.Rotations public
open import lib.path-seq.Split public
| {
"alphanum_fraction": 0.7901639344,
"avg_line_length": 27.7272727273,
"ext": "agda",
"hexsha": "db11be3b7058b729194e5add3ee2e2f9f5ada967",
"lang": "Agda",
"max_forks_count": 50,
"max_forks_repo_forks_event_max_datetime": "2022-02-14T03:03:25.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-10T01:48:08.000Z",
"max_forks_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "AntoineAllioux/HoTT-Agda",
"max_forks_repo_path": "core/lib/PathSeq.agda",
"max_issues_count": 31,
"max_issues_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_issues_repo_issues_event_max_datetime": "2021-10-03T19:15:25.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-03-05T20:09:00.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "AntoineAllioux/HoTT-Agda",
"max_issues_repo_path": "core/lib/PathSeq.agda",
"max_line_length": 41,
"max_stars_count": 294,
"max_stars_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "AntoineAllioux/HoTT-Agda",
"max_stars_repo_path": "core/lib/PathSeq.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-20T13:54:45.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T16:23:23.000Z",
"num_tokens": 74,
"size": 305
} |
{-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.IdNat {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.Properties
import Definition.Typed.Weakening as Twk
open import Definition.Typed.EqualityRelation
open import Definition.Typed.RedSteps
open import Definition.LogicalRelation
open import Definition.LogicalRelation.Irrelevance
open import Definition.LogicalRelation.ShapeView
open import Definition.LogicalRelation.Properties
open import Definition.LogicalRelation.Application
open import Definition.LogicalRelation.Substitution
import Definition.LogicalRelation.Weakening as Lwk
open import Definition.LogicalRelation.Substitution.Properties
import Definition.LogicalRelation.Substitution.Irrelevance as S
open import Definition.LogicalRelation.Substitution.Reflexivity
open import Definition.LogicalRelation.Substitution.Weakening
-- open import Definition.LogicalRelation.Substitution.Introductions.Nat
open import Definition.LogicalRelation.Substitution.Introductions.Empty
open import Definition.LogicalRelation.Substitution.Introductions.Pi
open import Definition.LogicalRelation.Substitution.Introductions.Idlemmas
open import Definition.LogicalRelation.Substitution.Introductions.IdUniv
open import Definition.LogicalRelation.Substitution.MaybeEmbed
-- open import Definition.LogicalRelation.Substitution.Introductions.SingleSubst
open import Definition.LogicalRelation.Substitution.Introductions.Universe
open import Tools.Product
open import Tools.Empty
import Tools.Unit as TU
import Tools.PropositionalEquality as PE
import Data.Nat as Nat
[ℕ] : ∀ {Γ l} → ⊢ Γ → Γ ⊩⟨ l ⟩ ℕ ^ [ ! , ι ⁰ ]
[ℕ] ⊢Γ = ℕᵣ (idRed:*: (univ (ℕⱼ ⊢Γ)))
[Id]ℕ : ∀ {Γ l t u}
(⊢Γ : ⊢ Γ)
([t] : Γ ⊩ℕ t ∷ℕ)
([u] : Γ ⊩ℕ u ∷ℕ)
→ Γ ⊩⟨ l ⟩ Id ℕ t u ^ [ % , ι ⁰ ]
[Id]ℕ {Γ} {l} {t} {u} ⊢Γ (ℕₜ .(suc m′) [[ ⊢tℕ , ⊢mℕ , dt ]] m≡m (sucᵣ {m′} [m′])) (ℕₜ .(suc n′) [[ ⊢uℕ , ⊢nℕ , du ]] n≡n (sucᵣ {n′} [n′])) =
let [Idmn] = [Id]ℕ ⊢Γ [m′] [n′]
⊢m′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [m′]
⊢n′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [n′]
nfId = univ⇒* ((IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢uℕ ⇨∷* IdℕSRed*Term′ ⊢m′ℕ ⊢uℕ ⊢nℕ du)
⇨∷* (Id-ℕ-SS ⊢m′ℕ ⊢n′ℕ ⇨ id (Idⱼ (ℕⱼ ⊢Γ) ⊢m′ℕ ⊢n′ℕ)))
in proj₁ (redSubst* nfId [Idmn])
[Id]ℕ {Γ} {l} {t} {u} ⊢Γ (ℕₜ .(suc m′) [[ ⊢tℕ , ⊢mℕ , dt ]] m≡m (sucᵣ {m′} [m′])) (ℕₜ .zero [[ ⊢uℕ , ⊢nℕ , du ]] n≡n zeroᵣ) =
let ⊢m′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [m′]
nfId = (IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢uℕ)
⇨∷* (IdℕSRed*Term′ ⊢m′ℕ ⊢uℕ ⊢nℕ du ⇨∷* (Id-ℕ-S0 ⊢m′ℕ ⇨ id (Emptyⱼ ⊢Γ)))
in Emptyᵣ [[ univ (Idⱼ (ℕⱼ ⊢Γ) ⊢tℕ ⊢uℕ) , univ (Emptyⱼ ⊢Γ) , univ⇒* nfId ]]
[Id]ℕ {Γ} {l} {t} {u} ⊢Γ (ℕₜ .(suc m′) [[ ⊢tℕ , ⊢mℕ , dt ]] m≡m (sucᵣ {m′} [m′])) (ℕₜ n [[ ⊢uℕ , ⊢nℕ , du ]] n≡n (ne (neNfₜ nen _ n∼n))) =
let ⊢m′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [m′]
nfId = (IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢uℕ) ⇨∷* IdℕSRed*Term′ ⊢m′ℕ ⊢uℕ ⊢nℕ du
m′≡m′ = escapeTermEq ([ℕ] {l = ι ⁰} ⊢Γ) (reflEqTerm ([ℕ] {l = ι ⁰} ⊢Γ) [m′])
in ne′ (Id ℕ (suc m′) n) [[ univ (Idⱼ (ℕⱼ ⊢Γ) ⊢tℕ ⊢uℕ) , univ (Idⱼ (ℕⱼ ⊢Γ) ⊢mℕ ⊢nℕ) , univ⇒* nfId ]] (IdℕSₙ nen) (~-IdℕS ⊢Γ m′≡m′ n∼n)
[Id]ℕ {Γ} {l} {t} {u} ⊢Γ (ℕₜ .zero [[ ⊢tℕ , ⊢mℕ , dt ]] m≡m zeroᵣ) (ℕₜ .(suc n′) [[ ⊢uℕ , ⊢nℕ , du ]] n≡n (sucᵣ {n′} [n′])) =
let ⊢n′ = escapeTerm ([ℕ] {l = ι ⁰} ⊢Γ) [n′]
nfId = (IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢uℕ)
⇨∷* (Idℕ0Red*Term′ ⊢uℕ ⊢nℕ du ⇨∷* (Id-ℕ-0S ⊢n′ ⇨ id (Emptyⱼ ⊢Γ)))
in Emptyᵣ [[ univ (Idⱼ (ℕⱼ ⊢Γ) ⊢tℕ ⊢uℕ) , univ (Emptyⱼ ⊢Γ) , univ⇒* nfId ]]
[Id]ℕ {Γ} {l} {t} {u} ⊢Γ (ℕₜ .zero [[ ⊢tℕ , ⊢mℕ , dt ]] m≡m zeroᵣ) (ℕₜ .zero [[ ⊢uℕ , ⊢nℕ , du ]] n≡n zeroᵣ) =
let nfId = (IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢uℕ)
⇨∷* (Idℕ0Red*Term′ ⊢uℕ ⊢nℕ du ⇨∷* (Id-ℕ-00 ⊢Γ ⇨ id (Unitⱼ ⊢Γ)))
in proj₁ (redSubst* (univ⇒* nfId) (maybeEmb″ (UnitType ⊢Γ)))
[Id]ℕ {Γ} {l} {t} {u} ⊢Γ (ℕₜ .zero [[ ⊢tℕ , ⊢mℕ , dt ]] m≡m zeroᵣ) (ℕₜ n [[ ⊢uℕ , ⊢nℕ , du ]] n≡n (ne (neNfₜ nen _ n∼n))) =
let nfId = (IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢uℕ) ⇨∷* Idℕ0Red*Term′ ⊢uℕ ⊢nℕ du
in ne′ (Id ℕ zero n) [[ univ (Idⱼ (ℕⱼ ⊢Γ) ⊢tℕ ⊢uℕ) , univ (Idⱼ (ℕⱼ ⊢Γ) (zeroⱼ ⊢Γ) ⊢nℕ) , univ⇒* nfId ]] (Idℕ0ₙ nen) (~-Idℕ0 ⊢Γ n∼n)
[Id]ℕ {Γ} {l} {t} {u} ⊢Γ (ℕₜ m [[ ⊢tℕ , ⊢mℕ , dt ]] m≡m (ne (neNfₜ nem _ m∼m))) [u] =
let
⊢u = escapeTerm ([ℕ] {l = ι ⁰} ⊢Γ) [u]
u≡u = escapeTermEq {l = ι ⁰} ([ℕ] ⊢Γ) (reflEqTerm ([ℕ] {l = ι ⁰} ⊢Γ) [u])
in ne′ (Id ℕ m u) [[ univ (Idⱼ (ℕⱼ ⊢Γ) ⊢tℕ ⊢u) , univ (Idⱼ (ℕⱼ ⊢Γ) ⊢mℕ ⊢u) ,
univ⇒* (IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢u) ]] (Idℕₙ nem) (~-Idℕ ⊢Γ m∼m u≡u)
escapeEqℕ₁ : ∀ {Γ m n} → Γ ⊩ℕ m ≡ n ∷ℕ → Γ ⊢ m ∷ ℕ ^ [ ! , ι ⁰ ]
escapeEqℕ₁ (ℕₜ₌ k k′ [[ ⊢t , ⊢u , d ]] d′ k≡k′ prop) = ⊢t
escapeEqℕ₂ : ∀ {Γ m n} → Γ ⊩ℕ m ≡ n ∷ℕ → Γ ⊢ n ∷ ℕ ^ [ ! , ι ⁰ ]
escapeEqℕ₂ (ℕₜ₌ k k′ d [[ ⊢t , ⊢u , d' ]] k≡k′ prop) = ⊢t
irrelevanceEqTermℕ : ∀ {Γ A t t′ u u′ r ll l}
(eqt : t PE.≡ t′) (equ : u PE.≡ u′)
(p : Γ ⊩⟨ l ⟩ A ^ [ r , ll ])
→ Γ ⊩⟨ l ⟩ t ≡ u ∷ A ^ [ r , ll ] / p → Γ ⊩⟨ l ⟩ t′ ≡ u′ ∷ A ^ [ r , ll ] / p
irrelevanceEqTermℕ PE.refl PE.refl p t≡u = t≡u
[IdExt]ℕ : ∀ {Γ l t u v w}
(⊢Γ : ⊢ Γ)
([t] : Γ ⊩ℕ t ∷ℕ)
([u] : Γ ⊩ℕ u ∷ℕ)
([v] : Γ ⊩ℕ v ∷ℕ)
([w] : Γ ⊩ℕ w ∷ℕ)
([t≡v] : Γ ⊩ℕ t ≡ v ∷ℕ)
([u≡w] : Γ ⊩ℕ u ≡ w ∷ℕ)
→ Γ ⊩⟨ l ⟩ Id ℕ t u ≡ Id ℕ v w ^ [ % , ι ⁰ ] / [Id]ℕ ⊢Γ [t] [u]
[IdExt]ℕ {Γ} {l} {t} {u} {v} {w} ⊢Γ
(ℕₜ .(suc _) [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ (sucᵣ {n} [t']))
(ℕₜ .(suc _) [[ ⊢uℕ , ⊢nℕ , du ]] n≡n (sucᵣ {n₂} [u']))
(ℕₜ .(suc _) [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ (sucᵣ {n₁} [v']))
(ℕₜ .(suc _) [[ ⊢wℕ , ⊢pℕ , dw ]] n≡n₃ (sucᵣ {n₃} [w']))
(ℕₜ₌ .(suc _) .(suc _) d₄ d′ k≡k′ (sucᵣ [t≡v']))
(ℕₜ₌ .(suc _) .(suc _) d₅ d′₁ k≡k′₁ (sucᵣ [u≡w'])) =
let t≡t' = suc-PE-injectivity (whrDet*Term (dt , sucₙ) (redₜ d₄ , sucₙ))
u≡u' = suc-PE-injectivity (whrDet*Term (du , sucₙ) (redₜ d₅ , sucₙ))
v≡v' = suc-PE-injectivity (whrDet*Term (dv , sucₙ) (redₜ d′ , sucₙ))
w≡w' = suc-PE-injectivity (whrDet*Term (dw , sucₙ) (redₜ d′₁ , sucₙ))
[t] = ℕₜ (suc _) [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ (sucᵣ [t'])
[u] = ℕₜ (suc _) [[ ⊢uℕ , ⊢nℕ , du ]] n≡n (sucᵣ [u'])
[v] = ℕₜ (suc _) [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ (sucᵣ [v'])
[w] = ℕₜ (suc _) [[ ⊢wℕ , ⊢pℕ , dw ]] n≡n₃ (sucᵣ [w'])
[Idmn] = [IdExt]ℕ {l = l} ⊢Γ [t'] [u'] [v'] [w'] (irrelevanceEqTermℕ {l = l} (PE.sym t≡t') (PE.sym v≡v') ([ℕ] ⊢Γ) [t≡v'])
(irrelevanceEqTermℕ {l = l} (PE.sym u≡u') (PE.sym w≡w') ([ℕ] ⊢Γ) [u≡w'])
⊢t′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [t']
⊢u′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [u']
nfId = univ⇒* ((IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢uℕ ⇨∷* IdℕSRed*Term′ ⊢t′ℕ ⊢uℕ ⊢nℕ du)
⇨∷* (Id-ℕ-SS ⊢t′ℕ ⊢u′ℕ ⇨ id (Idⱼ (ℕⱼ ⊢Γ) ⊢t′ℕ ⊢u′ℕ)))
⊢v′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [v']
⊢w′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [w']
nfId' = univ⇒* ((IdℕRed*Term′ ⊢vℕ ⊢oℕ dv ⊢wℕ ⇨∷* IdℕSRed*Term′ ⊢v′ℕ ⊢wℕ ⊢pℕ dw)
⇨∷* (Id-ℕ-SS ⊢v′ℕ ⊢w′ℕ ⇨ id (Idⱼ (ℕⱼ ⊢Γ) ⊢v′ℕ ⊢w′ℕ)))
[IdA] , [IdA≡ℕ] = redSubst* {l = l} nfId ([Id]ℕ ⊢Γ [t'] [u'])
[IdB] , [IdB≡ℕ] = redSubst* {l = l} nfId' ([Id]ℕ ⊢Γ [v'] [w'])
[IdA≡ℕ]′ = irrelevanceEq {A = Id ℕ t u} {B = Id ℕ n n₂} {l = l} [IdA] ([Id]ℕ ⊢Γ [t] [u]) [IdA≡ℕ]
[IdB≡ℕ]′ = irrelevanceEq {A = Id ℕ v w} {B = Id ℕ n₁ n₃} {l = l} {l′ = l} [IdB] ([Id]ℕ ⊢Γ [v] [w]) [IdB≡ℕ]
in transEq {A = Id ℕ t u} {B = Id ℕ n n₂} {C = Id ℕ v w} {l = l} {l′ = l} {l″ = l} ([Id]ℕ ⊢Γ [t] [u]) ([Id]ℕ ⊢Γ [t'] [u']) ([Id]ℕ ⊢Γ [v] [w])
[IdA≡ℕ]′
(transEq {A = Id ℕ n n₂} {B = Id ℕ n₁ n₃} {C = Id ℕ v w} {l = l} {l′ = l} {l″ = l} ([Id]ℕ ⊢Γ [t'] [u']) ([Id]ℕ ⊢Γ [v'] [w']) ([Id]ℕ ⊢Γ [v] [w])
[Idmn] (symEq {A = Id ℕ v w} {B = Id ℕ n₁ n₃} ([Id]ℕ ⊢Γ [v] [w]) ([Id]ℕ ⊢Γ [v'] [w']) [IdB≡ℕ]′))
[IdExt]ℕ {Γ} {l} {t} {u} {v} {w} ⊢Γ
(ℕₜ .(suc _) [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ (sucᵣ {n} [t']))
(ℕₜ .zero [[ ⊢uℕ , ⊢nℕ , du ]] n≡n zeroᵣ)
(ℕₜ .(suc _) [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ (sucᵣ {m} [v']))
(ℕₜ .zero [[ ⊢wℕ , ⊢pℕ , dw ]] n≡n₃ zeroᵣ)
(ℕₜ₌ .(suc _) .(suc _) d₄ d′ k≡k′ (sucᵣ x))
(ℕₜ₌ .zero .zero d₅ d′₁ k≡k′₁ zeroᵣ) =
let [t] = ℕₜ (suc _) [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ (sucᵣ [t'])
[u] = ℕₜ zero [[ ⊢uℕ , ⊢nℕ , du ]] n≡n zeroᵣ
[v] = ℕₜ (suc _) [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ (sucᵣ [v'])
[w] = ℕₜ zero [[ ⊢wℕ , ⊢pℕ , dw ]] n≡n₃ zeroᵣ
⊢t′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [t']
nfId = univ⇒* ((IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢uℕ)
⇨∷* (IdℕSRed*Term′ ⊢t′ℕ ⊢uℕ ⊢nℕ du ⇨∷* (Id-ℕ-S0 ⊢t′ℕ ⇨ id (Emptyⱼ ⊢Γ))))
⊢v′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [v']
nfId' = univ⇒* ((IdℕRed*Term′ ⊢vℕ ⊢oℕ dv ⊢wℕ)
⇨∷* (IdℕSRed*Term′ ⊢v′ℕ ⊢wℕ ⊢pℕ dw ⇨∷* (Id-ℕ-S0 ⊢v′ℕ ⇨ id (Emptyⱼ ⊢Γ))))
[Empty] = Emptyᵣ (idRed:*: (univ (Emptyⱼ ⊢Γ)))
[IdA] , [IdA≡ℕ] = redSubst* {l = l} nfId [Empty]
[IdB] , [IdB≡ℕ] = redSubst* {l = l} nfId' [Empty]
[IdA≡ℕ]′ = irrelevanceEq {A = Id ℕ t u} {B = Empty _} {l = l} {l′ = l} [IdA] ([Id]ℕ ⊢Γ [t] [u]) [IdA≡ℕ]
[IdB≡ℕ]′ = irrelevanceEq {A = Id ℕ v w} {B = Empty _} {l = l} {l′ = l} [IdB] ([Id]ℕ ⊢Γ [v] [w]) [IdB≡ℕ]
in transEq {A = Id ℕ t u} {B = Empty _} {C = Id ℕ v w} {l = l} {l′ = l} {l″ = l} ([Id]ℕ ⊢Γ [t] [u]) [Empty] ([Id]ℕ ⊢Γ [v] [w])
[IdA≡ℕ]′ (symEq {A = Id ℕ v w} {B = Empty _} {l = l} {l′ = l} ([Id]ℕ ⊢Γ [v] [w]) [Empty] [IdB≡ℕ]′)
[IdExt]ℕ {Γ} {l} {u} {t} {w} {v} ⊢Γ
(ℕₜ .zero [[ ⊢uℕ , ⊢nℕ , du ]] n≡n zeroᵣ)
(ℕₜ .(suc _) [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ (sucᵣ {n} [t']))
(ℕₜ .zero [[ ⊢wℕ , ⊢pℕ , dw ]] n≡n₃ zeroᵣ)
(ℕₜ .(suc _) [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ (sucᵣ {m} [v']))
(ℕₜ₌ .zero .zero d₅ d′₁ k≡k′₁ zeroᵣ)
(ℕₜ₌ .(suc _) .(suc _) d₄ d′ k≡k′ (sucᵣ x)) =
let [t] = ℕₜ (suc _) [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ (sucᵣ [t'])
[u] = ℕₜ zero [[ ⊢uℕ , ⊢nℕ , du ]] n≡n zeroᵣ
[v] = ℕₜ (suc _) [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ (sucᵣ [v'])
[w] = ℕₜ zero [[ ⊢wℕ , ⊢pℕ , dw ]] n≡n₃ zeroᵣ
⊢t′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [t']
nfId = univ⇒* ((IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢uℕ)
⇨∷* (IdℕSRed*Term′ ⊢t′ℕ ⊢uℕ ⊢nℕ du ⇨∷* (Id-ℕ-S0 ⊢t′ℕ ⇨ id (Emptyⱼ ⊢Γ))))
⊢v′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [v']
nfId' = univ⇒* ((IdℕRed*Term′ ⊢vℕ ⊢oℕ dv ⊢wℕ)
⇨∷* (IdℕSRed*Term′ ⊢v′ℕ ⊢wℕ ⊢pℕ dw ⇨∷* (Id-ℕ-S0 ⊢v′ℕ ⇨ id (Emptyⱼ ⊢Γ))))
[Empty] = Emptyᵣ (idRed:*: (univ (Emptyⱼ ⊢Γ)))
[IdA] , [IdA≡ℕ] = redSubst* {l = l} nfId [Empty]
[IdB] , [IdB≡ℕ] = redSubst* {l = l} nfId' [Empty]
[IdA≡ℕ]′ = irrelevanceEq {A = Id ℕ t u} {B = Empty _} {l = l} {l′ = l} [IdA] ([Id]ℕ ⊢Γ [t] [u]) [IdA≡ℕ]
[IdB≡ℕ]′ = irrelevanceEq {A = Id ℕ v w} {B = Empty _} {l = l} {l′ = l} [IdB] ([Id]ℕ ⊢Γ [v] [w]) [IdB≡ℕ]
in transEq {A = Id ℕ u t} {B = Empty _} {C = Id ℕ w v} {l = l} {l′ = l} {l″ = l} ([Id]ℕ ⊢Γ [u] [t]) [Empty] ([Id]ℕ ⊢Γ [w] [v])
[IdB≡ℕ]′ (symEq {A = Id ℕ w v} {B = Empty _} {l = l} {l′ = l} ([Id]ℕ ⊢Γ [w] [v]) [Empty] [IdA≡ℕ]′)
[IdExt]ℕ {Γ} {l} {t} {u} {v} {w} ⊢Γ (ℕₜ .zero [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ zeroᵣ) (ℕₜ .zero [[ ⊢uℕ , ⊢nℕ , du ]] n≡n zeroᵣ)
(ℕₜ .zero [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ zeroᵣ) (ℕₜ .zero [[ ⊢wℕ , ⊢pℕ , dw ]] n≡n₃ zeroᵣ)
(ℕₜ₌ .zero .zero d₄ d′ k≡k′ zeroᵣ) (ℕₜ₌ .zero .zero d₅ d′₁ k≡k′₁ zeroᵣ) =
let [t] = ℕₜ zero [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ zeroᵣ
[u] = ℕₜ zero [[ ⊢uℕ , ⊢nℕ , du ]] n≡n zeroᵣ
[v] = ℕₜ zero [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ zeroᵣ
[w] = ℕₜ zero [[ ⊢wℕ , ⊢pℕ , dw ]] n≡n₃ zeroᵣ
nfId = univ⇒* ((IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢uℕ)
⇨∷* (Idℕ0Red*Term′ ⊢uℕ ⊢nℕ du ⇨∷* (Id-ℕ-00 ⊢Γ ⇨ id (Unitⱼ ⊢Γ))))
nfId' = univ⇒* ((IdℕRed*Term′ ⊢vℕ ⊢oℕ dv ⊢wℕ)
⇨∷* (Idℕ0Red*Term′ ⊢wℕ ⊢pℕ dw ⇨∷* (Id-ℕ-00 ⊢Γ ⇨ id (Unitⱼ ⊢Γ))))
[Unit] = UnitType ⊢Γ
[IdA] , [IdA≡ℕ] = redSubst* nfId [Unit]
[IdB] , [IdB≡ℕ] = redSubst* nfId' [Unit]
[IdA≡ℕ]′ = irrelevanceEq {A = Id ℕ t u} {B = Unit} {l = ι ⁰} {l′ = l} [IdA] ([Id]ℕ ⊢Γ [t] [u]) [IdA≡ℕ]
[IdB≡ℕ]′ = irrelevanceEq {A = Id ℕ v w} {B = Unit} {l = ι ⁰} {l′ = l} [IdB] ([Id]ℕ ⊢Γ [v] [w]) [IdB≡ℕ]
in transEq {A = Id ℕ t u} {B = Unit} {C = Id ℕ v w} {l = l} {l′ = ι ⁰} {l″ = l} ([Id]ℕ ⊢Γ [t] [u]) [Unit] ([Id]ℕ ⊢Γ [v] [w])
[IdA≡ℕ]′ (symEq {A = Id ℕ v w} {B = Unit} {l = l} {l′ = ι ⁰} ([Id]ℕ ⊢Γ [v] [w]) [Unit] [IdB≡ℕ]′)
[IdExt]ℕ {Γ} {l} {t} {u} {v} {w} ⊢Γ (ℕₜ .(suc _) [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ (sucᵣ {t'} [t'])) (ℕₜ n [[ ⊢uℕ , ⊢nℕ , du ]] n≡n (ne (neNfₜ neKu ⊢ku k≡ku)))
(ℕₜ .(suc _) [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ (sucᵣ {v'} [v'])) (ℕₜ n₃ [[ ⊢wℕ , ⊢pℕ , dw ]] n≡n₃ (ne (neNfₜ neKw ⊢kw k≡kw)))
(ℕₜ₌ .(suc _) .(suc _) d₄ d′ k≡k′ (sucᵣ [t≡v'])) (ℕₜ₌ k₁ k′₁ d₅ d′₁ k≡k′₁ (ne (neNfₜ₌ neK neM K~M))) =
let t≡t' = suc-PE-injectivity (whrDet*Term (dt , sucₙ) (redₜ d₄ , sucₙ))
v≡v' = suc-PE-injectivity (whrDet*Term (dv , sucₙ) (redₜ d′ , sucₙ))
u≡u' = whrDet*Term (du , ne neKu) (redₜ d₅ , ne neK)
w≡w' = whrDet*Term (dw , ne neKw) (redₜ d′₁ , ne neM)
[t] = ℕₜ (suc _) [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ (sucᵣ [t'])
[u] = ℕₜ n [[ ⊢uℕ , ⊢nℕ , du ]] n≡n (ne (neNfₜ neKu ⊢ku k≡ku))
[v] = ℕₜ (suc _) [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ (sucᵣ [v'])
[w] = ℕₜ n₃ [[ ⊢wℕ , ⊢pℕ , dw ]] n≡n₃ (ne (neNfₜ neKw ⊢kw k≡kw))
[suct'] = ℕₜ (suc t') (idRedTerm:*: ⊢mℕ) n≡n₁ (sucᵣ [t'])
[n] = ℕₜ n (idRedTerm:*: ⊢nℕ) n≡n (ne (neNfₜ neKu ⊢ku k≡ku))
[sucv'] = ℕₜ (suc v') (idRedTerm:*: ⊢oℕ) n≡n₂ (sucᵣ [v'])
[n₃] = ℕₜ n₃ (idRedTerm:*: ⊢pℕ) n≡n₃ (ne (neNfₜ neKw ⊢kw k≡kw))
⊢t′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [t']
⊢v′ℕ = escapeTerm {l = ι ⁰} ([ℕ] ⊢Γ) [v']
nfId = univ⇒* ((IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢uℕ) ⇨∷* IdℕSRed*Term′ ⊢t′ℕ ⊢uℕ ⊢nℕ du)
nfId' = univ⇒* ((IdℕRed*Term′ ⊢vℕ ⊢oℕ dv ⊢wℕ) ⇨∷* IdℕSRed*Term′ ⊢v′ℕ ⊢wℕ ⊢pℕ dw)
[IdA] , [IdA≡ℕ] = redSubst* nfId ([Id]ℕ ⊢Γ [suct'] [n])
[IdB] , [IdB≡ℕ] = redSubst* nfId' ([Id]ℕ ⊢Γ [sucv'] [n₃])
[IdA≡ℕ]′ = irrelevanceEq {A = Id ℕ t u} {B = Id ℕ (suc t') n} {l = ι ⁰} {l′ = l} [IdA] ([Id]ℕ ⊢Γ [t] [u]) [IdA≡ℕ]
[IdB≡ℕ]′ = irrelevanceEq {A = Id ℕ v w} {B = Id ℕ (suc v') n₃} {l = ι ⁰} {l′ = l} [IdB] ([Id]ℕ ⊢Γ [v] [w]) [IdB≡ℕ]
[Idneutral] : Γ ⊩⟨ l ⟩ Id ℕ (suc t') n ≡ Id ℕ (suc v') n₃ ^ [ % , ι ⁰ ] / ([Id]ℕ ⊢Γ [suct'] [n])
[Idneutral] = ne₌ (Id ℕ (suc v') n₃) (idRed:*: (univ (Idⱼ (ℕⱼ ⊢Γ) ⊢oℕ ⊢pℕ))) (IdℕSₙ neKw)
(~-IdℕS ⊢Γ (let X = escapeTermEq {l = l} ([ℕ] ⊢Γ) [t≡v'] in
PE.subst (λ X → Γ ⊢ X ≅ _ ∷ ℕ ^ [ ! , ι ⁰ ]) (PE.sym t≡t') (PE.subst (λ X → Γ ⊢ _ ≅ X ∷ ℕ ^ [ ! , ι ⁰ ]) (PE.sym v≡v') X) )
(PE.subst (λ X → Γ ⊢ X ~ _ ∷ ℕ ^ [ ! , ι ⁰ ]) (PE.sym u≡u') (PE.subst (λ X → Γ ⊢ k₁ ~ X ∷ ℕ ^ [ ! , ι ⁰ ]) (PE.sym w≡w') K~M)))
in transEq {A = Id ℕ t u} {B = Id ℕ (suc t') n} {C = Id ℕ v w} {l = l} {l′ = l} {l″ = l} ([Id]ℕ ⊢Γ [t] [u]) ([Id]ℕ ⊢Γ [suct'] [n]) ([Id]ℕ ⊢Γ [v] [w])
[IdA≡ℕ]′
(transEq {A = Id ℕ (suc t') n} {B = Id ℕ (suc v') n₃} {C = Id ℕ v w} {l = l} {l′ = l} {l″ = l} ([Id]ℕ ⊢Γ [suct'] [n]) ([Id]ℕ ⊢Γ [sucv'] [n₃]) ([Id]ℕ ⊢Γ [v] [w])
[Idneutral] (symEq {A = Id ℕ v w} {B = Id ℕ (suc v') n₃} {l = l} {l′ = l} ([Id]ℕ ⊢Γ [v] [w]) ([Id]ℕ ⊢Γ [sucv'] [n₃]) [IdB≡ℕ]′))
[IdExt]ℕ {Γ} {l} {t} {u} {v} {w} ⊢Γ (ℕₜ n₁ [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ (ne (neNfₜ neKt ⊢kt k≡kt))) [u] (ℕₜ n₂ [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ (ne (neNfₜ neKv ⊢kv k≡kv))) [w]
(ℕₜ₌ k k′ d₄ d′ k≡k′ (ne (neNfₜ₌ neK neM K~M))) [u=w] =
let [t] = ℕₜ n₁ [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ (ne (neNfₜ neKt ⊢kt k≡kt))
[v] = ℕₜ n₂ [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ (ne (neNfₜ neKv ⊢kv k≡kv))
⊢u = escapeTerm ([ℕ] {l = ι ⁰} ⊢Γ) [u]
⊢w = escapeTerm ([ℕ] {l = ι ⁰} ⊢Γ) [w]
u≡w = escapeTermEq {l = ι ⁰} ([ℕ] ⊢Γ) [u=w]
t≡t' = whrDet*Term (dt , ne neKt) (redₜ d₄ , ne neK)
v≡v' = whrDet*Term (dv , ne neKv) (redₜ d′ , ne neM)
nfId = univ⇒* (IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢u)
nfId' = univ⇒* (IdℕRed*Term′ ⊢vℕ ⊢oℕ dv ⊢w)
[n₁] = ℕₜ n₁ (idRedTerm:*: ⊢mℕ) n≡n₁ (ne (neNfₜ neKt ⊢kt k≡kt))
[n₂] = ℕₜ n₂ (idRedTerm:*: ⊢oℕ) n≡n₂ (ne (neNfₜ neKv ⊢kv k≡kv))
[IdA] , [IdA≡ℕ] = redSubst* nfId ([Id]ℕ ⊢Γ [n₁] [u])
[IdB] , [IdB≡ℕ] = redSubst* nfId' ([Id]ℕ ⊢Γ [n₂] [w])
[IdA≡ℕ]′ = irrelevanceEq {A = Id ℕ t u} {B = Id ℕ n₁ u} {l = ι ⁰} {l′ = l} [IdA] ([Id]ℕ ⊢Γ [t] [u]) [IdA≡ℕ]
[IdB≡ℕ]′ = irrelevanceEq {A = Id ℕ v w} {B = Id ℕ n₂ w} {l = ι ⁰} {l′ = l} [IdB] ([Id]ℕ ⊢Γ [v] [w]) [IdB≡ℕ]
[Idneutral] : Γ ⊩⟨ l ⟩ Id ℕ n₁ u ≡ Id ℕ n₂ w ^ [ % , ι ⁰ ] / ([Id]ℕ ⊢Γ [n₁] [u])
[Idneutral] = ne₌ (Id ℕ n₂ w) (idRed:*: (univ (Idⱼ (ℕⱼ ⊢Γ) ⊢oℕ ⊢w))) (Idℕₙ neKv)
(~-Idℕ ⊢Γ (PE.subst (λ X → Γ ⊢ X ~ _ ∷ ℕ ^ [ ! , ι ⁰ ]) (PE.sym t≡t') (PE.subst (λ X → Γ ⊢ _ ~ X ∷ ℕ ^ [ ! , ι ⁰ ]) (PE.sym v≡v') K~M)) u≡w)
in transEq {A = Id ℕ t u} {B = Id ℕ n₁ u} {C = Id ℕ v w} {l = l} {l′ = l} {l″ = l} ([Id]ℕ ⊢Γ [t] [u]) ([Id]ℕ ⊢Γ [n₁] [u]) ([Id]ℕ ⊢Γ [v] [w])
[IdA≡ℕ]′
(transEq {A = Id ℕ n₁ u} {B = Id ℕ n₂ w} {C = Id ℕ v w} {l = l} {l′ = l} {l″ = l} ([Id]ℕ ⊢Γ [n₁] [u]) ([Id]ℕ ⊢Γ [n₂] [w]) ([Id]ℕ ⊢Γ [v] [w])
[Idneutral] (symEq {A = Id ℕ v w} {B = Id ℕ n₂ w} {l = l} {l′ = l} ([Id]ℕ ⊢Γ [v] [w]) ([Id]ℕ ⊢Γ [n₂] [w]) [IdB≡ℕ]′))
[IdExt]ℕ {Γ} {l} {t} {u} {v} {w} ⊢Γ (ℕₜ .zero [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ zeroᵣ) (ℕₜ n [[ ⊢uℕ , ⊢nℕ , du ]] n≡n (ne (neNfₜ neKu ⊢ku k≡ku)))
(ℕₜ .zero [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ zeroᵣ) (ℕₜ n₃ [[ ⊢wℕ , ⊢pℕ , dw ]] n≡n₃ (ne (neNfₜ neKw ⊢kw k≡kw)))
(ℕₜ₌ .zero .zero d₄ d′ k≡k′ zeroᵣ) (ℕₜ₌ k₁ k′₁ d₅ d′₁ k≡k′₁ (ne (neNfₜ₌ neK neM K~M))) =
let u≡u' = whrDet*Term (du , ne neKu) (redₜ d₅ , ne neK)
w≡w' = whrDet*Term (dw , ne neKw) (redₜ d′₁ , ne neM)
[t] = ℕₜ zero [[ ⊢tℕ , ⊢mℕ , dt ]] n≡n₁ zeroᵣ
[u] = ℕₜ n [[ ⊢uℕ , ⊢nℕ , du ]] n≡n (ne (neNfₜ neKu ⊢ku k≡ku))
[v] = ℕₜ zero [[ ⊢vℕ , ⊢oℕ , dv ]] n≡n₂ zeroᵣ
[w] = ℕₜ n₃ [[ ⊢wℕ , ⊢pℕ , dw ]] n≡n₃ (ne (neNfₜ neKw ⊢kw k≡kw))
[n] = ℕₜ n (idRedTerm:*: ⊢nℕ) n≡n (ne (neNfₜ neKu ⊢ku k≡ku))
[n₃] = ℕₜ n₃ (idRedTerm:*: ⊢pℕ) n≡n₃ (ne (neNfₜ neKw ⊢kw k≡kw))
[zero] = ℕₜ zero (idRedTerm:*: (zeroⱼ ⊢Γ)) (≅ₜ-zerorefl ⊢Γ) zeroᵣ
nfId = univ⇒* ((IdℕRed*Term′ ⊢tℕ ⊢mℕ dt ⊢uℕ) ⇨∷* Idℕ0Red*Term′ ⊢uℕ ⊢nℕ du)
nfId' = univ⇒* ((IdℕRed*Term′ ⊢vℕ ⊢oℕ dv ⊢wℕ) ⇨∷* Idℕ0Red*Term′ ⊢wℕ ⊢pℕ dw)
[IdA] , [IdA≡ℕ] = redSubst* nfId ([Id]ℕ ⊢Γ [zero] [n])
[IdB] , [IdB≡ℕ] = redSubst* nfId' ([Id]ℕ ⊢Γ [zero] [n₃])
[IdA≡ℕ]′ = irrelevanceEq {A = Id ℕ t u} {B = Id ℕ zero n} {l = ι ⁰} {l′ = l} [IdA] ([Id]ℕ ⊢Γ [t] [u]) [IdA≡ℕ]
[IdB≡ℕ]′ = irrelevanceEq {A = Id ℕ v w} {B = Id ℕ zero n₃} {l = ι ⁰} {l′ = l} [IdB] ([Id]ℕ ⊢Γ [v] [w]) [IdB≡ℕ]
[Idneutral] : Γ ⊩⟨ l ⟩ Id ℕ zero n ≡ Id ℕ zero n₃ ^ [ % , ι ⁰ ] / ([Id]ℕ ⊢Γ [zero] [n])
[Idneutral] = ne₌ (Id ℕ zero n₃) (idRed:*: (univ (Idⱼ (ℕⱼ ⊢Γ) ⊢oℕ ⊢pℕ))) (Idℕ0ₙ neKw)
(~-Idℕ0 ⊢Γ (PE.subst (λ X → Γ ⊢ X ~ _ ∷ ℕ ^ [ ! , ι ⁰ ]) (PE.sym u≡u') (PE.subst (λ X → Γ ⊢ k₁ ~ X ∷ ℕ ^ [ ! , ι ⁰ ]) (PE.sym w≡w') K~M)))
in transEq {A = Id ℕ t u} {B = Id ℕ zero n} {C = Id ℕ v w} {l = l} {l′ = l} {l″ = l} ([Id]ℕ ⊢Γ [t] [u]) ([Id]ℕ ⊢Γ [zero] [n]) ([Id]ℕ ⊢Γ [v] [w])
[IdA≡ℕ]′
(transEq {A = Id ℕ zero n} {B = Id ℕ zero n₃} {C = Id ℕ v w} {l = l} {l′ = l} {l″ = l} ([Id]ℕ ⊢Γ [zero] [n]) ([Id]ℕ ⊢Γ [zero] [n₃]) ([Id]ℕ ⊢Γ [v] [w])
[Idneutral] (symEq {A = Id ℕ v w} {B = Id ℕ zero n₃} {l = l} {l′ = l} ([Id]ℕ ⊢Γ [v] [w]) ([Id]ℕ ⊢Γ [zero] [n₃]) [IdB≡ℕ]′))
-- refuting cases
[IdExt]ℕ ⊢Γ (ℕₜ .zero d₁ n≡n₁ zeroᵣ) _ _ _ (ℕₜ₌ .(suc _) .(suc _) d₄ d′ k≡k′ (sucᵣ x)) _ = ⊥-elim (zero≢suc (whrDet*Term (redₜ d₁ , zeroₙ) (redₜ d₄ , sucₙ)))
[IdExt]ℕ ⊢Γ (ℕₜ n₁ d₁ n≡n₁ (ne (neNfₜ neK ⊢k k≡k))) _ _ _ (ℕₜ₌ .(suc _) .(suc _) d₄ d′ k≡k′ (sucᵣ x)) _ = ⊥-elim (suc≢ne neK (whrDet*Term (redₜ d₄ , sucₙ) (redₜ d₁ , ne neK)))
[IdExt]ℕ ⊢Γ _ _ (ℕₜ .zero d₂ n≡n₂ zeroᵣ) _ (ℕₜ₌ .(suc _) .(suc _) d₄ d′ k≡k′ (sucᵣ x)) _ = ⊥-elim (zero≢suc (whrDet*Term (redₜ d₂ , zeroₙ) (redₜ d′ , sucₙ)))
[IdExt]ℕ ⊢Γ _ _ (ℕₜ n₂ d₂ n≡n₂ (ne (neNfₜ neK ⊢k k≡k))) _ (ℕₜ₌ .(suc _) .(suc _) d₄ d′ k≡k′ (sucᵣ x)) _ = ⊥-elim (suc≢ne neK (whrDet*Term (redₜ d′ , sucₙ) (redₜ d₂ , ne neK)))
[IdExt]ℕ ⊢Γ _ (ℕₜ .zero d₁ n≡n₁ zeroᵣ) _ _ _ (ℕₜ₌ .(suc _) .(suc _) d₄ d′ k≡k′ (sucᵣ x)) = ⊥-elim (zero≢suc (whrDet*Term (redₜ d₁ , zeroₙ) (redₜ d₄ , sucₙ)))
[IdExt]ℕ ⊢Γ _ (ℕₜ n₁ d₁ n≡n₁ (ne (neNfₜ neK ⊢k k≡k))) _ _ _ (ℕₜ₌ .(suc _) .(suc _) d₄ d′ k≡k′ (sucᵣ x)) = ⊥-elim (suc≢ne neK (whrDet*Term (redₜ d₄ , sucₙ) (redₜ d₁ , ne neK)))
[IdExt]ℕ ⊢Γ _ _ _ (ℕₜ .zero d₂ n≡n₂ zeroᵣ) _ (ℕₜ₌ .(suc _) .(suc _) d₄ d′ k≡k′ (sucᵣ x)) = ⊥-elim (zero≢suc (whrDet*Term (redₜ d₂ , zeroₙ) (redₜ d′ , sucₙ)))
[IdExt]ℕ ⊢Γ _ _ _ (ℕₜ n₂ d₂ n≡n₂ (ne (neNfₜ neK ⊢k k≡k))) _ (ℕₜ₌ .(suc _) .(suc _) d₄ d′ k≡k′ (sucᵣ x)) = ⊥-elim (suc≢ne neK (whrDet*Term (redₜ d′ , sucₙ) (redₜ d₂ , ne neK)))
[IdExt]ℕ ⊢Γ (ℕₜ .(suc _) d n≡n (sucᵣ x₃)) _ _ _ (ℕₜ₌ .zero .zero d₅ d′₁ k≡k′₁ zeroᵣ) _ = ⊥-elim (zero≢suc (whrDet*Term (redₜ d₅ , zeroₙ) (redₜ d , sucₙ)))
[IdExt]ℕ ⊢Γ (ℕₜ n d n≡n (ne (neNfₜ neK ⊢k k≡k))) _ _ _ (ℕₜ₌ .zero .zero d₅ d′₁ k≡k′₁ zeroᵣ) _ = ⊥-elim (zero≢ne neK (whrDet*Term (redₜ d₅ , zeroₙ) (redₜ d , ne neK)))
[IdExt]ℕ ⊢Γ _ _ (ℕₜ .(suc _) d₃ n≡n₃ (sucᵣ x₃)) _ (ℕₜ₌ .zero .zero d₅ d′₁ k≡k′₁ zeroᵣ) _ = ⊥-elim (zero≢suc (whrDet*Term (redₜ d′₁ , zeroₙ) (redₜ d₃ , sucₙ)))
[IdExt]ℕ ⊢Γ _ _ (ℕₜ n₃ d₃ n≡n₃ (ne (neNfₜ neK ⊢k k≡k))) _ (ℕₜ₌ .zero .zero d₅ d′₁ k≡k′₁ zeroᵣ) _ = ⊥-elim (zero≢ne neK (whrDet*Term (redₜ d′₁ , zeroₙ) (redₜ d₃ , ne neK)))
[IdExt]ℕ ⊢Γ _ (ℕₜ .(suc _) d n≡n (sucᵣ x₃)) _ _ _ (ℕₜ₌ .zero .zero d₅ d′₁ k≡k′₁ zeroᵣ) = ⊥-elim (zero≢suc (whrDet*Term (redₜ d₅ , zeroₙ) (redₜ d , sucₙ)))
[IdExt]ℕ ⊢Γ _ (ℕₜ n d n≡n (ne (neNfₜ neK ⊢k k≡k))) _ _ _ (ℕₜ₌ .zero .zero d₅ d′₁ k≡k′₁ zeroᵣ) = ⊥-elim (zero≢ne neK (whrDet*Term (redₜ d₅ , zeroₙ) (redₜ d , ne neK)))
[IdExt]ℕ ⊢Γ _ _ _ (ℕₜ .(suc _) d₃ n≡n₃ (sucᵣ x₃)) _ (ℕₜ₌ .zero .zero d₅ d′₁ k≡k′₁ zeroᵣ) = ⊥-elim (zero≢suc (whrDet*Term (redₜ d′₁ , zeroₙ) (redₜ d₃ , sucₙ)))
[IdExt]ℕ ⊢Γ _ _ _ (ℕₜ n₃ d₃ n≡n₃ (ne (neNfₜ neK ⊢k k≡k))) _ (ℕₜ₌ .zero .zero d₅ d′₁ k≡k′₁ zeroᵣ) = ⊥-elim (zero≢ne neK (whrDet*Term (redₜ d′₁ , zeroₙ) (redₜ d₃ , ne neK)))
[IdExt]ℕ ⊢Γ (ℕₜ .(suc _) d₁ n≡n₁ (sucᵣ x₁)) _ _ _ (ℕₜ₌ k k′ d₄ d′ k≡k′ (ne (neNfₜ₌ neK neM k≡m))) _ = ⊥-elim (suc≢ne neK (whrDet*Term (redₜ d₁ , sucₙ) (redₜ d₄ , ne neK)))
[IdExt]ℕ ⊢Γ (ℕₜ .zero d₁ n≡n₁ zeroᵣ) _ _ _ (ℕₜ₌ k k′ d₄ d′ k≡k′ (ne (neNfₜ₌ neK neM k≡m))) _ = ⊥-elim (zero≢ne neK (whrDet*Term (redₜ d₁ , zeroₙ) (redₜ d₄ , ne neK)))
[IdExt]ℕ ⊢Γ _ _ (ℕₜ .(suc _) d₁ n≡n₁ (sucᵣ x₁)) _ (ℕₜ₌ k k′ d₄ d′ k≡k′ (ne (neNfₜ₌ neK neM k≡m))) _ = ⊥-elim (suc≢ne neM (whrDet*Term (redₜ d₁ , sucₙ) (redₜ d′ , ne neM)))
[IdExt]ℕ ⊢Γ _ _ (ℕₜ .zero d₁ n≡n₁ zeroᵣ) _ (ℕₜ₌ k k′ d₄ d′ k≡k′ (ne (neNfₜ₌ neK neM k≡m))) _ = ⊥-elim (zero≢ne neM (whrDet*Term (redₜ d₁ , zeroₙ) (redₜ d′ , ne neM)))
[IdExt]ℕ ⊢Γ _ (ℕₜ .(suc _) d₁ n≡n₁ (sucᵣ x₁)) _ _ _ (ℕₜ₌ k k′ d₄ d′ k≡k′ (ne (neNfₜ₌ neK neM k≡m))) = ⊥-elim (suc≢ne neK (whrDet*Term (redₜ d₁ , sucₙ) (redₜ d₄ , ne neK)))
[IdExt]ℕ ⊢Γ _ (ℕₜ .zero d₁ n≡n₁ zeroᵣ) _ _ _ (ℕₜ₌ k k′ d₄ d′ k≡k′ (ne (neNfₜ₌ neK neM k≡m))) = ⊥-elim (zero≢ne neK (whrDet*Term (redₜ d₁ , zeroₙ) (redₜ d₄ , ne neK)))
[IdExt]ℕ ⊢Γ _ _ _ (ℕₜ .(suc _) d₁ n≡n₁ (sucᵣ x₁)) _ (ℕₜ₌ k k′ d₄ d′ k≡k′ (ne (neNfₜ₌ neK neM k≡m))) = ⊥-elim (suc≢ne neM (whrDet*Term (redₜ d₁ , sucₙ) (redₜ d′ , ne neM)))
[IdExt]ℕ ⊢Γ _ _ _ (ℕₜ .zero d₁ n≡n₁ zeroᵣ) _ (ℕₜ₌ k k′ d₄ d′ k≡k′ (ne (neNfₜ₌ neK neM k≡m))) = ⊥-elim (zero≢ne neM (whrDet*Term (redₜ d₁ , zeroₙ) (redₜ d′ , ne neM)))
[Id]ℕGen : ∀ {Γ l A t u}
(⊢Γ : ⊢ Γ)
([A] : Γ ⊩ℕ A)
([t] : Γ ⊩⟨ l ⟩ t ∷ A ^ [ ! , ι ⁰ ] / ℕᵣ [A])
([u] : Γ ⊩⟨ l ⟩ u ∷ A ^ [ ! , ι ⁰ ] / ℕᵣ [A])
→ Γ ⊩⟨ l ⟩ Id A t u ^ [ % , ι ⁰ ]
[Id]ℕGen ⊢Γ [[ ⊢A , ⊢B , D ]] (ℕₜ n d n≡n prop) (ℕₜ n₁ d₁ n≡n₁ prop₁) =
let
[[ ⊢tℕ , _ , _ ]] = d
[[ ⊢uℕ , _ , _ ]] = d₁
in proj₁ (redSubst* (IdRed* (conv ⊢tℕ (sym (subset* D))) (conv ⊢uℕ (sym (subset* D))) D)
([Id]ℕ ⊢Γ (ℕₜ n d n≡n prop) (ℕₜ n₁ d₁ n≡n₁ prop₁)))
[IdExt]ℕGen : ∀ {A B t v u w Γ l l'}
(⊢Γ : ⊢ Γ)
([A] : Γ ⊩ℕ A)
([B] : Γ ⊩ℕ B)
([A≡B] : Γ ⊩⟨ l ⟩ A ≡ B ^ [ ! , ι ⁰ ] / ℕᵣ [A])
([t] : Γ ⊩⟨ l ⟩ t ∷ A ^ [ ! , ι ⁰ ] / ℕᵣ [A])
([v] : Γ ⊩⟨ l' ⟩ v ∷ B ^ [ ! , ι ⁰ ] / ℕᵣ [B])
([t≡v] : Γ ⊩⟨ l ⟩ t ≡ v ∷ A ^ [ ! , ι ⁰ ] / ℕᵣ [A])
([u] : Γ ⊩⟨ l ⟩ u ∷ A ^ [ ! , ι ⁰ ] / ℕᵣ [A])
([w] : Γ ⊩⟨ l' ⟩ w ∷ B ^ [ ! , ι ⁰ ] / ℕᵣ [B])
([u≡w] : Γ ⊩⟨ l ⟩ u ≡ w ∷ A ^ [ ! , ι ⁰ ] / ℕᵣ [A])
→ Γ ⊩⟨ l ⟩ Id A t u ≡ Id B v w ^ [ % , ι ⁰ ] / [Id]ℕGen ⊢Γ [A] [t] [u]
[IdExt]ℕGen {A} {B} {t} {v} {u} {w} {Γ} {l} {l'} ⊢Γ [[ ⊢A , ⊢B , D ]] [[ ⊢A₁ , ⊢B₁ , D₁ ]] [A≡B] [t] [v] [t≡v] [u] [w] [u≡w] =
let [A] = [[ ⊢A , ⊢B , D ]]
[B] = [[ ⊢A₁ , ⊢B₁ , D₁ ]]
[ℕ]' = [ℕ] {l = l} ⊢Γ
[A]' , [Aeq] = redSubst* D [ℕ]'
[B]' , [Beq] = redSubst* D₁ [ℕ]'
[t]′ = convTerm₁ {t = t} [A]' [ℕ]' [Aeq] (irrelevanceTerm {l = l} (ℕᵣ [A]) [A]' [t])
[u]′ = convTerm₁ {t = u} [B]' [ℕ]' [Beq] (irrelevanceTerm {l = l} (ℕᵣ [B]) [B]' [u])
[v]′ = convTerm₁ {t = v} [A]' [ℕ]' [Aeq] (irrelevanceTerm {l = l} (ℕᵣ [A]) [A]' [v])
[w]′ = convTerm₁ {t = w} [B]' [ℕ]' [Beq] (irrelevanceTerm {l = l} (ℕᵣ [B]) [B]' [w])
[t≡v]′ = convEqTerm₁ {t = t} {u = v} [A]' [ℕ]' [Aeq] (irrelevanceEqTerm {l = l} (ℕᵣ [A]) [A]' [t≡v])
[u≡w]′ = convEqTerm₁ {t = u} {u = w} [B]' [ℕ]' [Beq] (irrelevanceEqTerm {l = l} (ℕᵣ [B]) [B]' [u≡w])
X = irrelevanceEq {A = Id ℕ t u} {B = Id ℕ v w} {l = l} ([Id]ℕ ⊢Γ [t] [u]) ([Id]ℕ ⊢Γ [t]′ [u]′) ([IdExt]ℕ ⊢Γ [t]′ [u]′ [v]′ [w]′ [t≡v]′ [u≡w]′)
[IdA] , [IdA≡U] = redSubst* {l = l} (IdRed* (escapeTerm {l = l} (ℕᵣ [A]) [t]) (escapeTerm {l = l} (ℕᵣ [A]) [u]) D) ([Id]ℕ ⊢Γ [t]′ [u]′)
[IdB] , [IdB≡U] = redSubst* (IdRed* (escapeTerm {l = l} (ℕᵣ [B]) [v]) (escapeTerm {l = l} (ℕᵣ [B]) [w]) D₁) ([Id]ℕ ⊢Γ [v]′ [w]′)
[IDAtu] = [Id]ℕGen ⊢Γ [A] [t] [u]
[IDBvw] = [Id]ℕGen ⊢Γ [B] [v] [w]
[IdA≡U]′ = irrelevanceEq {A = Id A t u} {B = Id ℕ t u} [IdA] [IDAtu] [IdA≡U]
[IdB≡U]′ = irrelevanceEq {A = Id B v w} {B = Id ℕ v w} {l = l} {l′ = l} [IdB] [IDBvw] [IdB≡U]
in transEq {A = Id A t u} {B = Id ℕ t u} {C = Id B v w} {l = l} {l′ = l} {l″ = l} [IDAtu] ([Id]ℕ ⊢Γ [t]′ [u]′) [IDBvw]
[IdA≡U]′
(transEq {A = Id ℕ t u} {B = Id ℕ v w} {C = Id B v w} {l = l} {l′ = l} {l″ = l} ([Id]ℕ ⊢Γ [t]′ [u]′) ([Id]ℕ ⊢Γ [v]′ [w]′) [IDBvw]
X (symEq {A = Id B v w} {B = Id ℕ v w} [IDBvw] ([Id]ℕ ⊢Γ [v]′ [w]′) [IdB≡U]′))
| {
"alphanum_fraction": 0.4590642181,
"avg_line_length": 70.1758530184,
"ext": "agda",
"hexsha": "f643b80420ca21dc5af51db1d6dea3afe6b230c6",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2022-02-15T19:42:19.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-01-26T14:55:51.000Z",
"max_forks_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "CoqHott/logrel-mltt",
"max_forks_repo_path": "Definition/LogicalRelation/Substitution/Introductions/IdNat.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "CoqHott/logrel-mltt",
"max_issues_repo_path": "Definition/LogicalRelation/Substitution/Introductions/IdNat.agda",
"max_line_length": 178,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "CoqHott/logrel-mltt",
"max_stars_repo_path": "Definition/LogicalRelation/Substitution/Introductions/IdNat.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-17T16:13:53.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-06-21T08:39:01.000Z",
"num_tokens": 16660,
"size": 26737
} |
module Control.WellFounded where
open import Prelude
open import Prelude.Nat.Properties using (suc-inj)
data Acc {a} {A : Set a} (_<_ : A → A → Set a) (x : A) : Set a where
acc : (∀ y → y < x → Acc _<_ y) → Acc _<_ x
-- LessNat is well-founded --
private
wfNatSlow : (n : Nat) → Acc _<_ n
wfNatSlow′ : (n j y : Nat) → n ≡ suc (j + y) → Acc _<_ y
wfNatSlow′ (suc n) zero .n refl = wfNatSlow n
wfNatSlow′ (suc n) (suc j) y eq = wfNatSlow′ n j y (suc-inj eq)
wfNatSlow′ zero zero y ()
wfNatSlow′ zero (suc j) y ()
wfNatSlow n = acc λ { y (diff j eq) → wfNatSlow′ n j y eq }
-- Need to match on n to avoid unfolding on neutral argument!
wfNatFast : {k : Nat} → (n : Nat) → Acc _<_ n
wfNatFast {zero} n = wfNatSlow n
wfNatFast {suc k} zero = wfNatSlow zero
wfNatFast {suc k} (suc n) = acc λ m _ → wfNatFast {k} m
wfNat : (n : Nat) → Acc _<_ n
wfNat n = wfNatFast {1000000000} n
| {
"alphanum_fraction": 0.5939849624,
"avg_line_length": 30.0322580645,
"ext": "agda",
"hexsha": "9d927473609e61857865a0eaf9e46945905a228f",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "75016b4151ed601e28f4462cd7b6b1aaf5d0d1a6",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "lclem/agda-prelude",
"max_forks_repo_path": "src/Control/WellFounded.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "75016b4151ed601e28f4462cd7b6b1aaf5d0d1a6",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "lclem/agda-prelude",
"max_issues_repo_path": "src/Control/WellFounded.agda",
"max_line_length": 68,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "75016b4151ed601e28f4462cd7b6b1aaf5d0d1a6",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "lclem/agda-prelude",
"max_stars_repo_path": "src/Control/WellFounded.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 364,
"size": 931
} |
{-# OPTIONS --without-K --exact-split --safe #-}
module Contract where
open import Basic_Types
open import Identity
open import Homotopy_Equivalence
-- a contractable space means there is a point which is path-connected to any
-- other point in the same space
is_contr : Set → Set
is_contr A = Σ a ∶ A , (∀ (x : A) → a ≡ x)
| {
"alphanum_fraction": 0.7073170732,
"avg_line_length": 23.4285714286,
"ext": "agda",
"hexsha": "00ce375ccfa4679b6f3b4cc6d02a1e3b2f6cb69b",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "76b9ef64626b6d3bbb7ace4f1a16aeb447c54328",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "andyfreeyy/agda_and_math",
"max_forks_repo_path": "HoTT/Contract.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "76b9ef64626b6d3bbb7ace4f1a16aeb447c54328",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "andyfreeyy/agda_and_math",
"max_issues_repo_path": "HoTT/Contract.agda",
"max_line_length": 77,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "76b9ef64626b6d3bbb7ace4f1a16aeb447c54328",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "andyfreeyy/agda_and_math",
"max_stars_repo_path": "HoTT/Contract.agda",
"max_stars_repo_stars_event_max_datetime": "2020-05-24T10:56:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-03-23T09:01:42.000Z",
"num_tokens": 90,
"size": 328
} |
{-# 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
| {
"alphanum_fraction": 0.6301369863,
"avg_line_length": 26.0714285714,
"ext": "agda",
"hexsha": "3406296e9336917a6b842a20046009cdc1661fdc",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "KDr2/agda",
"max_forks_repo_path": "test/Succeed/Issue1115.agda",
"max_issues_count": 6,
"max_issues_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_issues_repo_issues_event_max_datetime": "2021-11-24T08:31:10.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-10-18T08:12:24.000Z",
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "KDr2/agda",
"max_issues_repo_path": "test/Succeed/Issue1115.agda",
"max_line_length": 65,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "KDr2/agda",
"max_stars_repo_path": "test/Succeed/Issue1115.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 129,
"size": 365
} |
-- Andreas, 2016-11-03, issue #2292
-- Internal error when debugging the coverage checker.
{-# OPTIONS -v tc.cover.top:10 #-} -- KEEP!
data ⊥ : Set where
⊥-elim : ∀{A : Set} → ⊥ → A
⊥-elim ()
| {
"alphanum_fraction": 0.6,
"avg_line_length": 19.5,
"ext": "agda",
"hexsha": "44a20206325baf2def13c2f2b1e6b168a8032dc9",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Succeed/Issue2292.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Succeed/Issue2292.agda",
"max_line_length": 54,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Succeed/Issue2292.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 70,
"size": 195
} |
-- Some theorems about operations on non-deterministic values
module nondet-thms where
open import bool
open import bool-thms
open import nat
open import eq
open import nat-thms
open import functions
open import nondet
----------------------------------------------------------------------
-- Theorems about values contained in non-deterministic values:
-- A proof that x is value of the non-deterministic tree y:
-- either it is equal to a deterministic value (ndrefl)
-- or it is somewhere in the tree.
-- If it is in the tree then we need to construct both branches of the tree,
-- and a proof that x is in one of the branches
-- A consequence of this is that any proof that x ∈ y contains the path
-- to x in the tree.
--
-- Example:
-- hInCoin : H ∈ coin
-- hInCoin = left (Val H) (Val T) ndrefl
--
-- Since H is on the left side of coin, we use the left constructor
-- The branches of the tree are (Val H) and (Val T),
-- and since H is identically equal to H this completes the proof.
data _∈_ {A : Set} (x : A) : (y : ND A) → Set where
ndrefl : x ∈ (Val x)
left : (l : ND A) → (r : ND A) → x ∈ l → x ∈ (l ?? r)
right : (l : ND A) → (r : ND A) → x ∈ r → x ∈ (l ?? r)
-- A basic inductive lemma that shows that ∈ is closed under function
-- application. That is, if x ∈ nx, then f x ∈ f $* nx
--
-- Example:
-- ndCons : ... → xs ∈ nxs → (x :: xs) ∈ (_::_ x) $* nxs
∈-$* : {A B : Set} → (f : A → B) → (x : A) → (nx : ND A)
→ x ∈ nx → (f x) ∈ (f $* nx)
∈-$* f x (Val .x) ndrefl = ndrefl
∈-$* f x (l ?? r) (left .l .r k) =
left (f $* l) (f $* r) (∈-$* f x l k)
∈-$* f x (l ?? r) (right .l .r k) =
right (f $* l) (f $* r) (∈-$* f x r k)
-- This is a similar result as ∈-$* but for non-deterministic application:
∈-*$* : {A B : Set} → (x : A) → (nx : ND A) → (f : A → B)
→ (nf : A → ND B) → x ∈ nx → f x ∈ nf x → f x ∈ (nf *$* nx)
∈-*$* x (Val .x) f nf ndrefl pf = pf
∈-*$* x (l ?? r) f nf (left .l .r p) pf =
left (nf *$* l) (nf *$* r) (∈-*$* x l f nf p pf)
∈-*$* x (l ?? r) f nf (right .l .r p) pf =
right (nf *$* l) (nf *$* r) (∈-*$* x r f nf p pf)
----------------------------------------------------------------------
-- Theorems about '$*':
-- Combine two $* applications into one:
$*-$* : ∀ {A B C : Set} → (f : B → C) (g : A → B) (xs : ND A)
→ f $* (g $* xs) ≡ (f ∘ g) $* xs
$*-$* f g (Val x) = refl
$*-$* f g (t1 ?? t2) rewrite $*-$* f g t1 | $*-$* f g t2 = refl
----------------------------------------------------------------------
-- Theorems about 'always':
-- Extend validity of a function with a deterministic argument to validity of
-- the corresponding non-deterministic function:
always-$* : ∀ {A : Set} → (p : A → 𝔹) (xs : ND A)
→ ((y : A) → p y ≡ tt)
→ always (p $* xs) ≡ tt
always-$* _ (Val y) prf = prf y
always-$* p (t1 ?? t2) prf
rewrite always-$* p t1 prf
| always-$* p t2 prf = refl
-- Extend validity of a function with a deterministic argument to validity of
-- the corresponding non-deterministic function:
always-*$* : ∀ {A : Set} → (p : A → ND 𝔹) (xs : ND A)
→ ((y : A) → always (p y) ≡ tt)
→ always (p *$* xs) ≡ tt
always-*$* _ (Val y) prf = prf y
always-*$* p (t1 ?? t2) prf
rewrite always-*$* p t1 prf
| always-*$* p t2 prf = refl
-- Extend validity of a deterministic function to validity of
-- corresponding function with non-deterministic result:
always-toND : ∀ {A : Set} → (p : A → 𝔹) (x : A)
→ (p x) ≡ tt → always (toND p x) ≡ tt
always-toND _ _ p = p
----------------------------------------------------------------------
-- Theorems about 'satisfy':
-- A theorem like filter-map in functional programming:
satisfy-$* : ∀ {A B : Set} → (f : A → B) (xs : ND A) (p : B → 𝔹)
→ (f $* xs) satisfy p ≡ xs satisfy (p ∘ f)
satisfy-$* _ (Val x) _ = refl
satisfy-$* f (t1 ?? t2) p
rewrite satisfy-$* f t1 p
| satisfy-$* f t2 p = refl
-- Extend validity of function with deterministic argument to validity of
-- non-deterministic function:
satisfy-*$* : ∀ {A B : Set} → (p : B → 𝔹) (f : A → ND B) (xs : ND A)
→ ((y : A) → (f y) satisfy p ≡ tt)
→ (f *$* xs) satisfy p ≡ tt
satisfy-*$* _ _ (Val y) prf = prf y
satisfy-*$* p f (t1 ?? t2) prf
rewrite satisfy-*$* p f t1 prf
| satisfy-*$* p f t2 prf = refl
----------------------------------------------------------------------
-- Theorems about 'every':
every-$* : ∀ (f : ℕ → ℕ) (v : ℕ) (x : ND ℕ) →
every _=ℕ_ v x ≡ tt → every _=ℕ_ (f v) (f $* x) ≡ tt
every-$* f v (Val x) u rewrite =ℕ-to-≡ {v} {x} u | =ℕ-refl (f x) = refl
every-$* f v (t1 ?? t2) u
rewrite every-$* f v t1 (&&-fst u)
| every-$* f v t2 (&&-snd {every _=ℕ_ v t1} {every _=ℕ_ v t2} u) = refl
----------------------------------------------------------------------
-- This theorms allows to weaken a predicate which is always satisfied:
weak-always-predicate : ∀ {A : Set} → (p p1 : A → 𝔹) (xs : ND A)
→ xs satisfy p ≡ tt
→ xs satisfy (λ x → p1 x || p x) ≡ tt
weak-always-predicate p p1 (Val x) u rewrite u | ||-tt (p1 x) = refl
weak-always-predicate p p1 (t1 ?? t2) u
rewrite weak-always-predicate p p1 t1 (&&-fst u)
| weak-always-predicate p p1 t2 (&&-snd {t1 satisfy p} {t2 satisfy p} u)
= refl
----------------------------------------------------------------------
| {
"alphanum_fraction": 0.4902470741,
"avg_line_length": 38.726618705,
"ext": "agda",
"hexsha": "ec31203da4f6bf610affcdb5dcf663c70ee6d61e",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b7cfdda11cdadeba882b6b72d75448acd8b0a294",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "mihanus/curry-agda",
"max_forks_repo_path": "nondet/nondet-thms.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b7cfdda11cdadeba882b6b72d75448acd8b0a294",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "mihanus/curry-agda",
"max_issues_repo_path": "nondet/nondet-thms.agda",
"max_line_length": 80,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "b7cfdda11cdadeba882b6b72d75448acd8b0a294",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "mihanus/curry-agda",
"max_stars_repo_path": "nondet/nondet-thms.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1867,
"size": 5383
} |
-- A minor variant of code reported by Andreas Abel. The code below
-- should be rejected.
open import Agda.Builtin.Size
data ⊥ : Set where
data SizeLt (i : Size) : Set where
size : (j : Size< i) → SizeLt i
<∞ : SizeLt ∞
<∞ = size ∞
data D (i : Size) : SizeLt i → Set where
c : ∀ {i' : Size< i} → ((j : SizeLt i') → D i' j) → D i (size i')
f : D ∞ <∞ → ⊥
f (c h) = f (h <∞)
d : ∀ i s → D i s
d i (size j) = c (d j)
loop : ⊥
loop = f (d ∞ <∞)
| {
"alphanum_fraction": 0.5242290749,
"avg_line_length": 18.16,
"ext": "agda",
"hexsha": "da2046ffbe334d6f0efb347dd21887a6c11a5fb1",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-04-01T18:30:09.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-04-01T18:30:09.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue1946-3.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2019-04-01T19:39:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-11-14T15:31:44.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue1946-3.agda",
"max_line_length": 67,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue1946-3.agda",
"max_stars_repo_stars_event_max_datetime": "2020-09-20T00:28:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-10-29T09:40:30.000Z",
"num_tokens": 190,
"size": 454
} |
module Vec where
open import SHE-Prelude
data Nat : Set where
z : Nat
s : Nat -> Nat
data Vec (X : Set) : Nat -> Set where
vNil : Vec X z
_:-_ : forall {n} ->
X -> Vec X n -> Vec X (s n)
_+N_ : Nat -> Nat -> Nat
z +N n = n
s m +N n = s (m +N n)
_vappend_ : forall {X m n} -> Vec X m -> Vec X n -> Vec X (m +N n)
vNil vappend ys = ys
(x :- xs) vappend ys = x :- (xs vappend ys)
vec : forall {n X} -> X -> Vec X n
vec {z} x = vNil
vec {s n} x = x :- vec x
_N>=_ : Nat -> Nat -> Set
m N>= z = One
z N>= s n = Zero
s m N>= s n = m N>= n
vtake : {X : Set}{m : Nat}(n : Nat) -> m N>= n -> Vec X m -> Vec X n
vtake (s n) () vNil
vtake z p xs = vNil
vtake (s n) p (x :- xs) = x :- (vtake n p xs)
VecApp : forall {n} -> Applicative \X -> Vec X n
VecApp {n} = record
{ pure = vec
; _<*>_ = vapp
} where
vapp : forall {n X Y} ->
Vec (X -> Y) n -> Vec X n -> Vec Y n
vapp vNil vNil = vNil
vapp (f :- fs) (x :- xs) = f x :- vapp fs xs
v1 : Vec Nat (s (s (s z)))
v1 = Applicative.pure VecApp z
v2 : Vec Nat (s z)
v2 = vtake (s z) <> v1
v3 : Vec Nat (s z)
v3 = vec {s z} z
v5 : Vec Nat (s z)
v5 = vtake (s z) <> (z :- (z :- vNil))
v6 : Vec Nat (s z)
v6 = vtake (s z) <> (z :- (z :- vNil))
| {
"alphanum_fraction": 0.4907033145,
"avg_line_length": 20.2786885246,
"ext": "agda",
"hexsha": "b9a0c2626d60a79b47e711d5eb93eb1d47f36d5e",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "3d0514c72c804acc10851b90a7ef82a5b4cbc1ff",
"max_forks_repo_licenses": [
"MIT-0"
],
"max_forks_repo_name": "iain-logan/she",
"max_forks_repo_path": "comparisons/agda/Vec.agda",
"max_issues_count": 11,
"max_issues_repo_head_hexsha": "3d0514c72c804acc10851b90a7ef82a5b4cbc1ff",
"max_issues_repo_issues_event_max_datetime": "2016-03-20T10:18:21.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-01-28T17:02:48.000Z",
"max_issues_repo_licenses": [
"MIT-0"
],
"max_issues_repo_name": "iain-logan/she",
"max_issues_repo_path": "comparisons/agda/Vec.agda",
"max_line_length": 68,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "3d0514c72c804acc10851b90a7ef82a5b4cbc1ff",
"max_stars_repo_licenses": [
"MIT-0"
],
"max_stars_repo_name": "iain-logan/she",
"max_stars_repo_path": "comparisons/agda/Vec.agda",
"max_stars_repo_stars_event_max_datetime": "2016-08-04T00:06:06.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-08-04T00:06:06.000Z",
"num_tokens": 528,
"size": 1237
} |
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommAlgebra.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.SIP
open import Cubical.Data.Sigma
open import Cubical.Algebra.Semigroup
open import Cubical.Algebra.Monoid
open import Cubical.Algebra.CommRing
open import Cubical.Algebra.Ring
open import Cubical.Algebra.Algebra
open import Cubical.Displayed.Base
open import Cubical.Displayed.Auto
open import Cubical.Displayed.Record
open import Cubical.Displayed.Universe
open import Cubical.Reflection.RecordEquiv
private
variable
ℓ ℓ' : Level
record IsCommAlgebra (R : CommRing ℓ) {A : Type ℓ'}
(0a : A) (1a : A)
(_+_ : A → A → A) (_·_ : A → A → A) (-_ : A → A)
(_⋆_ : ⟨ R ⟩ → A → A) : Type (ℓ-max ℓ ℓ') where
constructor iscommalgebra
field
isAlgebra : IsAlgebra (CommRing→Ring R) 0a 1a _+_ _·_ -_ _⋆_
·-comm : (x y : A) → x · y ≡ y · x
open IsAlgebra isAlgebra public
unquoteDecl IsCommAlgebraIsoΣ = declareRecordIsoΣ IsCommAlgebraIsoΣ (quote IsCommAlgebra)
record CommAlgebraStr (R : CommRing ℓ) (A : Type ℓ') : Type (ℓ-max ℓ ℓ') where
constructor commalgebrastr
field
0a : A
1a : A
_+_ : A → A → A
_·_ : A → A → A
-_ : A → A
_⋆_ : ⟨ R ⟩ → A → A
isCommAlgebra : IsCommAlgebra R 0a 1a _+_ _·_ -_ _⋆_
open IsCommAlgebra isCommAlgebra public
infix 8 -_
infixl 7 _·_
infixl 7 _⋆_
infixl 6 _+_
CommAlgebra : (R : CommRing ℓ) → ∀ ℓ' → Type (ℓ-max ℓ (ℓ-suc ℓ'))
CommAlgebra R ℓ' = Σ[ A ∈ Type ℓ' ] CommAlgebraStr R A
module _ {R : CommRing ℓ} where
open CommRingStr (snd R) using (1r) renaming (_+_ to _+r_; _·_ to _·s_)
CommAlgebraStr→AlgebraStr : {A : Type ℓ'} → CommAlgebraStr R A → AlgebraStr (CommRing→Ring R) A
CommAlgebraStr→AlgebraStr (commalgebrastr _ _ _ _ _ _ (iscommalgebra isAlgebra ·-comm)) =
algebrastr _ _ _ _ _ _ isAlgebra
CommAlgebra→Algebra : (A : CommAlgebra R ℓ') → Algebra (CommRing→Ring R) ℓ'
CommAlgebra→Algebra (_ , str) = (_ , CommAlgebraStr→AlgebraStr str)
CommAlgebra→CommRing : (A : CommAlgebra R ℓ') → CommRing ℓ'
CommAlgebra→CommRing (_ , commalgebrastr _ _ _ _ _ _ (iscommalgebra isAlgebra ·-comm)) =
_ , commringstr _ _ _ _ _ (iscommring (IsAlgebra.isRing isAlgebra) ·-comm)
isSetCommAlgebra : (A : CommAlgebra R ℓ') → isSet ⟨ A ⟩
isSetCommAlgebra A = isSetAlgebra (CommAlgebra→Algebra A)
makeIsCommAlgebra : {A : Type ℓ'} {0a 1a : A}
{_+_ _·_ : A → A → A} { -_ : A → A} {_⋆_ : ⟨ R ⟩ → A → A}
(isSet-A : isSet A)
(+-assoc : (x y z : A) → x + (y + z) ≡ (x + y) + z)
(+-rid : (x : A) → x + 0a ≡ x)
(+-rinv : (x : A) → x + (- x) ≡ 0a)
(+-comm : (x y : A) → x + y ≡ y + x)
(·-assoc : (x y z : A) → x · (y · z) ≡ (x · y) · z)
(·-lid : (x : A) → 1a · x ≡ x)
(·-ldist-+ : (x y z : A) → (x + y) · z ≡ (x · z) + (y · z))
(·-comm : (x y : A) → x · y ≡ y · x)
(⋆-assoc : (r s : ⟨ R ⟩) (x : A) → (r ·s s) ⋆ x ≡ r ⋆ (s ⋆ x))
(⋆-ldist : (r s : ⟨ R ⟩) (x : A) → (r +r s) ⋆ x ≡ (r ⋆ x) + (s ⋆ x))
(⋆-rdist : (r : ⟨ R ⟩) (x y : A) → r ⋆ (x + y) ≡ (r ⋆ x) + (r ⋆ y))
(⋆-lid : (x : A) → 1r ⋆ x ≡ x)
(⋆-lassoc : (r : ⟨ R ⟩) (x y : A) → (r ⋆ x) · y ≡ r ⋆ (x · y))
→ IsCommAlgebra R 0a 1a _+_ _·_ -_ _⋆_
makeIsCommAlgebra {A = A} {0a} {1a} {_+_} {_·_} { -_} {_⋆_} isSet-A
+-assoc +-rid +-rinv +-comm
·-assoc ·-lid ·-ldist-+ ·-comm
⋆-assoc ⋆-ldist ⋆-rdist ⋆-lid ⋆-lassoc
= iscommalgebra
(makeIsAlgebra
isSet-A
+-assoc +-rid +-rinv +-comm
·-assoc
(λ x → x · 1a ≡⟨ ·-comm _ _ ⟩ 1a · x ≡⟨ ·-lid _ ⟩ x ∎)
·-lid
(λ x y z → x · (y + z) ≡⟨ ·-comm _ _ ⟩
(y + z) · x ≡⟨ ·-ldist-+ _ _ _ ⟩
(y · x) + (z · x) ≡⟨ cong (λ u → (y · x) + u) (·-comm _ _) ⟩
(y · x) + (x · z) ≡⟨ cong (λ u → u + (x · z)) (·-comm _ _) ⟩
(x · y) + (x · z) ∎)
·-ldist-+
⋆-assoc
⋆-ldist
⋆-rdist
⋆-lid
⋆-lassoc
λ r x y → r ⋆ (x · y) ≡⟨ cong (λ u → r ⋆ u) (·-comm _ _) ⟩
r ⋆ (y · x) ≡⟨ sym (⋆-lassoc _ _ _) ⟩
(r ⋆ y) · x ≡⟨ ·-comm _ _ ⟩
x · (r ⋆ y) ∎)
·-comm
module _ (S : CommRing ℓ) where
open CommRingStr (snd S) renaming (1r to 1S)
open CommRingStr (snd R) using () renaming (_·_ to _·R_; _+_ to _+R_; 1r to 1R)
commAlgebraFromCommRing :
(_⋆_ : fst R → fst S → fst S)
→ ((r s : fst R) (x : fst S) → (r ·R s) ⋆ x ≡ r ⋆ (s ⋆ x))
→ ((r s : fst R) (x : fst S) → (r +R s) ⋆ x ≡ (r ⋆ x) + (s ⋆ x))
→ ((r : fst R) (x y : fst S) → r ⋆ (x + y) ≡ (r ⋆ x) + (r ⋆ y))
→ ((x : fst S) → 1R ⋆ x ≡ x)
→ ((r : fst R) (x y : fst S) → (r ⋆ x) · y ≡ r ⋆ (x · y))
→ CommAlgebra R ℓ
commAlgebraFromCommRing _⋆_ ·Assoc⋆ ⋆DistR ⋆DistL ⋆Lid ⋆Assoc· = fst S ,
commalgebrastr 0r 1S _+_ _·_ -_ _⋆_
(makeIsCommAlgebra is-set +Assoc +Rid +Rinv +Comm ·Assoc ·Lid ·Ldist+ ·Comm
·Assoc⋆ ⋆DistR ⋆DistL ⋆Lid ⋆Assoc·)
IsCommAlgebraEquiv : {A B : Type ℓ'}
(M : CommAlgebraStr R A) (e : A ≃ B) (N : CommAlgebraStr R B)
→ Type (ℓ-max ℓ ℓ')
IsCommAlgebraEquiv M e N =
IsAlgebraHom (CommAlgebraStr→AlgebraStr M) (e .fst) (CommAlgebraStr→AlgebraStr N)
CommAlgebraEquiv : (M N : CommAlgebra R ℓ') → Type (ℓ-max ℓ ℓ')
CommAlgebraEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsCommAlgebraEquiv (M .snd) e (N .snd)
IsCommAlgebraHom : {A B : Type ℓ'}
(M : CommAlgebraStr R A) (f : A → B) (N : CommAlgebraStr R B)
→ Type (ℓ-max ℓ ℓ')
IsCommAlgebraHom M f N =
IsAlgebraHom (CommAlgebraStr→AlgebraStr M) f (CommAlgebraStr→AlgebraStr N)
CommAlgebraHom : (M N : CommAlgebra R ℓ') → Type (ℓ-max ℓ ℓ')
CommAlgebraHom M N = Σ[ f ∈ (⟨ M ⟩ → ⟨ N ⟩) ] IsCommAlgebraHom (M .snd) f (N .snd)
module _ {M N : CommAlgebra R ℓ'} where
open CommAlgebraStr {{...}}
open IsAlgebraHom
private
instance
_ = snd M
_ = snd N
makeCommAlgebraHom : (f : fst M → fst N)
→ (fPres1 : f 1a ≡ 1a)
→ (fPres+ : (x y : fst M) → f (x + y) ≡ f x + f y)
→ (fPres· : (x y : fst M) → f (x · y) ≡ f x · f y)
→ (fPres⋆ : (r : fst R) (x : fst M) → f (r ⋆ x) ≡ r ⋆ f x)
→ CommAlgebraHom M N
makeCommAlgebraHom f fPres1 fPres+ fPres· fPres⋆ = f , isHom
where fPres0 =
f 0a ≡⟨ sym (+-rid _) ⟩
f 0a + 0a ≡⟨ cong (λ u → f 0a + u) (sym (+-rinv (f 0a))) ⟩
f 0a + (f 0a - f 0a) ≡⟨ +-assoc (f 0a) (f 0a) (- f 0a) ⟩
(f 0a + f 0a) - f 0a ≡⟨ cong (λ u → u - f 0a) (sym (fPres+ 0a 0a)) ⟩
f (0a + 0a) - f 0a ≡⟨ cong (λ u → f u - f 0a) (+-lid 0a) ⟩
f 0a - f 0a ≡⟨ +-rinv (f 0a) ⟩
0a ∎
isHom : IsCommAlgebraHom (snd M) f (snd N)
pres0 isHom = fPres0
pres1 isHom = fPres1
pres+ isHom = fPres+
pres· isHom = fPres·
pres- isHom = (λ x →
f (- x) ≡⟨ sym (+-rid _) ⟩
(f (- x) + 0a) ≡⟨ cong (λ u → f (- x) + u) (sym (+-rinv (f x))) ⟩
(f (- x) + (f x - f x)) ≡⟨ +-assoc _ _ _ ⟩
((f (- x) + f x) - f x) ≡⟨ cong (λ u → u - f x) (sym (fPres+ _ _)) ⟩
(f ((- x) + x) - f x) ≡⟨ cong (λ u → f u - f x) (+-linv x) ⟩
(f 0a - f x) ≡⟨ cong (λ u → u - f x) fPres0 ⟩
(0a - f x) ≡⟨ +-lid _ ⟩ (- f x) ∎)
pres⋆ isHom = fPres⋆
isPropIsCommAlgebraHom : (f : fst M → fst N) → isProp (IsCommAlgebraHom (snd M) f (snd N))
isPropIsCommAlgebraHom f = isPropIsAlgebraHom
(CommRing→Ring R)
(snd (CommAlgebra→Algebra M))
f
(snd (CommAlgebra→Algebra N))
isPropIsCommAlgebra : (R : CommRing ℓ) {A : Type ℓ'}
(0a 1a : A)
(_+_ _·_ : A → A → A)
(-_ : A → A)
(_⋆_ : ⟨ R ⟩ → A → A)
→ isProp (IsCommAlgebra R 0a 1a _+_ _·_ -_ _⋆_)
isPropIsCommAlgebra R _ _ _ _ _ _ =
isOfHLevelRetractFromIso 1 IsCommAlgebraIsoΣ
(isPropΣ (isPropIsAlgebra _ _ _ _ _ _ _)
(λ alg → isPropΠ2 λ _ _ → alg .IsAlgebra.is-set _ _))
𝒮ᴰ-CommAlgebra : (R : CommRing ℓ) → DUARel (𝒮-Univ ℓ') (CommAlgebraStr R) (ℓ-max ℓ ℓ')
𝒮ᴰ-CommAlgebra R =
𝒮ᴰ-Record (𝒮-Univ _) (IsCommAlgebraEquiv {R = R})
(fields:
data[ 0a ∣ nul ∣ pres0 ]
data[ 1a ∣ nul ∣ pres1 ]
data[ _+_ ∣ bin ∣ pres+ ]
data[ _·_ ∣ bin ∣ pres· ]
data[ -_ ∣ autoDUARel _ _ ∣ pres- ]
data[ _⋆_ ∣ autoDUARel _ _ ∣ pres⋆ ]
prop[ isCommAlgebra ∣ (λ _ _ → isPropIsCommAlgebra _ _ _ _ _ _ _) ])
where
open CommAlgebraStr
open IsAlgebraHom
-- faster with some sharing
nul = autoDUARel (𝒮-Univ _) (λ A → A)
bin = autoDUARel (𝒮-Univ _) (λ A → A → A → A)
CommAlgebraPath : (R : CommRing ℓ) → (A B : CommAlgebra R ℓ') → (CommAlgebraEquiv A B) ≃ (A ≡ B)
CommAlgebraPath R = ∫ (𝒮ᴰ-CommAlgebra R) .UARel.ua
isGroupoidCommAlgebra : {R : CommRing ℓ} → isGroupoid (CommAlgebra R ℓ')
isGroupoidCommAlgebra A B = isOfHLevelRespectEquiv 2 (CommAlgebraPath _ _ _) (isSetAlgebraEquiv _ _)
| {
"alphanum_fraction": 0.4706820901,
"avg_line_length": 41.0983606557,
"ext": "agda",
"hexsha": "8e80df43a33a94cfc3a00d912425df35ac69e3b9",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "9f9ad9dad7404c75cf457f81ba5ac269afe1b1a7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "lpw25/cubical",
"max_forks_repo_path": "Cubical/Algebra/CommAlgebra/Base.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "9f9ad9dad7404c75cf457f81ba5ac269afe1b1a7",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "lpw25/cubical",
"max_issues_repo_path": "Cubical/Algebra/CommAlgebra/Base.agda",
"max_line_length": 100,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "9f9ad9dad7404c75cf457f81ba5ac269afe1b1a7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "lpw25/cubical",
"max_stars_repo_path": "Cubical/Algebra/CommAlgebra/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 4072,
"size": 10028
} |
{-# OPTIONS --safe #-}
module Definition.Conversion.EqRelInstance where
open import Definition.Untyped
open import Definition.Untyped.Properties using (wkSingleSubstId)
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.Weakening using (_∷_⊆_; wkEq; step; id)
open import Definition.Conversion
open import Definition.Conversion.Reduction
open import Definition.Conversion.Universe
open import Definition.Conversion.Stability
open import Definition.Conversion.Soundness
open import Definition.Conversion.Lift
open import Definition.Conversion.Conversion
open import Definition.Conversion.Transitivity
open import Definition.Conversion.Weakening
open import Definition.Conversion.Whnf
open import Definition.Typed.EqualityRelation
open import Definition.Typed.Consequences.Syntactic
open import Definition.Typed.Consequences.Substitution
open import Definition.Typed.Consequences.Injectivity
open import Definition.Typed.Consequences.Equality
open import Definition.Typed.Consequences.Reduction
open import Definition.Conversion.Symmetry
open import Tools.Nat
open import Tools.Product
import Tools.PropositionalEquality as PE
open import Tools.Function
-- Algorithmic equality of neutrals with injected conversion.
data _⊢_~_∷_^_ (Γ : Con Term) (k l A : Term) (r : TypeInfo) : Set where
↑ : ∀ {B} → Γ ⊢ A ≡ B ^ r → Γ ⊢ k ~ l ↑ B ^ r → Γ ⊢ k ~ l ∷ A ^ r
-- Properties of algorithmic equality of neutrals with injected conversion.
~-var : ∀ {x A r Γ} → Γ ⊢ var x ∷ A ^ r → Γ ⊢ var x ~ var x ∷ A ^ r
~-var x =
let ⊢A = syntacticTerm x
in ↑ (refl ⊢A) (var-refl′ x)
~-app : ∀ {f g a b F G Γ rF lF lG lΠ}
→ Γ ⊢ f ~ g ∷ Π F ^ rF ° lF ▹ G ° lG ° lΠ ^ [ ! , ι lΠ ]
→ Γ ⊢ a [genconv↑] b ∷ F ^ [ rF , ι lF ]
→ Γ ⊢ f ∘ a ^ lΠ ~ g ∘ b ^ lΠ ∷ G [ a ] ^ [ ! , ι lG ]
~-app {rF = !} (↑ A≡B (~↑! x)) x₁ =
let _ , ⊢B = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B
ΠFG≡B′ = trans A≡B (subset* (red D))
H , E , B≡ΠHE = Π≡A ΠFG≡B′ whnfB′
F≡H , _ , _ , _ , G≡E = injectivity (PE.subst (λ x → _ ⊢ _ ≡ x ^ _) B≡ΠHE ΠFG≡B′)
_ , ⊢f , _ = syntacticEqTerm (soundnessConv↑Term x₁)
in ↑ (substTypeEq G≡E (refl ⊢f))
(app-cong′ (PE.subst (λ x → _ ⊢ _ ~ _ ↓! x ^ _)
B≡ΠHE ([~] _ (red D) whnfB′ x))
(convConvTerm x₁ F≡H))
~-app {rF = %} (↑ A≡B (~↑! x)) x₁ =
let _ , ⊢B = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B
ΠFG≡B′ = trans A≡B (subset* (red D))
H , E , B≡ΠHE = Π≡A ΠFG≡B′ whnfB′
F≡H , _ , _ , _ , G≡E = injectivity (PE.subst (λ x → _ ⊢ _ ≡ x ^ _) B≡ΠHE ΠFG≡B′)
_ , ⊢f , _ = syntacticEqTerm (proj₂ (proj₂ (soundness~↑% x₁)))
in ↑ (substTypeEq G≡E (genRefl ⊢f))
(app-cong′ (PE.subst (λ x → _ ⊢ _ ~ _ ↓! x ^ _)
B≡ΠHE ([~] _ (red D) whnfB′ x))
(conv~↑% x₁ F≡H))
~-natrec : ∀ {z z′ s s′ n n′ F F′ Γ lF}
→ (Γ ∙ ℕ ^ [ ! , ι ⁰ ]) ⊢ F [conv↑] F′ ^ [ ! , ι lF ] →
Γ ⊢ z [conv↑] z′ ∷ (F [ zero ]) ^ ι lF →
Γ ⊢ s [conv↑] s′ ∷ (Π ℕ ^ ! ° ⁰ ▹ (F ^ ! ° lF ▹▹ F [ suc (var 0) ]↑ ° lF ° lF) ° lF ° lF) ^ ι lF →
Γ ⊢ n ~ n′ ∷ ℕ ^ [ ! , ι ⁰ ] →
Γ ⊢ natrec lF F z s n ~ natrec lF F′ z′ s′ n′ ∷ (F [ n ]) ^ [ ! , ι lF ]
~-natrec {n = n} {n′ = n′} x x₁ x₂ (↑ A≡B (~↑! x₄)) =
let _ , ⊢B = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B
ℕ≡B′ = trans A≡B (subset* (red D))
B≡ℕ = ℕ≡A ℕ≡B′ whnfB′
k~l′ = PE.subst (λ x → _ ⊢ n ~ n′ ↓! x ^ _) B≡ℕ
([~] _ (red D) whnfB′ x₄)
⊢F , _ = syntacticEq (soundnessConv↑ x)
_ , ⊢n , _ = syntacticEqTerm (soundness~↓! k~l′)
in ↑ (refl (substType ⊢F ⊢n)) (natrec-cong′ x x₁ x₂ k~l′)
~-Emptyrec : ∀ {e e' F F′ Γ l lEmpty}
→ Γ ⊢ F [conv↑] F′ ^ [ ! , ι l ] →
Γ ⊢ e ∷ Empty lEmpty ^ [ % , ι lEmpty ] →
Γ ⊢ e' ∷ Empty lEmpty ^ [ % , ι lEmpty ] →
Γ ⊢ Emptyrec l lEmpty F e ~ Emptyrec l lEmpty F′ e' ∷ F ^ [ ! , ι l ]
~-Emptyrec {e = e} {e' = e'} x ⊢e ⊢e' =
let k~l′ = %~↑ ⊢e ⊢e'
⊢F , _ = syntacticEq (soundnessConv↑ x)
in ↑ (refl ⊢F) (Emptyrec-cong′ x k~l′)
~-IdCong : ∀ {A A' : Term} {l : Level} {t t' u u' : Term} {Γ : Con Term} →
Γ ⊢ A ~ A' ∷ Univ ! l ^ [ ! , next l ] →
Γ ⊢ t [conv↑] t' ∷ A ^ ι l →
Γ ⊢ u [conv↑] u' ∷ A ^ ι l →
Γ ⊢ Id A t u ~ Id A' t' u' ∷ SProp l ^ [ ! , next l ]
~-IdCong (↑ A≡B (~↑! x)) t~t' u~u' =
let ⊢Γ = wfEqTerm (soundnessConv↑Term t~t')
_ , ⊢B = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B
U≡B′ = trans A≡B (subset* (red D))
B≡U = U≡A-whnf U≡B′ whnfB′
A~A′ = PE.subst (λ x → _ ⊢ _ ~ _ ↓! x ^ _) B≡U
([~] _ (red D) whnfB′ x)
in ↑ (refl (Ugenⱼ ⊢Γ)) (~↑! (Id-cong A~A′ t~t' u~u'))
~-Idℕ : ∀ {t t' u u' : Term} {Γ : Con Term} →
⊢ Γ →
Γ ⊢ t ~ t' ∷ ℕ ^ [ ! , ι ⁰ ] →
Γ ⊢ u [genconv↑] u' ∷ ℕ ^ [ ! , ι ⁰ ] →
Γ ⊢ Id ℕ t u ~ Id ℕ t' u' ∷ SProp ⁰ ^ [ ! , next ⁰ ]
~-Idℕ ⊢Γ (↑ A≡B (~↑! x)) u~u' =
let _ , ⊢B = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B
ℕ≡B′ = trans A≡B (subset* (red D))
B≡ℕ = ℕ≡A ℕ≡B′ whnfB′
t~t′ = PE.subst (λ x → _ ⊢ _ ~ _ ↓! x ^ _) B≡ℕ
([~] _ (red D) whnfB′ x)
in ↑ (refl (Ugenⱼ ⊢Γ)) (~↑! (Id-ℕ t~t′ u~u'))
~-Idℕ0 : ∀ {u u' : Term} {Γ : Con Term} →
⊢ Γ →
Γ ⊢ u ~ u' ∷ ℕ ^ [ ! , ι ⁰ ] →
Γ ⊢ Id ℕ zero u ~ Id ℕ zero u' ∷ SProp ⁰ ^ [ ! , next ⁰ ]
~-Idℕ0 ⊢Γ (↑ A≡B (~↑! x)) =
let _ , ⊢B = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B
ℕ≡B′ = trans A≡B (subset* (red D))
B≡ℕ = ℕ≡A ℕ≡B′ whnfB′
t~t′ = PE.subst (λ x → _ ⊢ _ ~ _ ↓! x ^ _) B≡ℕ
([~] _ (red D) whnfB′ x)
in ↑ (refl (Ugenⱼ ⊢Γ)) (~↑! (Id-ℕ0 t~t′))
~-IdℕS : ∀ {t t' u u' : Term} {Γ : Con Term} →
⊢ Γ →
Γ ⊢ t [genconv↑] t' ∷ ℕ ^ [ ! , ι ⁰ ] →
Γ ⊢ u ~ u' ∷ ℕ ^ [ ! , ι ⁰ ] →
Γ ⊢ Id ℕ (suc t) u ~ Id ℕ (suc t') u' ∷ SProp ⁰ ^ [ ! , next ⁰ ]
~-IdℕS ⊢Γ X (↑ A≡B (~↑! x)) =
let _ , ⊢B = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B
ℕ≡B′ = trans A≡B (subset* (red D))
B≡ℕ = ℕ≡A ℕ≡B′ whnfB′
t~t′ = PE.subst (λ x → _ ⊢ _ ~ _ ↓! x ^ _) B≡ℕ
([~] _ (red D) whnfB′ x)
in ↑ (refl (Ugenⱼ ⊢Γ)) (~↑! (Id-ℕS X t~t′))
~-IdU : ∀ {t t' u u' : Term} {Γ : Con Term} →
⊢ Γ →
Γ ⊢ t ~ t' ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ u [genconv↑] u' ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ Id (U ⁰) t u ~ Id (U ⁰) t' u' ∷ SProp ¹ ^ [ ! , next ¹ ]
~-IdU ⊢Γ (↑ A≡B (~↑! x)) X =
let _ , ⊢B = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B
U≡B′ = trans A≡B (subset* (red D))
B≡U = U≡A-whnf U≡B′ whnfB′
t~t′ = PE.subst (λ x → _ ⊢ _ ~ _ ↓! x ^ _) B≡U
([~] _ (red D) whnfB′ x)
in ↑ (refl (Ugenⱼ ⊢Γ)) (~↑! (Id-U t~t′ X))
~-IdUℕ : ∀ {u u' : Term} {Γ : Con Term} →
⊢ Γ →
Γ ⊢ u ~ u' ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ Id (U ⁰) ℕ u ~ Id (U ⁰) ℕ u' ∷ SProp ¹ ^ [ ! , next ¹ ]
~-IdUℕ ⊢Γ (↑ A≡B (~↑! x)) =
let _ , ⊢B = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B
U≡B′ = trans A≡B (subset* (red D))
B≡U = U≡A-whnf U≡B′ whnfB′
t~t′ = PE.subst (λ x → _ ⊢ _ ~ _ ↓! x ^ _) B≡U
([~] _ (red D) whnfB′ x)
in ↑ (refl (Ugenⱼ ⊢Γ)) (~↑! (Id-Uℕ t~t′))
~-IdUΠ : ∀ {A : Term} {rA : Relevance} {B A' B' u u' : Term}
{Γ : Con Term} →
Γ ⊢ Π A ^ rA ° ⁰ ▹ B ° ⁰ ° ⁰ [genconv↑] Π A' ^ rA ° ⁰ ▹ B' ° ⁰ ° ⁰ ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ u ~ u' ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ Id (U ⁰) (Π A ^ rA ° ⁰ ▹ B ° ⁰ ° ⁰) u ~
Id (U ⁰) (Π A' ^ rA ° ⁰ ▹ B' ° ⁰ ° ⁰) u' ∷ SProp ¹ ^ [ ! , next ¹ ]
~-IdUΠ X (↑ A≡B (~↑! x)) =
let ⊢Γ = wfEqTerm (soundnessConv↑Term X)
_ , ⊢B = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B
U≡B′ = trans A≡B (subset* (red D))
B≡U = U≡A-whnf U≡B′ whnfB′
t~t′ = PE.subst (λ x → _ ⊢ _ ~ _ ↓! x ^ _) B≡U
([~] _ (red D) whnfB′ x)
in ↑ (refl (Ugenⱼ ⊢Γ)) (~↑! (Id-UΠ X t~t′))
~-castcong : ∀ {A A' B B' e e' t t' : Term} {Γ : Con Term} →
Γ ⊢ A ~ A' ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ B [genconv↑] B' ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ t [genconv↑] t' ∷ A ^ [ ! , ι ⁰ ] →
Γ ⊢ e ∷ Id (U ⁰) A B ^ [ % , next ⁰ ] →
Γ ⊢ e' ∷ Id (U ⁰) A' B' ^ [ % , next ⁰ ] →
Γ ⊢ cast ⁰ A B e t ~ cast ⁰ A' B' e' t' ∷ B ^ [ ! , ι ⁰ ]
~-castcong (↑ A≡B (~↑! x)) X Y ⊢e ⊢e' =
let _ , ⊢B , _ = syntacticEqTerm (soundnessConv↑Term X)
_ , ⊢B' = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B'
U≡B′ = trans A≡B (subset* (red D))
B≡U = U≡A-whnf U≡B′ whnfB′
t~t′ = PE.subst (λ x → _ ⊢ _ ~ _ ↓! x ^ _) B≡U
([~] _ (red D) whnfB′ x)
in ↑ (refl (univ ⊢B)) (~↑! (cast-cong t~t′ X Y ⊢e ⊢e'))
~-castℕ : ∀ {B B' e e' t t' : Term} {Γ : Con Term} →
⊢ Γ →
Γ ⊢ B ~ B' ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ t [genconv↑] t' ∷ ℕ ^ [ ! , ι ⁰ ] →
Γ ⊢ e ∷ Id (U ⁰) ℕ B ^ [ % , next ⁰ ] →
Γ ⊢ e' ∷ Id (U ⁰) ℕ B' ^ [ % , next ⁰ ] →
Γ ⊢ cast ⁰ ℕ B e t ~ cast ⁰ ℕ B' e' t' ∷ B ^ [ ! , ι ⁰ ]
~-castℕ ⊢Γ (↑ A≡B (~↑! x)) X ⊢e ⊢e' =
let _ , ⊢B' = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B'
U≡B′ = trans A≡B (subset* (red D))
B≡U = U≡A-whnf U≡B′ whnfB′
t~t′ = PE.subst (λ x → _ ⊢ _ ~ _ ↓! x ^ _) B≡U
([~] _ (red D) whnfB′ x)
_ , ⊢B , _ = syntacticEqTerm (soundness~↓! t~t′)
in ↑ (refl (univ ⊢B)) (~↑! (cast-ℕ t~t′ X ⊢e ⊢e'))
~-castℕℕ : ∀ {e e' t t' : Term} {Γ : Con Term} →
⊢ Γ →
Γ ⊢ t ~ t' ∷ ℕ ^ [ ! , ι ⁰ ] →
Γ ⊢ e ∷ Id (U ⁰) ℕ ℕ ^ [ % , next ⁰ ] →
Γ ⊢ e' ∷ Id (U ⁰) ℕ ℕ ^ [ % , next ⁰ ] →
Γ ⊢ cast ⁰ ℕ ℕ e t ~ cast ⁰ ℕ ℕ e' t' ∷ ℕ ^ [ ! , ι ⁰ ]
~-castℕℕ ⊢Γ (↑ A≡B (~↑! x)) ⊢e ⊢e' =
let _ , ⊢B' = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B'
ℕ≡B′ = trans A≡B (subset* (red D))
B≡ℕ = ℕ≡A ℕ≡B′ whnfB′
t~t′ = PE.subst (λ x → _ ⊢ _ ~ _ ↓! x ^ _) B≡ℕ
([~] _ (red D) whnfB′ x)
_ , ⊢B , _ = syntacticEqTerm (soundness~↓! t~t′)
in ↑ (refl (univ (ℕⱼ ⊢Γ))) (~↑! (cast-ℕℕ t~t′ ⊢e ⊢e'))
~-castΠ : ∀ {A A' : Term} {rA : Relevance} {P P' B B' e e' t t' : Term}
{Γ : Con Term} →
Γ ⊢ Π A ^ rA ° ⁰ ▹ P ° ⁰ ° ⁰ [genconv↑] Π A' ^ rA ° ⁰ ▹ P' ° ⁰ ° ⁰ ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ B ~ B' ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ t [genconv↑] t' ∷ Π A ^ rA ° ⁰ ▹ P ° ⁰ ° ⁰ ^ [ ! , ι ⁰ ] →
Γ ⊢ e ∷ Id (U ⁰) (Π A ^ rA ° ⁰ ▹ P ° ⁰ ° ⁰) B ^ [ % , next ⁰ ] →
Γ ⊢ e' ∷ Id (U ⁰) (Π A' ^ rA ° ⁰ ▹ P' ° ⁰ ° ⁰) B' ^ [ % , next ⁰ ] →
Γ ⊢ cast ⁰ (Π A ^ rA ° ⁰ ▹ P ° ⁰ ° ⁰) B e t ~ cast ⁰ (Π A' ^ rA ° ⁰ ▹ P' ° ⁰ ° ⁰) B' e' t' ∷ B ^ [ ! , ι ⁰ ]
~-castΠ X (↑ A≡B (~↑! x)) Y ⊢e ⊢e' =
let _ , ⊢B' = syntacticEq A≡B
B′ , whnfB′ , D = whNorm ⊢B'
U≡B′ = trans A≡B (subset* (red D))
B≡U = U≡A-whnf U≡B′ whnfB′
t~t′ = PE.subst (λ x → _ ⊢ _ ~ _ ↓! x ^ _) B≡U
([~] _ (red D) whnfB′ x)
_ , ⊢B , _ = syntacticEqTerm (soundness~↓! t~t′)
in ↑ (refl (univ ⊢B)) (~↑! (cast-Π X t~t′ Y ⊢e ⊢e'))
~-castℕΠ : ∀ {A A' : Term} {rA : Relevance} {P P' e e' t t' : Term}
{Γ : Con Term} →
Γ ⊢ A ∷ Univ rA ⁰ ^ [ ! , next ⁰ ] →
(Γ ∙ A ^ [ rA , ι ⁰ ]) ⊢ P ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ Π A ^ rA ° ⁰ ▹ P ° ⁰ ° ⁰ [genconv↑] Π A' ^ rA ° ⁰ ▹ P' ° ⁰ ° ⁰ ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ t [genconv↑] t' ∷ ℕ ^ [ ! , ι ⁰ ] →
Γ ⊢ e ∷ Id (U ⁰) ℕ (Π A ^ rA ° ⁰ ▹ P ° ⁰ ° ⁰) ^ [ % , next ⁰ ] →
Γ ⊢ e' ∷ Id (U ⁰) ℕ (Π A' ^ rA ° ⁰ ▹ P' ° ⁰ ° ⁰) ^ [ % , next ⁰ ] →
Γ ⊢ cast ⁰ ℕ (Π A ^ rA ° ⁰ ▹ P ° ⁰ ° ⁰) e t ~ cast ⁰ ℕ (Π A' ^ rA ° ⁰ ▹ P' ° ⁰ ° ⁰) e' t' ∷
Π A ^ rA ° ⁰ ▹ P ° ⁰ ° ⁰ ^ [ ! , ι ⁰ ]
~-castℕΠ ⊢A ⊢P X Y ⊢e ⊢e' = ↑ (refl (univ (Πⱼ ≡is≤ PE.refl ▹ ≡is≤ PE.refl ▹ ⊢A ▹ ⊢P))) (~↑! (cast-ℕΠ X Y ⊢e ⊢e'))
~-castΠℕ : ∀ {A A' : Term} {rA : Relevance} {P P' e e' t t' : Term}
{Γ : Con Term} →
Γ ⊢ A ∷ Univ rA ⁰ ^ [ ! , next ⁰ ] →
(Γ ∙ A ^ [ rA , ι ⁰ ]) ⊢ P ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ Π A ^ rA ° ⁰ ▹ P ° ⁰ ° ⁰ [genconv↑] Π A' ^ rA ° ⁰ ▹ P' ° ⁰ ° ⁰
∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ t [genconv↑] t' ∷ Π A ^ rA ° ⁰ ▹ P ° ⁰ ° ⁰ ^ [ ! , ι ⁰ ] →
Γ ⊢ e ∷ Id (U ⁰) (Π A ^ rA ° ⁰ ▹ P ° ⁰ ° ⁰) ℕ ^ [ % , next ⁰ ] →
Γ ⊢ e' ∷ Id (U ⁰) (Π A' ^ rA ° ⁰ ▹ P' ° ⁰ ° ⁰) ℕ ^ [ % , next ⁰ ] →
Γ ⊢ cast ⁰ (Π A ^ rA ° ⁰ ▹ P ° ⁰ ° ⁰) ℕ e t ~
cast ⁰ (Π A' ^ rA ° ⁰ ▹ P' ° ⁰ ° ⁰) ℕ e' t' ∷ ℕ ^ [ ! , ι ⁰ ]
~-castΠℕ ⊢A ⊢P X Y ⊢e ⊢e' = ↑ (refl (univ (ℕⱼ (wfTerm ⊢A)))) (~↑! (cast-Πℕ X Y ⊢e ⊢e'))
~-castΠΠ%! : ∀ {A A' P P' B B' Q Q' e e' t t' : Term} {Γ : Con Term} →
Γ ⊢ A ∷ Univ % ⁰ ^ [ ! , next ⁰ ] →
(Γ ∙ A ^ [ % , ι ⁰ ]) ⊢ P ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ Π A ^ % ° ⁰ ▹ P ° ⁰ ° ⁰ [genconv↑] Π A' ^ % ° ⁰ ▹ P' ° ⁰ ° ⁰ ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ B ∷ Univ ! ⁰ ^ [ ! , next ⁰ ] →
(Γ ∙ B ^ [ ! , ι ⁰ ]) ⊢ Q ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ Π B ^ ! ° ⁰ ▹ Q ° ⁰ ° ⁰ [genconv↑] Π B' ^ ! ° ⁰ ▹ Q' ° ⁰ ° ⁰ ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ t [genconv↑] t' ∷ Π A ^ % ° ⁰ ▹ P ° ⁰ ° ⁰ ^ [ ! , ι ⁰ ] →
Γ ⊢ e ∷ Id (U ⁰) (Π A ^ % ° ⁰ ▹ P ° ⁰ ° ⁰) (Π B ^ ! ° ⁰ ▹ Q ° ⁰ ° ⁰) ^ [ % , next ⁰ ] →
Γ ⊢ e' ∷ Id (U ⁰) (Π A' ^ % ° ⁰ ▹ P' ° ⁰ ° ⁰) (Π B' ^ ! ° ⁰ ▹ Q' ° ⁰ ° ⁰) ^ [ % , next ⁰ ] →
Γ ⊢ cast ⁰ (Π A ^ % ° ⁰ ▹ P ° ⁰ ° ⁰) (Π B ^ ! ° ⁰ ▹ Q ° ⁰ ° ⁰) e t ~
cast ⁰ (Π A' ^ % ° ⁰ ▹ P' ° ⁰ ° ⁰) (Π B' ^ ! ° ⁰ ▹ Q' ° ⁰ ° ⁰) e' t' ∷ Π B ^ ! ° ⁰ ▹ Q ° ⁰ ° ⁰ ^ [ ! , ι ⁰ ]
~-castΠΠ%! ⊢A ⊢P X ⊢B ⊢Q Y t~t' ⊢e ⊢e' = ↑ (refl (univ (Πⱼ ≡is≤ PE.refl ▹ ≡is≤ PE.refl ▹ ⊢B ▹ ⊢Q)))
(~↑! (cast-ΠΠ%! X Y t~t' ⊢e ⊢e'))
~-castΠΠ!% : ∀ {A A' P P' B B' Q Q' e e' t t' : Term} {Γ : Con Term} →
Γ ⊢ A ∷ Univ ! ⁰ ^ [ ! , next ⁰ ] →
(Γ ∙ A ^ [ ! , ι ⁰ ]) ⊢ P ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ Π A ^ ! ° ⁰ ▹ P ° ⁰ ° ⁰ [genconv↑] Π A' ^ ! ° ⁰ ▹ P' ° ⁰ ° ⁰ ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ B ∷ Univ % ⁰ ^ [ ! , next ⁰ ] →
(Γ ∙ B ^ [ % , ι ⁰ ]) ⊢ Q ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ Π B ^ % ° ⁰ ▹ Q ° ⁰ ° ⁰ [genconv↑] Π B' ^ % ° ⁰ ▹ Q' ° ⁰ ° ⁰ ∷ U ⁰ ^ [ ! , next ⁰ ] →
Γ ⊢ t [genconv↑] t' ∷ Π A ^ ! ° ⁰ ▹ P ° ⁰ ° ⁰ ^ [ ! , ι ⁰ ] →
Γ ⊢ e ∷ Id (U ⁰) (Π A ^ ! ° ⁰ ▹ P ° ⁰ ° ⁰) (Π B ^ % ° ⁰ ▹ Q ° ⁰ ° ⁰) ^ [ % , next ⁰ ] →
Γ ⊢ e' ∷ Id (U ⁰) (Π A' ^ ! ° ⁰ ▹ P' ° ⁰ ° ⁰) (Π B' ^ % ° ⁰ ▹ Q' ° ⁰ ° ⁰) ^ [ % , next ⁰ ] →
Γ ⊢ cast ⁰ (Π A ^ ! ° ⁰ ▹ P ° ⁰ ° ⁰) (Π B ^ % ° ⁰ ▹ Q ° ⁰ ° ⁰) e t ~
cast ⁰ (Π A' ^ ! ° ⁰ ▹ P' ° ⁰ ° ⁰) (Π B' ^ % ° ⁰ ▹ Q' ° ⁰ ° ⁰) e' t' ∷ Π B ^ % ° ⁰ ▹ Q ° ⁰ ° ⁰ ^ [ ! , ι ⁰ ]
~-castΠΠ!% ⊢A ⊢P X ⊢B ⊢Q Y t~t' ⊢e ⊢e' = ↑ (refl (univ (Πⱼ ≡is≤ PE.refl ▹ ≡is≤ PE.refl ▹ ⊢B ▹ ⊢Q)))
(~↑! (cast-ΠΠ!% X Y t~t' ⊢e ⊢e'))
~-sym : {k l A : Term} {r : TypeInfo} {Γ : Con Term} → Γ ⊢ k ~ l ∷ A ^ r → Γ ⊢ l ~ k ∷ A ^ r
~-sym (↑ A≡B x) =
let ⊢Γ = wfEq A≡B
B , A≡B′ , l~k = sym~↑ (reflConEq ⊢Γ) x
in ↑ (trans A≡B A≡B′) l~k
~-trans : {k l m A : Term} {r : TypeInfo} {Γ : Con Term}
→ Γ ⊢ k ~ l ∷ A ^ r → Γ ⊢ l ~ m ∷ A ^ r
→ Γ ⊢ k ~ m ∷ A ^ r
~-trans (↑ x (~↑! x₁)) (↑ x₂ (~↑! x₃)) =
let ⊢Γ = wfEq x
k~m , _ = trans~↑! PE.refl (reflConEq ⊢Γ) x₁ x₃
in ↑ x (~↑! k~m)
~-trans (↑ x (~↑% x₁)) (↑ x₂ (~↑% x₃)) =
let ⊢Γ = wfEq x
k~m = trans~↑% (reflConEq ⊢Γ) x₁ (conv~↑% x₃ (trans (sym x₂) x))
in ↑ x (~↑% k~m)
~-wk : {k l A : Term} {r : TypeInfo} {ρ : Wk} {Γ Δ : Con Term} →
ρ ∷ Δ ⊆ Γ →
⊢ Δ → Γ ⊢ k ~ l ∷ A ^ r → Δ ⊢ wk ρ k ~ wk ρ l ∷ wk ρ A ^ r
~-wk x x₁ (↑ x₂ x₃) = ↑ (wkEq x x₁ x₂) (wk~↑ x x₁ x₃)
~-conv : {k l A B : Term} {r : TypeInfo} {Γ : Con Term} →
Γ ⊢ k ~ l ∷ A ^ r → Γ ⊢ A ≡ B ^ r → Γ ⊢ k ~ l ∷ B ^ r
~-conv (↑ x x₁) x₂ = ↑ (trans (sym x₂) x) x₁
~-to-conv : {k l A : Term} {Γ : Con Term} {r : TypeInfo} →
Γ ⊢ k ~ l ∷ A ^ r → Γ ⊢ k [genconv↑] l ∷ A ^ r
~-to-conv {r = [ ! , ll ]} (↑ x x₁) = convConvTerm (lift~toConv↑ x₁) (sym x)
~-to-conv {r = [ % , ll ]} (↑ x (~↑% x₁)) = conv~↑% x₁ (sym x)
un-univConv : ∀ {A B : Term} {r : Relevance} {l : Level} {Γ : Con Term} →
Γ ⊢ A [conv↑] B ^ [ r , ι l ] →
Γ ⊢ A [conv↑] B ∷ Univ r l ^ next l
un-univConv {A} {B} {r} {l} ([↑] A′ B′ D D′ whnfA′ whnfB′ (univ x)) =
let ⊢Γ = wfEqTerm (soundnessConv↓Term x)
in [↑]ₜ (Univ r l) A′ B′ (id (Ugenⱼ ⊢Γ)) (un-univ⇒* D) (un-univ⇒* D′) Uₙ whnfA′ whnfB′ x
Πₜ-cong : ∀ {F G H E rF rG lF lG lΠ Γ}
→ lF ≤ lΠ
→ lG ≤ lΠ
→ Γ ⊢ F ^ [ rF , ι lF ]
→ Γ ⊢ F [conv↑] H ∷ Univ rF lF ^ next lF
→ Γ ∙ F ^ [ rF , ι lF ] ⊢ G [conv↑] E ∷ Univ rG lG ^ next lG
→ Γ ⊢ Π F ^ rF ° lF ▹ G ° lG ° lΠ [conv↑] Π H ^ rF ° lF ▹ E ° lG ° lΠ ∷ Univ rG lΠ ^ next lΠ
Πₜ-cong lF< lG< x x₁ x₂ = liftConvTerm (Π-cong PE.refl PE.refl PE.refl PE.refl lF< lG< x x₁ x₂)
~-irrelevance : {k l A : Term} {Γ : Con Term} {ll : TypeLevel}
→ Γ ⊢ k ∷ A ^ [ % , ll ]
→ Γ ⊢ l ∷ A ^ [ % , ll ]
→ Γ ⊢ k ~ l ∷ A ^ [ % , ll ]
~-irrelevance ⊢k ⊢l =
let X = ~↑% (%~↑ ⊢k ⊢l)
⊢A = syntacticTerm ⊢k
in ↑ (refl ⊢A) X
soundnessgenConv : ∀ {a b A r Γ} → Γ ⊢ a [genconv↑] b ∷ A ^ r → Γ ⊢ a ≡ b ∷ A ^ r
soundnessgenConv {r = [ ! , l ]} = soundnessConv↑Term
soundnessgenConv {r = [ % , l ]} x = proj₂ (proj₂ (soundness~↑% x))
symgenConv : ∀ {t u A r Γ} → Γ ⊢ t [genconv↑] u ∷ A ^ r → Γ ⊢ u [genconv↑] t ∷ A ^ r
symgenConv {r = [ ! , l ]} = symConvTerm
symgenConv {r = [ % , l ]} t<>u = let ⊢Γ = wfEqTerm (proj₂ (proj₂ (soundness~↑% t<>u)))
in sym~↑% (reflConEq ⊢Γ) t<>u
wkgenConv↑Term : ∀ {ρ t u A Γ r Δ} ([ρ] : ρ ∷ Δ ⊆ Γ) → ⊢ Δ
→ Γ ⊢ t [genconv↑] u ∷ A ^ r
→ Δ ⊢ wk ρ t [genconv↑] wk ρ u ∷ wk ρ A ^ r
wkgenConv↑Term {r = [ ! , l ]} = wkConv↑Term
wkgenConv↑Term {r = [ % , l ]} = wk~↑%
convgenconv : ∀ {t u A B : Term} {r : TypeInfo} {Γ : Con Term} →
Γ ⊢ t [genconv↑] u ∷ A ^ r →
Γ ⊢ A ≡ B ^ r → Γ ⊢ t [genconv↑] u ∷ B ^ r
convgenconv {r = [ ! , l ]} = convConvTerm
convgenconv {r = [ % , l ]} = conv~↑%
transgenConv : ∀ {t u v A : Term} {r : TypeInfo} {Γ : Con Term} →
Γ ⊢ t [genconv↑] u ∷ A ^ r →
Γ ⊢ u [genconv↑] v ∷ A ^ r → Γ ⊢ t [genconv↑] v ∷ A ^ r
transgenConv {r = [ ! , l ]} = transConvTerm
transgenConv {r = [ % , l ]} = trans~↑!Term
-- Algorithmic equality instance of the generic equality relation.
instance eqRelInstance : EqRelSet
eqRelInstance = eqRel _⊢_[conv↑]_^_ _⊢_[genconv↑]_∷_^_ _⊢_~_∷_^_
~-to-conv soundnessConv↑ soundnessgenConv
univConv↑ un-univConv
symConv symgenConv ~-sym
transConv transgenConv ~-trans
convgenconv ~-conv
wkConv↑ wkgenConv↑Term ~-wk
reductionConv↑ reductionConv↑Term
(liftConv ∘ᶠ (U-refl PE.refl)) ( liftConvTerm ∘ᶠ (U-refl PE.refl))
(liftConvTerm ∘ᶠ ℕ-refl)
(liftConvTerm ∘ᶠ (Empty-refl PE.refl))
Πₜ-cong
(λ x x₁ x₂ → liftConvTerm (∃-cong PE.refl x x₁ x₂))
(liftConvTerm ∘ᶠ zero-refl)
(liftConvTerm ∘ᶠ suc-cong)
(λ l< l<' x x₁ x₂ x₃ x₄ x₅ → liftConvTerm (η-eq l< l<' x x₁ x₂ x₃ x₄ x₅))
~-var ~-app ~-natrec ~-Emptyrec
~-IdCong ~-Idℕ ~-Idℕ0 ~-IdℕS ~-IdU ~-IdUℕ ~-IdUΠ
~-castcong ~-castℕ ~-castℕℕ ~-castΠ ~-castℕΠ ~-castΠℕ ~-castΠΠ%! ~-castΠΠ!%
~-irrelevance
| {
"alphanum_fraction": 0.4106384068,
"avg_line_length": 45.4255813953,
"ext": "agda",
"hexsha": "23b885835d11ce4b6f841f69f86c60c163125035",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2022-02-15T19:42:19.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-01-26T14:55:51.000Z",
"max_forks_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "CoqHott/logrel-mltt",
"max_forks_repo_path": "Definition/Conversion/EqRelInstance.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "CoqHott/logrel-mltt",
"max_issues_repo_path": "Definition/Conversion/EqRelInstance.agda",
"max_line_length": 116,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "CoqHott/logrel-mltt",
"max_stars_repo_path": "Definition/Conversion/EqRelInstance.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-17T16:13:53.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-06-21T08:39:01.000Z",
"num_tokens": 10148,
"size": 19533
} |
open import Array
open import Array.APL
open import Data.Nat
open import Data.Nat.Properties
open import Data.Nat.DivMod hiding (_/_)
open import Data.Fin hiding (_≤_; _<_; _+_) --using (Fin; zero; suc; toℕ)
open import Data.Vec
open import Data.Vec.Properties
open import Relation.Binary.PropositionalEquality
open import Data.Product
open import Function
open import Relation.Nullary
open import Relation.Nullary.Decidable
open import Data.Unit using (⊤)
open import Agda.Builtin.Float
-- Save some typing when selecting from index-vectors/shapes
-- converted into arrays.
pattern I0 = (zero ∷ [])
pattern I1 = (suc zero ∷ [])
pattern I2 = (suc (suc zero) ∷ [])
pattern I3 = (suc (suc (suc zero)) ∷ [])
-- Verbose facts about transitivity of <, ≤, and ≡
a≤b⇒b≡c⇒a≤c : ∀ {a b c} → a ≤ b → b ≡ c → a ≤ c
a≤b⇒b≡c⇒a≤c a≤b refl = a≤b
a≤b⇒a≡c⇒b≡d⇒c≤d : ∀ {a b c d} → a ≤ b → a ≡ c → b ≡ d → c ≤ d
a≤b⇒a≡c⇒b≡d⇒c≤d a≤b refl refl = a≤b
a<b⇒0<b : ∀ {a b} → a < b → zero < b
a<b⇒0<b {a} a<b = ≤-trans (s≤s z≤n) a<b
a<b⇒c≤a⇒c<b : ∀ {a b c} → a < b → c ≤ a → c < b
a<b⇒c≤a⇒c<b a<b z≤n = a<b⇒0<b a<b
a<b⇒c≤a⇒c<b (s≤s a<b) (s≤s c≤a) = s≤s (a<b⇒c≤a⇒c<b a<b c≤a)
a≤b⇒c≤a⇒c≤b : ∀ {a b c} → a ≤ b → c ≤ a → c ≤ b
a≤b⇒c≤a⇒c≤b {a} {b} {c} a≤b c≤a = ≤-trans c≤a a≤b
A<B⇒B≤C⇒A≤C : ∀ {n}{ix s s₁ : Ar ℕ 1 (n ∷ [])}
→ ix <a s → s₁ ≥a s → s₁ ≥a ix
A<B⇒B≤C⇒A≤C {ix = imap x} {imap x₁} {imap x₂} ix<s ix≤s₁ iv = ≤-trans (<⇒≤ $ ix<s iv) (ix≤s₁ iv)
A≥B⇒A≡C⇒C≥B : ∀ {d s}{A B C : Ar ℕ d s}
→ A ≥a B → A =a C → C ≥a B
A≥B⇒A≡C⇒C≥B {A = imap x} {imap x₁} {imap x₂} A≥B A≡C iv rewrite (sym $ A≡C iv) = A≥B iv
-- Something that could go in Stdlib.
≡⇒≤ : ∀ {a b} → a ≡ b → a ≤ b
≡⇒≤ refl = ≤-refl
a≤a*b : ∀ {a b} → a ≤ a * suc b
a≤a*b {a} {b = zero} rewrite (*-identityʳ a) = ≤-refl
a≤a*b {a} {b = suc b} = ≤-trans a≤a*b (*-monoʳ-≤ a (≤-step ≤-refl))
a-s[b]+1≡a-b : ∀ {a b} → b < a → a ∸ suc b + 1 ≡ a ∸ b
a-s[b]+1≡a-b {a} {b} pf = begin
a ∸ suc (b) + 1 ≡⟨ sym $ +-∸-comm 1 pf ⟩
a + 1 ∸ suc b ≡⟨ cong₂ _∸_ (+-comm a 1) (refl {x = suc b}) ⟩
a ∸ b
∎
where open ≡-Reasoning
conv-ix-inb : ∀ {n}{ix s s₁ : Ar ℕ 1 (n ∷ [])}
→ (ix<s : ix <a s)
→ (s₁≥s : s₁ ≥a s)
→ (s₁ -ₙ ix) {≥ = A<B⇒B≤C⇒A≤C {s₁ = s₁} ix<s s₁≥s}
≥a ((s₁ -ₙ s) {≥ = s₁≥s} +ₙ (scal 1))
conv-ix-inb {ix = imap ix} {imap s} {imap s₁} ix<s s₁≥s iv =
let
s₁-[1+ix]≥s₁-s = ∸-monoʳ-≤ (s₁ iv) (ix<s iv)
s₁-[1+ix]+1≥s₁-s+1 = +-monoˡ-≤ 1 s₁-[1+ix]≥s₁-s
in a≤b⇒b≡c⇒a≤c s₁-[1+ix]+1≥s₁-s+1 (a-s[b]+1≡a-b {a = s₁ iv} {b = ix iv} (≤-trans (ix<s iv) (s₁≥s iv)))
undo-sa-as : ∀ {n} {s s₁ : Vec ℕ n}{ix : Ar ℕ 1 (n ∷ [])}{≥1}
→ ((imap (λ iv → lookup s₁ (ix-lookup iv zero)) -ₙ ix) {≥ = ≥1})
=a imap (λ z → lookup (a→s ((imap (λ iv → lookup s₁ (ix-lookup iv zero)) -ₙ ix) {≥ = ≥1}))
(ix-lookup z zero))
undo-sa-as {s₁ = s₁} {ix = (imap ix)} {≥1} iv = sym $ s→a∘a→s ((s→a s₁ -ₙ imap ix) {≥ = ≥1}) iv
-- conv ← {a←⍵ ⋄ w←⍺ ⋄ ⊃+/,w×{(1+(⍴a)-⍴w)↑⍵↓a}¨⍳⍴w}
conv : ∀ {n s s₁}
→ Ar Float n s
→ Ar Float n s₁
→ {s₁≥s : s→a s₁ ≥a s→a s}
→ let sr = a→s $ (s→a s₁ -ₙ s→a s) {≥ = s₁≥s} +ₙ scal 1
in Ar Float n sr
conv {n = n} {s = s} {s₁ = s₁} w a {s₁≥s} = let
sr = (s→a s₁ -ₙ s→a s) {≥ = s₁≥s} +ₙ scal 1
idxs = ι ρ w
rots ix ix<s = let
~ix≥ρa = A<B⇒B≤C⇒A≤C ix<s s₁≥s
ix↓a = (ix ↓ a) {pf = ~ix≥ρa}
~ix-inb = conv-ix-inb {s₁ = s→a s₁} ix<s s₁≥s
~ρix↓a≥sr = A≥B⇒A≡C⇒C≥B
~ix-inb
(undo-sa-as {s = s} {s₁ = s₁} {≥1 = ~ix≥ρa})
in
(sr ↑ ix↓a) {pf = ~ρix↓a≥sr }
rots-unw ix,ix<s = (let
ix , ix<s = ix,ix<s
in rots ix ix<s)
r = rots-unw ̈ idxs
mul = w ̈⟨ (λ weight arr → arr ×ᵣ scal weight) ⟩ (subst-ar (a→s∘s→a s) r)
res = reduce-1d (, mul) _+ᵣ_ (cst 0.0)
in res
module conv-test where
open import Array.Repr
cex₁ = conv (cst {s = 1 ∷ []} 2.0)
(imap {s = 2 ∷ []} λ { (zero ∷ []) → 2.0 ; (suc zero ∷ []) → 3.0})
{s₁≥s = λ { (zero ∷ []) → s≤s z≤n} }
cex₂ = conv (mkempty (3 ∷ 0 ∷ []) refl)
(cst {s = 5 ∷ 0 ∷ []} 1.0)
{λ { (zero ∷ []) → s≤s (s≤s (s≤s z≤n)) ;
(suc zero ∷ []) → z≤n}}
repex₁ = a→rt cex₁
-- blog←{⍺×⍵×1-⍵}
blog : ∀ {n s} → Ar Float n s → Ar Float n s → Ar Float n s
blog α ω = α ×ᵣ ω ×ᵣ (scal 1.0) -ᵣ ω
-- backbias←{+/,⍵}
backbias : ∀ {n s} → Ar Float n s → Scal Float
backbias ω = _+ᵣ_ / , ω
-- XXX we can define unary -ᵣ and ÷ᵣ to make it even nicer.
-- logistic←{÷1+*-⍵}
logistic : ∀ {n s} → Ar Float n s → Ar Float n s
logistic {s} ω = (scal 1.0) ÷ᵣ (scal 1.0) +ᵣ *ᵣ (scal 0.0) -ᵣ ω
-- XXX Note that even though we had to specify n-n instances
-- explicitly, we didn't truly mimic the APL expression below.
-- As per APL semantics, meansqerr accepts the combination
-- of arguments 0-n, n-n and n-0. So the fact that we had
-- to specialise suggests that we didn't truly implement
-- the original behaviour.
-- meansqerr←{÷∘2+/,(⍺-⍵)*2}
meansqerr : ∀ {n s} → Ar Float n s → Ar Float n s → Scal Float
meansqerr α ω =
_÷⟨ n-n ⟩ᵣ (cst 2.0) $ (_+⟨ n-n ⟩ᵣ_ / , (α -⟨ n-n ⟩ᵣ ω) ×ᵣ (α -⟨ n-n ⟩ᵣ ω))
-- backavgpool←{2⌿2/⍵÷4}⍤2
backavgpool : ∀ {s}
→ Ar Float 2 s
→ Ar Float 2 $ a→s (s→a s ×ₙ (scal 2))
backavgpool {m ∷ n ∷ []} (imap f) =
imap (λ iv → let
ix , ix<r = ix→a iv
px = (ix ÷ₙ (cst 2)) {≥0 = λ _ → s≤s z≤n}
pv = a→ix px (s→a (m ∷ n ∷ [])) λ jv →
let
x = a<b⇒c≤a⇒c<b (ix<r jv) (m/n*n≤m _ 2)
y = a≤b⇒b≡c⇒a≤c x (*-lookup {jv = jv}{m = m}{n = n})
in *-cancelʳ-< _ _ y
in f pv)
÷ᵣ (scal 4.0)
where
*-lookup : ∀ {jv : Ix 1 (2 ∷ [])}{m n}
→ lookup (m * 2 ∷ n * 2 ∷ []) (ix-lookup jv zero)
≡ lookup (m ∷ n ∷ []) (ix-lookup jv zero) * 2
*-lookup {jv = I0} = refl
*-lookup {jv = I1} = refl
-- This should be perfectly generaliseable --- instead of 2
-- we can use any m>0
a<b⇒k<2⇒a*2+k<b*2 : ∀ {a b k} → a < b → k < 2 → a * 2 + k < b * 2
a<b⇒k<2⇒a*2+k<b*2 {a} {b} {zero} a<b k<2
rewrite (+-identityʳ (a * 2))
| (*-comm a 2)
| (*-comm b 2) = *-monoʳ-< 1 a<b
a<b⇒k<2⇒a*2+k<b*2 {a} {b} {suc zero} a<b k<2 = ≤-trans (s≤s (≡⇒≤ (+-comm _ 1)))
(*-monoˡ-≤ 2 a<b)
a<b⇒k<2⇒a*2+k<b*2 {a} {b} {suc (suc k)} a<b (s≤s (s≤s ()))
A<B⇒K<2⇒A*2+K<B*2 : ∀ {n s}{a b k : Ar ℕ n s} → a <a b → k <a (cst 2) → ((a ×ₙ (scal 2)) +ₙ k) <a (b ×ₙ (scal 2))
A<B⇒K<2⇒A*2+K<B*2 {a = imap a} {imap b} {imap k} a<b k<2 = λ iv → a<b⇒k<2⇒a*2+k<b*2 (a<b iv) (k<2 iv)
-- avgpool←{÷∘4{+/,⍵}⌺(2 2⍴2)⍤2⊢⍵}
avgpool-explicit : ∀ {s}
→ Ar Float 2 $ a→s (s→a s ×ₙ (scal 2))
→ Ar Float 2 s
avgpool-explicit {s} (imap p) =
imap (λ iv → let
sh = (s→a s ×ₙ scal 2)
ix , ix<s = ix→a iv
bx = ix ×ₙ scal 2
s-00 = s→a (0 ∷ 0 ∷ [])
i1 = a→ix (bx +ₙ s-00) sh (A<B⇒K<2⇒A*2+K<B*2 {k = s-00} ix<s
λ { I0 → s≤s z≤n; I1 → s≤s z≤n})
s-01 = s→a (0 ∷ 1 ∷ [])
i2 = a→ix (bx +ₙ s-01) sh (A<B⇒K<2⇒A*2+K<B*2 {k = s-01} ix<s
λ { I0 → s≤s z≤n; I1 → s≤s (s≤s z≤n)})
s-10 = s→a (1 ∷ 0 ∷ [])
i3 = a→ix (bx +ₙ s-10) sh (A<B⇒K<2⇒A*2+K<B*2 {k = s-10} ix<s
λ { I0 → s≤s (s≤s z≤n); I1 → s≤s z≤n })
s-11 = s→a (1 ∷ 1 ∷ [])
i4 = a→ix (bx +ₙ s-11) sh (A<B⇒K<2⇒A*2+K<B*2 {k = s-11} ix<s
λ { I0 → s≤s (s≤s z≤n) ; I1 → s≤s (s≤s z≤n) })
s = _÷⟨ n-n ⟩ᵣ (scal 4.0) $
(scal $ p i1) +⟨ n-n ⟩ᵣ (scal $ p i2)
+⟨ n-n ⟩ᵣ (scal $ p i2) +⟨ n-n ⟩ᵣ (scal $ p i3)
+⟨ n-n ⟩ᵣ (scal $ p i4)
in unscal s)
-- avgpool←{÷∘4{+/,⍵}⌺(2 2⍴2)⍤2⊢⍵}
avgpool : ∀ {s}
→ Ar Float 2 $ a→s (s→a s ×ₙ (scal 2))
→ Ar Float 2 s
avgpool {s} (imap p) = imap (λ iv → let
sh = (s→a s ×ₙ scal 2)
ix , ix<s = ix→a iv
bx = ix ×ₙ scal 2
ixs = ι (cst {s = 2 ∷ []} 2)
use-ixs i,pf = let
i , pf = i,pf
jx = bx +⟨ n-n ⟩ₙ i
in p (a→ix jx sh (A<B⇒K<2⇒A*2+K<B*2 ix<s pf))
s = _÷⟨ n-n ⟩ᵣ (scal 4.0) $ _+⟨ n-n ⟩ᵣ_ / , use-ixs ̈ ixs
in unscal s)
-- multiconv←{(a ws bs)←⍵⋄bs{⍺+⍵ conv a}⍤(0,(⍴⍴a))⊢ws}
multiconv : ∀ {n m s sw so} → (a : Ar Float n s)
→ (ws : Ar (Ar Float n sw) m so)
→ (bs : Ar Float m so)
→ {≥ : (s→a s) ≥a (s→a sw)}
→ Ar (Ar Float n (a→s $ ((s→a s -ₙ s→a sw) {≥}) +ₙ (scal 1))) m so
multiconv a ws bs {≥} = bs ̈⟨ (λ b w → (scal b) +ᵣ conv w a {≥}) ⟩ ws
--look-at-avgpl : ∀ {s} → (a : Ar Float 2 $ a→s (s→a s ×ₙ (scal 2))) → avgpool {s = s} a ≡ {!!}
--look-at-avgpl {x₁ ∷ x₂ ∷ []} (imap f) = {!!}
module test-avgpool where
test-avgp = avgpool {s = 1 ∷ 1 ∷ []} (imap λ { (zero ∷ zero ∷ []) → 1.0 ;
(zero ∷ suc zero ∷ []) → 2.0 ;
(suc zero ∷ zero ∷ []) → 3.0 ;
(suc zero ∷ suc zero ∷ []) → 4.0 })
avgp-val = unimap test-avgp $ zero ∷ zero ∷ []
-- This should go into APL operators.
areplicate : ∀ {a}{X : Set a}{s} → (k : ℕ) → Ar X 1 s → Ar X _ _
areplicate k (imap f) = let
x = imap λ iv → imap {d = 1} {s = k ∷ []} λ _ → f iv
in , flatten x
test-repl = a→s $ areplicate 2 $ proj₁ ̈ ι (scal 5)
∸-monoˡ-< : ∀ {m n o} → m < n → o ≤ m → m ∸ o < n ∸ o
∸-monoˡ-< {o = zero} m<n o≤m = m<n
∸-monoˡ-< {suc m} {o = suc o} (s≤s m<n) (s≤s o≤m) = ∸-monoˡ-< m<n o≤m
a+b-a≡a : ∀ {n} {s₁ : Vec ℕ n} {s : Ix 1 (n ∷ []) → ℕ}
{jv : Ix 1 (n ∷ [])} →
lookup (tabulate (λ i → s (i ∷ []) + lookup s₁ i))
(ix-lookup jv zero)
∸ s jv
≡ lookup s₁ (ix-lookup jv zero)
a+b-a≡a {zero} {[]} {s} {x ∷ []} = magic-fin x
a+b-a≡a {suc n} {x ∷ s₁} {s} {I0} = m+n∸m≡n (s I0) x
a+b-a≡a {suc n} {x ∷ s₁} {s} {suc j ∷ []} = a+b-a≡a {s₁ = s₁} {s = λ { (j ∷ []) → s (suc j ∷ [])}} {jv = j ∷ []}
pre-pad : ∀ {a}{X : Set a}{n}{s₁ : Vec ℕ n}
→ (sh : Ar ℕ 1 (n ∷ []))
→ X
→ (a : Ar X n s₁)
→ Ar X n (a→s $ sh +ₙ ρ a)
pre-pad {s₁ = s₁} (imap s) e (imap f) = imap body
where
body : _
body iv = let ix , ix<s = ix→a iv
in case ix ≥a? (imap s) of λ where
(yes p) → let
fx = (ix -ₙ (imap s)) {≥ = p}
fv = a→ix fx (s→a s₁)
λ jv → a<b⇒b≡c⇒a<c
(∸-monoˡ-< (ix<s jv) (p jv))
(a+b-a≡a {s₁ = s₁} {s = s} {jv = jv})
in f (subst-ix (λ i → lookup∘tabulate _ i) fv)
(no ¬p) → e
arel-thm : ∀ {n s}{a b : Ar ℕ n s} → ARel _≥_ a b → a ≥a b
arel-thm {a = imap a} {imap b} pf = pf
≥a-lkup : ∀ {n s}{a b : Ar ℕ n s} → a ≥a b → (iv : Ix n s) → unimap a iv ≥ unimap b iv
≥a-lkup {a = imap a} {imap b} p iv = p iv
_↑⟨_⟩_ : ∀ {a}{X : Set a}{n}{s : Vec ℕ n}
→ (sh : Ar ℕ 1 (n ∷ []))
→ X
→ (a : Ar X n s)
→ Ar X n (a→s sh)
_↑⟨_⟩_ {s = s} (imap sh) e (imap a) = imap body
where
body : _
body iv = let ix , ix<s = ix→a iv
in case ix <a? (ρ imap a) of λ where
(yes p) → let
av = a→ix ix (ρ imap a) p
in a (subst-ix (λ i → lookup∘tabulate _ i) av)
(no ¬p) → e
-- backin←{(d w in)←⍵⋄⊃+/,w{(⍴in)↑(-⍵+⍴d)↑⍺×d}¨⍳⍴w}
backin : ∀ {n s s₁} → (inp : Ar Float n s)
→ (w : Ar Float n s₁)
→ .{≥ : s→a s ≥a s→a s₁}
→ (d : Ar Float n $ a→s $ (s→a s -ₙ s→a s₁) {≥} +ₙ scal 1)
→ Ar Float n s
backin {n}{s}{s₁} inp w d = let
ixs = ι (ρ w)
use-ixs i,pf = let
i , pf = i,pf
iv = (a→ix i (ρ w) pf)
wᵢ = (unimap w) (subst-ix (λ i → lookup∘tabulate _ i) iv)
x = pre-pad i 0.0 (d ×ᵣ scal wᵢ)
y = (ρ inp) ↑⟨ 0.0 ⟩ x
in y
s = reduce-1d (, use-ixs ̈ ixs) _+ᵣ_ (cst 0.0)
in subst-ar (λ i → lookup∘tabulate _ i) s
s-w+1≤s : ∀ {s w} → s ≥ w → s > 0 → w > 0 → s ∸ w + 1 ≤ s
s-w+1≤s {suc s} {suc w} (s≤s s≥w) s>0 w>0 rewrite (+-comm (s ∸ w) 1) = s≤s (m∸n≤m s w)
helper : ∀ {n} {sI sw : Vec ℕ n}
→ s→a sI ≥a s→a sw
→ (cst 0) <a s→a sI
→ (cst 0) <a s→a sw
→ (iv : Ix 1 (n ∷ []))
→ lookup sI (ix-lookup iv zero) ≥
lookup (tabulate (λ i → lookup sI i ∸ lookup sw i + 1))
(ix-lookup iv zero)
helper {sI = sI} {sw} sI≥sw sI>0 sw>0 (x ∷ [])
rewrite (lookup∘tabulate (λ i → lookup sI i ∸ lookup sw i + 1) x) =
s-w+1≤s (sI≥sw (x ∷ [])) (sI>0 (x ∷ [])) (sw>0 (x ∷ []))
-- sI - (sI - sw + 1) + 1 = sw
shape-same : ∀ {n} {sI sw : Vec ℕ n}
→ s→a sI ≥a s→a sw
→ (cst 0) <a s→a sI
→ (cst 0) <a s→a sw
→ (i : Fin n)
→ lookup
(tabulate
(λ i₁ →
lookup sI i₁ ∸
lookup (tabulate (λ i₂ → lookup sI i₂ ∸ lookup sw i₂ + 1)) i₁
+ 1))
i
≡ lookup sw i
shape-same {suc n} {x ∷ sI} {y ∷ sw} I≥w I>0 w>0 zero =
begin
x ∸ (x ∸ y + 1) + 1 ≡⟨ sym $ +-∸-comm {m = x} 1 {o = (x ∸ y + 1)} (s-w+1≤s (I≥w I0) (I>0 I0) (w>0 I0)) ⟩
x + 1 ∸ (x ∸ y + 1) ≡⟨ cong (x + 1 ∸_) (sym $ +-∸-comm {m = x} 1 {o = y} (I≥w I0)) ⟩
x + 1 ∸ (x + 1 ∸ y) ≡⟨ m∸[m∸n]≡n {m = x + 1} {n = y} (a≤b⇒b≡c⇒a≤c (≤-step $ I≥w I0) (+-comm 1 x)) ⟩
y
∎
where open ≡-Reasoning
shape-same {suc n} {x ∷ sI} {x₁ ∷ sw} I≥w I>0 w>0 (suc i) =
shape-same {sI = sI} {sw = sw} (λ { (i ∷ []) → I≥w (suc i ∷ []) })
(λ { (i ∷ []) → I>0 (suc i ∷ []) })
(λ { (i ∷ []) → w>0 (suc i ∷ []) }) i
{-backmulticonv ← {
(d_out weights in bias) ← ⍵
d_in ← +⌿d_out {backin ⍺ ⍵ in} ⍤((⍴⍴in), (⍴⍴in)) ⊢ weights
d_w ← {⍵ conv in} ⍤(⍴⍴in) ⊢ d_out
d_bias ← backbias ⍤(⍴⍴in) ⊢ d_out
d_in d_w d_bias
}-}
backmulticonv : ∀ {n m}{sI sw so}
→ (W : Ar (Ar Float n sw) m so)
→ (I : Ar Float n sI)
→ (B : Ar Float m so)
-- We can get rid of these two expressions if we rewrite
-- the convolution to accept s+1 ≥ w, and not s ≥ w.
→ {>I : (cst 0) <a s→a sI}
→ {>w : (cst 0) <a s→a sw}
→ {≥ : s→a sI ≥a s→a sw}
→ (δo : Ar (Ar Float n (a→s $ (s→a sI -ₙ s→a sw) {≥} +ₙ (scal 1))) m so)
→ (typeOf W) × (typeOf I) × (typeOf B)
backmulticonv {sI = sI} {sw} {so} W I B {sI>0} {sw>0} {sI≥sw} δo = let
δI = reduce-1d (, (W ̈⟨ (λ x y → backin I x {sI≥sw} y) ⟩ δo)) _+ᵣ_ (cst 0.0)
δW = (λ x → conv x I {s₁≥s = helper {sI = sI} {sw = sw} sI≥sw sI>0 sw>0}) ̈ δo
δB = backbias ̈ δo
in (imap (λ iv → subst-ar (shape-same {sI = sI} {sw = sw} sI≥sw sI>0 sw>0) ((unimap δW) iv)) ,
δI ,
imap (λ iv → unscal $ unimap δB iv))
instance
auto≥ : ∀ {m n : ℕ} → {{_ : True (m ≥? n)}} → m ≥ n
auto≥ {m} {n} {{c}} = toWitness c
auto≥a : ∀ {d s}{p q : Ar ℕ d s} {_ : True (p ≥a? q)} → (p ≥a q)
auto≥a {p = imap x} {imap x₁} { c } = toWitness c
auto<a : ∀ {d s}{p q : Ar ℕ d s} {{_ : True (p <a? q)}} → (p <a q)
auto<a {p = imap x} {imap x₁} ⦃ c ⦄ = toWitness c
test-zhang : (inp : Ar Float _ (28 ∷ 28 ∷ []))
→ (k₁ : Ar Float _ (6 ∷ 5 ∷ 5 ∷ []))
→ (b₁ : Ar Float _ (6 ∷ []))
→ (k₂ : Ar Float _ (12 ∷ 6 ∷ 5 ∷ 5 ∷ []))
→ (b₂ : Ar Float _ (12 ∷ []))
→ (fc : Ar Float _ (10 ∷ 12 ∷ 1 ∷ 4 ∷ 4 ∷ []))
→ (b : Ar Float _ (10 ∷ []))
→ Ar Float _ (10 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ [])
test-zhang inp k₁ b₁ k₂ b₂ fc b = let
c₁ = logistic ̈ multiconv inp (nest k₁) b₁ {auto≥a}
s₁ = avgpool {s = 12 ∷ 12 ∷ []} ̈ c₁
c₂ = logistic ̈ multiconv (flatten s₁) (nest k₂) b₂ {auto≥a}
s₂ = avgpool {s = 4 ∷ 4 ∷ []} ̈ (nest {s = _ ∷ _ ∷ []} $ flatten c₂)
r = logistic ̈ multiconv (flatten s₂) (nest fc) b {auto≥a}
in flatten r
train-zhang :(inp : Ar Float _ (28 ∷ 28 ∷ []))
→ (k₁ : Ar Float _ (6 ∷ 5 ∷ 5 ∷ []))
→ (b₁ : Ar Float _ (6 ∷ []))
→ (k₂ : Ar Float _ (12 ∷ 6 ∷ 5 ∷ 5 ∷ []))
→ (b₂ : Ar Float _ (12 ∷ []))
→ (fc : Ar Float _ (10 ∷ 12 ∷ 1 ∷ 4 ∷ 4 ∷ []))
→ (b : Ar Float _ (10 ∷ []))
→ (target : Ar Float _ (10 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ []))
→ typeOf k₁ × typeOf b₁ × typeOf k₂ × typeOf b₂ × typeOf fc × typeOf b × Scal Float
train-zhang inp k₁ b₁ k₂ b₂ fc b target = let
c₁ = logistic ̈ multiconv inp (nest k₁) b₁ {auto≥a}
s₁ = avgpool {s = 12 ∷ 12 ∷ []} ̈ c₁
c₂ = logistic ̈ multiconv (flatten s₁) (nest k₂) b₂ {auto≥a}
s₂ = avgpool {s = 4 ∷ 4 ∷ []} ̈ (nest {s = _ ∷ _ ∷ []} $ flatten c₂)
o = flatten $ logistic ̈ multiconv (flatten s₂) (nest fc) b {auto≥a}
δo = o -ᵣ target
ε = meansqerr (, o) (, target)
δfc , δs₂ , δb = backmulticonv (nest fc) (flatten s₂) b {>I = auto<a} {>w = auto<a} {≥ = auto≥a}
(nest (blog δo o))
δc₂ = backavgpool ̈ (nest {s = _ ∷ _ ∷ []} δs₂)
δk₂ , δs₁ , δb₂ = backmulticonv (nest k₂) (flatten s₁) b₂ {>I = auto<a} {>w = auto<a} {≥ = auto≥a}
(nest (blog (flatten δc₂) (flatten c₂)))
δc₁ = backavgpool ̈ (nest {s = _ ∷ []} δs₁)
δk₁ , _ , δb₁ = backmulticonv (nest k₁) inp b₁ {>I = auto<a} {>w = auto<a} {≥ = auto≥a}
(nest (blog (flatten δc₁) (flatten c₁)))
in (flatten δk₁) , δb₁ , (flatten δk₂) , δb₂ , (flatten δfc) , δb , ε
| {
"alphanum_fraction": 0.407226827,
"avg_line_length": 38.6981132075,
"ext": "agda",
"hexsha": "6413515fbab965412ba9b7af1f7d2afffdfdf9c3",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2020-10-12T07:19:48.000Z",
"max_forks_repo_forks_event_min_datetime": "2020-10-12T07:19:48.000Z",
"max_forks_repo_head_hexsha": "584fedb30552f820c0668cedae53ec3d926860b5",
"max_forks_repo_licenses": [
"0BSD"
],
"max_forks_repo_name": "ashinkarov/agda-array",
"max_forks_repo_path": "CNN.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "584fedb30552f820c0668cedae53ec3d926860b5",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"0BSD"
],
"max_issues_repo_name": "ashinkarov/agda-array",
"max_issues_repo_path": "CNN.agda",
"max_line_length": 113,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "584fedb30552f820c0668cedae53ec3d926860b5",
"max_stars_repo_licenses": [
"0BSD"
],
"max_stars_repo_name": "ashinkarov/agda-array",
"max_stars_repo_path": "CNN.agda",
"max_stars_repo_stars_event_max_datetime": "2021-06-15T14:21:32.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-05-09T13:53:46.000Z",
"num_tokens": 8810,
"size": 18459
} |
data Dec (A : Set) : Set where
yes : A → Dec A
no : Dec A
record ⊤ : Set where constructor tt
data _≡_ {A : Set}(x : A) : A → Set where
refl : x ≡ x
subst : ∀ {A}(P : A → Set){x y} → x ≡ y → P x → P y
subst P refl px = px
cong : ∀ {A B}(f : A → B){x y} → x ≡ y → f x ≡ f y
cong f refl = refl
postulate _≟_ : (n n' : ⊤) → Dec (n ≡ n')
record _×_ A B : Set where
constructor _,_
field proj₁ : A
proj₂ : B
open _×_
data Maybe : Set where
nothing : Maybe
data Blah (a : Maybe × ⊤) : Set where
blah : {b : Maybe × ⊤} → Blah b → Blah a
update : {A : Set} → ⊤ → A → A
update n m with n ≟ n
update n m | yes p = m
update n m | no = m
lem-upd : ∀ {A} n (m : A) → update n m ≡ m
lem-upd n m with n ≟ n
... | yes p = refl
... | no = refl
bug : {x : Maybe × ⊤} → proj₁ x ≡ nothing → Blah x
bug ia = blah (bug (subst {⊤}
(λ _ → proj₁ {B = ⊤}
(update tt (nothing , tt)) ≡ nothing)
refl (cong proj₁ (lem-upd _ _))))
| {
"alphanum_fraction": 0.4765166341,
"avg_line_length": 21.7446808511,
"ext": "agda",
"hexsha": "c51138e15fa1d5375f9b1ff941cf2033b8f10dec",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "redfish64/autonomic-agda",
"max_forks_repo_path": "test/Fail/Issue970.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "redfish64/autonomic-agda",
"max_issues_repo_path": "test/Fail/Issue970.agda",
"max_line_length": 72,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "redfish64/autonomic-agda",
"max_stars_repo_path": "test/Fail/Issue970.agda",
"max_stars_repo_stars_event_max_datetime": "2015-12-07T20:14:00.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-03-28T14:51:03.000Z",
"num_tokens": 401,
"size": 1022
} |
open import Common.Prelude
open import TestHarness
open import TestBool using ( not; _∧_ ; _↔_ )
module TestList where
_++_ : ∀ {X} → List X → List X → List X
[] ++ ys = ys
(x ∷ xs) ++ ys = x ∷ (xs ++ ys)
revApp : ∀ {X} → List X → List X → List X
revApp [] ys = ys
revApp (x ∷ xs) ys = revApp xs (x ∷ ys)
reverse : ∀ {X} → List X → List X
reverse xs = revApp xs []
_≟_ : List Bool → List Bool → Bool
[] ≟ [] = true
(x ∷ xs) ≟ (y ∷ ys) = (x ↔ y) ∧ (xs ≟ ys)
_ ≟ - = false
[tt] = true ∷ []
[ff] = false ∷ []
[tt,ff] = true ∷ [ff]
[ff,tt] = false ∷ [tt]
[ff,tt,ff] = false ∷ [tt,ff]
tests : Tests
tests _ = (
assert ([] ≟ []) "[]=[]" ,
assert (not ([tt] ≟ [ff])) "[tt]≠[ff]" ,
assert (([] ++ [tt]) ≟ [tt]) "[]++[tt]=[tt]" ,
assert (([tt] ++ []) ≟ [tt]) "[tt]++[]=[tt]" ,
assert (([tt] ++ [ff]) ≟ [tt,ff]) "[tt]++[ff]=[tt,ff]" ,
assert (([ff,tt] ++ [ff]) ≟ [ff,tt,ff]) "[ff,tt]++[ff]=[ff,tt,ff]" ,
assert (not (([ff] ++ [tt]) ≟ [tt,ff])) "[ff]++[tt]≠[tt,ff]" ,
assert (not (([tt] ++ [tt]) ≟ [tt,ff])) "[tt]++[tt]≠[tt,ff]" ,
assert (reverse [tt,ff] ≟ [ff,tt]) "rev[tt,ff]=[ff,tt]" ,
assert (reverse (reverse [tt,ff]) ≟ [tt,ff]) "rev(rev[tt,ff])=[tt,ff]" ,
assert (not (reverse [tt,ff] ≟ [tt,ff])) "rev[tt,ff]≠[tt,ff]"
)
| {
"alphanum_fraction": 0.4479326187,
"avg_line_length": 30.3720930233,
"ext": "agda",
"hexsha": "ad492116f1723f8f3dabcf4169b72b073e06c42d",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "redfish64/autonomic-agda",
"max_forks_repo_path": "test/js/TestList.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "redfish64/autonomic-agda",
"max_issues_repo_path": "test/js/TestList.agda",
"max_line_length": 76,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "redfish64/autonomic-agda",
"max_stars_repo_path": "test/js/TestList.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 565,
"size": 1306
} |
{-# OPTIONS --safe #-}
module Data.Vec.Sigma where
open import Prelude
open import Data.Unit.UniversePolymorphic renaming (⊤ to ⊤′)
Vec⁺ : Type a → ℕ → Type a
Vec⁺ A zero = A
Vec⁺ A (suc n) = A × Vec⁺ A n
Vec : Type a → ℕ → Type a
Vec A 0 = ⊤′
Vec A (suc n) = Vec⁺ A n
private variable n : ℕ
open import Data.List using (List; _∷_; [])
toList⁺ : Vec⁺ A n → List A
toList⁺ {n = zero } x = x ∷ []
toList⁺ {n = suc n} (x , xs) = x ∷ toList⁺ xs
toList : Vec A n → List A
toList {n = zero } _ = []
toList {n = suc n} = toList⁺
| {
"alphanum_fraction": 0.5751391466,
"avg_line_length": 19.962962963,
"ext": "agda",
"hexsha": "830079aefcb081c56ea638330dc8de63e2431317",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "oisdk/agda-playground",
"max_forks_repo_path": "Data/Vec/Sigma.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "oisdk/agda-playground",
"max_issues_repo_path": "Data/Vec/Sigma.agda",
"max_line_length": 60,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "oisdk/agda-playground",
"max_stars_repo_path": "Data/Vec/Sigma.agda",
"max_stars_repo_stars_event_max_datetime": "2021-11-16T08:11:34.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-09-11T17:45:41.000Z",
"num_tokens": 210,
"size": 539
} |
-- Regression, introduced by the fix of issue 1759
module Issue1815 where
module _ (A : Set) where
record R1 : Set where
field f1 : A
record R2 : Set where
field f2 : R1
open R1 f2 public
-- Parameter A is hidden in type of field f1 in R1 ...
test1 : ∀ A (r : R1 A) → A
test1 A r = R1.f1 r
-- ... and should be so in the type of field f1 in R2, too.
shouldFail : ∀ A (r : R2 A) → A
shouldFail A r = R2.f1 A r
| {
"alphanum_fraction": 0.626450116,
"avg_line_length": 20.5238095238,
"ext": "agda",
"hexsha": "d80603649db04ec2b341bfd4a7b7c2de4eca6e0f",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Fail/Issue1815.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Fail/Issue1815.agda",
"max_line_length": 59,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Fail/Issue1815.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 154,
"size": 431
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.Vec.Relation.Binary.Equality.Propositional directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Vec.Relation.Equality.Propositional where
open import Data.Vec.Relation.Binary.Equality.Propositional public
| {
"alphanum_fraction": 0.5170842825,
"avg_line_length": 33.7692307692,
"ext": "agda",
"hexsha": "bfd71856248ea45fcff7f64e02d6dbfe1c6bd360",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "omega12345/agda-mode",
"max_forks_repo_path": "test/asset/agda-stdlib-1.0/Data/Vec/Relation/Equality/Propositional.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "omega12345/agda-mode",
"max_issues_repo_path": "test/asset/agda-stdlib-1.0/Data/Vec/Relation/Equality/Propositional.agda",
"max_line_length": 72,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "omega12345/agda-mode",
"max_stars_repo_path": "test/asset/agda-stdlib-1.0/Data/Vec/Relation/Equality/Propositional.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 72,
"size": 439
} |
open import Issue1251.NonTerminating
| {
"alphanum_fraction": 0.8918918919,
"avg_line_length": 18.5,
"ext": "agda",
"hexsha": "3a1335688690e338786654b7df22703e470e5dcd",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Fail/Issue1251.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Fail/Issue1251.agda",
"max_line_length": 36,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Fail/Issue1251.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 9,
"size": 37
} |
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
open import Agda.Builtin.Float
data ⊥ : Set where
defNegZero : -0.0 ≡ 0.0 → ⊥
defNegZero ()
primEqNegZero : primFloatEquality -0.0 0.0 ≡ false
primEqNegZero = refl
primLtNegZero₁ : primFloatNumericalLess 0.0 -0.0 ≡ false
primLtNegZero₁ = refl
primLtNegZero₂ : primFloatNumericalLess -0.0 0.0 ≡ false
primLtNegZero₂ = refl
primShowNegZero : primShowFloat -0.0 ≡ "-0.0"
primShowNegZero = refl
| {
"alphanum_fraction": 0.7554112554,
"avg_line_length": 21,
"ext": "agda",
"hexsha": "08d51caa544dfa0c967a64dcbebe90ecac1c7504",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "pthariensflame/agda",
"max_forks_repo_path": "test/Succeed/Issue2169.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "pthariensflame/agda",
"max_issues_repo_path": "test/Succeed/Issue2169.agda",
"max_line_length": 56,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "pthariensflame/agda",
"max_stars_repo_path": "test/Succeed/Issue2169.agda",
"max_stars_repo_stars_event_max_datetime": "2015-12-07T20:14:00.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-03-28T14:51:03.000Z",
"num_tokens": 170,
"size": 462
} |
{-# OPTIONS --universe-polymorphism #-}
open import Categories.Category
open import Categories.Object.BinaryProducts
open import Categories.Object.Exponentiating
module Categories.Object.Exponentiating.Adjunction {o ℓ e}
(C : Category o ℓ e)
(binary : BinaryProducts C)
(Σ : Category.Obj C)
(exponentiating : Exponentiating C binary Σ) where
open Category C
open BinaryProducts binary
open Exponentiating exponentiating
import Categories.Object.Product
open Categories.Object.Product C
import Categories.Object.Product.Morphisms
open Categories.Object.Product.Morphisms C
open Equiv
open HomReasoning
import Categories.Object.Exponentiating.Functor
open Categories.Object.Exponentiating.Functor C binary Σ exponentiating
open import Categories.Functor
using (Functor; Contravariant)
renaming (id to idF; _≡_ to _≡F_; _∘_ to _∘F_)
open import Categories.Adjunction hiding (_≡_; id)
open import Categories.NaturalTransformation
using (NaturalTransformation; module NaturalTransformation)
open import Categories.Monad
using (Monad)
Σ↑-Self-Adjunction : Adjunction (Functor.op Σ↑-Functor) Σ↑-Functor
Σ↑-Self-Adjunction = record
{ unit = record
{ η = λ _ → flip id
; commute = unit-commute
}
; counit = record
{ η = λ _ → flip id
; commute = counit-commute
}
; zig = zig-zag
; zag = zig-zag
} where
.lem₁ : ∀{A B C D}{f : (B × C) ⇒ D}{g : A ⇒ (C × B)}
→ (f ∘ swap ∘ second id) ∘ g
≡ f ∘ swap ∘ g
lem₁ {A}{B}{C}{D}{f}{g} =
begin
(f ∘ swap ∘ second id) ∘ g
↓⟨ (refl ⟩∘⟨ refl ⟩∘⟨ second-id product) ⟩∘⟨ refl ⟩
(f ∘ swap ∘ id) ∘ g
↓⟨ (refl ⟩∘⟨ identityʳ) ⟩∘⟨ refl ⟩
(f ∘ swap) ∘ g
↓⟨ assoc ⟩
f ∘ swap ∘ g
∎
.lem₂ : ∀ {X Y}{f : X ⇒ Y}
→ eval {Σ↑ Y} ∘ first (flip id ∘ f)
≡ eval {X} ∘ swap ∘ second [Σ↑ f ]
lem₂ {X}{Y}{f} =
begin
eval {Σ↑ Y} ∘ first (flip id ∘ f)
↑⟨ refl ⟩∘⟨ first∘first ⟩
eval {Σ↑ Y} ∘ first (flip id) ∘ first f
↑⟨ assoc ⟩
(eval {Σ↑ Y} ∘ first (flip id)) ∘ first f
↓⟨ β ⟩∘⟨ refl ⟩
(eval {Y} ∘ swap ∘ second id) ∘ first f
↓⟨ lem₁ ⟩
eval {Y} ∘ swap ∘ first f
↓⟨ refl ⟩∘⟨ swap∘⁂ ⟩
eval {Y} ∘ second f ∘ swap
↑⟨ assoc ⟩
(eval {Y} ∘ second f) ∘ swap
↑⟨ β ⟩∘⟨ refl ⟩
(eval {X} ∘ first (λ-abs X (eval {Y} ∘ second f))) ∘ swap
↓⟨ assoc ⟩
eval {X} ∘ first (λ-abs X (eval {Y} ∘ second f)) ∘ swap
↑⟨ refl ⟩∘⟨ swap∘⁂ ⟩
eval {X} ∘ swap ∘ second (λ-abs X (eval ∘ second f))
∎
.unit-commute : ∀ {X Y} (f : X ⇒ Y)
→ flip id ∘ f ≡ [Σ² f ] ∘ flip id
unit-commute {X}{Y} f =
begin
flip id ∘ f
↓⟨ λ-unique lem₂ ⟩
flip [Σ↑ f ]
↑⟨ λ-cong lem₁ ⟩
λ-abs (Σ↑ Y) ((eval {X} ∘ swap ∘ second id) ∘ second [Σ↑ f ])
↓⟨ λ-distrib ⟩
[Σ↑ [Σ↑ f ] ] ∘ flip id
∎
.counit-commute : ∀ {X Y} (f : X ⇒ Y)
→ [Σ² f ] ∘ flip id ≡ flip id ∘ f
counit-commute f = sym (unit-commute f)
.zig-zag : ∀{X}
→ id ≡ [Σ↑ flip id ] ∘ flip id
zig-zag {X} =
begin
id
↑⟨ flip² ⟩
flip (flip id)
↑⟨ λ-cong lem₁ ⟩
λ-abs X ((eval ∘ swap ∘ second id) ∘ second (flip id))
↓⟨ λ-distrib ⟩
[Σ↑ flip id ] ∘ flip id
∎
| {
"alphanum_fraction": 0.5332940483,
"avg_line_length": 28.2833333333,
"ext": "agda",
"hexsha": "f8d51fff80869e07c8a5f48025e20f53c1b8ad57",
"lang": "Agda",
"max_forks_count": 23,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T13:50:56.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-02-05T13:03:09.000Z",
"max_forks_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "p-pavel/categories",
"max_forks_repo_path": "Categories/Object/Exponentiating/Adjunction.agda",
"max_issues_count": 19,
"max_issues_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2",
"max_issues_repo_issues_event_max_datetime": "2019-08-09T16:31:40.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-05-23T06:47:10.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "p-pavel/categories",
"max_issues_repo_path": "Categories/Object/Exponentiating/Adjunction.agda",
"max_line_length": 71,
"max_stars_count": 98,
"max_stars_repo_head_hexsha": "36f4181d751e2ecb54db219911d8c69afe8ba892",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "copumpkin/categories",
"max_stars_repo_path": "Categories/Object/Exponentiating/Adjunction.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-08T05:20:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-04-15T14:57:33.000Z",
"num_tokens": 1285,
"size": 3394
} |
module Test where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
module Q where
module R where
f : Nat -> Nat
f n = suc n
module B (n : Nat) where
open Q.R public
q = f n
module Bz = B zero
postulate
_==_ : {A : Set} -> A -> A -> Set
refl : {A : Set}{x : A} -> x == x
| {
"alphanum_fraction": 0.53,
"avg_line_length": 13.0434782609,
"ext": "agda",
"hexsha": "d9e1aeb510f0709a0b68198b35b57f0a4917756e",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "masondesu/agda",
"max_forks_repo_path": "src/prototyping/modules/flat/Test.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "masondesu/agda",
"max_issues_repo_path": "src/prototyping/modules/flat/Test.agda",
"max_line_length": 35,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/agda-kanso",
"max_stars_repo_path": "src/prototyping/modules/flat/Test.agda",
"max_stars_repo_stars_event_max_datetime": "2019-11-27T04:41:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-11-27T04:41:05.000Z",
"num_tokens": 112,
"size": 300
} |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.DStructures.Equivalences.GroupSplitEpiAction where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Function
open import Cubical.Foundations.Structure
open import Cubical.Data.Sigma
open import Cubical.Data.Unit
open import Cubical.Relation.Binary
open import Cubical.Structures.Subtype
open import Cubical.Algebra.Group
open import Cubical.Structures.LeftAction
open import Cubical.Algebra.Group.Semidirect
open import Cubical.DStructures.Base
open import Cubical.DStructures.Meta.Isomorphism
open import Cubical.DStructures.Structures.Group
open import Cubical.DStructures.Structures.SplitEpi
open import Cubical.DStructures.Structures.Action
open Kernel
open GroupHom -- such .fun!
open GroupLemmas
open MorphismLemmas
{-
After associating, we have two DURGs over Grp
Grp × LAS × isAction Grp × (F × B) × isSecRet
| |
\ /
Grp
Action gives split mono:
α π₂
G₀ --> H ↦ G₀ ↔ H ⋊⟨ α ⟩ G₀
ι₂
Split mono gives Action:
σ Ad∘ι
G₀ ↔ G₁ ↦ G₀ --> ker σ
ι
-}
module _ (ℓ ℓ' : Level) where
𝒮ᴰ-Iso-GroupAct-SplitEpi-* : 𝒮ᴰ-♭PIso (idfun (Group {ℓ}))
(𝒮ᴰ-G\GLasAction ℓ (ℓ-max ℓ ℓ'))
(𝒮ᴰ-G\GFBSplitEpi ℓ (ℓ-max ℓ ℓ'))
RelIso.fun (𝒮ᴰ-Iso-GroupAct-SplitEpi-* G₀) (H , _α_ , isAct) = H⋊G₀ , (ι₂ α , π₂ α) , π₂-hasSec α
where
-- combine the action structure and axioms
α = groupaction _α_ isAct
-- semidirect product induced by the action α
H⋊G₀ : Group {ℓ-max ℓ ℓ'}
H⋊G₀ = H ⋊⟨ α ⟩ G₀
RelIso.inv (𝒮ᴰ-Iso-GroupAct-SplitEpi-* G₀) (G₁ , (ι , σ) , isSplit) = ker-σ , _α_ , isAct
where
open GroupNotation₀ G₀
open GroupNotation₁ G₁
open SplitEpiNotation ι σ isSplit
open IsGroupAction
-- G₀ will act on ker σ
ker-σ : Group {ℓ-max ℓ ℓ'}
ker-σ = ker σ
-- notation: group operation of ker σ
_+ₖ_ = GroupStr._+_ (snd ker-σ)
-- the left action structure of G₀ on ker σ
-- is given by
-- g α h := ιg + h - ιg
_α_ : LeftActionStructure ⟨ G₀ ⟩ ⟨ ker-σ ⟩
g α (h , p) = (ig +₁ h) -₁ ig , q
where
ig = 𝒾 g
abstract
-- proof that (ig +₁ h) -₁ ig
-- lies in ker-σ
q = s ((ig +₁ h) -₁ ig)
≡⟨ σ .isHom (ig +₁ h) (-₁ ig) ⟩
s (ig +₁ h) +₀ s (-₁ ig)
≡⟨ cong (s (ig +₁ h) +₀_)
(mapInv σ ig) ⟩
s (ig +₁ h) -₀ si g
≡⟨ cong (_+₀ -₀ (s ig))
(σ .isHom ig h) ⟩
(si g +₀ s h) -₀ si g
≡⟨ cong (λ z → ((si g) +₀ z) -₀ (si g))
p ⟩
((si g) +₀ 0₀) -₀ (si g)
≡⟨ cong (_+₀ -₀ (s ig))
(rId₀ (s ig)) ⟩
(si g) -₀ (si g)
≡⟨ rCancel₀ (si g) ⟩
0₀ ∎
-- proof that the left action structure α
-- satisfies the group action axioms
abstract
isAct : IsGroupAction G₀ ker-σ _α_
-- at every g, g α_ is a homomorphism, that is
-- g α (h + h') ≡ g α h + g α h'
isAct .isHom g (h , p) (h' , p') = subtypeWitnessIrrelevance (sg-typeProp σ) q
where
ig = ι .fun g
-ig = -₁ ig
q = fst (g α ((h , p) +ₖ (h' , p')))
≡⟨ refl ⟩
(ig +₁ (h +₁ h')) -₁ ig
≡⟨ cong (λ z → (ig +₁ (z +₁ h')) +₁ (-₁ ig))
(sym (rId₁ h)
∙ cong (h +₁_) (sym (lCancel₁ ig))) ⟩
(ig +₁ ((h +₁ (-ig +₁ ig)) +₁ h')) -₁ ig
≡⟨ cong (λ z → (ig +₁ (z +₁ h')) -₁ ig)
(assoc₁ h -ig ig) ⟩
(ig +₁ (((h +₁ -ig) +₁ ig) +₁ h')) -₁ ig
≡⟨ cong (λ z → (ig +₁ z) -₁ ig)
(sym (assoc₁ (h -₁ ig) ig h')) ⟩
(ig +₁ ((h +₁ -ig) +₁ (ig +₁ h'))) -₁ ig
≡⟨ cong (_+₁ -ig)
(assoc₁ ig (h -₁ ig) (ig +₁ h')) ⟩
((ig +₁ (h +₁ -ig)) +₁ (ig +₁ h')) -₁ ig
≡⟨ cong (λ z → (z +₁ (ig +₁ h')) -₁ ig)
(assoc₁ ig h -ig) ⟩
(((ig +₁ h) +₁ -ig) +₁ (ig +₁ h')) -₁ ig
≡⟨ sym (assoc₁ ((ig +₁ h) -₁ ig) (ig +₁ h') -ig) ⟩
((ig +₁ h) +₁ -ig) +₁ ((ig +₁ h') +₁ -ig)
≡⟨ refl ⟩
fst ((g α (h , p)) +ₖ (g α (h' , p'))) ∎
-- α satisfies the identity law, that is
-- 0 α h = h for every h
isAct .identity (h , p) = subtypeWitnessIrrelevance (sg-typeProp σ) q
where
q = fst (0₀ α (h , p))
≡⟨ cong (λ z → (z +₁ h) +₁ (-₁ z))
(mapId ι) ⟩
(0₁ +₁ h) +₁ (-₁ 0₁)
≡⟨ cong ((0₁ +₁ h) +₁_)
(invId G₁) ∙∙
rId₁ (0₁ +₁ h) ∙∙
lId₁ h ⟩
h ∎
-- α is associative in the sense that
-- (g +₀ g') α h = g α (g' α h)
isAct .assoc g g' (h , p) = subtypeWitnessIrrelevance (sg-typeProp σ) q
where
ig = ι .fun g
ig' = ι .fun g'
-ig = -₁ ig
-ig' = -₁ ig'
q = (ι .fun (g +₀ g') +₁ h) -₁ (ι .fun (g +₀ g'))
≡⟨ cong (λ z → (z +₁ h) -₁ z)
(ι .isHom g g') ⟩
((ig +₁ ig') +₁ h) -₁ (ig +₁ ig')
≡⟨ cong (((ig +₁ ig') +₁ h) +₁_)
(invDistr G₁ ig ig') ⟩
((ig +₁ ig') +₁ h) +₁ (-ig' -₁ ig)
≡⟨ cong (_+₁ (-ig' +₁ -ig))
(sym (assoc₁ ig ig' h)) ⟩
(ig +₁ (ig' +₁ h)) +₁ (-ig' -₁ ig)
≡⟨ assoc₁ (ig +₁ (ig' +₁ h)) -ig' -ig ⟩
((ig +₁ (ig' +₁ h)) -₁ ig') -₁ ig
≡⟨ cong (_+₁ -ig)
(sym (assoc₁ ig (ig' +₁ h) -ig')) ⟩
fst (g α (g' α (h , p))) ∎
-- end of abstract
RelIso.rightInv (𝒮ᴰ-Iso-GroupAct-SplitEpi-* G₀) (G₁ , (ι , σ) , isSplit) = G₁-≅ , (ι-≅ , σ-≅) , isSplit-≅
where
-- get our hands dirty with shameless reference to what we're constructing,
-- such is the power of copatterns!
-- back: turn the given split epi into the group action tuple ga
ga = RelIso.inv (𝒮ᴰ-Iso-GroupAct-SplitEpi-* G₀) (G₁ , (ι , σ) , isSplit)
-- map ga forth to the split epi tuple se'
se' = RelIso.fun (𝒮ᴰ-Iso-GroupAct-SplitEpi-* G₀) ga
-- notation
-- short for (ker σ) ⋊⟨ Adᵢ ⟩ G₀
kσ⋊G₀ = fst se'
-- the group action ga
_α_ = fst (snd ga)
isAct = snd (snd ga)
open GroupNotation₀ G₀
open GroupNotation₁ G₁
-- notational convention:
-- g : ⟨ G₀ ⟩
-- h : ⟨ G₁ ⟩
-- p : witness that g is in ker σ
open SplitEpiNotation ι σ isSplit
-- (ker σ) ⋊⟨ Adᵢ ⟩ G₀ ≃ G₁
G₁-≅ : GroupEquiv kσ⋊G₀ G₁
GroupEquiv.eq G₁-≅ = isoToEquiv isom
where
isom : Iso ⟨ kσ⋊G₀ ⟩ ⟨ G₁ ⟩
-- map forth is straight forward
Iso.fun isom ((h , p) , g) = h +₁ 𝒾 g
-- beginning of Iso.inv isom h
-- G₁ part of the map
fst (fst (Iso.inv isom h)) = h +₁ (is- h)
-- proof that G₁ part is in ker σ
snd (fst (Iso.inv isom h)) = q
where
abstract
q = s (h +₁ is- h)
≡⟨ σ .isHom h (is- h) ⟩
s h +₀ s (is- h)
≡⟨ cong (s h +₀_)
(funExt⁻ (cong GroupHom.fun isSplit) (s- h)) ⟩
s h +₀ (s- h)
≡⟨ cong (s h +₀_)
(mapInv σ h) ⟩
s h -₀ (s h)
≡⟨ rCancel₀ (s h) ⟩
0₀ ∎
-- G₀ part of the map
snd (Iso.inv isom h) = s h
-- end of Iso.inv isom h
-- beginning of Iso.leftInv isom ((h , p) , g)
Iso.leftInv isom ((h , p) , g) = ΣPathP (subtypeWitnessIrrelevance (sg-typeProp σ) q , q')
where
abstract
q = (h +₁ 𝒾 g) +₁ is- (h +₁ 𝒾 g)
≡⟨ cong (λ z → (h +₁ 𝒾 g) +₁ is z)
(invDistr G₁ h (𝒾 g)) ⟩
(h +₁ 𝒾 g) +₁ is ((-i g) -₁ h)
≡⟨ cong (λ z → (h +₁ 𝒾 g) +₁ 𝒾 z)
(σ .isHom (-i g) (-₁ h)) ⟩
(h +₁ 𝒾 g) +₁ 𝒾 ((s-i g) +₀ (s- h))
≡⟨ cong (λ z → (h +₁ 𝒾 g) +₁ 𝒾 ((s-i g) +₀ z))
(mapInv σ h ∙∙
cong -₀_ p ∙∙
invId G₀) ⟩
(h +₁ 𝒾 g) +₁ 𝒾 ((s-i g) +₀ 0₀)
≡⟨ cong (λ z → (h +₁ 𝒾 g) +₁ 𝒾 z)
(rId₀ (s-i g)) ⟩
(h +₁ 𝒾 g) +₁ 𝒾 (s-i g)
≡⟨ cong (λ z → (h +₁ 𝒾 g) +₁ 𝒾 z )
(mapInv σ (𝒾 g)) ⟩
(h +₁ 𝒾 g) +₁ 𝒾 (-si g)
≡⟨ cong ((h +₁ 𝒾 g) +₁_)
(mapInv ι (si g)) ⟩
(h +₁ 𝒾 g) -₁ (isi g)
≡⟨ cong (λ z → (h +₁ 𝒾 g) -₁ (𝒾 z))
(funExt⁻ (cong GroupHom.fun isSplit) g ) ⟩
(h +₁ 𝒾 g) -₁ (𝒾 g)
≡⟨ sym (assoc₁ h (𝒾 g) (-i g)) ⟩
h +₁ (𝒾 g -₁ (𝒾 g))
≡⟨ cong (h +₁_)
(rCancel₁ (𝒾 g)) ⟩
h +₁ 0₁
≡⟨ rId₁ h ⟩
h ∎
q' = s (h +₁ 𝒾 g)
≡⟨ σ .isHom h (𝒾 g) ⟩
s h +₀ si g
≡⟨ cong (_+₀ si g) p ⟩
0₀ +₀ si g
≡⟨ lId₀ (si g) ⟩
si g
≡⟨ funExt⁻ (cong GroupHom.fun isSplit) g ⟩
g ∎
-- end of Iso.leftInv isom ((h , p) , g)
Iso.rightInv isom h = q
where
ish = 𝒾 (s h)
abstract
q = (h +₁ 𝒾 (s (-₁ h))) +₁ ish
≡⟨ cong (λ z → (h +₁ z) +₁ ish) (cong 𝒾 (mapInv σ h) ∙ mapInv ι (s h)) ⟩
(h +₁ (-₁ ish)) +₁ ish
≡⟨ sym (assoc₁ h (-₁ ish) ish) ⟩
h +₁ ((-₁ ish) +₁ ish)
≡⟨ (cong (h +₁_) (lCancel₁ ish)) ∙ (rId₁ h) ⟩
h ∎
-- end of Iso.rightInv isom h
-- end of Iso ⟨ kσ⋊G₀ ⟩ ⟨ G₁ ⟩
GroupEquiv.isHom G₁-≅ ((h , p) , g) ((h' , p') , g') = q
where
abstract
q = (h +₁ ((𝒾 g +₁ h') +₁ (-₁ 𝒾 g))) +₁ 𝒾 (g +₀ g')
≡⟨ cong ((h +₁ ((𝒾 g +₁ h') +₁ (-₁ 𝒾 g))) +₁_)
(ι .isHom g g') ⟩
(h +₁ ((𝒾 g +₁ h') +₁ (-₁ 𝒾 g))) +₁ (𝒾 g +₁ 𝒾 g')
≡⟨ sym (assoc₁ h ((𝒾 g +₁ h') +₁ (-₁ 𝒾 g)) (𝒾 g +₁ 𝒾 g')) ⟩
h +₁ (((𝒾 g +₁ h') +₁ (-₁ 𝒾 g)) +₁ (𝒾 g +₁ 𝒾 g'))
≡⟨ cong (h +₁_)
(sym (assoc₁ (𝒾 g +₁ h') (-₁ 𝒾 g) (𝒾 g +₁ 𝒾 g'))) ⟩
h +₁ ((𝒾 g +₁ h') +₁ ((-₁ 𝒾 g) +₁ (𝒾 g +₁ 𝒾 g')))
≡⟨ cong (λ z → h +₁ ((𝒾 g +₁ h') +₁ z))
(assoc₁ (-₁ 𝒾 g) (𝒾 g) (𝒾 g')) ⟩
h +₁ ((𝒾 g +₁ h') +₁ (((-₁ 𝒾 g) +₁ 𝒾 g) +₁ 𝒾 g'))
≡⟨ cong (λ z → h +₁ ((𝒾 g +₁ h') +₁ (z +₁ 𝒾 g')))
(lCancel₁ (𝒾 g)) ⟩
h +₁ ((𝒾 g +₁ h') +₁ (0₁ +₁ 𝒾 g'))
≡⟨ cong (λ z → h +₁ ((𝒾 g +₁ h') +₁ z))
(lId₁ (𝒾 g')) ⟩
h +₁ ((𝒾 g +₁ h') +₁ 𝒾 g')
≡⟨ cong (h +₁_)
(sym (assoc₁ (𝒾 g) h' (𝒾 g'))) ⟩
h +₁ (𝒾 g +₁ (h' +₁ 𝒾 g'))
≡⟨ assoc₁ h (𝒾 g) (h' +₁ 𝒾 g') ⟩
(h +₁ 𝒾 g) +₁ (h' +₁ 𝒾 g') ∎
-- end of GroupEquiv kσ⋊G₀ G₁
ι-≅ : (g : ⟨ G₀ ⟩) → 0₁ +₁ (𝒾 g) ≡ 𝒾 g
ι-≅ g = lId₁ (𝒾 g)
σ-≅ : (((h , _) , g) : ⟨ kσ⋊G₀ ⟩) → g ≡ s (h +₁ 𝒾 g)
σ-≅ ((h , p) , g) = q
where
abstract
q = g
≡⟨ funExt⁻ (cong fun (sym isSplit)) g ⟩
s (𝒾 g)
≡⟨ sym (lId₀ (s (𝒾 g))) ⟩
0₀ +₀ s (𝒾 g)
≡⟨ cong (_+₀ s (𝒾 g)) (sym p) ⟩
s h +₀ s (𝒾 g)
≡⟨ sym (σ .isHom h (𝒾 g)) ⟩
s (h +₁ 𝒾 g) ∎
isSplit-≅ : Unit
isSplit-≅ = tt
RelIso.leftInv (𝒮ᴰ-Iso-GroupAct-SplitEpi-* G₀) (H , _α_ , isAct) = H-≅ , α-≅ , isAct-≅
where
-- import notation
open GroupNotation₀ G₀
open GroupNotationᴴ H
open ActionNotationα (groupaction _α_ isAct) using (α-id)
se = RelIso.fun (𝒮ᴰ-Iso-GroupAct-SplitEpi-* G₀) (H , _α_ , isAct)
ga' = RelIso.inv (𝒮ᴰ-Iso-GroupAct-SplitEpi-* G₀) se
-- H under fun and then inv
ker-π₂ = fst ga'
-- the adjoint action w.t.r. ι₂
_β_ = fst (snd ga')
β-isAct = snd (snd ga')
-- inclusion of G₀ into H ⋊⟨ α ⟩ G₀
ι = ι₂ (groupaction _α_ isAct)
𝒾 = ι .fun
G₀-≅ : GroupEquiv G₀ G₀
G₀-≅ = idGroupEquiv G₀
H-≅ : GroupEquiv ker-π₂ H
GroupEquiv.eq H-≅ = isoToEquiv isom
where
isom : Iso ⟨ ker-π₂ ⟩ ⟨ H ⟩
Iso.fun isom ((h , g) , p) = h
Iso.inv isom h = (h , 0₀) , refl
Iso.leftInv isom ((h , g) , p) = q
where
abstract
r : (h , 0₀) ≡ (h , g)
r = ΣPathP (refl , sym p)
q : ((h , 0₀) , refl) ≡ ((h , g) , p)
q = ΣPathP (r , isProp→PathP (λ i → set₀ (snd (r i)) 0₀) refl p)
Iso.rightInv isom h = refl
GroupEquiv.isHom H-≅ ((h , g) , p) ((h' , g') , p') = q
where
abstract
q : h +ᴴ (g α h') ≡ h +ᴴ h'
q = h +ᴴ (g α h')
≡⟨ cong (λ z → h +ᴴ (z α h')) p ⟩
h +ᴴ (0₀ α h')
≡⟨ cong (h +ᴴ_) (α-id h') ⟩
h +ᴴ h' ∎
α-≅ : (g : ⟨ G₀ ⟩) (((h , g') , p) : ⟨ ker-π₂ ⟩)
→ GroupEquiv.eq H-≅ .fst (g β ((h , g') , p)) ≡ g α h
α-≅ g ((h , g') , p) = q
where
open ActionLemmas (groupaction _α_ isAct)
abstract
q = (0ᴴ +ᴴ (g α h)) +ᴴ ((g +₀ g') α ((-₀ g) α (-ᴴ 0ᴴ)))
≡⟨ cong (_+ᴴ ((g +₀ g') α ((-₀ g) α (-ᴴ 0ᴴ))))
(lIdᴴ (g α h)) ⟩
(g α h) +ᴴ ((g +₀ g') α ((-₀ g) α (-ᴴ 0ᴴ)))
≡⟨ cong (λ z → (g α h) +ᴴ ((g +₀ g') α ((-₀ g) α z)))
(invId H) ⟩
(g α h) +ᴴ ((g +₀ g') α ((-₀ g) α 0ᴴ))
≡⟨ cong (λ z → (g α h) +ᴴ ((g +₀ g') α z))
(actOnUnit (-₀ g)) ⟩
(g α h) +ᴴ ((g +₀ g') α 0ᴴ)
≡⟨ cong ((g α h) +ᴴ_)
(actOnUnit (g +₀ g')) ⟩
(g α h) +ᴴ 0ᴴ
≡⟨ rIdᴴ (g α h) ⟩
g α h ∎
isAct-≅ : Unit
isAct-≅ = tt
IsoActionSplitEpi-* : Iso (GGLasAct ℓ (ℓ-max ℓ ℓ')) (SplitEpi' ℓ (ℓ-max ℓ ℓ'))
IsoActionSplitEpi-* =
𝒮ᴰ-♭PIso-Over→TotalIso idIso
(𝒮ᴰ-G\GLasAction ℓ (ℓ-max ℓ ℓ'))
(𝒮ᴰ-G\GFBSplitEpi ℓ (ℓ-max ℓ ℓ'))
𝒮ᴰ-Iso-GroupAct-SplitEpi-*
IsoActionSplitEpi : Iso (Action ℓ (ℓ-max ℓ ℓ')) (SplitEpi ℓ (ℓ-max ℓ ℓ'))
IsoActionSplitEpi = compIso (IsoAction ℓ (ℓ-max ℓ ℓ'))
(compIso IsoActionSplitEpi-* (IsoSplitEpi' ℓ (ℓ-max ℓ ℓ')))
| {
"alphanum_fraction": 0.3665113999,
"avg_line_length": 37.6812933025,
"ext": "agda",
"hexsha": "3be8db7ee0af5efc48a01e4d3893b40263da0bba",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "c345dc0c49d3950dc57f53ca5f7099bb53a4dc3a",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Schippmunk/cubical",
"max_forks_repo_path": "Cubical/DStructures/Equivalences/GroupSplitEpiAction.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c345dc0c49d3950dc57f53ca5f7099bb53a4dc3a",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Schippmunk/cubical",
"max_issues_repo_path": "Cubical/DStructures/Equivalences/GroupSplitEpiAction.agda",
"max_line_length": 107,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "c345dc0c49d3950dc57f53ca5f7099bb53a4dc3a",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Schippmunk/cubical",
"max_stars_repo_path": "Cubical/DStructures/Equivalences/GroupSplitEpiAction.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 6081,
"size": 16316
} |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Base
module lib.PathGroupoid where
module _ {i} {A : Type i} where
{- Concatenation of paths
There are two different definitions of concatenation of paths, [_∙_] and [_∙'_],
with different definitionnal behaviour. Maybe we should have only one but it’s
sometimes useful to have both (in particular in lib.types.Paths).
-}
infixr 80 _∙_ _∙'_
_∙_ : {x y z : A}
→ (x == y → y == z → x == z)
idp ∙ q = q
_∙'_ : {x y z : A}
→ (x == y → y == z → x == z)
q ∙' idp = q
∙=∙' : {x y z : A} (p : x == y) (q : y == z)
→ p ∙ q == p ∙' q
∙=∙' idp idp = idp
∙'=∙ : {x y z : A} (p : x == y) (q : y == z)
→ p ∙' q == p ∙ q
∙'=∙ idp idp = idp
∙-assoc : {x y z t : A} (p : x == y) (q : y == z) (r : z == t)
→ (p ∙ q) ∙ r == p ∙ (q ∙ r)
∙-assoc idp _ _ = idp
∙'-assoc : {x y z t : A} (p : x == y) (q : y == z) (r : z == t)
→ (p ∙' q) ∙' r == p ∙' (q ∙' r)
∙'-assoc _ _ idp = idp
-- [∙-unit-l] and [∙'-unit-r] are definitional
∙-unit-r : {x y : A} (q : x == y) → q ∙ idp == q
∙-unit-r idp = idp
∙'-unit-l : {x y : A} (q : x == y) → idp ∙' q == q
∙'-unit-l idp = idp
{- Reversal of paths -}
! : {x y : A} → (x == y → y == x)
! idp = idp
!-inv-l : {x y : A} (p : x == y) → (! p) ∙ p == idp
!-inv-l idp = idp
!-inv'-l : {x y : A} (p : x == y) → (! p) ∙' p == idp
!-inv'-l idp = idp
!-inv-r : {x y : A} (p : x == y) → p ∙ (! p) == idp
!-inv-r idp = idp
!-inv'-r : {x y : A} (p : x == y) → p ∙' (! p) == idp
!-inv'-r idp = idp
{- Interactions between operations
A lemma of the form [!-∙ …] gives a result of the form [! (_∙_ …) == …],
and so on.
-}
!-∙ : {x y z : A} (p : x == y) (q : y == z) → ! (p ∙ q) == ! q ∙ ! p
!-∙ idp idp = idp
∙-! : {x y z : A} (q : y == z) (p : x == y) → ! q ∙ ! p == ! (p ∙ q)
∙-! idp idp = idp
!-∙' : {x y z : A} (p : x == y) (q : y == z) → ! (p ∙' q) == ! q ∙' ! p
!-∙' idp idp = idp
∙'-! : {x y z : A} (q : y == z) (p : x == y) → ! q ∙' ! p == ! (p ∙' q)
∙'-! idp idp = idp
!-! : {x y : A} (p : x == y) → ! (! p) == p
!-! idp = idp
{- Horizontal compositions -}
infixr 80 _∙2_ _∙'2_
_∙2_ : {x y z : A} {p p' : x == y} {q q' : y == z} (α : p == p') (β : q == q')
→ p ∙ q == p' ∙ q'
_∙2_ {p = idp} idp β = β
_∙'2_ : {x y z : A} {p p' : x == y} {q q' : y == z} (α : p == p') (β : q == q')
→ p ∙' q == p' ∙' q'
_∙'2_ {q = idp} α idp = α
idp∙2idp : {x y z : A} (p : x == y) (q : y == z)
→ (idp {a = p}) ∙2 (idp {a = q}) == idp
idp∙2idp idp idp = idp
idp∙'2idp : {x y z : A} (p : x == y) (q : y == z)
→ (idp {a = p}) ∙'2 (idp {a = q}) == idp
idp∙'2idp idp idp = idp
{-
Sometimes we need to restart a new section in order to have everything in the
previous one generalized.
-}
module _ {i} {A : Type i} where
{- Whisker and horizontal composition for Eckmann-Hilton argument -}
infixr 80 _∙ᵣ_ _⋆2_ _⋆'2_
infixl 80 _∙ₗ_
_∙ᵣ_ : {x y z : A} {p p' : x == y} (α : p == p') (q : y == z)
→ p ∙ q == p' ∙ q
_∙ᵣ_ {p = p} {p' = p'} α idp = ∙-unit-r p ∙ α ∙ ! (∙-unit-r p')
_∙ₗ_ : {x y z : A} {q q' : y == z} (p : x == y) (β : q == q')
→ p ∙ q == p ∙ q'
_∙ₗ_ {q = q} {q' = q'} idp β = β
_⋆2_ : {x y z : A} {p p' : x == y} {q q' : y == z}
(α : p == p') (β : q == q')
→ p ∙ q == p' ∙ q'
_⋆2_ {p' = p'} {q = q} α β = (α ∙ᵣ q) ∙ (p' ∙ₗ β)
_⋆'2_ : {x y z : A} {p p' : x == y} {q q' : y == z}
(α : p == p') (β : q == q')
→ p ∙ q == p' ∙ q'
_⋆'2_ {p = p} {q' = q'} α β = (p ∙ₗ β) ∙ (α ∙ᵣ q')
⋆2=⋆'2 : {x y z : A} {p p' : x == y} {q q' : y == z}
(α : p == p') (β : q == q')
→ α ⋆2 β == α ⋆'2 β
⋆2=⋆'2 {p = idp} {q = idp} idp idp = idp
module _ {i} {A : Type i} where
anti-whisker-right : {x y z : A} (p : y == z) {q r : x == y}
→ (q ∙ p == r ∙ p → q == r)
anti-whisker-right idp {q} {r} h =
! (∙-unit-r q) ∙ (h ∙ ∙-unit-r r)
anti-whisker-left : {x y z : A} (p : x == y) {q r : y == z}
→ (p ∙ q == p ∙ r → q == r)
anti-whisker-left idp h = h
{- Dependent stuff -}
module _ {i j} {A : Type i} {B : A → Type j} where
{- Dependent constant path -}
idpᵈ : {x : A} {u : B x} → u == u [ B ↓ idp ]
idpᵈ = idp
{- Dependent opposite path -}
!ᵈ : {x y : A} {p : x == y} {u : B x} {v : B y}
→ (u == v [ B ↓ p ] → v == u [ B ↓ (! p)])
!ᵈ {p = idp} = !
!ᵈ' : {x y : A} {p : x == y} {u : B y} {v : B x}
→ (u == v [ B ↓ (! p) ] → v == u [ B ↓ p ])
!ᵈ' {p = idp} = !
!ᵈ-!ᵈ' : {x y : A} {p : x == y} {u : B y} {v : B x}
→ (q : u == v [ B ↓ (! p) ])
→ !ᵈ (!ᵈ' q) == q
!ᵈ-!ᵈ' {p = idp} idp = idp
{- Dependent concatenation -}
infixr 80 _∙ᵈ_ _∙'ᵈ_ _◃_ _▹_ _!◃_ _▹!_
_∙ᵈ_ : {x y z : A} {p : x == y} {p' : y == z}
{u : B x} {v : B y} {w : B z}
→ (u == v [ B ↓ p ]
→ v == w [ B ↓ p' ]
→ u == w [ B ↓ (p ∙ p') ])
_∙ᵈ_ {p = idp} {p' = idp} q r = q ∙ r
_◃_ = _∙ᵈ_
◃idp : {x : A} {v w : B x} (q : w == v)
→ q ◃ idp == q
◃idp idp = idp
idp◃ : {x y : A} {p : x == y}
{u : B x} {v : B y} (r : u == v [ B ↓ p ])
→ idp ◃ r == r
idp◃ {p = idp} r = idp
_∙'ᵈ_ : {x y z : A} {p : x == y} {p' : y == z}
{u : B x} {v : B y} {w : B z}
→ (u == v [ B ↓ p ]
→ v == w [ B ↓ p' ]
→ u == w [ B ↓ (p ∙' p') ])
_∙'ᵈ_ {p = idp} {p' = idp} q r = q ∙' r
_▹_ = _∙'ᵈ_
{- That’s not perfect, because [q] could be a dependent path. But in that case
this is not well typed… -}
idp▹ : {x : A} {v w : B x} (q : v == w)
→ idp ▹ q == q
idp▹ idp = idp
▹idp : {x y : A} {p : x == y}
{u : B x} {v : B y} (q : u == v [ B ↓ p ])
→ q ▹ idp == q
▹idp {p = idp} idp = idp
_▹!_ : {x y z : A} {p : x == y} {p' : z == y}
{u : B x} {v : B y} {w : B z}
→ u == v [ B ↓ p ]
→ w == v [ B ↓ p' ]
→ u == w [ B ↓ p ∙' (! p') ]
_▹!_ {p' = idp} q idp = q
idp▹! : {x : A} {v w : B x} (q : w == v)
→ idp ▹! q == ! q
idp▹! idp = idp
_!◃_ : {x y z : A} {p : y == x} {p' : y == z}
{u : B x} {v : B y} {w : B z}
→ v == u [ B ↓ p ]
→ v == w [ B ↓ p' ]
→ u == w [ B ↓ (! p) ∙ p' ]
_!◃_ {p = idp} idp q = q
!◃idp :{x : A} {v w : B x} (q : v == w)
→ q !◃ idp == ! q
!◃idp idp = idp
{-
This is some kind of dependent horizontal composition (used in [apd∙]).
-}
infixr 80 _∙2ᵈ_ _∙'2ᵈ_
_∙2ᵈ_ : {x y z : Π A B}
{a a' : A} {p : a == a'} {q : x a == y a} {q' : x a' == y a'}
{r : y a == z a} {r' : y a' == z a'}
→ (q == q' [ (λ a → x a == y a) ↓ p ])
→ (r == r' [ (λ a → y a == z a) ↓ p ])
→ (q ∙ r == q' ∙ r' [ (λ a → x a == z a) ↓ p ])
_∙2ᵈ_ {p = idp} α β = α ∙2 β
_∙'2ᵈ_ : {x y z : Π A B}
{a a' : A} {p : a == a'} {q : x a == y a} {q' : x a' == y a'}
{r : y a == z a} {r' : y a' == z a'}
→ (q == q' [ (λ a → x a == y a) ↓ p ])
→ (r == r' [ (λ a → y a == z a) ↓ p ])
→ (q ∙' r == q' ∙' r' [ (λ a → x a == z a) ↓ p ])
_∙'2ᵈ_ {p = idp} α β = α ∙'2 β
{-
[apd∙] reduces a term of the form [apd (λ a → q a ∙ r a) p], do not confuse it
with [apd-∙] which reduces a term of the form [apd f (p ∙ q)].
-}
apd∙ : {a a' : A} {x y z : Π A B}
(q : (a : A) → x a == y a) (r : (a : A) → y a == z a)
(p : a == a')
→ apd (λ a → q a ∙ r a) p == apd q p ∙2ᵈ apd r p
apd∙ q r idp = ! (idp∙2idp (q _) (r _))
apd∙' : {a a' : A} {x y z : Π A B}
(q : (a : A) → x a == y a) (r : (a : A) → y a == z a)
(p : a == a')
→ apd (λ a → q a ∙' r a) p == apd q p ∙'2ᵈ apd r p
apd∙' q r idp = ! (idp∙'2idp (q _) (r _))
module _ {i j} {A : Type i} {B : A → Type j} where
{- Exchange -}
▹-∙'2ᵈ : {x y z : Π A B}
{a a' a'' : A} {p : a == a'} {p' : a' == a''}
{q0 : x a == y a} {q0' : x a' == y a'}
{r0 : y a == z a} {r0' : y a' == z a'}
{q0'' : x a'' == y a''} {r0'' : y a'' == z a''}
(q : q0 == q0' [ (λ a → x a == y a) ↓ p ])
(r : r0 == r0' [ (λ a → y a == z a) ↓ p ])
(s : q0' == q0'' [ (λ a → x a == y a) ↓ p' ])
(t : r0' == r0'' [ (λ a → y a == z a) ↓ p' ])
→ (q ∙'2ᵈ r) ▹ (s ∙'2ᵈ t) == (q ▹ s) ∙'2ᵈ (r ▹ t)
▹-∙'2ᵈ {p = idp} {p' = idp} {q0} {.q0} {r0} {.r0} idp idp idp idp =
ap (λ u → (idp {a = q0} ∙'2 idp {a = r0}) ∙' u) (idp∙'2idp q0 r0)
| {
"alphanum_fraction": 0.3547448794,
"avg_line_length": 27.7811447811,
"ext": "agda",
"hexsha": "f4a953ff3d9281fb45ff7433e4f531e2aaa53608",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "timjb/HoTT-Agda",
"max_forks_repo_path": "core/lib/PathGroupoid.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "timjb/HoTT-Agda",
"max_issues_repo_path": "core/lib/PathGroupoid.agda",
"max_line_length": 82,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "timjb/HoTT-Agda",
"max_stars_repo_path": "core/lib/PathGroupoid.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 4383,
"size": 8251
} |
module Lec2Start where
open import Lec1Done
------------------------------------------------------------------------------
-- Vectors -- the star of exercise 1
------------------------------------------------------------------------------
data Vec (X : Set) : Nat -> Set where -- like lists, but length-indexed
[] : Vec X zero
_,-_ : {n : Nat} -> X -> Vec X n -> Vec X (suc n)
infixr 4 _,-_ -- the "cons" operator associates to the right
------------------------------------------------------------------------------
-- Taking a Prefix of a Vector
------------------------------------------------------------------------------
{-+}
vTake : (m n : Nat) -> m >= n -> {X : Set} -> Vec X m -> Vec X n
vTake m n m>=n xs = {!!}
{+-}
------------------------------------------------------------------------------
-- Things to Prove
------------------------------------------------------------------------------
{-+}
vTakeIdFact : (n : Nat){X : Set}(xs : Vec X n) ->
vTake n n (refl->= n) xs == xs
vTakeIdFact n xs = {!!}
vTakeCpFact : (m n p : Nat)(m>=n : m >= n)(n>=p : n >= p)
{X : Set}(xs : Vec X m) ->
vTake m p (trans->= m n p m>=n n>=p) xs ==
vTake n p n>=p (vTake m n m>=n xs)
{- hit p first: why? -}
vTakeCpFact m n p m>=n n>=p xs = {!!}
{+-}
------------------------------------------------------------------------------
-- Splittings (which bear some relationship to <= from ex1)
------------------------------------------------------------------------------
data _<[_]>_ : Nat -> Nat -> Nat -> Set where
zzz : zero <[ zero ]> zero
lll : {l m r : Nat} -> l <[ m ]> r
-> suc l <[ suc m ]> r
rrr : {l m r : Nat} -> l <[ m ]> r
-> l <[ suc m ]> suc r
{-+}
_>[_]<_ : {X : Set}{l m r : Nat} ->
Vec X l -> l <[ m ]> r -> Vec X r ->
Vec X m
xl >[ nnn ]< xr = {!!}
{+-}
{-+}
data FindSplit {X : Set}{l m r : Nat}(nnn : l <[ m ]> r)
: (xs : Vec X m) -> Set where
splitBits : (xl : Vec X l)(xr : Vec X r) -> FindSplit nnn (xl >[ nnn ]< xr)
{+-}
{-+}
findSplit : {X : Set}{l m r : Nat}(nnn : l <[ m ]> r)(xs : Vec X m) ->
FindSplit nnn xs
findSplit nnn xs = {!!}
{+-}
------------------------------------------------------------------------------
-- what I should remember to say
------------------------------------------------------------------------------
-- What's the difference between m>=n and m >= n ?
{- m>=n (without spaces) is just an identifier; it could be anything,
but it has been chosen to be suggestive of its *type* which is
m >= n (with spaces) which is the proposition that m is at least n.
By "proposition", I mean "type with at most one inhabitant", where
we care more about whether there is an inhabitant or not than which
one (because there's never a choice). Finished code does not show
us the types of its components, and that's not always a good thing.
Here, by picking nice names, we get something of an aide-memoire. -}
-- What does (x ,-_) mean?
{- It's a "left section". Right sections (_,- xs) also exist sometimes.
Why only sometimes? -}
-- "Why is it stuck?"
{- Proof by induction isn't just flailing about, you know? The trick is
to pick the case analysis that provokes the "stuck" programs to do a
step of computation. Then the same reasoning that justifies the
termination of the program will justify the induction in a proof
about it. -}
| {
"alphanum_fraction": 0.4154910097,
"avg_line_length": 36.887755102,
"ext": "agda",
"hexsha": "e2979a564aebeffc43292f34367b424bc4d67d83",
"lang": "Agda",
"max_forks_count": 8,
"max_forks_repo_forks_event_max_datetime": "2021-09-21T15:58:10.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-04-13T21:40:15.000Z",
"max_forks_repo_head_hexsha": "3dc7abca7ad868316bb08f31c77fbba0d3910225",
"max_forks_repo_licenses": [
"Unlicense"
],
"max_forks_repo_name": "haroldcarr/learn-haskell-coq-ml-etc",
"max_forks_repo_path": "agda/course/2017-conor_mcbride_cs410/CS410-17-master/nowyoutry/Lec2Start.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "3dc7abca7ad868316bb08f31c77fbba0d3910225",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Unlicense"
],
"max_issues_repo_name": "haroldcarr/learn-haskell-coq-ml-etc",
"max_issues_repo_path": "agda/course/2017-conor_mcbride_cs410/CS410-17-master/nowyoutry/Lec2Start.agda",
"max_line_length": 78,
"max_stars_count": 36,
"max_stars_repo_head_hexsha": "3dc7abca7ad868316bb08f31c77fbba0d3910225",
"max_stars_repo_licenses": [
"Unlicense"
],
"max_stars_repo_name": "haroldcarr/learn-haskell-coq-ml-etc",
"max_stars_repo_path": "agda/course/2017-conor_mcbride_cs410/CS410-17-master/lectures/Lec2Start.agda",
"max_stars_repo_stars_event_max_datetime": "2021-07-30T06:55:03.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-29T14:37:15.000Z",
"num_tokens": 920,
"size": 3615
} |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.types.Group
open import lib.types.CommutingSquare
open import lib.groups.Homomorphism
open import lib.groups.Isomorphism
module lib.groups.CommutingSquare where
-- A new type to keep the parameters.
record CommSquareᴳ {i₀ i₁ j₀ j₁}
{G₀ : Group i₀} {G₁ : Group i₁} {H₀ : Group j₀} {H₁ : Group j₁}
(φ₀ : G₀ →ᴳ H₀) (φ₁ : G₁ →ᴳ H₁) (ξG : G₀ →ᴳ G₁) (ξH : H₀ →ᴳ H₁)
: Type (lmax (lmax i₀ i₁) (lmax j₀ j₁)) where
constructor comm-sqrᴳ
field
commutesᴳ : ∀ g₀ → GroupHom.f (ξH ∘ᴳ φ₀) g₀ == GroupHom.f (φ₁ ∘ᴳ ξG) g₀
infix 0 _□$ᴳ_
_□$ᴳ_ = CommSquareᴳ.commutesᴳ
CommSquareᴳ-∘v : ∀ {i₀ i₁ i₂ j₀ j₁ j₂}
{G₀ : Group i₀} {G₁ : Group i₁} {G₂ : Group i₂}
{H₀ : Group j₀} {H₁ : Group j₁} {H₂ : Group j₂}
{φ : G₀ →ᴳ H₀} {ψ : G₁ →ᴳ H₁} {χ : G₂ →ᴳ H₂}
{ξG : G₀ →ᴳ G₁} {ξH : H₀ →ᴳ H₁}
{μA : G₁ →ᴳ G₂} {μB : H₁ →ᴳ H₂}
→ CommSquareᴳ ψ χ μA μB
→ CommSquareᴳ φ ψ ξG ξH
→ CommSquareᴳ φ χ (μA ∘ᴳ ξG) (μB ∘ᴳ ξH)
CommSquareᴳ-∘v {ξG = ξG} {μB = μB} (comm-sqrᴳ □₁₂) (comm-sqrᴳ □₀₁) =
comm-sqrᴳ λ g₀ → ap (GroupHom.f μB) (□₀₁ g₀) ∙ □₁₂ (GroupHom.f ξG g₀)
CommSquareᴳ-inverse-v : ∀ {i₀ i₁ j₀ j₁}
{G₀ : Group i₀} {G₁ : Group i₁} {H₀ : Group j₀} {H₁ : Group j₁}
{φ₀ : G₀ →ᴳ H₀} {φ₁ : G₁ →ᴳ H₁} {ξG : G₀ →ᴳ G₁} {ξH : H₀ →ᴳ H₁}
→ CommSquareᴳ φ₀ φ₁ ξG ξH
→ (ξG-ise : is-equiv (GroupHom.f ξG)) (ξH-ise : is-equiv (GroupHom.f ξH))
→ CommSquareᴳ φ₁ φ₀ (GroupIso.g-hom (ξG , ξG-ise)) (GroupIso.g-hom (ξH , ξH-ise))
CommSquareᴳ-inverse-v (comm-sqrᴳ □) ξG-ise ξH-ise =
comm-sqrᴳ (commutes (CommSquare-inverse-v (comm-sqr □) ξG-ise ξH-ise))
| {
"alphanum_fraction": 0.6161429452,
"avg_line_length": 37.7441860465,
"ext": "agda",
"hexsha": "0401ce367792165a644f613408acae8cbedd10b5",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2018-12-26T21:31:57.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-12-26T21:31:57.000Z",
"max_forks_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "mikeshulman/HoTT-Agda",
"max_forks_repo_path": "core/lib/groups/CommutingSquare.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "mikeshulman/HoTT-Agda",
"max_issues_repo_path": "core/lib/groups/CommutingSquare.agda",
"max_line_length": 83,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "mikeshulman/HoTT-Agda",
"max_stars_repo_path": "core/lib/groups/CommutingSquare.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 880,
"size": 1623
} |
module Control.SimplePar where
open import Prelude
open import Builtin.Float
open import Builtin.Coinduction
Val : Set
Val = Float
data IVar (A : Set) : Set where
ivar : Int → IVar A
data Trace : Set where
Get : IVar Val → (Val -> Trace) → Trace
Put : IVar Val → Val → Trace → Trace
New : (IVar Val -> Trace) → Trace
Fork : Trace → Trace → Trace
Done : Trace
record Par (A : Set) : Set where
constructor par
field
runCont : (A → Trace) → Trace
instance
FunctorPar : Functor Par
fmap {{FunctorPar}} f (par runCont) = par λ c → runCont (c ∘ f)
ApplicativePar : Applicative Par
pure {{ApplicativePar}} a = par λ c → c a
_<*>_ {{ApplicativePar}} (par runCont₁) (par runCont₂) =
par λ bcont → runCont₁ λ a → runCont₂ λ ab → bcont (a ab)
MonadPar : Monad Par
_>>=_ {{MonadPar}} (par runCont') k =
par λ c → runCont' λ a → Par.runCont (k a) c
data Stream (A : Set) : Set where
_∷_ : (a : A) (as : ∞ (Stream A)) → Stream A
instance
FunctorStream : Functor Stream
fmap {{FunctorStream}} f (a ∷ as) = f a ∷ ♯ fmap f (♭ as)
data IntMap (A : Set) : Set where
ε : IntMap A
_↦_,_ : Int → A → IntMap A → IntMap A
find : {A : Set} → Int → IntMap A → Maybe A
find x ε = nothing
find x (y ↦ a , m) =
ifYes x == y then just a else find x m
remove : {A : Set} → Int → IntMap A → IntMap A
remove x ε = ε
remove x (y ↦ a , m) =
ifYes x == y
then remove x m
else y ↦ a , remove x m
insertWith : {A : Set} → (A → A → A) → Int → A → IntMap A → IntMap A
insertWith f x a ε = x ↦ a , ε
insertWith f x a (y ↦ b , m) =
ifYes x == y
then y ↦ f a b , insertWith f x a m
else x ↦ a , insertWith f x a m
infix 2 _∌_
infix 3 _↦ε,_ _↦_,_
data Heap : Set
data _∌_ : Heap → Int → Set
data Heap where
∅ : Heap
_↦ε,_ : (ix : Int) → (h : Heap) → ⦃ p : h ∌ ix ⦄ → Heap
_↦_,_ : (ix : Int) → (v : Val) → (h : Heap) → ⦃ p : h ∌ ix ⦄ → Heap
data _∌_ where
∅∌ : {ix : Int} → ∅ ∌ ix
ε∌ : {ix ix' : Int} {h : Heap}
→ ⦃ p : h ∌ ix ⦄ → ¬ (ix' ≡ ix) → ix ↦ε, h ∌ ix'
v∌ : {ix ix' : Int} {h : Heap} {v : Val}
→ ⦃ p : h ∌ ix ⦄ → ¬ (ix' ≡ ix) → ix ↦ v , h ∌ ix'
-- data Lookup (ix : Int) (h : Heap) : Maybe Val → Dec (h ∌ ix) → Set where
-- isn : ⦃ p : h ∌ ix ⦄ → Lookup ix h nothing (yes p)
-- isε : ⦃ p : ¬ (h ∌ ix) ⦄ → Lookup ix h nothing (no p)
-- isval : (v : Val) → ⦃ p : ¬ (h ∌ ix) ⦄ → Lookup ix h (just v) (no p)
-- lookupHeap : (ix : Int) → (h : Heap) → Σ (Maybe Val) (λ v → Σ (Dec (h ∌ ix)) (λ p → Lookup ix h v p))
-- lookupHeap ix ∅ = nothing , yes ∅∌ , isn
-- lookupHeap ix (ix' ↦ε, h) with ix == ix'
-- ... | yes refl = nothing , no (λ { (ε∌ p) → p refl }) , isε
-- ... | no p with lookupHeap ix h
-- ... | (.nothing , .(yes _) , isn) = nothing , yes (ε∌ p) , isn
-- ... | (.nothing , .(no _) , isε) = nothing , yes (ε∌ p) , isn
-- ... | (.(just v) , .(no _) , isval v) = just v , no (λ { (ε∌ q) → {!!} }) , {!isval!}
-- lookupHeap ix (ix' ↦ v , h) = {!!}
lookupHeap : (ix : Int) → (h : Heap) → Maybe Val × Dec (h ∌ ix)
lookupHeap ix ∅ = nothing , yes ∅∌
lookupHeap ix (ix' ↦ε, h) with ix == ix'
... | yes refl = nothing , no λ { (ε∌ p) → p refl }
... | no p = fst (lookupHeap ix h) , yes (ε∌ p)
lookupHeap ix (ix' ↦ v , h) with ix == ix'
... | yes refl = just v , no λ { (v∌ p) → p refl }
... | no p = fst (lookupHeap ix h) , yes (v∌ p)
infix 2 _≤ₕ_
data _≤ₕ_ : Heap → Heap → Set where
h≤h : {h : Heap} → h ≤ₕ h
h≤ε : {h : Heap} {ix : Int} ⦃ p : h ∌ ix ⦄
→ h ≤ₕ ix ↦ε, h
h≤v : {h : Heap} {ix : Int} {v : Val} ⦃ p : h ∌ ix ⦄
→ h ≤ₕ ix ↦ v , h
ε≤v : {h : Heap} {ix : Int} {v : Val} ⦃ p : h ∌ ix ⦄
→ ix ↦ε, h ≤ₕ ix ↦ v , h
h≤s : {h₁ h₂ : Heap} {ix : Int} {v w : Val} ⦃ p₁ : h₁ ∌ ix ⦄ ⦃ p₂ : h₂ ∌ ix ⦄
→ h₁ ≤ₕ h₂ → v ≤ w → ix ↦ v , h₁ ≤ₕ ix ↦ w , h₂
Blkd = IntMap (List (Val → Trace))
data Exn : Set where
Deadlock : Blkd → Exn
MultiplePut : Val → Int → Val → Exn
yank : {A : Set} → Nat → A → List A → A × List A
yank n x xs =
case splitAt (natMod (length (x ∷ xs)) n) (x ∷ xs) of
λ { (hd , []) → x , hd
; (hd , x ∷ tl) → x , hd ++ tl
}
step : (Trace × List Trace) → Blkd → Int → Heap → Either Exn (List Trace × Blkd × Int × Heap)
sched : Stream Nat → List Trace → Blkd → Int → Heap → Either Exn Heap
{-# TERMINATING #-}
sched randoms [] ε cntr heap =
return heap
sched randoms [] blkd cntr heap =
left (Deadlock blkd)
sched (rnd ∷ rs) (t ∷ ts) blkd cntr heap =
caseM step (yank rnd t ts) blkd cntr heap of
λ { (threads' , blkd' , cntr' , heap') →
sched (♭ rs) threads' blkd' cntr' heap' }
step (Get (ivar ix) k , others) blkd cntr heap =
case lookupHeap ix heap of
λ { (nothing , p) → return (others , insertWith _++_ ix [ k ] blkd , cntr , heap)
; (just v , p) → return (k v ∷ others , blkd , cntr , heap) }
step (Put (ivar ix) v t₂ , others) blkd cntr heap =
case lookupHeap ix heap of
λ { (nothing , yes p) → case find ix blkd of
λ { nothing → return (t₂ ∷ others , blkd , cntr , (ix ↦ v , heap) ⦃ p = p ⦄)
; (just ls) → return (t₂ ∷ map (λ k → k v) ls ++ others , remove ix blkd , cntr , heap) }
; (nothing , no p) → case find ix blkd of
λ { nothing → return {!!}
; (just ls) → return (t₂ ∷ map (λ k → k v) ls ++ others , remove ix blkd , cntr , heap) }
; (just v₀ , _) → left (MultiplePut v ix v₀) }
-- λ { nothing → case find ix blkd of
-- λ { nothing → return (t₂ ∷ others , blkd , cntr , ix ↦ v , {!!})
-- ; (just ls) → {!!} }
-- ; (just v) → {!!} }
-- let heap' = ix ↦ v , heap
-- in case (lookupHeap ix heap) of
-- λ { nothing → case find ix blkd of
-- λ { nothing → return (t₂ ∷ others , blkd , cntr , heap')
-- ; (just ls) → return (t₂ ∷ map (λ k → k v) ls ++ others , remove ix blkd , cntr , heap) }
-- ; (just v₀) → left (MultiplePut v ix v₀) }
step (New k , others) blkd cntr heap =
return (k (ivar cntr) ∷ others , blkd , cntr + 1 , {!!})
-- return (k (ivar cntr) ∷ others , blkd , cntr + 1 , cntr ↦ε, heap)
step (Fork t₁ t₂ , others) blkd cntr heap =
return (t₁ ∷ t₂ ∷ others , blkd , cntr , heap)
step (Done , others) blkd cntr heap =
return (others , blkd , cntr , heap)
monotonicity : ∀ {threads} {blkd} {cntr} {heap}
→ ∀ {threads'} {blkd'} {cntr'} {heap'}
→ step threads blkd cntr heap ≡ right (threads' , blkd' , cntr' , heap')
→ heap ≤ₕ heap'
monotonicity {Get (ivar ix) k , others} {heap = heap} p with (lookupHeap ix heap)
monotonicity {Get (ivar ix) k , others} p | q = {!!}
monotonicity {Put (ivar ix) v t₂ , others} {heap = heap} p with (lookupHeap ix heap)
monotonicity {Put (ivar ix) v t₂ , others} {blkd = blkd} p | q = {!!}
monotonicity {New k , others} p = {!!}
monotonicity {Fork t₁ t₂ , others} p = {!!}
monotonicity {Done , others} p = {!!}
| {
"alphanum_fraction": 0.5260462394,
"avg_line_length": 35.780104712,
"ext": "agda",
"hexsha": "2803776f82bf97cf330e479c66397e4337d30c81",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2020-05-31T01:16:10.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-08T23:39:18.000Z",
"max_forks_repo_head_hexsha": "470cf1e705080b99616999c97463d7b7aa3c47db",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "ranjitjhala/verified-instances",
"max_forks_repo_path": "experiments/Control/SimplePar.agda",
"max_issues_count": 10,
"max_issues_repo_head_hexsha": "470cf1e705080b99616999c97463d7b7aa3c47db",
"max_issues_repo_issues_event_max_datetime": "2019-03-07T19:40:25.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-09-06T13:53:41.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "ranjitjhala/verified-instances",
"max_issues_repo_path": "experiments/Control/SimplePar.agda",
"max_line_length": 104,
"max_stars_count": 8,
"max_stars_repo_head_hexsha": "470cf1e705080b99616999c97463d7b7aa3c47db",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "lkuper/verified-instances",
"max_stars_repo_path": "experiments/Control/SimplePar.agda",
"max_stars_repo_stars_event_max_datetime": "2021-03-03T16:56:59.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-08-17T15:04:00.000Z",
"num_tokens": 2738,
"size": 6834
} |
-- Andreas, 2019-05-03, issue #3732
--
-- Do not erase constructor arguments when bound to Haskell data type.
-- Otherwise, it is not predictable how the Haskell constructors should look like.
-- {-# OPTIONS -v compile:100 #-}
open import Agda.Builtin.IO
open import Agda.Builtin.Unit
{-# FOREIGN GHC data I = Bar #-}
{-# FOREIGN GHC data S = Foo I #-}
module NonMutual where
data I : Set where
bar : I
{-# COMPILE GHC I = data I (Bar) #-}
data S : Set where
foo : (i : I) → S
{-# COMPILE GHC S = data S (Foo) #-}
-- It could be that an earlier type embeds a later type, by virtue of mutual blocks:
{-# FOREIGN GHC data I2 = Bar2 #-}
{-# FOREIGN GHC data S2 = Foo2 I2 #-}
module Mutual where
mutual
data S : Set where
foo : (i : I) → S
{-# COMPILE GHC S = data S2 (Foo2) #-}
data I : Set where
bar : I
{-# COMPILE GHC I = data I2 (Bar2) #-}
postulate
main : IO ⊤
{-# COMPILE GHC main = return () #-}
| {
"alphanum_fraction": 0.612565445,
"avg_line_length": 19.4897959184,
"ext": "agda",
"hexsha": "f5233229b10bc0a64e2eb6c127f14534789b4851",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Compiler/simple/Issue3732.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Compiler/simple/Issue3732.agda",
"max_line_length": 84,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Compiler/simple/Issue3732.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 283,
"size": 955
} |
module Metalogic.Linear.SequentCalculus {ℓₚ} (Proposition : Set(ℓₚ)) where
| {
"alphanum_fraction": 0.7866666667,
"avg_line_length": 37.5,
"ext": "agda",
"hexsha": "49219d687002c5ccaa0c593af47a57985c72cc96",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Lolirofle/stuff-in-agda",
"max_forks_repo_path": "old/Metalogic/Linear/SequentCalculus.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "old/Metalogic/Linear/SequentCalculus.agda",
"max_line_length": 74,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Lolirofle/stuff-in-agda",
"max_stars_repo_path": "old/Metalogic/Linear/SequentCalculus.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-05T06:53:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:58:13.000Z",
"num_tokens": 28,
"size": 75
} |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Base
open import lib.Function
open import lib.PathFunctor
open import lib.PathGroupoid
module lib.path-seq.Concat {i} {A : Type i} where
infixr 80 _∙∙_
_∙∙_ : {a a' a'' : A}
→ a =-= a' → a' =-= a'' → a =-= a''
_∙∙_ [] t = t
_∙∙_ (p ◃∙ s) t = p ◃∙ (s ∙∙ t)
∙∙-assoc : {a a' a'' a''' : A}
(s : a =-= a') (t : a' =-= a'') (u : a'' =-= a''')
→ (s ∙∙ t) ∙∙ u == s ∙∙ (t ∙∙ u)
∙∙-assoc [] t u = idp
∙∙-assoc (p ◃∙ s) t u = ap (p ◃∙_) (∙∙-assoc s t u)
∙∙-unit-r : {a a' : A} (s : a =-= a')
→ s ∙∙ [] == s
∙∙-unit-r [] = idp
∙∙-unit-r (p ◃∙ s) = ap (p ◃∙_) (∙∙-unit-r s)
infixl 80 _∙▹_
_∙▹_ : {a a' a'' : A}
→ a =-= a' → a' == a'' → a =-= a''
_∙▹_ {a} {a'} {a''} s p = s ∙∙ (p ◃∙ [])
↯-∙∙ : {a a' a'' : A} (s : a =-= a') (t : a' =-= a'')
→ ↯ (s ∙∙ t) == ↯ s ∙ ↯ t
↯-∙∙ [] t = idp
↯-∙∙ (p ◃∙ []) [] = ! (∙-unit-r p)
↯-∙∙ (p ◃∙ []) (p' ◃∙ t) = idp
↯-∙∙ (p ◃∙ s@(_ ◃∙ _)) t =
ap (λ y → p ∙ y) (↯-∙∙ s t) ∙
! (∙-assoc p (↯ s) (↯ t))
| {
"alphanum_fraction": 0.356,
"avg_line_length": 25,
"ext": "agda",
"hexsha": "c6f987e0a834e825e2dec883137e2fb2aca1d4ac",
"lang": "Agda",
"max_forks_count": 50,
"max_forks_repo_forks_event_max_datetime": "2022-02-14T03:03:25.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-10T01:48:08.000Z",
"max_forks_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "AntoineAllioux/HoTT-Agda",
"max_forks_repo_path": "core/lib/path-seq/Concat.agda",
"max_issues_count": 31,
"max_issues_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_issues_repo_issues_event_max_datetime": "2021-10-03T19:15:25.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-03-05T20:09:00.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "AntoineAllioux/HoTT-Agda",
"max_issues_repo_path": "core/lib/path-seq/Concat.agda",
"max_line_length": 53,
"max_stars_count": 294,
"max_stars_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "AntoineAllioux/HoTT-Agda",
"max_stars_repo_path": "core/lib/path-seq/Concat.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-20T13:54:45.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T16:23:23.000Z",
"num_tokens": 604,
"size": 1000
} |
module Pi0 where
open import Data.Empty
open import Data.Unit
open import Data.Sum
open import Data.Product
open import Groupoid
infixr 10 _◎_
infixr 30 _⟷_
------------------------------------------------------------------------------
-- Level 0:
-- Types at this level are just plain sets with no interesting path structure.
-- The path structure is defined at levels 1 and beyond.
data U : Set where
ZERO : U
ONE : U
PLUS : U → U → U
TIMES : U → U → U
⟦_⟧ : U → Set
⟦ ZERO ⟧ = ⊥
⟦ ONE ⟧ = ⊤
⟦ PLUS t₁ t₂ ⟧ = ⟦ t₁ ⟧ ⊎ ⟦ t₂ ⟧
⟦ TIMES t₁ t₂ ⟧ = ⟦ t₁ ⟧ × ⟦ t₂ ⟧
-- Programs
-- We use pointed types; programs map a pointed type to another
-- In other words, each program takes one particular value to another; if we
-- want to work on another value, we generally use another program
record U• : Set where
constructor •[_,_]
field
∣_∣ : U
• : ⟦ ∣_∣ ⟧
open U•
Space : (t• : U•) → Set
Space •[ t , v ] = ⟦ t ⟧
point : (t• : U•) → Space t•
point •[ t , v ] = v
-- examples of plain types, values, and pointed types
ONE• : U•
ONE• = •[ ONE , tt ]
BOOL : U
BOOL = PLUS ONE ONE
BOOL² : U
BOOL² = TIMES BOOL BOOL
TRUE : ⟦ BOOL ⟧
TRUE = inj₁ tt
FALSE : ⟦ BOOL ⟧
FALSE = inj₂ tt
BOOL•F : U•
BOOL•F = •[ BOOL , FALSE ]
BOOL•T : U•
BOOL•T = •[ BOOL , TRUE ]
-- The actual programs are the commutative semiring isomorphisms between
-- pointed types.
data _⟷_ : U• → U• → Set where
unite₊ : ∀ {t v} → •[ PLUS ZERO t , inj₂ v ] ⟷ •[ t , v ]
uniti₊ : ∀ {t v} → •[ t , v ] ⟷ •[ PLUS ZERO t , inj₂ v ]
swap1₊ : ∀ {t₁ t₂ v₁} → •[ PLUS t₁ t₂ , inj₁ v₁ ] ⟷ •[ PLUS t₂ t₁ , inj₂ v₁ ]
swap2₊ : ∀ {t₁ t₂ v₂} → •[ PLUS t₁ t₂ , inj₂ v₂ ] ⟷ •[ PLUS t₂ t₁ , inj₁ v₂ ]
assocl1₊ : ∀ {t₁ t₂ t₃ v₁} →
•[ PLUS t₁ (PLUS t₂ t₃) , inj₁ v₁ ] ⟷
•[ PLUS (PLUS t₁ t₂) t₃ , inj₁ (inj₁ v₁) ]
assocl2₊ : ∀ {t₁ t₂ t₃ v₂} →
•[ PLUS t₁ (PLUS t₂ t₃) , inj₂ (inj₁ v₂) ] ⟷
•[ PLUS (PLUS t₁ t₂) t₃ , inj₁ (inj₂ v₂) ]
assocl3₊ : ∀ {t₁ t₂ t₃ v₃} →
•[ PLUS t₁ (PLUS t₂ t₃) , inj₂ (inj₂ v₃) ] ⟷
•[ PLUS (PLUS t₁ t₂) t₃ , inj₂ v₃ ]
assocr1₊ : ∀ {t₁ t₂ t₃ v₁} →
•[ PLUS (PLUS t₁ t₂) t₃ , inj₁ (inj₁ v₁) ] ⟷
•[ PLUS t₁ (PLUS t₂ t₃) , inj₁ v₁ ]
assocr2₊ : ∀ {t₁ t₂ t₃ v₂} →
•[ PLUS (PLUS t₁ t₂) t₃ , inj₁ (inj₂ v₂) ] ⟷
•[ PLUS t₁ (PLUS t₂ t₃) , inj₂ (inj₁ v₂) ]
assocr3₊ : ∀ {t₁ t₂ t₃ v₃} →
•[ PLUS (PLUS t₁ t₂) t₃ , inj₂ v₃ ] ⟷
•[ PLUS t₁ (PLUS t₂ t₃) , inj₂ (inj₂ v₃) ]
unite⋆ : ∀ {t v} → •[ TIMES ONE t , (tt , v) ] ⟷ •[ t , v ]
uniti⋆ : ∀ {t v} → •[ t , v ] ⟷ •[ TIMES ONE t , (tt , v) ]
swap⋆ : ∀ {t₁ t₂ v₁ v₂} →
•[ TIMES t₁ t₂ , (v₁ , v₂) ] ⟷ •[ TIMES t₂ t₁ , (v₂ , v₁) ]
assocl⋆ : ∀ {t₁ t₂ t₃ v₁ v₂ v₃} →
•[ TIMES t₁ (TIMES t₂ t₃) , (v₁ , (v₂ , v₃)) ] ⟷
•[ TIMES (TIMES t₁ t₂) t₃ , ((v₁ , v₂) , v₃) ]
assocr⋆ : ∀ {t₁ t₂ t₃ v₁ v₂ v₃} →
•[ TIMES (TIMES t₁ t₂) t₃ , ((v₁ , v₂) , v₃) ] ⟷
•[ TIMES t₁ (TIMES t₂ t₃) , (v₁ , (v₂ , v₃)) ]
distz : ∀ {t v absurd} →
•[ TIMES ZERO t , (absurd , v) ] ⟷ •[ ZERO , absurd ]
factorz : ∀ {t v absurd} →
•[ ZERO , absurd ] ⟷ •[ TIMES ZERO t , (absurd , v) ]
dist1 : ∀ {t₁ t₂ t₃ v₁ v₃} →
•[ TIMES (PLUS t₁ t₂) t₃ , (inj₁ v₁ , v₃) ] ⟷
•[ PLUS (TIMES t₁ t₃) (TIMES t₂ t₃) , inj₁ (v₁ , v₃) ]
dist2 : ∀ {t₁ t₂ t₃ v₂ v₃} →
•[ TIMES (PLUS t₁ t₂) t₃ , (inj₂ v₂ , v₃) ] ⟷
•[ PLUS (TIMES t₁ t₃) (TIMES t₂ t₃) , inj₂ (v₂ , v₃) ]
factor1 : ∀ {t₁ t₂ t₃ v₁ v₃} →
•[ PLUS (TIMES t₁ t₃) (TIMES t₂ t₃) , inj₁ (v₁ , v₃) ] ⟷
•[ TIMES (PLUS t₁ t₂) t₃ , (inj₁ v₁ , v₃) ]
factor2 : ∀ {t₁ t₂ t₃ v₂ v₃} →
•[ PLUS (TIMES t₁ t₃) (TIMES t₂ t₃) , inj₂ (v₂ , v₃) ] ⟷
•[ TIMES (PLUS t₁ t₂) t₃ , (inj₂ v₂ , v₃) ]
id⟷ : ∀ {t v} → •[ t , v ] ⟷ •[ t , v ]
sym⟷ : ∀ {t₁ t₂ v₁ v₂} → (•[ t₁ , v₁ ] ⟷ •[ t₂ , v₂ ]) →
(•[ t₂ , v₂ ] ⟷ •[ t₁ , v₁ ])
_◎_ : ∀ {t₁ t₂ t₃ v₁ v₂ v₃} → (•[ t₁ , v₁ ] ⟷ •[ t₂ , v₂ ]) →
(•[ t₂ , v₂ ] ⟷ •[ t₃ , v₃ ]) →
(•[ t₁ , v₁ ] ⟷ •[ t₃ , v₃ ])
_⊕1_ : ∀ {t₁ t₂ t₃ t₄ v₁ v₂ v₃ v₄} →
(•[ t₁ , v₁ ] ⟷ •[ t₃ , v₃ ]) → (•[ t₂ , v₂ ] ⟷ •[ t₄ , v₄ ]) →
(•[ PLUS t₁ t₂ , inj₁ v₁ ] ⟷ •[ PLUS t₃ t₄ , inj₁ v₃ ])
_⊕2_ : ∀ {t₁ t₂ t₃ t₄ v₁ v₂ v₃ v₄} →
(•[ t₁ , v₁ ] ⟷ •[ t₃ , v₃ ]) → (•[ t₂ , v₂ ] ⟷ •[ t₄ , v₄ ]) →
(•[ PLUS t₁ t₂ , inj₂ v₂ ] ⟷ •[ PLUS t₃ t₄ , inj₂ v₄ ])
_⊗_ : ∀ {t₁ t₂ t₃ t₄ v₁ v₂ v₃ v₄} →
(•[ t₁ , v₁ ] ⟷ •[ t₃ , v₃ ]) → (•[ t₂ , v₂ ] ⟷ •[ t₄ , v₄ ]) →
(•[ TIMES t₁ t₂ , (v₁ , v₂) ] ⟷ •[ TIMES t₃ t₄ , (v₃ , v₄) ])
-- example programs
NOT•T : •[ BOOL , TRUE ] ⟷ •[ BOOL , FALSE ]
NOT•T = swap1₊
NOT•F : •[ BOOL , FALSE ] ⟷ •[ BOOL , TRUE ]
NOT•F = swap2₊
CNOT•Fx : {b : ⟦ BOOL ⟧} →
•[ BOOL² , (FALSE , b) ] ⟷ •[ BOOL² , (FALSE , b) ]
CNOT•Fx = dist2 ◎ ((id⟷ ⊗ NOT•F) ⊕2 id⟷) ◎ factor2
CNOT•TF : •[ BOOL² , (TRUE , FALSE) ] ⟷ •[ BOOL² , (TRUE , TRUE) ]
CNOT•TF = dist1 ◎
((id⟷ ⊗ NOT•F) ⊕1 (id⟷ {TIMES ONE BOOL} {(tt , TRUE)})) ◎
factor1
CNOT•TT : •[ BOOL² , (TRUE , TRUE) ] ⟷ •[ BOOL² , (TRUE , FALSE) ]
CNOT•TT = dist1 ◎
((id⟷ ⊗ NOT•T) ⊕1 (id⟷ {TIMES ONE BOOL} {(tt , TRUE)})) ◎
factor1
-- The evaluation of a program is not done in order to figure out the output
-- value. Both the input and output values are encoded in the type of the
-- program; what the evaluation does is follow the path to constructively
-- reach the ouput value from the input value. Even though programs of the
-- same pointed types are, by definition, observationally equivalent, they
-- may follow different paths. At this point, we simply declare that all such
-- programs are "the same." At the next level, we will weaken this "path
-- irrelevant" equivalence and reason about which paths can be equated to
-- other paths via 2paths etc.
-- Even though individual types are sets, the universe of types is a
-- groupoid. The objects of this groupoid are the pointed types; the
-- morphisms are the programs; and the equivalence of programs is the
-- degenerate observational equivalence that equates every two programs that
-- are extensionally equivalent.
_obs≅_ : {t₁ t₂ : U•} → (c₁ c₂ : t₁ ⟷ t₂) → Set
c₁ obs≅ c₂ = ⊤
UG : 1Groupoid
UG = record
{ set = U•
; _↝_ = _⟷_
; _≈_ = _obs≅_
; id = id⟷
; _∘_ = λ y⟷z x⟷y → x⟷y ◎ y⟷z
; _⁻¹ = sym⟷
; lneutr = λ _ → tt
; rneutr = λ _ → tt
; assoc = λ _ _ _ → tt
; equiv = record { refl = tt
; sym = λ _ → tt
; trans = λ _ _ → tt
}
; linv = λ _ → tt
; rinv = λ _ → tt
; ∘-resp-≈ = λ _ _ → tt
}
------------------------------------------------------------------------------
-- Simplifiy various compositions
simplifySym : {t₁ t₂ : U•} → (c₁ : t₁ ⟷ t₂) → (t₂ ⟷ t₁)
simplifySym unite₊ = uniti₊
simplifySym uniti₊ = unite₊
simplifySym swap1₊ = swap2₊
simplifySym swap2₊ = swap1₊
simplifySym assocl1₊ = assocr1₊
simplifySym assocl2₊ = assocr2₊
simplifySym assocl3₊ = assocr3₊
simplifySym assocr1₊ = assocl1₊
simplifySym assocr2₊ = assocl2₊
simplifySym assocr3₊ = assocl3₊
simplifySym unite⋆ = uniti⋆
simplifySym uniti⋆ = unite⋆
simplifySym swap⋆ = swap⋆
simplifySym assocl⋆ = assocr⋆
simplifySym assocr⋆ = assocl⋆
simplifySym distz = factorz
simplifySym factorz = distz
simplifySym dist1 = factor1
simplifySym dist2 = factor2
simplifySym factor1 = dist1
simplifySym factor2 = dist2
simplifySym id⟷ = id⟷
simplifySym (sym⟷ c) = c
simplifySym (c₁ ◎ c₂) = simplifySym c₂ ◎ simplifySym c₁
simplifySym (c₁ ⊕1 c₂) = simplifySym c₁ ⊕1 simplifySym c₂
simplifySym (c₁ ⊕2 c₂) = simplifySym c₁ ⊕2 simplifySym c₂
simplifySym (c₁ ⊗ c₂) = simplifySym c₁ ⊗ simplifySym c₂
simplifyl◎ : {t₁ t₂ t₃ : U•} → (c₁ : t₁ ⟷ t₂) → (c₂ : t₂ ⟷ t₃) → (t₁ ⟷ t₃)
simplifyl◎ id⟷ c = c
simplifyl◎ unite₊ uniti₊ = id⟷
simplifyl◎ uniti₊ unite₊ = id⟷
simplifyl◎ swap1₊ swap2₊ = id⟷
simplifyl◎ swap2₊ swap1₊ = id⟷
simplifyl◎ assocl1₊ assocr1₊ = id⟷
simplifyl◎ assocl2₊ assocr2₊ = id⟷
simplifyl◎ assocl3₊ assocr3₊ = id⟷
simplifyl◎ assocr1₊ assocl1₊ = id⟷
simplifyl◎ assocr2₊ assocl2₊ = id⟷
simplifyl◎ assocr3₊ assocl3₊ = id⟷
simplifyl◎ unite⋆ uniti⋆ = id⟷
simplifyl◎ uniti⋆ unite⋆ = id⟷
simplifyl◎ swap⋆ swap⋆ = id⟷
simplifyl◎ assocl⋆ assocr⋆ = id⟷
simplifyl◎ assocr⋆ assocl⋆ = id⟷
simplifyl◎ factorz distz = id⟷
simplifyl◎ dist1 factor1 = id⟷
simplifyl◎ dist2 factor2 = id⟷
simplifyl◎ factor1 dist1 = id⟷
simplifyl◎ factor2 dist2 = id⟷
simplifyl◎ (c₁ ◎ c₂) c₃ = c₁ ◎ (c₂ ◎ c₃)
simplifyl◎ (c₁ ⊕1 c₂) swap1₊ = swap1₊ ◎ (c₂ ⊕2 c₁)
simplifyl◎ (c₁ ⊕2 c₂) swap2₊ = swap2₊ ◎ (c₂ ⊕1 c₁)
simplifyl◎ (_⊗_ {ONE} c₁ c₂) unite⋆ = unite⋆ ◎ c₂
simplifyl◎ (c₁ ⊗ c₂) swap⋆ = swap⋆ ◎ (c₂ ⊗ c₁)
simplifyl◎ (c₁ ⊗ c₂) (c₃ ⊗ c₄) = (c₁ ◎ c₃) ⊗ (c₂ ◎ c₄)
simplifyl◎ c₁ c₂ = c₁ ◎ c₂
simplifyr◎ : {t₁ t₂ t₃ : U•} → (c₁ : t₁ ⟷ t₂) → (c₂ : t₂ ⟷ t₃) → (t₁ ⟷ t₃)
simplifyr◎ c id⟷ = c
simplifyr◎ unite₊ uniti₊ = id⟷
simplifyr◎ uniti₊ unite₊ = id⟷
simplifyr◎ swap1₊ swap2₊ = id⟷
simplifyr◎ swap2₊ swap1₊ = id⟷
simplifyr◎ assocl1₊ assocr1₊ = id⟷
simplifyr◎ assocl2₊ assocr2₊ = id⟷
simplifyr◎ assocl3₊ assocr3₊ = id⟷
simplifyr◎ assocr1₊ assocl1₊ = id⟷
simplifyr◎ assocr2₊ assocl2₊ = id⟷
simplifyr◎ assocr3₊ assocl3₊ = id⟷
simplifyr◎ unite⋆ uniti⋆ = id⟷
simplifyr◎ uniti⋆ unite⋆ = id⟷
simplifyr◎ swap⋆ swap⋆ = id⟷
simplifyr◎ assocl⋆ assocr⋆ = id⟷
simplifyr◎ assocr⋆ assocl⋆ = id⟷
simplifyr◎ factorz distz = id⟷
simplifyr◎ dist1 factor1 = id⟷
simplifyr◎ dist2 factor2 = id⟷
simplifyr◎ factor1 dist1 = id⟷
simplifyr◎ factor2 dist2 = id⟷
simplifyr◎ (c₁ ◎ c₂) c₃ = c₁ ◎ (c₂ ◎ c₃)
simplifyr◎ (c₁ ⊕1 c₂) swap1₊ = swap1₊ ◎ (c₂ ⊕2 c₁)
simplifyr◎ (c₁ ⊕2 c₂) swap2₊ = swap2₊ ◎ (c₂ ⊕1 c₁)
simplifyr◎ (_⊗_ {ONE} {ONE} c₁ c₂) unite⋆ = unite⋆ ◎ c₂
simplifyr◎ (c₁ ⊗ c₂) swap⋆ = swap⋆ ◎ (c₂ ⊗ c₁)
simplifyr◎ (c₁ ⊗ c₂) (c₃ ⊗ c₄) = (c₁ ◎ c₃) ⊗ (c₂ ◎ c₄)
simplifyr◎ c₁ c₂ = c₁ ◎ c₂
| {
"alphanum_fraction": 0.5309682477,
"avg_line_length": 34.9452054795,
"ext": "agda",
"hexsha": "933f1c5f39ed98ec065130d6c3a35d08ec1ff8ec",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2019-09-10T09:47:13.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-05-29T01:56:33.000Z",
"max_forks_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "JacquesCarette/pi-dual",
"max_forks_repo_path": "Univalence/PiWithLevels/Pi0.agda",
"max_issues_count": 4,
"max_issues_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1",
"max_issues_repo_issues_event_max_datetime": "2021-10-29T20:41:23.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-06-07T16:27:41.000Z",
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "JacquesCarette/pi-dual",
"max_issues_repo_path": "Univalence/PiWithLevels/Pi0.agda",
"max_line_length": 80,
"max_stars_count": 14,
"max_stars_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "JacquesCarette/pi-dual",
"max_stars_repo_path": "Univalence/PiWithLevels/Pi0.agda",
"max_stars_repo_stars_event_max_datetime": "2021-05-05T01:07:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-08-18T21:40:15.000Z",
"num_tokens": 4748,
"size": 10204
} |
module Issue939 where
record Sigma (A : Set)(P : A → Set) : Set where
field
fst : A
.snd : P fst
open Sigma
postulate
A : Set
P : A → Set
x : A
.p : P x
ex : Sigma A P
ex = record
{ fst = x
; snd = p
}
-- Note: we do not need --irrelevant-projections to use them on the lhs.
ex' : Sigma A P
fst ex' = x
snd ex' = p
-- WAS: Giving p yields the following error:
-- Identifier p is declared irrelevant, so it cannot be used here
-- when checking that the expression p has type P (fst ex')
-- Fixed. Andreas, 2013-11-05
| {
"alphanum_fraction": 0.6067615658,
"avg_line_length": 18.1290322581,
"ext": "agda",
"hexsha": "dd52805a72ab2f0348edfa4ee8093a0be284452c",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue939.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue939.agda",
"max_line_length": 72,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue939.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 181,
"size": 562
} |
open import Data.Nat
open import Data.Product
open import Data.Empty
open import Relation.Binary.PropositionalEquality
module Stream where
record Stream (A : Set) : Set where
coinductive
field
head : A
tail : Stream A
open Stream public
get : ∀ {A : Set} → Stream A → ℕ → A
get s zero = head s
get s (suc i) = get s i
{-
natsFrom : ℕ → Stream ℕ
head (natsFrom x) = x
tail (natsFrom x) = natsFrom (suc x)
nats : Stream ℕ
nats = natsFrom 0
complicated-way-to-say-2 : head (tail (tail nats)) ≡ 2
complicated-way-to-say-2 = refl
-- thread a relation R through the elements of a stream
record Trans {A : Set}(R : A → A → Set)(as : Stream A) : Set where
coinductive
field
trans-head : R (head as) (head (tail as))
trans-tail : Trans R (tail as)
open Trans
-- We can prove our generation of natural numbers to be correct!
nats-correct : (n : ℕ) → Trans (λ x y → suc x ≡ y) (natsFrom n)
trans-head (nats-correct n) = refl
trans-tail (nats-correct n) = nats-correct (suc n)
-----------------------------
-- Talking Distr. Systems! --
-- I hope I got the names right
postulate
State : Set
Event : Set
Enabled : State → Event → Set
action : (s : State)(e : Event)
→ (enev : Enabled s e)
→ State
_l-t_ : (State → Set) → (State → Set) → Set
-- indicates a given post-state is a possible
-- outcome from a given pre-state; witnesses the
-- translation to the relational scheme I mentioned
_⟶_ : State → State → Set
s ⟶ s' = ∃[ e ] (Σ (Enabled s e) (λ enev → action s e enev ≡ s'))
-- A Behavior, then, is a stream of states
-- such that it starts at s₀ and all states
-- are linked through the _⟶_ relation.
-- You might want to have this in a single Beh record
-- instead of assembling it from primitives
Beh : State → Set
Beh s₀ = Σ (Stream State)
(λ st → head st ≡ s₀ × Trans _⟶_ st)
module Absurd-DO-NOT-TRY-AT-HOME where
data HeadOrTail {A : Set}(P : A → Set)(Q : Stream A → Set)
: Stream A → Set where
on-head : ∀{s} → P (head s) → HeadOrTail P Q s
-- there might be a case for including (¬ P (head s)) here...
on-tail : ∀{s} → Q (tail s) → HeadOrTail P Q s
record Any {A : Set}(P : A → Set)(as : Stream A) : Set where
coinductive
field
any : HeadOrTail P (Any P) as
open Any public
-- Witness is a proof by induction that places us
-- at the position where P 'holds'; but as we shall see,
-- this might never be the case and; even though the
-- 'recursive' call makes 'progress' by traversing to the tail,
-- it is not enough and we broke math anyway
--
-- Exercise to the reader: mark this function as
-- NON_TERMINATING instead to see how Agda would stop us
-- from breaking math! NON_TERMINATING definitions never reduce
-- during typechecking; rendering them almost useless. They are only used
-- when doing actual user IO AFAIC
{-# TERMINATING #-}
witness : {A : Set}{P : A → Set}{as : Stream A}
→ Any P as → Stream A
witness x with any x
...| on-head {s} _ = s
...| on-tail {s} x' = witness {as = tail s} x'
{-# NON_TERMINATING #-}
witness-satP : {A : Set}{P : A → Set}{as : Stream A}
→ (x : Any P as) → P (head (witness x))
witness-satP x with any x
...| on-head {s} p = p
...| on-tail x' = witness-satP x'
never : {A : Set}(P : A → Set)(as : Stream A) → Any P as
any (never P as) = on-tail (never P (tail as))
-- This is why induction and coinduction can't be mixed! xD
-- note that even marking one of them as non-terminating we still
-- run into trouble
oh-no! : ⊥
oh-no! = witness-satP (never (λ _ → ⊥) nats)
-----------------------------------------
-- Trying Again; with naturals to help --
mutual
data AtF {A : Set}(P : A → Set)
: Stream A → ℕ → Set where
on-head : ∀{s} → P (head s) → AtF P s 0
on-tail : ∀{s n} → At P (tail s) n → AtF P s (suc n)
record At {A : Set}(P : A → Set)(as : Stream A)(i : ℕ) : Set where
coinductive
field
α : AtF P as i
open At
_satisfies_at_ : ∀{s₀}(σ : Beh s₀)(P : State → Set) → ℕ → Set
σ satisfies P at i = At P (proj₁ σ) i
-- Now, we can prove that a for all finite prefixes
-- of an infinite behaviour such that they satisfy P
-- at some observable point, they will satisfy Q at
-- some future obervable point.
-- Note the use of the word observable here! I like to think of coinduction
-- in terms of dominos-chain-reaction. Imagine we want to knock a domino
-- x₀ and we want to reason whether or not it knocks over a domino x'.
-- Now sawy we reason like this:
-- that we x₀ will knock x₁; which in turn will knock x₂; ... and
-- eventually will knock x'. Well; it is induction that guarantees
-- this for us, and induction requires the number of dominoes between
-- x and x' to be countable (isomorphic to ℕ).
--
-- If there truly is an infinite number of dominoes between x and x',
-- it means that no matter how far we get, there will always be
-- at least one domino between where we are and x'; and the wave of
-- knocks will never reach x', hence, that type of reasoning is plain invalid.
--
-- Behaviors are pottentially plain infinite; some systems never stop.
-- We still want to guarantee certain invariants.
--
-- Soundness, as I see it, is a proof that given any behavior σ
-- that eventually satisfy P; and given that P leads to Q;
-- any behaviour that forks of the point where σ satisfied P
-- must satisfy Q; A first sketch in agda could be:
soundness : {P Q : State → Set}
→ ∀{s₀ i}(σ : Beh s₀)(prf : σ satisfies P at i)
→ P l-t Q
→ Σ ℕ (λ j → σ satisfies Q at (j + i)) -- j + i already guarantess it is the future
soundness = {! may-the-force-be-with-us !}
-}
| {
"alphanum_fraction": 0.6032989004,
"avg_line_length": 33.530726257,
"ext": "agda",
"hexsha": "c093fddc44a369b8f21aa09b62397e9b550df7a6",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "391e148f391dc2d246249193788a0d203285b38e",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "lisandrasilva/agda-liveness",
"max_forks_repo_path": "src/Stream.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "391e148f391dc2d246249193788a0d203285b38e",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Apache-2.0"
],
"max_issues_repo_name": "lisandrasilva/agda-liveness",
"max_issues_repo_path": "src/Stream.agda",
"max_line_length": 95,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "391e148f391dc2d246249193788a0d203285b38e",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "lisandrasilva/agda-liveness",
"max_stars_repo_path": "src/Stream.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1827,
"size": 6002
} |
{-# OPTIONS --copatterns #-}
module EmptyInductiveRecord where
mutual
data E : Set where
e : F -> E
record F : Set where
inductive
constructor c
field f : E
open F
data ⊥ : Set where
elim : E → ⊥
elim (e (c x)) = elim x
elim' : E → ⊥
elim' (e y) = elim' (f y)
| {
"alphanum_fraction": 0.5734265734,
"avg_line_length": 13,
"ext": "agda",
"hexsha": "4ecff1c93fb1a2a8fb0ca8e021beb476b94dcf4f",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Succeed/EmptyInductiveRecord.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Succeed/EmptyInductiveRecord.agda",
"max_line_length": 33,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Succeed/EmptyInductiveRecord.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 101,
"size": 286
} |
{-# OPTIONS --no-main #-}
data List (A : Set) : Set where
[] : List A
_∷_ : A → List A → List A
{-# COMPILE GHC List = data Non (Sense) #-} -- should result in warning when compiling
{-# BUILTIN LIST List #-}
{-# BUILTIN NIL [] #-}
{-# BUILTIN CONS _∷_ #-}
| {
"alphanum_fraction": 0.5580524345,
"avg_line_length": 24.2727272727,
"ext": "agda",
"hexsha": "70fa8a4f9ea6f09ea05e9ffbd2d27f932e3e8575",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Succeed/CompileBuiltinListWarning.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Succeed/CompileBuiltinListWarning.agda",
"max_line_length": 86,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Succeed/CompileBuiltinListWarning.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 82,
"size": 267
} |
Subsets and Splits