Search is not available for this dataset
text
string | meta
dict |
|---|---|
-- {-# OPTIONS -v tc.meta:20 #-}
-- Agdalist 2010-09-24 David Leduc
module Issue323 where
data Sigma (A : Set)(B : A -> Set) : Set where
_,_ : (a : A) -> B a -> Sigma A B
data Trivial {A : Set}(a : A) : Set where
trivial : Trivial a
lemma : (A : Set)(x y : A) -> Trivial (x , y)
lemma A x y = trivial | {
"alphanum_fraction": 0.5714285714,
"avg_line_length": 25.6666666667,
"ext": "agda",
"hexsha": "844fa4e83a2685b254b8489ce2a91b39909160ce",
"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": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "masondesu/agda",
"max_forks_repo_path": "test/succeed/Issue323.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "masondesu/agda",
"max_issues_repo_path": "test/succeed/Issue323.agda",
"max_line_length": 46,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/agda-kanso",
"max_stars_repo_path": "test/succeed/Issue323.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": 114,
"size": 308
} |
import Lvl
open import Type
module Type.Functions.Inverse {ℓₗ : Lvl.Level}{ℓₒ₁}{ℓₒ₂} {X : Type{ℓₒ₁}} {Y : Type{ℓₒ₂}} where
open import Function.Domains
open import Type.Functions {ℓₗ}{ℓₒ₁}{ℓₒ₂} {X}{Y}
open import Type.Properties.Empty
open import Type.Properties.Singleton {ℓₒ₁}{ℓₒ₂}
inv : (f : X → Y) → ⦃ _ : Bijective(f) ⦄ → (Y → X)
inv f ⦃ Bijective.intro(proof) ⦄ (y) with proof{y}
... | IsUnit.intro (Unapply.intro x) _ = x
invᵣ : (f : X → Y) → ⦃ _ : Surjective(f) ⦄ → (Y → X)
invᵣ f ⦃ Surjective.intro(proof) ⦄ (y) with proof{y}
... | ◊.intro ⦃ Unapply.intro x ⦄ = x
| {
"alphanum_fraction": 0.6305841924,
"avg_line_length": 32.3333333333,
"ext": "agda",
"hexsha": "387b1dc0fb1b06dadc7513b586a42b401c9c00e4",
"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/Type/Functions/Inverse.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/Type/Functions/Inverse.agda",
"max_line_length": 94,
"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/Type/Functions/Inverse.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": 259,
"size": 582
} |
module Issue2486.HaskellB where
{-# FOREIGN GHC import qualified MAlonzo.Code.Issue2486.ImportB as B #-}
{-# FOREIGN GHC
data Test = Con B.BBool
#-}
| {
"alphanum_fraction": 0.7189542484,
"avg_line_length": 15.3,
"ext": "agda",
"hexsha": "c6706f8467fa723770e91f8a29f7cea10a33a1e2",
"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/Issue2486/HaskellB.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/Issue2486/HaskellB.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/Compiler/simple/Issue2486/HaskellB.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": 43,
"size": 153
} |
module FreeVarPresheaves where
open import Data.Nat as Nat
import Level
open import Categories.Category
open import Categories.Presheaf
open import Relation.Binary.Core
open import Relation.Binary
open import Function using (flip)
module DTO = DecTotalOrder Nat.decTotalOrder
data ℕ-≤-eq {n m : ℕ} : Rel (n ≤ m) Level.zero where
triv-eq : ∀ {p q} → ℕ-≤-eq p q
ℕ-≤-eq-equivRel : ∀ {n m} → IsEquivalence (ℕ-≤-eq {n} {m})
ℕ-≤-eq-equivRel = record
{ refl = triv-eq
; sym = λ _ → triv-eq
; trans = λ _ _ → triv-eq
}
{-
trans-assoc : ∀ {a ℓ} {A : Set a} →
{_<_ : Rel A ℓ} →
{trans : Transitive _<_} →
∀ {w x y z : A} → ∀{p : w < x} → ∀{q : x < y} → ∀{r : y < z} →
(trans p (trans q r)) ≡ (trans (trans p q) r)
trans-assoc = {!!}
-}
ℕ-≤-eq-assoc : {m n k i : ℕ} {p : m ≤ n} {q : n ≤ k} {r : k ≤ i} →
ℕ-≤-eq (DTO.trans p (DTO.trans q r)) (DTO.trans (DTO.trans p q) r)
ℕ-≤-eq-assoc = triv-eq
trans-resp-ℕ-≤-eq : {m n k : ℕ} {p r : n ≤ k} {q s : m ≤ n} →
ℕ-≤-eq p r → ℕ-≤-eq q s → ℕ-≤-eq (DTO.trans q p) (DTO.trans s r)
trans-resp-ℕ-≤-eq _ _ = triv-eq
op : Category Level.zero Level.zero Level.zero
op = record
{ Obj = ℕ
; _⇒_ = Nat._≤_
; _≡_ = ℕ-≤-eq
; _∘_ = flip DTO.trans
; id = DTO.refl
; assoc = ℕ-≤-eq-assoc
; identityˡ = triv-eq
; identityʳ = triv-eq
; equiv = ℕ-≤-eq-equivRel
; ∘-resp-≡ = trans-resp-ℕ-≤-eq
}
Ctx a = List (Var a)
data Var : (Γ : Ctx) → Set where
zero : ∀{Γ} → TyVar (Γ + 1)
succ : ∀{Γ} (x : TyVar Γ) → TyVar (Γ + 1)
| {
"alphanum_fraction": 0.5449141347,
"avg_line_length": 25.6610169492,
"ext": "agda",
"hexsha": "17d8622b3cc6885f0cef06be371c5a6868259f00",
"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": "8fc7a6cd878f37f9595124ee8dea62258da28aa4",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "hbasold/Sandbox",
"max_forks_repo_path": "TypeTheory/Common/FreeVarPresheaves.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "8fc7a6cd878f37f9595124ee8dea62258da28aa4",
"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": "hbasold/Sandbox",
"max_issues_repo_path": "TypeTheory/Common/FreeVarPresheaves.agda",
"max_line_length": 68,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "8fc7a6cd878f37f9595124ee8dea62258da28aa4",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "hbasold/Sandbox",
"max_stars_repo_path": "TypeTheory/Common/FreeVarPresheaves.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 677,
"size": 1514
} |
-- Andreas, 2015-08-27 Allow rewrite rules for symbols defined in other file
{-# OPTIONS --rewriting #-}
open import Common.Nat
open import Common.Equality
{-# BUILTIN REWRITE _≡_ #-}
x+0 : ∀ x → x + 0 ≡ x
x+0 zero = refl
x+0 (suc x) rewrite x+0 x = refl
{-# REWRITE x+0 #-} -- adding rewrite rule for + is ok
x+0+0 : ∀{x} → (x + 0) + 0 ≡ x
x+0+0 = refl
| {
"alphanum_fraction": 0.6066481994,
"avg_line_length": 20.0555555556,
"ext": "agda",
"hexsha": "5f3b6f290199713b5c3fb1811753479ecb085d7a",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "alhassy/agda",
"max_forks_repo_path": "test/Succeed/Issue1550.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/Issue1550.agda",
"max_line_length": 76,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "alhassy/agda",
"max_stars_repo_path": "test/Succeed/Issue1550.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": 136,
"size": 361
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- A universe which includes several kinds of "relatedness" for sets,
-- such as equivalences, surjections and bijections
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Function.Related where
open import Level
open import Function
open import Function.Equality using (_⟨$⟩_)
open import Function.Equivalence as Eq using (Equivalence)
open import Function.Injection as Inj using (Injection; _↣_)
open import Function.Inverse as Inv using (Inverse; _↔_)
open import Function.LeftInverse as LeftInv using (LeftInverse)
open import Function.Surjection as Surj using (Surjection)
open import Relation.Binary
open import Relation.Binary.PropositionalEquality as P using (_≡_)
------------------------------------------------------------------------
-- Wrapper types
-- Synonyms which are used to make _∼[_]_ below "constructor-headed"
-- (which implies that Agda can deduce the universe code from an
-- expression matching any of the right-hand sides).
record _←_ {a b} (A : Set a) (B : Set b) : Set (a ⊔ b) where
constructor lam
field app-← : B → A
open _←_ public
record _↢_ {a b} (A : Set a) (B : Set b) : Set (a ⊔ b) where
constructor lam
field app-↢ : B ↣ A
open _↢_ public
------------------------------------------------------------------------
-- Relatedness
-- There are several kinds of "relatedness".
-- The idea to include kinds other than equivalence and bijection came
-- from Simon Thompson and Bengt Nordström. /NAD
data Kind : Set where
implication : Kind
reverse-implication : Kind
equivalence : Kind
injection : Kind
reverse-injection : Kind
left-inverse : Kind
surjection : Kind
bijection : Kind
-- Interpretation of the codes above. The code "bijection" is
-- interpreted as Inverse rather than Bijection; the two types are
-- equivalent.
infix 4 _∼[_]_
_∼[_]_ : ∀ {ℓ₁ ℓ₂} → Set ℓ₁ → Kind → Set ℓ₂ → Set _
A ∼[ implication ] B = A → B
A ∼[ reverse-implication ] B = A ← B
A ∼[ equivalence ] B = Equivalence (P.setoid A) (P.setoid B)
A ∼[ injection ] B = Injection (P.setoid A) (P.setoid B)
A ∼[ reverse-injection ] B = A ↢ B
A ∼[ left-inverse ] B = LeftInverse (P.setoid A) (P.setoid B)
A ∼[ surjection ] B = Surjection (P.setoid A) (P.setoid B)
A ∼[ bijection ] B = Inverse (P.setoid A) (P.setoid B)
-- A non-infix synonym.
Related : Kind → ∀ {ℓ₁ ℓ₂} → Set ℓ₁ → Set ℓ₂ → Set _
Related k A B = A ∼[ k ] B
-- The bijective equality implies any kind of relatedness.
↔⇒ : ∀ {k x y} {X : Set x} {Y : Set y} →
X ∼[ bijection ] Y → X ∼[ k ] Y
↔⇒ {implication} = _⟨$⟩_ ∘ Inverse.to
↔⇒ {reverse-implication} = lam ∘′ _⟨$⟩_ ∘ Inverse.from
↔⇒ {equivalence} = Inverse.equivalence
↔⇒ {injection} = Inverse.injection
↔⇒ {reverse-injection} = lam ∘′ Inverse.injection ∘ Inv.sym
↔⇒ {left-inverse} = Inverse.left-inverse
↔⇒ {surjection} = Inverse.surjection
↔⇒ {bijection} = id
-- Actual equality also implies any kind of relatedness.
≡⇒ : ∀ {k ℓ} {X Y : Set ℓ} → X ≡ Y → X ∼[ k ] Y
≡⇒ P.refl = ↔⇒ Inv.id
------------------------------------------------------------------------
-- Special kinds of kinds
-- Kinds whose interpretation is symmetric.
data Symmetric-kind : Set where
equivalence : Symmetric-kind
bijection : Symmetric-kind
-- Forgetful map.
⌊_⌋ : Symmetric-kind → Kind
⌊ equivalence ⌋ = equivalence
⌊ bijection ⌋ = bijection
-- The proof of symmetry can be found below.
-- Kinds whose interpretation include a function which "goes in the
-- forward direction".
data Forward-kind : Set where
implication : Forward-kind
equivalence : Forward-kind
injection : Forward-kind
left-inverse : Forward-kind
surjection : Forward-kind
bijection : Forward-kind
-- Forgetful map.
⌊_⌋→ : Forward-kind → Kind
⌊ implication ⌋→ = implication
⌊ equivalence ⌋→ = equivalence
⌊ injection ⌋→ = injection
⌊ left-inverse ⌋→ = left-inverse
⌊ surjection ⌋→ = surjection
⌊ bijection ⌋→ = bijection
-- The function.
⇒→ : ∀ {k x y} {X : Set x} {Y : Set y} → X ∼[ ⌊ k ⌋→ ] Y → X → Y
⇒→ {implication} = id
⇒→ {equivalence} = _⟨$⟩_ ∘ Equivalence.to
⇒→ {injection} = _⟨$⟩_ ∘ Injection.to
⇒→ {left-inverse} = _⟨$⟩_ ∘ LeftInverse.to
⇒→ {surjection} = _⟨$⟩_ ∘ Surjection.to
⇒→ {bijection} = _⟨$⟩_ ∘ Inverse.to
-- Kinds whose interpretation include a function which "goes backwards".
data Backward-kind : Set where
reverse-implication : Backward-kind
equivalence : Backward-kind
reverse-injection : Backward-kind
left-inverse : Backward-kind
surjection : Backward-kind
bijection : Backward-kind
-- Forgetful map.
⌊_⌋← : Backward-kind → Kind
⌊ reverse-implication ⌋← = reverse-implication
⌊ equivalence ⌋← = equivalence
⌊ reverse-injection ⌋← = reverse-injection
⌊ left-inverse ⌋← = left-inverse
⌊ surjection ⌋← = surjection
⌊ bijection ⌋← = bijection
-- The function.
⇒← : ∀ {k x y} {X : Set x} {Y : Set y} → X ∼[ ⌊ k ⌋← ] Y → Y → X
⇒← {reverse-implication} = app-←
⇒← {equivalence} = _⟨$⟩_ ∘ Equivalence.from
⇒← {reverse-injection} = _⟨$⟩_ ∘ Injection.to ∘ app-↢
⇒← {left-inverse} = _⟨$⟩_ ∘ LeftInverse.from
⇒← {surjection} = _⟨$⟩_ ∘ Surjection.from
⇒← {bijection} = _⟨$⟩_ ∘ Inverse.from
-- Kinds whose interpretation include functions going in both
-- directions.
data Equivalence-kind : Set where
equivalence : Equivalence-kind
left-inverse : Equivalence-kind
surjection : Equivalence-kind
bijection : Equivalence-kind
-- Forgetful map.
⌊_⌋⇔ : Equivalence-kind → Kind
⌊ equivalence ⌋⇔ = equivalence
⌊ left-inverse ⌋⇔ = left-inverse
⌊ surjection ⌋⇔ = surjection
⌊ bijection ⌋⇔ = bijection
-- The functions.
⇒⇔ : ∀ {k x y} {X : Set x} {Y : Set y} →
X ∼[ ⌊ k ⌋⇔ ] Y → X ∼[ equivalence ] Y
⇒⇔ {equivalence} = id
⇒⇔ {left-inverse} = LeftInverse.equivalence
⇒⇔ {surjection} = Surjection.equivalence
⇒⇔ {bijection} = Inverse.equivalence
-- Conversions between special kinds.
⇔⌊_⌋ : Symmetric-kind → Equivalence-kind
⇔⌊ equivalence ⌋ = equivalence
⇔⌊ bijection ⌋ = bijection
→⌊_⌋ : Equivalence-kind → Forward-kind
→⌊ equivalence ⌋ = equivalence
→⌊ left-inverse ⌋ = left-inverse
→⌊ surjection ⌋ = surjection
→⌊ bijection ⌋ = bijection
←⌊_⌋ : Equivalence-kind → Backward-kind
←⌊ equivalence ⌋ = equivalence
←⌊ left-inverse ⌋ = left-inverse
←⌊ surjection ⌋ = surjection
←⌊ bijection ⌋ = bijection
------------------------------------------------------------------------
-- Opposites
-- For every kind there is an opposite kind.
_op : Kind → Kind
implication op = reverse-implication
reverse-implication op = implication
equivalence op = equivalence
injection op = reverse-injection
reverse-injection op = injection
left-inverse op = surjection
surjection op = left-inverse
bijection op = bijection
-- For every morphism there is a corresponding reverse morphism of the
-- opposite kind.
reverse : ∀ {k a b} {A : Set a} {B : Set b} →
A ∼[ k ] B → B ∼[ k op ] A
reverse {implication} = lam
reverse {reverse-implication} = app-←
reverse {equivalence} = Eq.sym
reverse {injection} = lam
reverse {reverse-injection} = app-↢
reverse {left-inverse} = Surj.fromRightInverse
reverse {surjection} = Surjection.right-inverse
reverse {bijection} = Inv.sym
------------------------------------------------------------------------
-- For a fixed universe level every kind is a preorder and each
-- symmetric kind is an equivalence
K-refl : ∀ {k ℓ} → Reflexive (Related k {ℓ})
K-refl {implication} = id
K-refl {reverse-implication} = lam id
K-refl {equivalence} = Eq.id
K-refl {injection} = Inj.id
K-refl {reverse-injection} = lam Inj.id
K-refl {left-inverse} = LeftInv.id
K-refl {surjection} = Surj.id
K-refl {bijection} = Inv.id
K-reflexive : ∀ {k ℓ} → _≡_ ⇒ Related k {ℓ}
K-reflexive P.refl = K-refl
K-trans : ∀ {k ℓ₁ ℓ₂ ℓ₃} → Trans (Related k {ℓ₁} {ℓ₂})
(Related k {ℓ₂} {ℓ₃})
(Related k {ℓ₁} {ℓ₃})
K-trans {implication} = flip _∘′_
K-trans {reverse-implication} = λ f g → lam (app-← f ∘ app-← g)
K-trans {equivalence} = flip Eq._∘_
K-trans {injection} = flip Inj._∘_
K-trans {reverse-injection} = λ f g → lam (Inj._∘_ (app-↢ f) (app-↢ g))
K-trans {left-inverse} = flip LeftInv._∘_
K-trans {surjection} = flip Surj._∘_
K-trans {bijection} = flip Inv._∘_
SK-sym : ∀ {k ℓ₁ ℓ₂} → Sym (Related ⌊ k ⌋ {ℓ₁} {ℓ₂})
(Related ⌊ k ⌋ {ℓ₂} {ℓ₁})
SK-sym {equivalence} = Eq.sym
SK-sym {bijection} = Inv.sym
SK-isEquivalence : ∀ k ℓ → IsEquivalence {ℓ = ℓ} (Related ⌊ k ⌋)
SK-isEquivalence k ℓ = record
{ refl = K-refl
; sym = SK-sym
; trans = K-trans
}
SK-setoid : Symmetric-kind → (ℓ : Level) → Setoid _ _
SK-setoid k ℓ = record { isEquivalence = SK-isEquivalence k ℓ }
K-isPreorder : ∀ k ℓ → IsPreorder _↔_ (Related k)
K-isPreorder k ℓ = record
{ isEquivalence = SK-isEquivalence bijection ℓ
; reflexive = ↔⇒
; trans = K-trans
}
K-preorder : Kind → (ℓ : Level) → Preorder _ _ _
K-preorder k ℓ = record { isPreorder = K-isPreorder k ℓ }
------------------------------------------------------------------------
-- Equational reasoning
-- Equational reasoning for related things.
module EquationalReasoning where
infix 3 _∎
infixr 2 _∼⟨_⟩_ _↔⟨_⟩_ _↔⟨⟩_ _≡⟨_⟩_
_∼⟨_⟩_ : ∀ {k x y z} (X : Set x) {Y : Set y} {Z : Set z} →
X ∼[ k ] Y → Y ∼[ k ] Z → X ∼[ k ] Z
_ ∼⟨ X↝Y ⟩ Y↝Z = K-trans X↝Y Y↝Z
-- Isomorphisms can be combined with any other kind of relatedness.
_↔⟨_⟩_ : ∀ {k x y z} (X : Set x) {Y : Set y} {Z : Set z} →
X ↔ Y → Y ∼[ k ] Z → X ∼[ k ] Z
X ↔⟨ X↔Y ⟩ Y⇔Z = X ∼⟨ ↔⇒ X↔Y ⟩ Y⇔Z
_↔⟨⟩_ : ∀ {k x y} (X : Set x) {Y : Set y} →
X ∼[ k ] Y → X ∼[ k ] Y
X ↔⟨⟩ X⇔Y = X⇔Y
_≡⟨_⟩_ : ∀ {k ℓ z} (X : Set ℓ) {Y : Set ℓ} {Z : Set z} →
X ≡ Y → Y ∼[ k ] Z → X ∼[ k ] Z
X ≡⟨ X≡Y ⟩ Y⇔Z = X ∼⟨ ≡⇒ X≡Y ⟩ Y⇔Z
_∎ : ∀ {k x} (X : Set x) → X ∼[ k ] X
X ∎ = K-refl
sym = SK-sym
{-# WARNING_ON_USAGE sym
"Warning: EquationalReasoning.sym was deprecated in v0.17.
Please use SK-sym instead."
#-}
------------------------------------------------------------------------
-- Every unary relation induces a preorder and, for symmetric kinds,
-- an equivalence. (No claim is made that these relations are unique.)
InducedRelation₁ : Kind → ∀ {a s} {A : Set a} →
(A → Set s) → A → A → Set _
InducedRelation₁ k S = λ x y → S x ∼[ k ] S y
InducedPreorder₁ : Kind → ∀ {a s} {A : Set a} →
(A → Set s) → Preorder _ _ _
InducedPreorder₁ k S = record
{ _≈_ = _≡_
; _∼_ = InducedRelation₁ k S
; isPreorder = record
{ isEquivalence = P.isEquivalence
; reflexive = reflexive ∘
K-reflexive ∘
P.cong S
; trans = K-trans
}
} where open Preorder (K-preorder _ _)
InducedEquivalence₁ : Symmetric-kind → ∀ {a s} {A : Set a} →
(A → Set s) → Setoid _ _
InducedEquivalence₁ k S = record
{ _≈_ = InducedRelation₁ ⌊ k ⌋ S
; isEquivalence = record
{ refl = K-refl
; sym = SK-sym
; trans = K-trans
}
}
------------------------------------------------------------------------
-- Every binary relation induces a preorder and, for symmetric kinds,
-- an equivalence. (No claim is made that these relations are unique.)
InducedRelation₂ : Kind → ∀ {a b s} {A : Set a} {B : Set b} →
(A → B → Set s) → B → B → Set _
InducedRelation₂ k _S_ = λ x y → ∀ {z} → (z S x) ∼[ k ] (z S y)
InducedPreorder₂ : Kind → ∀ {a b s} {A : Set a} {B : Set b} →
(A → B → Set s) → Preorder _ _ _
InducedPreorder₂ k _S_ = record
{ _≈_ = _≡_
; _∼_ = InducedRelation₂ k _S_
; isPreorder = record
{ isEquivalence = P.isEquivalence
; reflexive = λ x≡y {z} →
reflexive $
K-reflexive $
P.cong (_S_ z) x≡y
; trans = λ i↝j j↝k → K-trans i↝j j↝k
}
} where open Preorder (K-preorder _ _)
InducedEquivalence₂ : Symmetric-kind →
∀ {a b s} {A : Set a} {B : Set b} →
(A → B → Set s) → Setoid _ _
InducedEquivalence₂ k _S_ = record
{ _≈_ = InducedRelation₂ ⌊ k ⌋ _S_
; isEquivalence = record
{ refl = refl
; sym = λ i↝j → sym i↝j
; trans = λ i↝j j↝k → trans i↝j j↝k
}
} where open Setoid (SK-setoid _ _)
------------------------------------------------------------------------
-- DEPRECATED NAMES
------------------------------------------------------------------------
-- Please use the new names as continuing support for the old names is
-- not guaranteed.
-- Version 0.17
preorder = K-preorder
{-# WARNING_ON_USAGE preorder
"Warning: preorder was deprecated in v0.17.
Please use K-preorder instead."
#-}
setoid = SK-setoid
{-# WARNING_ON_USAGE setoid
"Warning: setoid was deprecated in v0.17.
Please use SK-setoid instead."
#-}
| {
"alphanum_fraction": 0.5538984052,
"avg_line_length": 31.6448598131,
"ext": "agda",
"hexsha": "855428beb515d5ffdc533f646c68008e5c06c992",
"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/Function/Related.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/Function/Related.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/Function/Related.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 4531,
"size": 13544
} |
{-
An experiment of transporting rev-++-distr from lists to lists where
the arguments to cons have been flipped inspired by section 2 of
https://arxiv.org/abs/2010.00774
Note that Agda doesn't care about the order of constructors so we
can't do exactly the same example.
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Experiments.List where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Univalence
open import Cubical.Data.Sigma
infixr 5 _∷_
infixl 5 _∷'_
infixr 5 _++_
-- Normal lists
data List (A : Type) : Type where
[] : List A
_∷_ : (x : A) (xs : List A) → List A
-- Lists where the arguments to cons have been flipped
data List' (A : Type) : Type where
[] : List' A
_∷'_ : (xs : List' A) (x : A) → List' A
variable
A : Type
-- Some operations and properties for List
_++_ : List A → List A → List A
[] ++ ys = ys
(x ∷ xs) ++ ys = x ∷ xs ++ ys
rev : List A → List A
rev [] = []
rev (x ∷ xs) = rev xs ++ (x ∷ [])
++-unit-r : (xs : List A) → xs ++ [] ≡ xs
++-unit-r [] = refl
++-unit-r (x ∷ xs) = cong (_∷_ x) (++-unit-r xs)
++-assoc : (xs ys zs : List A) → (xs ++ ys) ++ zs ≡ xs ++ ys ++ zs
++-assoc [] ys zs = refl
++-assoc (x ∷ xs) ys zs = cong (_∷_ x) (++-assoc xs ys zs)
rev-++-distr : (xs ys : List A) → rev (xs ++ ys) ≡ rev ys ++ rev xs
rev-++-distr [] ys = sym (++-unit-r (rev ys))
rev-++-distr (x ∷ xs) ys = cong (_++ _) (rev-++-distr xs ys) ∙ ++-assoc (rev ys) (rev xs) (x ∷ [])
-- We now want to transport this to List'. For this we first establish
-- an isomorphism of the types.
toList' : List A → List' A
toList' [] = []
toList' (x ∷ xs) = toList' xs ∷' x
fromList' : List' A → List A
fromList' [] = []
fromList' (xs ∷' x) = x ∷ fromList' xs
toFrom : (xs : List' A) → toList' (fromList' xs) ≡ xs
toFrom [] = refl
toFrom (xs ∷' x) i = toFrom xs i ∷' x
fromTo : (xs : List A) → fromList' (toList' xs) ≡ xs
fromTo [] = refl
fromTo (x ∷ xs) i = x ∷ fromTo xs i
ListIso : Iso (List A) (List' A)
ListIso = iso toList' fromList' toFrom fromTo
ListEquiv : List A ≃ List' A
ListEquiv = isoToEquiv ListIso
-- We then use univalence to turn this into a path
ListPath : (A : Type) → List A ≡ List' A
ListPath A = isoToPath (ListIso {A = A})
-- We can now use this path to transport the operations and properties
-- from List to List'
module transport where
-- First make a suitable Σ-type packaging what we need for the
-- transport (note that _++_ and rev here are part of the Σ-type).
-- It should be possible to automatically generate this given a module/file.
T : Type → Type
T X = Σ[ _++_ ∈ (X → X → X) ] Σ[ rev ∈ (X → X) ] ((xs ys : X) → rev (xs ++ ys) ≡ rev ys ++ rev xs)
-- We can now transport the instance of T for List to List'
T-List' : T (List' A)
T-List' {A = A} = transport (λ i → T (ListPath A i)) (_++_ , rev , rev-++-distr)
-- Getting the operations and property for List' is then just a matter of projecting them out
_++'_ : List' A → List' A → List' A
_++'_ = T-List' .fst
rev' : List' A → List' A
rev' = T-List' .snd .fst
rev-++-distr' : (xs ys : List' A) → rev' (xs ++' ys) ≡ rev' ys ++' rev' xs
rev-++-distr' = T-List' .snd .snd
-- To connect this with the Cubical Agda paper consider the following
-- (painfully) manual transport. This is really what the above code
-- unfolds to.
module manualtransport where
_++'_ : List' A → List' A → List' A
_++'_ {A = A} = transport (λ i → ListPath A i → ListPath A i → ListPath A i) _++_
rev' : List' A → List' A
rev' {A = A} = transport (λ i → ListPath A i → ListPath A i) rev
rev-++-distr' : (xs ys : List' A) → rev' (xs ++' ys) ≡ rev' ys ++' rev' xs
rev-++-distr' {A = A} = transport (λ i → (xs ys : ListPath A i)
→ revP i (appP i xs ys) ≡ appP i (revP i ys) (revP i xs))
rev-++-distr
where
appP : PathP (λ i → ListPath A i → ListPath A i → ListPath A i) _++_ _++'_
appP i = transp (λ j → ListPath A (i ∧ j) → ListPath A (i ∧ j) → ListPath A (i ∧ j)) (~ i) _++_
revP : PathP (λ i → ListPath A i → ListPath A i) rev rev'
revP i = transp (λ j → ListPath A (i ∧ j) → ListPath A (i ∧ j)) (~ i) rev
-- The above operations for List' are derived by going back and
-- forth. With the SIP we can do better and transport properties for
-- user defined operations (assuming that the operations are
-- well-defined wrt to the forward direction of the equivalence).
open import Cubical.Foundations.SIP
open import Cubical.Structures.Axioms
open import Cubical.Structures.Product
open import Cubical.Structures.Pointed
open import Cubical.Structures.Function
-- For illustrative purposes we first apply the SIP manually. This
-- requires quite a bit of boilerplate code which is automated in the
-- next module.
module manualSIP (A : Type) where
-- First define the raw structure without axioms. This is just the
-- signature of _++_ and rev.
RawStruct : Type → Type
RawStruct X = (X → X → X) × (X → X)
-- Some boilerplate code which can be automated
e1 : StrEquiv (λ x → x → x → x) ℓ-zero
e1 = FunctionEquivStr+ pointedEquivAction
(FunctionEquivStr+ pointedEquivAction PointedEquivStr)
e2 : StrEquiv (λ x → x → x) ℓ-zero
e2 = FunctionEquivStr+ pointedEquivAction PointedEquivStr
RawEquivStr : StrEquiv RawStruct _
RawEquivStr = ProductEquivStr e1 e2
rawUnivalentStr : UnivalentStr _ RawEquivStr
rawUnivalentStr = productUnivalentStr e1 he1 e2 he2
where
he2 : UnivalentStr (λ z → z → z) e2
he2 = functionUnivalentStr+ pointedEquivAction pointedTransportStr
PointedEquivStr pointedUnivalentStr
he1 : UnivalentStr (λ z → z → z → z) e1
he1 = functionUnivalentStr+ pointedEquivAction pointedTransportStr e2 he2
-- Now the property that we want to transport
P : (X : Type) → RawStruct X → Type
P X (_++_ , rev) = ((xs ys : X) → rev (xs ++ ys) ≡ rev ys ++ rev xs)
-- Package things up for List
List-Struct : Σ[ X ∈ Type ] (Σ[ s ∈ RawStruct X ] (P X s))
List-Struct = List A , (_++_ , rev) , rev-++-distr
-- We now give direct definitions of ++' and rev' for List'
_++'_ : List' A → List' A → List' A
[] ++' ys = ys
(xs ∷' x) ++' ys = (xs ++' ys) ∷' x
rev' : List' A → List' A
rev' [] = []
rev' (xs ∷' x) = rev' xs ++' ([] ∷' x)
-- We then package this up into a raw structure on List'
List'-RawStruct : Σ[ X ∈ Type ] (RawStruct X)
List'-RawStruct = List' A , (_++'_ , rev')
-- Finally we prove that toList' commutes with _++_ and rev. Note
-- that this could be a lot more complex, see for example the Matrix
-- example (Cubical.Algebra.Matrix).
toList'-++ : (xs ys : List A) → toList' (xs ++ ys) ≡ toList' xs ++' toList' ys
toList'-++ [] ys = refl
toList'-++ (x ∷ xs) ys i = toList'-++ xs ys i ∷' x
toList'-rev : (xs : List A) → toList' (rev xs) ≡ rev' (toList' xs)
toList'-rev [] = refl
toList'-rev (x ∷ xs) = toList'-++ (rev xs) (x ∷ []) ∙ cong (_++' ([] ∷' x)) (toList'-rev xs)
-- We can now get the property for ++' and rev' via the SIP
rev-++-distr' : (xs ys : List' A) → rev' (xs ++' ys) ≡ rev' ys ++' rev' xs
rev-++-distr' = transferAxioms rawUnivalentStr List-Struct List'-RawStruct
(ListEquiv , toList'-++ , toList'-rev)
-- Note that rev-++-distr' is really talking about the direct
-- definitions of ++' and rev', not the transported operations as in
-- the previous attempt.
-- We now automate parts of the above construction
open import Cubical.Structures.Auto
module SIP-auto (A : Type) where
-- First define the raw structure without axioms. This is just the
-- signature of _++_ and rev.
RawStruct : Type → Type
RawStruct X = (X → X → X) × (X → X)
-- Some automated SIP magic
RawEquivStr : _
RawEquivStr = AutoEquivStr RawStruct
rawUnivalentStr : UnivalentStr _ RawEquivStr
rawUnivalentStr = autoUnivalentStr RawStruct
-- Now the property that we want to transport
P : (X : Type) → RawStruct X → Type
P X (_++_ , rev) = ((xs ys : X) → rev (xs ++ ys) ≡ rev ys ++ rev xs)
-- Package things up for List
List-Struct : Σ[ X ∈ Type ] (Σ[ s ∈ RawStruct X ] (P X s))
List-Struct = List A , (_++_ , rev) , rev-++-distr
-- We now give direct definitions of ++' and rev' for List'
_++'_ : List' A → List' A → List' A
[] ++' ys = ys
(xs ∷' x) ++' ys = (xs ++' ys) ∷' x
rev' : List' A → List' A
rev' [] = []
rev' (xs ∷' x) = rev' xs ++' ([] ∷' x)
-- We then package this up into a raw structure on List'
List'-RawStruct : Σ[ X ∈ Type ] (RawStruct X)
List'-RawStruct = List' A , (_++'_ , rev')
-- Finally we prove that toList' commutes with _++_ and rev. Note
-- that this could be a lot more complex, see for example the Matrix
-- example (Cubical.Algebra.Matrix).
toList'-++ : (xs ys : List A) → toList' (xs ++ ys) ≡ toList' xs ++' toList' ys
toList'-++ [] ys = refl
toList'-++ (x ∷ xs) ys i = toList'-++ xs ys i ∷' x
toList'-rev : (xs : List A) → toList' (rev xs) ≡ rev' (toList' xs)
toList'-rev [] = refl
toList'-rev (x ∷ xs) = toList'-++ (rev xs) (x ∷ []) ∙ cong (_++' ([] ∷' x)) (toList'-rev xs)
-- We can now get the property for ++' and rev' via the SIP
rev-++-distr' : (xs ys : List' A) → rev' (xs ++' ys) ≡ rev' ys ++' rev' xs
rev-++-distr' = transferAxioms rawUnivalentStr List-Struct List'-RawStruct
(ListEquiv , toList'-++ , toList'-rev)
-- Note that rev-++-distr' is really talking about the direct
-- definitions of ++' and rev', not the transported operations as in
-- the previous attempt.
| {
"alphanum_fraction": 0.6041368011,
"avg_line_length": 34.1468531469,
"ext": "agda",
"hexsha": "5cd54deba3c3ee3306d64f16eb1ca6f79579f978",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "dan-iel-lee/cubical",
"max_forks_repo_path": "Cubical/Experiments/List.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/Experiments/List.agda",
"max_line_length": 100,
"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/Experiments/List.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 3320,
"size": 9766
} |
-- {-# OPTIONS -v tc.meta:100 #-}
-- Andreas, 2011-04-20
-- see Abel Pientka TLCA 2011
module PruningNonMillerPattern where
data _≡_ {A : Set}(a : A) : A -> Set where
refl : a ≡ a
data Nat : Set where
zero : Nat
suc : Nat -> Nat
-- bad variable y in head position
test : let X : Nat -> Nat -> Nat
X = _
Y : Nat -> Nat -> Nat
Y = _
in (C : Set) ->
(({x y : Nat} -> X x x ≡ suc (Y x y)) ->
({x y : Nat} -> Y x x ≡ x) ->
({x y : Nat} -> X (Y x y) y ≡ X x x) -> C) -> C
test C k = k refl refl refl
{- none of these equations is immediately solvable. However,
from 1. we deduce that Y does not depend on its second argument, thus
from 2. we solve Y x y = x, and then
eqn. 3. simplifies to X x y = X x x, thus, X does not depend on its second arg,
we can then solve using 1. X x y = suc x
-}
-- a variant, where pruning is even triggered from a non-pattern
test' : let X : Nat -> Nat -> Nat
X = _
Y : Nat -> Nat -> Nat
Y = _
in (C : Set) ->
(({x y : Nat} -> X x (suc x) ≡ suc (Y x y)) -> -- non-pattern lhs
({x y : Nat} -> Y x x ≡ x) ->
({x y : Nat} -> X (Y x y) y ≡ X x x) -> C) -> C
test' C k = k refl refl refl
-- another variant, where the pruned argument does not have an offending
-- variable in the head, but in a non-eliminateable position
-- (argument to a datatype)
data Sing {A : Set} : A → Set where
sing : (x : A) -> Sing x
-- bad rigid under a data type constructor
test2 : let X : Nat -> Nat -> Nat
X = _
Y : Nat → Set -> Nat
Y = _
in (C : Set) ->
(({x y : Nat} -> X x x ≡ suc (Y x (Sing (suc y)))) ->
({x y : Nat} -> Y x (Sing x) ≡ x) ->
({x y : Nat} -> X (Y x (Sing y)) y ≡ X x x) -> C) -> C
test2 C k = k refl refl refl
T : Nat → Set
T zero = Nat
T (suc _) = Nat → Nat
-- bad rigid y under a Pi type constructor
test3 : let X : Nat -> Nat -> Nat
X = _
Y : Nat → Set -> Nat
Y = _
in (C : Set) ->
(({x y : Nat} -> X x x ≡ suc (Y x (T y -> T y))) ->
({x y : Nat} -> Y x (Sing x) ≡ x) ->
({x y : Nat} -> X (Y x (Sing y)) y ≡ X x x) -> C) -> C
test3 C k = k refl refl refl
-- bad rigid y in head position under a lambda
test4 : let X : Nat -> Nat -> Nat
X = _
Y : Nat → (Nat → Nat) -> Nat
Y = _
in (C : Set) ->
((∀ {x : Nat} {y : Nat → Nat} -> X x x ≡ suc (Y x (λ k → y zero))) ->
(∀ {x : Nat} {y : Nat → Nat} -> Y x (λ k → y zero) ≡ x) ->
(∀ {x : Nat} {y : Nat } -> X (Y x (λ k → y)) y ≡ X x x) -> C) -> C
test4 C k = k refl refl refl
-- bad variable in irrelevant position
test5 : let X : Nat -> Nat -> Nat
X = _
Y : Nat -> .Nat -> Nat
Y = _
in (C : Set) ->
(({x y : Nat} -> X x (suc x) ≡ suc (Y x (suc y))) -> -- non-pattern lhs
({x y : Nat} -> Y x x ≡ x) ->
({x y : Nat} -> X (Y x (suc y)) y ≡ X x x) -> C) -> C
test5 C k = k refl refl refl
| {
"alphanum_fraction": 0.4346082665,
"avg_line_length": 34.1263157895,
"ext": "agda",
"hexsha": "c0d0bd91f1dae9864bb7108b3083f339a718d996",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "20596e9dd9867166a64470dd24ea68925ff380ce",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "np/agda-git-experiment",
"max_forks_repo_path": "test/succeed/PruningNonMillerPattern.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "20596e9dd9867166a64470dd24ea68925ff380ce",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "np/agda-git-experiment",
"max_issues_repo_path": "test/succeed/PruningNonMillerPattern.agda",
"max_line_length": 84,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "20596e9dd9867166a64470dd24ea68925ff380ce",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "np/agda-git-experiment",
"max_stars_repo_path": "test/succeed/PruningNonMillerPattern.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": 1094,
"size": 3242
} |
module BTree.Equality.Properties {A : Set} where
open import BTree {A}
open import BTree.Equality {A}
open import Relation.Binary.Core
trans≃ : Transitive _≃_
trans≃ ≃lf ≃lf = ≃lf
trans≃ (≃nd x x' l≃r l≃l' l'≃r') (≃nd .x' x'' _ l'≃l'' l''≃r'') = ≃nd x x'' l≃r (trans≃ l≃l' l'≃l'') l''≃r''
symm≃ : Symmetric _≃_
symm≃ ≃lf = ≃lf
symm≃ (≃nd x x' l≃r l≃l' l'≃r') = ≃nd x' x l'≃r' (symm≃ l≃l') l≃r
| {
"alphanum_fraction": 0.5664160401,
"avg_line_length": 28.5,
"ext": "agda",
"hexsha": "71818ebcfee9256188b8fbcbf5400b8baf69e3e8",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "bgbianchi/sorting",
"max_forks_repo_path": "agda/BTree/Equality/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "bgbianchi/sorting",
"max_issues_repo_path": "agda/BTree/Equality/Properties.agda",
"max_line_length": 110,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "bgbianchi/sorting",
"max_stars_repo_path": "agda/BTree/Equality/Properties.agda",
"max_stars_repo_stars_event_max_datetime": "2021-08-24T22:11:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-05-21T12:50:35.000Z",
"num_tokens": 220,
"size": 399
} |
{-# OPTIONS --safe #-}
module Cubical.Algebra.Ring where
open import Cubical.Algebra.Ring.Base public
open import Cubical.Algebra.Ring.Properties public
| {
"alphanum_fraction": 0.7922077922,
"avg_line_length": 25.6666666667,
"ext": "agda",
"hexsha": "ca6659831babbcf980b807e55b8d38e211ce0444",
"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/Algebra/Ring.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/Algebra/Ring.agda",
"max_line_length": 50,
"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/Algebra/Ring.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": 36,
"size": 154
} |
{-# OPTIONS --cubical --safe #-}
open import Prelude
open import Algebra
module Data.Maybe.Monoid {ℓ} (sgr : Semigroup ℓ) where
open import Data.Maybe
open Semigroup sgr
_«∙»_ : Maybe 𝑆 → Maybe 𝑆 → Maybe 𝑆
nothing «∙» y = y
just x «∙» nothing = just x
just x «∙» just y = just (x ∙ y)
maybeMonoid : Monoid ℓ
maybeMonoid .Monoid.𝑆 = Maybe 𝑆
maybeMonoid .Monoid._∙_ = _«∙»_
maybeMonoid .Monoid.ε = nothing
maybeMonoid .Monoid.assoc nothing y z = refl
maybeMonoid .Monoid.assoc (just x) nothing z = refl
maybeMonoid .Monoid.assoc (just x) (just x₁) nothing = refl
maybeMonoid .Monoid.assoc (just x) (just y) (just z) = cong just (assoc x y z)
maybeMonoid .Monoid.ε∙ _ = refl
maybeMonoid .Monoid.∙ε nothing = refl
maybeMonoid .Monoid.∙ε (just x) = refl
| {
"alphanum_fraction": 0.698013245,
"avg_line_length": 26.9642857143,
"ext": "agda",
"hexsha": "823960e2a07856199a813e98a4b72524dd2d0968",
"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/Maybe/Monoid.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/Maybe/Monoid.agda",
"max_line_length": 78,
"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/Maybe/Monoid.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": 285,
"size": 755
} |
{- Copyright © 2015 Benjamin Barenblat
Licensed under the Apache License, Version 2.0 (the ‘License’); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed
under the License is distributed on an ‘AS IS’ BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License. -}
module B.Prelude.Number where
import Algebra
import Data.Integer
import Data.Integer.Properties
import Data.Nat
import Data.Nat.Properties
open import Level using (_⊔_)
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
open Data.Integer using (ℤ) public
open Data.Nat using (ℕ) public
record NearSemiring {c} {ℓ} (A : Set c) : Set (Level.suc (c ⊔ ℓ)) where
field
structure : Algebra.NearSemiring c ℓ
typeEquality : A ≡ Algebra.NearSemiring.Carrier structure
NearSemiringInstance : ∀ {c ℓ}
→ (structure : Algebra.NearSemiring c ℓ)
→ NearSemiring (Algebra.NearSemiring.Carrier structure)
NearSemiringInstance structure =
record { structure = structure; typeEquality = refl }
private
change₂ : ∀ {c ℓ A′}
→ ⦃ witness : NearSemiring {c} {ℓ} A′ ⦄
→ ((r : Algebra.NearSemiring c ℓ)
→ let A = Algebra.NearSemiring.Carrier r in
A → A → A)
→ A′ → A′ → A′
change₂ ⦃ witness ⦄ f rewrite NearSemiring.typeEquality witness =
f (NearSemiring.structure witness)
_*_ : ∀ {c ℓ A} → ⦃ _ : NearSemiring {c} {ℓ} A ⦄ → A → A → A
_*_ = change₂ Algebra.NearSemiring._*_
instance
NearSemiring-ℕ : NearSemiring ℕ
NearSemiring-ℕ =
NearSemiringInstance (Algebra.CommutativeSemiring.nearSemiring
Data.Nat.Properties.commutativeSemiring)
NearSemiring-ℤ : NearSemiring ℤ
NearSemiring-ℤ =
NearSemiringInstance (Algebra.CommutativeRing.nearSemiring
Data.Integer.Properties.commutativeRing)
| {
"alphanum_fraction": 0.6952469711,
"avg_line_length": 35.1803278689,
"ext": "agda",
"hexsha": "02024d0e879633be50f7183b32908f702cc2d347",
"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": "c1fd2daa41aa1b915f74b4c09c6e62c79320e8ec",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "bbarenblat/B",
"max_forks_repo_path": "Prelude/Number.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c1fd2daa41aa1b915f74b4c09c6e62c79320e8ec",
"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": "bbarenblat/B",
"max_issues_repo_path": "Prelude/Number.agda",
"max_line_length": 79,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "c1fd2daa41aa1b915f74b4c09c6e62c79320e8ec",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "bbarenblat/B",
"max_stars_repo_path": "Prelude/Number.agda",
"max_stars_repo_stars_event_max_datetime": "2017-06-30T15:59:38.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-06-30T15:59:38.000Z",
"num_tokens": 588,
"size": 2146
} |
postulate
foo : Set
bar : Set
baz : Set → Set
baz fooo = Fooo
| {
"alphanum_fraction": 0.6029411765,
"avg_line_length": 8.5,
"ext": "agda",
"hexsha": "6f36fd3bcb2145c1648544d3a712be87eb9ce756",
"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/Issue1903.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/Issue1903.agda",
"max_line_length": 15,
"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/Issue1903.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": 27,
"size": 68
} |
{-# OPTIONS --without-K --safe #-}
module Dodo.Unary.Union where
-- Stdlib imports
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; cong)
open import Level using (Level; _⊔_)
open import Function using (_∘_; _∘₂_)
open import Data.Sum using (_⊎_; inj₁; inj₂; swap)
open import Data.Product using (_,_)
open import Data.Empty using (⊥-elim)
open import Relation.Unary using (Pred)
-- Local imports
open import Dodo.Unary.Equality
open import Dodo.Unary.Unique
open import Dodo.Unary.Disjoint
-- # Definitions
infixl 30 _∪₁_
_∪₁_ : {a ℓ₁ ℓ₂ : Level} {A : Set a}
→ Pred A ℓ₁
→ Pred A ℓ₂
→ Pred A (ℓ₁ ⊔ ℓ₂)
_∪₁_ p q x = p x ⊎ q x
-- # Properties
module _ {a ℓ : Level} {A : Set a} {R : Pred A ℓ} where
∪₁-idem : (R ∪₁ R) ⇔₁ R
∪₁-idem = ⇔: ⊆-proof (λ _ → inj₁)
where
⊆-proof : (R ∪₁ R) ⊆₁' R
⊆-proof _ (inj₁ Rx) = Rx
⊆-proof _ (inj₂ Rx) = Rx
module _ {a ℓ₁ ℓ₂ : Level} {A : Set a} {P : Pred A ℓ₁} {Q : Pred A ℓ₂} where
∪₁-comm : (P ∪₁ Q) ⇔₁ (Q ∪₁ P)
∪₁-comm = ⇔: (λ _ → swap) (λ _ → swap)
module _ {a ℓ₁ ℓ₂ ℓ₃ : Level} {A : Set a}
{P : Pred A ℓ₁} {Q : Pred A ℓ₂} {R : Pred A ℓ₃} where
∪₁-assoc : (P ∪₁ Q) ∪₁ R ⇔₁ P ∪₁ (Q ∪₁ R)
∪₁-assoc = ⇔: ⊆-proof ⊇-proof
where
⊆-proof : ((P ∪₁ Q) ∪₁ R) ⊆₁' (P ∪₁ (Q ∪₁ R))
⊆-proof _ (inj₁ (inj₁ Px)) = inj₁ Px
⊆-proof _ (inj₁ (inj₂ Qx)) = inj₂ (inj₁ Qx)
⊆-proof _ (inj₂ Rx) = inj₂ (inj₂ Rx)
⊇-proof : (P ∪₁ (Q ∪₁ R)) ⊆₁' ((P ∪₁ Q) ∪₁ R)
⊇-proof _ (inj₁ Px) = inj₁ (inj₁ Px)
⊇-proof _ (inj₂ (inj₁ Qx)) = inj₁ (inj₂ Qx)
⊇-proof _ (inj₂ (inj₂ Rx)) = inj₂ Rx
-- # Operations
-- ## Operations: General
module _ {a ℓ₁ ℓ₂ : Level} {A : Set a} {P : Pred A ℓ₁} {Q : Pred A ℓ₂} where
∪₁-unique-pred :
Disjoint₁ P Q
→ UniquePred P
→ UniquePred Q
→ UniquePred (P ∪₁ Q)
∪₁-unique-pred _ uniqueP _ x (inj₁ Px₁) (inj₁ Px₂) = cong inj₁ (uniqueP x Px₁ Px₂)
∪₁-unique-pred disPQ _ _ x (inj₁ Px) (inj₂ Qx) = ⊥-elim (disPQ x (Px , Qx))
∪₁-unique-pred disPQ _ _ x (inj₂ Qx) (inj₁ Px) = ⊥-elim (disPQ x (Px , Qx))
∪₁-unique-pred _ _ uniqueQ x (inj₂ Qx₁) (inj₂ Qx₂) = cong inj₂ (uniqueQ x Qx₁ Qx₂)
-- ## Operations: ⊆₁
module _ {a ℓ₁ ℓ₂ ℓ₃ : Level} {A : Set a}
{P : Pred A ℓ₁} {Q : Pred A ℓ₂} {R : Pred A ℓ₃} where
∪₁-combine-⊆₁ : P ⊆₁ Q → R ⊆₁ Q → (P ∪₁ R) ⊆₁ Q
∪₁-combine-⊆₁ (⊆: P⊆Q) (⊆: R⊆Q) = ⊆: lemma
where
lemma : (P ∪₁ R) ⊆₁' Q
lemma x (inj₁ Px) = P⊆Q x Px
lemma x (inj₂ Rx) = R⊆Q x Rx
module _ {a ℓ₁ ℓ₂ : Level} {A : Set a} {P : Pred A ℓ₁} {Q : Pred A ℓ₂} where
∪₁-introˡ : P ⊆₁ (Q ∪₁ P)
∪₁-introˡ = ⊆: λ{_ → inj₂}
∪₁-introʳ : P ⊆₁ (P ∪₁ Q)
∪₁-introʳ = ⊆: λ{_ → inj₁}
module _ {a ℓ₁ ℓ₂ ℓ₃ : Level} {A : Set a}
{P : Pred A ℓ₁} {Q : Pred A ℓ₂} {R : Pred A ℓ₃} where
∪₁-introˡ-⊆₁ : P ⊆₁ R → P ⊆₁ (Q ∪₁ R)
∪₁-introˡ-⊆₁ (⊆: P⊆R) = ⊆: (inj₂ ∘₂ P⊆R)
∪₁-introʳ-⊆₁ : P ⊆₁ Q → P ⊆₁ (Q ∪₁ R)
∪₁-introʳ-⊆₁ (⊆: P⊆Q) = ⊆: (inj₁ ∘₂ P⊆Q)
∪₁-elimˡ-⊆₁ : (P ∪₁ Q) ⊆₁ R → Q ⊆₁ R
∪₁-elimˡ-⊆₁ (⊆: [P∪Q]⊆R) = ⊆: (λ x → [P∪Q]⊆R x ∘ inj₂)
∪₁-elimʳ-⊆₁ : (P ∪₁ Q) ⊆₁ R → P ⊆₁ R
∪₁-elimʳ-⊆₁ (⊆: [P∪Q]⊆R) = ⊆: (λ x → [P∪Q]⊆R x ∘ inj₁)
module _ {a ℓ₁ ℓ₂ ℓ₃ : Level} {A : Set a}
{P : Pred A ℓ₁} {Q : Pred A ℓ₂} {R : Pred A ℓ₃} where
∪₁-substˡ-⊆₁ : P ⊆₁ Q → (P ∪₁ R) ⊆₁ (Q ∪₁ R)
∪₁-substˡ-⊆₁ (⊆: P⊆Q) = ⊆: lemma
where
lemma : (P ∪₁ R) ⊆₁' (Q ∪₁ R)
lemma x (inj₁ Px) = inj₁ (P⊆Q x Px)
lemma x (inj₂ Rx) = inj₂ Rx
∪₁-substʳ-⊆₁ : P ⊆₁ Q → (R ∪₁ P) ⊆₁ (R ∪₁ Q)
∪₁-substʳ-⊆₁ (⊆: P⊆Q) = ⊆: lemma
where
lemma : (R ∪₁ P) ⊆₁' (R ∪₁ Q)
lemma x (inj₁ Rx) = inj₁ Rx
lemma x (inj₂ Px) = inj₂ (P⊆Q x Px)
-- ## Operations: ⇔₂
module _ {a ℓ₁ ℓ₂ ℓ₃ : Level} {A : Set a}
{P : Pred A ℓ₁} {Q : Pred A ℓ₂} {R : Pred A ℓ₃} where
∪₁-substˡ : P ⇔₁ Q → (P ∪₁ R) ⇔₁ (Q ∪₁ R)
∪₁-substˡ = ⇔₁-compose ∪₁-substˡ-⊆₁ ∪₁-substˡ-⊆₁
∪₁-substʳ : P ⇔₁ Q → (R ∪₁ P) ⇔₁ (R ∪₁ Q)
∪₁-substʳ = ⇔₁-compose ∪₁-substʳ-⊆₁ ∪₁-substʳ-⊆₁
| {
"alphanum_fraction": 0.513062951,
"avg_line_length": 27.1554054054,
"ext": "agda",
"hexsha": "ca82714096b9967fa279691be3a4ee650f65cf92",
"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": "376f0ccee1e1aa31470890e494bcb534324f598a",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "sourcedennis/agda-dodo",
"max_forks_repo_path": "src/Dodo/Unary/Union.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "376f0ccee1e1aa31470890e494bcb534324f598a",
"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": "sourcedennis/agda-dodo",
"max_issues_repo_path": "src/Dodo/Unary/Union.agda",
"max_line_length": 94,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "376f0ccee1e1aa31470890e494bcb534324f598a",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "sourcedennis/agda-dodo",
"max_stars_repo_path": "src/Dodo/Unary/Union.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2199,
"size": 4019
} |
module Recutter where
open import Basics
open import All
open import Cutting
open import Perm
module RECUTTER {I}(C : I |> I) where
open _|>_
CutKit : (I -> Set) -> Set
CutKit P = (i : I)(c : Cuts C i) -> P i -> All P (inners C c)
Subs : List I -> Set
Subs = All (\ i -> One + Cuts C i)
subCollect : (is : List I) -> Subs is -> List I
subCollect is cs = collect is (all (\ i -> (\ _ -> i ,- []) <+> inners C) is cs)
Sub : I |> Sg I (Cuts C)
Cuts Sub (i , c) = Subs (inners C c)
inners Sub {i , c} cs = subCollect (inners C c) cs
Recutter : Set
Recutter = (i : I)(c c' : Cuts C i) ->
Sg (Cuts Sub (i , c)) \ d -> Sg (Cuts Sub (i , c')) \ d' ->
inners Sub d ~ inners Sub d'
module NATRECUT where
open RECUTTER NatCut
data CutCompare (x x' y y' n : Nat) : Set where
cutLt : (d : Nat) -> (x +N suc d) == y -> (suc d +N y') == x' ->
CutCompare x x' y y' n
cutEq : x == y -> x' == y' ->
CutCompare x x' y y' n
cutGt : (d : Nat) -> (y +N suc d) == x -> (suc d +N x') == y' ->
CutCompare x x' y y' n
sucInj : {x y : Nat} -> suc x == suc y -> x == y
sucInj (refl (suc _)) = refl _
cutCompare : (x x' y y' n : Nat) -> (x +N x') == n -> (y +N y') == n ->
CutCompare x x' y y' n
cutCompare zero .n zero .n n (refl _) (refl _)
= cutEq (refl _) (refl _)
cutCompare zero .(suc (y +N y')) (suc y) y' .(suc (y +N y')) (refl _) (refl _)
= cutLt y (refl _) (refl _)
cutCompare (suc x) x' zero .(suc (x +N x')) .(suc (x +N x')) (refl _) (refl _)
= cutGt x (refl _) (refl _)
cutCompare (suc x) x' (suc y) y' zero () ()
cutCompare (suc x) x' (suc y) y' (suc n) xq yq
with cutCompare x x' y y' n (sucInj xq) (sucInj yq)
cutCompare (suc x) x' (suc .(x +N suc d)) y' (suc n) xq yq
| cutLt d (refl _) bq = cutLt d (refl _) bq
cutCompare (suc x) x' (suc .x) y' (suc n) xq yq
| cutEq (refl _) bq = cutEq (refl _) bq
cutCompare (suc .(y +N suc d)) x' (suc y) y' (suc n) xq yq
| cutGt d (refl _) bq = cutGt d (refl _) bq
NatRecut : Recutter
NatRecut n (a , b , qab) (c , d , qcd) with cutCompare a b c d n qab qcd
NatRecut n (a , b , qab) (c , d , qcd) | cutLt e q0 q1
= (inl <> , inr (suc e , d , q1) , <>)
, (inr (a , suc e , q0) , inl <> , <>)
, reflP _
NatRecut n (a , b , qab) (.a , .b , qcd) | cutEq (refl .a) (refl .b)
= (inl <> , inl <> , <>)
, (inl <> , inl <> , <>)
, reflP _
NatRecut n (a , b , qab) (c , d , qcd) | cutGt e q0 q1
= (inr (c , suc e , q0) , inl <> , <>)
, (inl <> , inr (suc e , b , q1) , <>)
, reflP _
module SUBCOLLECTLEMMA where
open _|>_
open RECUTTER
subCollectLemma : forall {I J}(C : I |> I)(D : J |> J)
(f : I -> J)(g : (i : I) -> Cuts C i -> Cuts D (f i)) ->
(q : (i : I)(c : Cuts C i) -> inners D (g i c) == list f (inners C c)) ->
(is : List I)(ps : All (\ i -> One + Cuts C i) is) ->
subCollect D (list f is) (allRe f is (all (\ i -> id +map g i) is ps)) ==
list f (subCollect C is ps)
subCollectLemma C D f g q [] <> = refl []
subCollectLemma C D f g q (i ,- is) (inl <> , ps) =
refl (f i ,-_) =$= subCollectLemma C D f g q is ps
subCollectLemma C D f g q (i ,- is) (inr c , ps) =
(inners D (g i c) +L
subCollect D (list f is) (allRe f is (allAp is (allPu (\ i -> id +map g i) is) ps)))
=[ refl _+L_ =$= q i c =$= subCollectLemma C D f g q is ps >=
(list f (inners C c) +L list f (subCollect C is ps))
=[ catNatural f (inners C c) (subCollect C is ps) >=
list f (inners C c +L subCollect C is ps)
[QED]
| {
"alphanum_fraction": 0.4899456522,
"avg_line_length": 36.4356435644,
"ext": "agda",
"hexsha": "f9a084fa765274755bac141447a2b1e70efbf22a",
"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": "454cdd18f56db0b0d1643a1fcf36951b5ece395c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "pigworker/InteriorDesign",
"max_forks_repo_path": "Recutter.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "454cdd18f56db0b0d1643a1fcf36951b5ece395c",
"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": "pigworker/InteriorDesign",
"max_issues_repo_path": "Recutter.agda",
"max_line_length": 93,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "454cdd18f56db0b0d1643a1fcf36951b5ece395c",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "pigworker/InteriorDesign",
"max_stars_repo_path": "Recutter.agda",
"max_stars_repo_stars_event_max_datetime": "2018-07-31T02:00:13.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-06-18T15:25:39.000Z",
"num_tokens": 1516,
"size": 3680
} |
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Conversion {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.LogicalRelation.Irrelevance
open import Definition.LogicalRelation.Properties
open import Definition.LogicalRelation.Substitution
open import Tools.Product
-- Conversion from left to right of valid terms.
convᵛ : ∀ {t A B Γ l}
([Γ] : ⊩ᵛ Γ)
([A] : Γ ⊩ᵛ⟨ l ⟩ A / [Γ])
([B] : Γ ⊩ᵛ⟨ l ⟩ B / [Γ])
→ Γ ⊩ᵛ⟨ l ⟩ A ≡ B / [Γ] / [A]
→ Γ ⊩ᵛ⟨ l ⟩ t ∷ A / [Γ] / [A]
→ Γ ⊩ᵛ⟨ l ⟩ t ∷ B / [Γ] / [B]
convᵛ [Γ] [A] [B] [A≡B] [t] ⊢Δ [σ] =
let [σA] = proj₁ ([A] ⊢Δ [σ])
[σB] = proj₁ ([B] ⊢Δ [σ])
[σA≡σB] = irrelevanceEq [σA] [σA] ([A≡B] ⊢Δ [σ])
[σt] = proj₁ ([t] ⊢Δ [σ])
[σt≡σ′t] = λ σ′ → proj₂ ([t] ⊢Δ [σ]) {σ′ = σ′}
in convTerm₁ [σA] [σB] [σA≡σB] [σt]
, λ [σ′] [σ≡σ′] → convEqTerm₁ [σA] [σB] [σA≡σB] (([σt≡σ′t] _) [σ′] [σ≡σ′])
-- Conversion from right to left of valid terms.
conv₂ᵛ : ∀ {t A B Γ l}
([Γ] : ⊩ᵛ Γ)
([A] : Γ ⊩ᵛ⟨ l ⟩ A / [Γ])
([B] : Γ ⊩ᵛ⟨ l ⟩ B / [Γ])
→ Γ ⊩ᵛ⟨ l ⟩ A ≡ B / [Γ] / [A]
→ Γ ⊩ᵛ⟨ l ⟩ t ∷ B / [Γ] / [B]
→ Γ ⊩ᵛ⟨ l ⟩ t ∷ A / [Γ] / [A]
conv₂ᵛ [Γ] [A] [B] [A≡B] [t] ⊢Δ [σ] =
let [σA] = proj₁ ([A] ⊢Δ [σ])
[σB] = proj₁ ([B] ⊢Δ [σ])
[σA≡σB] = irrelevanceEq [σA] [σA] ([A≡B] ⊢Δ [σ])
[σt] = proj₁ ([t] ⊢Δ [σ])
[σt≡σ′t] = λ σ′ → (proj₂ ([t] ⊢Δ [σ]) {σ′ = σ′})
in convTerm₂ [σA] [σB] [σA≡σB] [σt]
, λ [σ′] [σ≡σ′] → convEqTerm₂ [σA] [σB] [σA≡σB] (([σt≡σ′t] _) [σ′] [σ≡σ′])
-- Conversion from left to right of valid term equality.
convEqᵛ : ∀ {t u A B Γ l}
([Γ] : ⊩ᵛ Γ)
([A] : Γ ⊩ᵛ⟨ l ⟩ A / [Γ])
([B] : Γ ⊩ᵛ⟨ l ⟩ B / [Γ])
→ Γ ⊩ᵛ⟨ l ⟩ A ≡ B / [Γ] / [A]
→ Γ ⊩ᵛ⟨ l ⟩ t ≡ u ∷ A / [Γ] / [A]
→ Γ ⊩ᵛ⟨ l ⟩ t ≡ u ∷ B / [Γ] / [B]
convEqᵛ [Γ] [A] [B] [A≡B] [t≡u] ⊢Δ [σ] =
let [σA] = proj₁ ([A] ⊢Δ [σ])
[σB] = proj₁ ([B] ⊢Δ [σ])
[σA≡σB] = irrelevanceEq [σA] [σA] ([A≡B] ⊢Δ [σ])
in convEqTerm₁ [σA] [σB] [σA≡σB] ([t≡u] ⊢Δ [σ])
| {
"alphanum_fraction": 0.4281780633,
"avg_line_length": 35.1451612903,
"ext": "agda",
"hexsha": "40238a3253cc0fc32fc49e971c4eb47f7c0346e0",
"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/Substitution/Conversion.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/Substitution/Conversion.agda",
"max_line_length": 84,
"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/Substitution/Conversion.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1196,
"size": 2179
} |
module Abstract where
abstract
f
: {A : Set}
→ A
→ A
f x
= x
g
: {A : Set}
→ A
→ A
g x
= x
h
: {A : Set}
→ A
→ A
h x
= f x
_
: {A : Set}
→ A
→ A
_
= λ x → x
| {
"alphanum_fraction": 0.2839506173,
"avg_line_length": 7.3636363636,
"ext": "agda",
"hexsha": "946d7f368f51fe73a943fe5d0a60d85428451da2",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2022-03-01T16:38:14.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-03-01T16:38:14.000Z",
"max_forks_repo_head_hexsha": "f327f9aab8dcb07022b857736d8201906bba02e9",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "msuperdock/agda-unused",
"max_forks_repo_path": "data/declaration/Abstract.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "f327f9aab8dcb07022b857736d8201906bba02e9",
"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": "msuperdock/agda-unused",
"max_issues_repo_path": "data/declaration/Abstract.agda",
"max_line_length": 21,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "f327f9aab8dcb07022b857736d8201906bba02e9",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "msuperdock/agda-unused",
"max_stars_repo_path": "data/declaration/Abstract.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-01T16:38:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-10-29T09:38:43.000Z",
"num_tokens": 111,
"size": 243
} |
-- 2012-03-06 Andreas
-- Errors during printing of debug messages should not propagate to the
-- top level
{-# OPTIONS -v tc.meta.assign:10 #-}
module Issue578 where
-- Skipping import of Level will leave us with no level builtins
-- import Level
data D : Set where
-- This will generate a debug message, but it cannot be printed
-- since there are no bindings for the level builtins.
-- However, the file should still succeed.
| {
"alphanum_fraction": 0.7390300231,
"avg_line_length": 25.4705882353,
"ext": "agda",
"hexsha": "a4443f9a6b73a6e55bb90d3ec687711d333e8fbd",
"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/Issue578.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/Issue578.agda",
"max_line_length": 71,
"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/Issue578.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": 433
} |
-- Andreas, 2017-01-19, issue #2416, probably regression
-- Give failed for constrained size
-- {-# OPTIONS -v interaction.give:40 #-}
-- {-# OPTIONS -v tc.conv:10 #-}
-- {-# OPTIONS -v tc.conv.coerce:70 #-}
-- {-# OPTIONS -v tc.size:40 #-}
-- {-# OPTIONS -v tc.check.internal:40 #-}
open import Common.Size
open import Common.Equality
data Nat i : Set where
zero : Nat i
suc : (j : Size< i) (n : Nat j) → Nat i
postulate
divideBySuc : Nat ∞ → ∀ k → Nat k → Nat k
div-self : ∀ l (n : Nat l) → divideBySuc n (↑ l) (suc {! l !} n) ≡ suc l zero
-- Cannot solve size constraints
-- [i, n] i ≤ _j_19 i n
-- [i, n] (↑ _j_19 i n) ≤ _i_18 i n
-- [i, n] (↑ _j_20 i n) ≤ _i_18 i n
-- Reason: inconsistent upper bound for 20
-- when checking that zero is a valid argument to a function of type
| {
"alphanum_fraction": 0.608531995,
"avg_line_length": 29.5185185185,
"ext": "agda",
"hexsha": "f444830be2f1525f2dcd967deb675d26158f9a87",
"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/interaction/Issue2416.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/interaction/Issue2416.agda",
"max_line_length": 79,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/interaction/Issue2416.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": 279,
"size": 797
} |
open import Auto
open import Function using (const)
open import Data.Bool using (Bool; true; false)
open import Data.Bool.Show as Bool using ()
open import Data.List using (_∷_; [])
open import Data.Maybe
open import Data.Nat using (ℕ; suc; zero)
open import Data.Nat.Show as Nat using ()
open import Data.String using (String; _++_)
open import Data.Sum renaming (_⊎_ to Either; inj₁ to left; inj₂ to right)
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
module Auto.Example.TypeClasses where
--------------------------------------------------------------------------------
-- * We can construct a class for the Show function (as a dependent record) * --
--------------------------------------------------------------------------------
record Show (A : Set) : Set where
constructor mkShow
field
show : A → String
open Show {{...}}
--------------------------------------------------------------------------------
-- * And set up a list of rules which guide the instance resolution * --
--------------------------------------------------------------------------------
rules : HintDB
rules = [] << quote instShowEither << quote instShowBool << quote instShowNat
where
instShowBool : Show Bool
instShowBool = mkShow Bool.show
instShowNat : Show ℕ
instShowNat = mkShow Nat.show
instShowEither : {A B : Set} → Show A → Show B → Show (Either A B)
instShowEither {A} {B} instShowA instShowB = mkShow showEither
where
showEither : Either A B → String
showEither (left x) = "left " ++ show x
showEither (right y) = "right " ++ show y
--------------------------------------------------------------------------------
-- * Using these rules and `auto` we can easily and robustly compute the * --
-- * instances we need. * --
--------------------------------------------------------------------------------
example₁ : String
example₁ = show (left true) ++ show (right 4)
where
instance
inst : Show (Either Bool ℕ)
inst = tactic (auto 5 rules)
--------------------------------------------------------------------------------
-- * This fails due to normalisation from the non-dependent pair _×_ to the * --
-- * dependent pair Σ (as `A × B` is defined as `Σ A (λ _ → B)`). * --
--------------------------------------------------------------------------------
module DefaultPair where
open import Data.Product using (_×_; _,_)
instShowPair : {A B : Set} → Show A → Show B → Show (A × B)
instShowPair {A} {B} showA showB = record { show = showPair }
where
showPair : A × B → String
showPair (proj₁ , proj₂) = show proj₁ ++ "," ++ show proj₂
inst : Exception unsupportedSyntax
inst = unquote (auto 5 (rules << quote instShowPair) g)
where
g = quoteTerm (Show (Bool × ℕ))
--------------------------------------------------------------------------------
-- * So we're forced to use a custom pair, which isn't derived from * --
-- * a dependent pair * --
--------------------------------------------------------------------------------
module CustomPair where
data _×_ (A B : Set) : Set where
_,_ : A → B → A × B
instShowPair : ∀ {A B} → Show A → Show B → Show (A × B)
instShowPair {A} {B} showA showB = record { show = showPair }
where
showPair : A × B → String
showPair (proj₁ , proj₂) = show proj₁ ++ "," ++ show proj₂
example₂ : String
example₂ = show (true , 1)
where
instance
inst : Show (Bool × ℕ)
inst = tactic (auto 5 (rules << quote instShowPair))
--------------------------------------------------------------------------------
-- * This fails due to something super weird which I haven't encountered * --
-- * before at all... * --
--------------------------------------------------------------------------------
module AbstractPair where
open import Data.Product as Σ using (Σ)
abstract
_×_ : (A B : Set) → Set
A × B = Σ A (const B)
instShowPair : ∀ {A B} → Show A → Show B → Show (A × B)
instShowPair {A} {B} showA showB = record { show = showPair }
where
showPair : A × B → String
showPair (proj₁ Σ., proj₂) = show proj₁ ++ "," ++ show proj₂
_,_ : {A B : Set} (x : A) (y : B) → A × B
_,_ = Σ._,_
--inst : Show (Bool × ℕ)
--inst = tactic (auto 5 (rules << quote instShowPair))
| {
"alphanum_fraction": 0.4626044875,
"avg_line_length": 34.7022900763,
"ext": "agda",
"hexsha": "7694047d529d7eca69b064e6675d2e8ed4f9680a",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2019-07-07T07:37:07.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-07-10T10:47:30.000Z",
"max_forks_repo_head_hexsha": "f384b5c236645fcf8ab93179723a7355383a8716",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "wenkokke/AutoInAgda",
"max_forks_repo_path": "src/Auto/Example/TypeClasses.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "f384b5c236645fcf8ab93179723a7355383a8716",
"max_issues_repo_issues_event_max_datetime": "2017-11-06T16:49:27.000Z",
"max_issues_repo_issues_event_min_datetime": "2017-11-03T09:46:19.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "wenkokke/AutoInAgda",
"max_issues_repo_path": "src/Auto/Example/TypeClasses.agda",
"max_line_length": 80,
"max_stars_count": 22,
"max_stars_repo_head_hexsha": "f384b5c236645fcf8ab93179723a7355383a8716",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "wenkokke/AutoInAgda",
"max_stars_repo_path": "src/Auto/Example/TypeClasses.agda",
"max_stars_repo_stars_event_max_datetime": "2021-03-20T15:04:47.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-07-18T18:14:09.000Z",
"num_tokens": 1040,
"size": 4546
} |
module Peano where
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
_+_ : ℕ → ℕ → ℕ
zero + zero = zero
zero + n = n
(suc n) + m = suc (n + m)
data _even : ℕ → Set where
ZERO : zero even
STEP : ∀ x → x even → suc (suc x) even
proof₁ : suc (suc (suc (suc zero))) even
proof₁ = STEP (suc (suc zero)) (STEP zero ZERO)
| {
"alphanum_fraction": 0.527696793,
"avg_line_length": 20.1764705882,
"ext": "agda",
"hexsha": "9900b507e8bd083e40755157fb331753baa922f0",
"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": "6178c6ff150b11a462d40f0f3a0fd3ccc8d5ffb0",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "prt2121/tdd-playground",
"max_forks_repo_path": "agda/Peano.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "6178c6ff150b11a462d40f0f3a0fd3ccc8d5ffb0",
"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": "prt2121/tdd-playground",
"max_issues_repo_path": "agda/Peano.agda",
"max_line_length": 49,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "6178c6ff150b11a462d40f0f3a0fd3ccc8d5ffb0",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "prt2121/tdd-playground",
"max_stars_repo_path": "agda/Peano.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 133,
"size": 343
} |
{- Name: Bowornmet (Ben) Hudson
-- define the source language from the paper
-}
open import Preliminaries
open import Preorder-withmax
module Source-lang where
-- define the source language from the paper
-- we want to focus on arrow, cross, and nat types
data Tp : Set where
unit : Tp
nat : Tp
susp : Tp → Tp
_->s_ : Tp → Tp → Tp
_×s_ : Tp → Tp → Tp
data Cost : Set where
0c : Cost
1c : Cost
_+c_ : Cost → Cost → Cost
data Equals0c : Cost → Set where
Eq0-0c : Equals0c 0c
Eq0-+c : ∀ {c c'} → Equals0c c → Equals0c c' → Equals0c (c +c c')
-- represent a context as a list of types
Ctx = List Tp
-- de Bruijn indices (for free variables)
data _∈_ : Tp → Ctx → Set where
i0 : ∀ {Γ τ}
→ τ ∈ (τ :: Γ)
iS : ∀ {Γ τ τ1}
→ τ ∈ Γ
→ τ ∈ (τ1 :: Γ)
data _|-_ : Ctx → Tp → Set where
unit : ∀ {Γ}
→ Γ |- unit
var : ∀ {Γ τ}
→ τ ∈ Γ
→ Γ |- τ
z : ∀ {Γ}
→ Γ |- nat
suc : ∀ {Γ}
→ (e : Γ |- nat)
→ Γ |- nat
rec : ∀ {Γ τ}
→ Γ |- nat
→ Γ |- τ
→ (nat :: (susp τ :: Γ)) |- τ
→ Γ |- τ
lam : ∀ {Γ τ ρ}
→ (ρ :: Γ) |- τ
→ Γ |- (ρ ->s τ)
app : ∀ {Γ τ1 τ2}
→ Γ |- (τ2 ->s τ1)
→ Γ |- τ2
→ Γ |- τ1
prod : ∀ {Γ τ1 τ2}
→ Γ |- τ1
→ Γ |- τ2
→ Γ |- (τ1 ×s τ2)
l-proj : ∀ {Γ τ1 τ2}
→ Γ |- (τ1 ×s τ2)
→ Γ |- τ1
r-proj : ∀ {Γ τ1 τ2}
→ Γ |- (τ1 ×s τ2)
→ Γ |- τ2
-- include split, delay/susp/force instead of usual elim rules for products
delay : ∀ {Γ τ}
→ Γ |- τ
→ Γ |- susp τ
force : ∀ {Γ τ}
→ Γ |- susp τ
→ Γ |- τ
split : ∀ {Γ τ τ1 τ2}
→ Γ |- (τ1 ×s τ2)
→ (τ1 :: (τ2 :: Γ)) |- τ
→ Γ |- τ
------weakening and substitution lemmas
-- renaming function
rctx : Ctx → Ctx → Set
rctx Γ Γ' = ∀ {τ} → τ ∈ Γ' → τ ∈ Γ
-- re: transferring variables in contexts
lem1 : ∀ {Γ Γ' τ} → rctx Γ Γ' → rctx (τ :: Γ) (τ :: Γ')
lem1 d i0 = i0
lem1 d (iS x) = iS (d x)
-- renaming lemma
ren : ∀ {Γ Γ' τ} → Γ' |- τ → rctx Γ Γ' → Γ |- τ
ren unit d = unit
ren (var x) d = var (d x)
ren z d = z
ren (suc e) d = suc (ren e d)
ren (rec e e0 e1) d = rec (ren e d) (ren e0 d) (ren e1 (lem1 (lem1 d)))
ren (lam e) d = lam (ren e (lem1 d))
ren (app e1 e2) d = app (ren e1 d) (ren e2 d)
ren (prod e1 e2) d = prod (ren e1 d) (ren e2 d)
ren (l-proj e) d = l-proj (ren e d)
ren (r-proj e) d = r-proj (ren e d)
ren (delay e) d = delay (ren e d)
ren (force e) d = force (ren e d)
ren (split e e1) d = split (ren e d) (ren e1 (lem1 (lem1 d)))
-- substitution
sctx : Ctx → Ctx → Set
sctx Γ Γ' = ∀ {τ} → τ ∈ Γ' → Γ |- τ
-- weakening a context
wkn : ∀ {Γ τ1 τ2} → Γ |- τ2 → (τ1 :: Γ) |- τ2
wkn e = ren e iS
-- weakening also works with substitution
wkn-s : ∀ {Γ τ1 Γ'} → sctx Γ Γ' → sctx (τ1 :: Γ) Γ'
wkn-s d = λ f → wkn (d f)
wkn-r : ∀ {Γ τ1 Γ'} → rctx Γ Γ' → rctx (τ1 :: Γ) Γ'
wkn-r d = λ x → iS (d x)
-- lem2 (need a lemma for subst like we did for renaming)
lem2 : ∀ {Γ Γ' τ} → sctx Γ Γ' → sctx (τ :: Γ) (τ :: Γ')
lem2 d i0 = var i0
lem2 d (iS i) = wkn (d i)
-- another substitution lemma
lem3 : ∀ {Γ τ} → Γ |- τ → sctx Γ (τ :: Γ)
lem3 e i0 = e
lem3 e (iS i) = var i
lem3' : ∀ {Γ Γ' τ} → sctx Γ Γ' → Γ |- τ → sctx Γ (τ :: Γ')
lem3' Θ e i0 = e
lem3' Θ e (iS i) = Θ i
-- one final lemma needed for the last stepping rule. Thank you Professor Licata!
lem4 : ∀ {Γ τ1 τ2} → Γ |- τ1 → Γ |- τ2 → sctx Γ (τ1 :: (τ2 :: Γ))
lem4 e1 e2 i0 = e1
lem4 e1 e2 (iS i0) = e2
lem4 e1 e2 (iS (iS i)) = var i
lem4' : ∀ {Γ Γ' τ1 τ2} → sctx Γ Γ' → Γ |- τ1 → Γ |- τ2 → sctx Γ (τ1 :: (τ2 :: Γ'))
lem4' Θ a b i0 = a
lem4' Θ a b (iS i0) = b
lem4' Θ a b (iS (iS i)) = Θ i
lem5 : ∀ {Γ τ1 τ2} → Γ |- (τ1 ×s τ2) → sctx Γ ((τ1 ×s τ2) :: (τ1 :: (τ2 :: Γ)))
lem5 e i0 = e
lem5 e (iS i0) = l-proj e
lem5 e (iS (iS i0)) = r-proj e
lem5 e (iS (iS (iS i))) = var i
ids-2 : ∀ {Γ τ} → Γ |- τ → sctx Γ Γ → Γ |- τ
ids-2 e Θ = e
-- the 'real' substitution lemma (if (x : τ') :: Γ |- (e : τ) and Γ |- (e : τ') , then Γ |- e[x -> e'] : τ)
subst : ∀ {Γ Γ' τ} → sctx Γ Γ' → Γ' |- τ → Γ |- τ
subst d unit = unit
subst d (var x) = d x
subst d z = z
subst d (suc x) = suc (subst d x)
subst d (rec e e0 e1) = rec (subst d e) (subst d e0) (subst (lem2 (lem2 d)) e1)
subst d (lam e) = lam (subst (lem2 d) e)
subst d (app e1 e2) = app (subst d e1) (subst d e2)
subst d (prod e1 e2) = prod (subst d e1) (subst d e2)
subst d (l-proj e) = l-proj (subst d e)
subst d (r-proj e) = r-proj (subst d e)
subst d (delay e) = delay (subst d e)
subst d (force e) = force (subst d e)
subst d (split e e1) = split (subst d e) (subst (lem2 (lem2 d)) e1)
s-comp1 : ∀ {Γ Γ' Γ''} → sctx Γ Γ' → sctx Γ'' Γ → sctx Γ'' Γ'
s-comp1 Θ Θ' = subst Θ' o Θ
postulate
subst-compose : ∀ {Γ Γ' τ τ1} (Θ : sctx Γ Γ') (v : Γ |- τ) (e : (τ :: Γ' |- τ1) )
→ subst (lem3 v) (subst (lem2 Θ) e) == subst (lem3' Θ v) e
--subst-compose {Γ} {_} Θ v e = {!!}
postulate
subst-compose2 : ∀ {Γ Γ' τ} (Θ : sctx Γ Γ') (n : Γ |- nat) (e1 : Γ' |- τ) (e2 : (nat :: (susp τ :: Γ')) |- τ)
→ subst (lem4 n (delay (rec n (subst Θ e1) (subst (lem2 (lem2 Θ)) e2)))) (subst (lem2 (lem2 Θ)) e2) ==
subst (lem4' Θ n (delay (rec n (subst Θ e1) (subst (lem2 (lem2 Θ)) e2)))) e2
postulate
subst-compose3 : ∀ {Γ Γ' τ τ1 τ2} (Θ : sctx Γ Γ') (e1 : (τ1 :: (τ2 :: Γ')) |- τ) (v1 : Γ |- τ1) (v2 : Γ |- τ2)
→ subst (lem4 v1 v2) (subst (lem2 (lem2 Θ)) e1) == subst (lem4' Θ v1 v2) e1
postulate
subst-compose4 : ∀ {Γ Γ' τ} (Θ : sctx Γ Γ') (v' : Γ |- nat) (r : Γ |- susp τ) (e2 : (nat :: (susp τ :: Γ')) |- τ)
→ subst (lem4 v' r) (subst (lem2 (lem2 Θ)) e2) == subst (lem4' Θ v' r) e2
-------
data val : ∀ {τ} → [] |- τ → Set where
z-isval : val z
suc-isval : (e : [] |- nat) → (val e)
→ val (suc e)
pair-isval : ∀ {τ1 τ2} (e1 : [] |- τ1) → (e2 : [] |- τ2)
→ val e1 → val e2
→ val (prod e1 e2)
lam-isval : ∀ {ρ τ} (e : (ρ :: []) |- τ)
→ val (lam e)
unit-isval : val unit
delay-isval : ∀ {τ} (e : [] |- τ) → val (delay e)
mutual
-- define evals (e : source exp) (v : value) (c : nat)
-- analogous to "e evaluates to v in c steps"
-- see figure 4 of paper
data evals : {τ : Tp} → [] |- τ → [] |- τ → Cost → Set where
pair-evals : ∀ {n1 n2}
→ {τ1 τ2 : Tp} {e1 v1 : [] |- τ1} {e2 v2 : [] |- τ2}
→ evals e1 v1 n1
→ evals e2 v2 n2
→ evals (prod e1 e2) (prod v1 v2) (n1 +c n2)
lam-evals : ∀ {ρ τ} {e : (ρ :: []) |- τ}
→ evals (lam e) (lam e) 0c
app-evals : ∀ {n0 n1 n}
→ {τ1 τ2 : Tp} {e0 : [] |- (τ1 ->s τ2)} {e0' : (τ1 :: []) |- τ2} {e1 v1 : [] |- τ1} {v : [] |- τ2}
→ evals e0 (lam e0') n0
→ evals e1 v1 n1
→ evals (subst (lem3 v1) e0') v n
→ evals (app e0 e1) v ((n0 +c n1) +c n)
z-evals : evals z z 0c
s-evals : ∀ {n}
→ {e v : [] |- nat}
→ evals e v n
→ evals (suc e) (suc v) n
unit-evals : evals unit unit 0c
rec-evals : ∀ {n1 n2}
→ {τ : Tp} {e v : [] |- nat} {e0 v' : [] |- τ} {e1 : (nat :: (susp τ :: [])) |- τ}
→ evals e v n1
→ evals-rec-branch e0 e1 v v' n2
→ evals (rec e e0 e1) v' (n1 +c (1c +c n2))
-- adding some new rules to the mix
delay-evals : {τ : Tp} {e : [] |- τ}
→ evals (delay e) (delay e) 0c
force-evals : ∀ {n1 n2}
→ {τ : Tp} {e' v : [] |- τ} {e : [] |- susp τ}
→ evals e (delay e') n1
→ evals e' v n2
→ evals (force e) v (n1 +c n2)
split-evals : ∀ {n1 n2}
→ {τ τ1 τ2 : Tp} {e0 : [] |- (τ1 ×s τ2)} {v1 : [] |- τ1} {v2 : [] |- τ2} {e1 : (τ1 :: (τ2 :: [])) |- τ} {v : [] |- τ}
→ evals e0 (prod v1 v2) n1
→ evals (subst (lem4 v1 v2) e1) v n2
→ evals (split e0 e1) v (n1 +c n2)
-- means evals (rec v e0 e1) v' n
-- but helpful to have a separate type for this
data evals-rec-branch {τ : Tp} (e0 : [] |- τ) (e1 : (nat :: (susp τ :: [])) |- τ) : (e : [] |- nat) (v : [] |- τ) → Cost → Set where
evals-rec-z : ∀ {v n} → evals e0 v n → evals-rec-branch e0 e1 z v n
evals-rec-s : ∀ {v v' n} → evals (subst (lem4 v (delay (rec v e0 e1))) e1) v' n
→ evals-rec-branch e0 e1 (suc v) v' n
evals-val : {τ : Tp} {e : [] |- τ} {v : [] |- τ} {n : Cost} → evals e v n → val v
evals-val (pair-evals D D₁) = pair-isval _ _ (evals-val D) (evals-val D₁)
evals-val lam-evals = lam-isval _
evals-val (app-evals D D₁ D₂) = evals-val D₂
evals-val z-evals = z-isval
evals-val (s-evals D) = suc-isval _ (evals-val D)
evals-val unit-evals = unit-isval
evals-val (rec-evals x (evals-rec-z D)) = evals-val D
evals-val (rec-evals x (evals-rec-s D)) = evals-val D
evals-val delay-evals = delay-isval _
evals-val (force-evals D D₁) = evals-val D₁
evals-val (split-evals D D₁) = evals-val D₁
val-evals-inversion : {τ : Tp} {v v' : [] |- τ} {n : Cost} → val v → evals v v' n → (v == v') × Equals0c n
val-evals-inversion z-isval z-evals = Refl , Eq0-0c
val-evals-inversion (suc-isval e valv) (s-evals evv) = ap suc (fst IH) , snd IH where
IH = val-evals-inversion valv evv
val-evals-inversion (pair-isval e1 e2 valv valv₁) (pair-evals evv evv₁) = ap2 prod (fst IH1) (fst IH2) , Eq0-+c (snd IH1) (snd IH2) where
IH1 = val-evals-inversion valv evv
IH2 = val-evals-inversion valv₁ evv₁
val-evals-inversion (lam-isval e) lam-evals = Refl , Eq0-0c
val-evals-inversion unit-isval unit-evals = Refl , Eq0-0c
val-evals-inversion (delay-isval e) delay-evals = Refl , Eq0-0c
---------- some sample programs in the source language
--dbl(n : nat) = 2*n
dbl : ∀ {Γ} → Γ |- (nat ->s nat)
dbl = lam (rec (var i0) z (suc (suc (force (var (iS i0))))))
--add(x : nat , y : nat) = x+y
add : ∀ {Γ} → Γ |- (nat ->s (nat ->s nat))
add = lam (lam (rec (var (iS i0)) (var i0) (suc (force (var (iS i0))))))
--mult(x : nat , y : nat) = x*y
mult : ∀ {Γ} → Γ |- (nat ->s (nat ->s nat))
mult = lam (lam (rec (var (iS i0)) z (app (app add (var (iS (iS i0)))) (force (var (iS i0))))))
| {
"alphanum_fraction": 0.4613587515,
"avg_line_length": 35.5514950166,
"ext": "agda",
"hexsha": "4ef8b582acde03a61a68e7b5b46b91175011b639",
"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": "2404a6ef2688f879bda89860bb22f77664ad813e",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "benhuds/Agda",
"max_forks_repo_path": "complexity-drafts/Source-lang.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "2404a6ef2688f879bda89860bb22f77664ad813e",
"max_issues_repo_issues_event_max_datetime": "2020-05-12T00:32:45.000Z",
"max_issues_repo_issues_event_min_datetime": "2020-03-23T08:39:04.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "benhuds/Agda",
"max_issues_repo_path": "complexity-drafts/Source-lang.agda",
"max_line_length": 139,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "2404a6ef2688f879bda89860bb22f77664ad813e",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "benhuds/Agda",
"max_stars_repo_path": "complexity-drafts/Source-lang.agda",
"max_stars_repo_stars_event_max_datetime": "2019-08-08T12:27:18.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-04-26T20:22:22.000Z",
"num_tokens": 4466,
"size": 10701
} |
------------------------------------------------------------------------
-- Lemmas related to application of substitutions
------------------------------------------------------------------------
open import Data.Universe.Indexed
module deBruijn.Substitution.Data.Application.Application222
{i u e} {Uni : IndexedUniverse i u e}
where
import deBruijn.Context; open deBruijn.Context Uni
open import deBruijn.Substitution.Data.Application.Application221
open import deBruijn.Substitution.Data.Basics
open import deBruijn.Substitution.Data.Map
open import deBruijn.Substitution.Data.Simple
open import Function using (_$_)
open import Level using (_⊔_)
import Relation.Binary.PropositionalEquality as P
open P.≡-Reasoning
-- Lemmas related to application.
record Application₂₂₂
{t₁} {T₁ : Term-like t₁}
{t₂} {T₂ : Term-like t₂}
-- Simple substitutions for the first kind of terms.
(simple₁ : Simple T₁)
-- Simple substitutions for the second kind of terms.
(simple₂ : Simple T₂)
-- A translation from the first to the second kind of terms.
(trans : [ T₁ ⟶⁼ T₂ ])
: Set (i ⊔ u ⊔ e ⊔ t₁ ⊔ t₂) where
open Term-like T₁ using () renaming (_⊢_ to _⊢₁_)
open Term-like T₂ using ([_]) renaming (_⊢_ to _⊢₂_; _≅-⊢_ to _≅-⊢₂_)
open Simple simple₁
using ()
renaming ( id to id₁; sub to sub₁; var to var₁
; wk to wk₁; wk[_] to wk₁[_]
; _↑ to _↑₁; _↑_ to _↑₁_; _↑⁺_ to _↑⁺₁_; _↑₊_ to _↑₊₁_
; _↑⋆ to _↑⋆₁; _↑⁺⋆_ to _↑⁺⋆₁_
)
open Simple simple₂
using ()
renaming ( var to var₂
; weaken to weaken₂; weaken[_] to weaken₂[_]; wk⁺ to wk⁺₂
; wk-subst to wk-subst₂; wk-subst[_] to wk-subst₂[_]
; _↑ to _↑₂; _↑_ to _↑₂_; _↑⁺_ to _↑⁺₂_; _↑₊_ to _↑₊₂_
)
field
application₂₂₁ : Application₂₂₁ simple₁ simple₂ trans
open Application₂₂₁ application₂₂₁ public
abstract
-- A variant of suc-/∋-↑.
suc-/⊢⋆-↑⋆ :
∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ}
σ {τ} (x : Γ ∋ τ) (ρs : Subs T₁ ρ̂) →
var₂ · suc[ σ ] x /⊢⋆ ρs ↑⋆₁ ≅-⊢₂
var₂ · x /⊢⋆ (ρs ▻ wk₁[ σ /⋆ ρs ])
suc-/⊢⋆-↑⋆ σ x ε = begin
[ var₂ · suc x ] ≡⟨ P.sym $ var-/⊢-wk-↑⁺ ε x ⟩
[ var₂ · x /⊢ wk₁ ] ∎
suc-/⊢⋆-↑⋆ σ x (ρs ▻ ρ) = begin
[ var₂ · suc[ σ ] x /⊢⋆ ρs ↑⋆₁ /⊢ ρ ↑₁ ] ≡⟨ /⊢-cong (suc-/⊢⋆-↑⋆ σ x ρs) (P.refl {x = [ ρ ↑₁ ]}) ⟩
[ var₂ · x /⊢⋆ ρs /⊢ wk₁[ σ /⋆ ρs ] /⊢ ρ ↑₁ ] ≡⟨ P.sym $ /⊢-/⊢-wk (σ /⋆ ρs) (var₂ · x /⊢⋆ ρs) ρ ⟩
[ var₂ · x /⊢⋆ ρs /⊢ ρ /⊢ wk₁ ] ∎
-- The antecedent of var-/⊢⋆-↑⁺⋆-⇒-/⊢⋆-↑⁺⋆ follows from a less
-- complicated statement.
var-/⊢⋆-⇒-var-/⊢⋆-↑⁺⋆ :
∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} {ρs₁ : Subs T₁ ρ̂} {ρs₂ : Subs T₁ ρ̂} →
(∀ {σ} (x : Γ ∋ σ) → var₂ · x /⊢⋆ ρs₁ ≅-⊢₂ var₂ · x /⊢⋆ ρs₂) →
∀ Γ⁺ {σ} (x : Γ ++⁺ Γ⁺ ∋ σ) →
var₂ · x /⊢⋆ ρs₁ ↑⁺⋆₁ Γ⁺ ≅-⊢₂ var₂ · x /⊢⋆ ρs₂ ↑⁺⋆₁ Γ⁺
var-/⊢⋆-⇒-var-/⊢⋆-↑⁺⋆ hyp ε x = hyp x
var-/⊢⋆-⇒-var-/⊢⋆-↑⁺⋆ {ρs₁ = ρs₁} {ρs₂} hyp (Γ⁺ ▻ σ) zero = begin
[ var₂ · zero /⊢⋆ ρs₁ ↑⁺⋆₁ (Γ⁺ ▻ σ) ] ≡⟨ zero-/⊢⋆-↑⋆ σ (ρs₁ ↑⁺⋆₁ Γ⁺) ⟩
[ var₂ · zero ] ≡⟨ P.sym $ zero-/⊢⋆-↑⋆ σ (ρs₂ ↑⁺⋆₁ Γ⁺) ⟩
[ var₂ · zero /⊢⋆ ρs₂ ↑⁺⋆₁ (Γ⁺ ▻ σ) ] ∎
var-/⊢⋆-⇒-var-/⊢⋆-↑⁺⋆ {ρs₁ = ρs₁} {ρs₂} hyp (Γ⁺ ▻ σ) (suc x) = begin
[ var₂ · suc x /⊢⋆ ρs₁ ↑⁺⋆₁ (Γ⁺ ▻ σ) ] ≡⟨ suc-/⊢⋆-↑⋆ σ x (ρs₁ ↑⁺⋆₁ Γ⁺) ⟩
[ var₂ · x /⊢⋆ ρs₁ ↑⁺⋆₁ Γ⁺ /⊢ wk₁ ] ≡⟨ /⊢-cong (var-/⊢⋆-⇒-var-/⊢⋆-↑⁺⋆ hyp Γ⁺ x) (P.refl {x = [ wk₁ ]}) ⟩
[ var₂ · x /⊢⋆ ρs₂ ↑⁺⋆₁ Γ⁺ /⊢ wk₁ ] ≡⟨ P.sym $ suc-/⊢⋆-↑⋆ σ x (ρs₂ ↑⁺⋆₁ Γ⁺) ⟩
[ var₂ · suc x /⊢⋆ ρs₂ ↑⁺⋆₁ (Γ⁺ ▻ σ) ] ∎
-- Variants of var-/⊢⋆-↑⁺⋆-⇒-/⊢⋆-↑⁺⋆ which may be easier to use.
var-/⊢⋆-⇒-/⊢⋆-↑⁺⋆ :
∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} (ρs₁ : Subs T₁ ρ̂) (ρs₂ : Subs T₁ ρ̂) →
(∀ {σ} (x : Γ ∋ σ) → var₂ · x /⊢⋆ ρs₁ ≅-⊢₂ var₂ · x /⊢⋆ ρs₂) →
∀ Γ⁺ {σ} (t : Γ ++⁺ Γ⁺ ⊢₂ σ) →
t /⊢⋆ ρs₁ ↑⁺⋆₁ Γ⁺ ≅-⊢₂ t /⊢⋆ ρs₂ ↑⁺⋆₁ Γ⁺
var-/⊢⋆-⇒-/⊢⋆-↑⁺⋆ ρs₁ ρs₂ hyp =
var-/⊢⋆-↑⁺⋆-⇒-/⊢⋆-↑⁺⋆ ρs₁ ρs₂ (var-/⊢⋆-⇒-var-/⊢⋆-↑⁺⋆ hyp)
var-/⊢⋆-⇒-/⊢⋆ :
∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} (ρs₁ : Subs T₁ ρ̂) (ρs₂ : Subs T₁ ρ̂) →
(∀ {σ} (x : Γ ∋ σ) → var₂ · x /⊢⋆ ρs₁ ≅-⊢₂ var₂ · x /⊢⋆ ρs₂) →
∀ {σ} (t : Γ ⊢₂ σ) → t /⊢⋆ ρs₁ ≅-⊢₂ t /⊢⋆ ρs₂
var-/⊢⋆-⇒-/⊢⋆ ρs₁ ρs₂ hyp = var-/⊢⋆-⇒-/⊢⋆-↑⁺⋆ ρs₁ ρs₂ hyp ε
-- The identity substitution has no effect.
/⊢-id : ∀ {Γ σ} (t : Γ ⊢₂ σ) → t /⊢ id₁ ≅-⊢₂ t
/⊢-id = var-/⊢⋆-⇒-/⊢⋆ (ε ▻ id₁) ε var-/⊢-id
-- id is a right identity of _∘_.
∘-id : ∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} (ρ : Sub T₂ ρ̂) → ρ ∘ id₁ ≅-⇨ ρ
∘-id ρ = extensionality P.refl λ x → begin
[ x /∋ ρ ∘ id₁ ] ≡⟨ /∋-∘ x ρ id₁ ⟩
[ x /∋ ρ /⊢ id₁ ] ≡⟨ /⊢-id (x /∋ ρ) ⟩
[ x /∋ ρ ] ∎
-- Lifting distributes over composition.
∘-↑ : ∀ {Γ Δ Ε} σ {ρ̂₁ : Γ ⇨̂ Δ} {ρ̂₂ : Δ ⇨̂ Ε}
(ρ₁ : Sub T₂ ρ̂₁) (ρ₂ : Sub T₁ ρ̂₂) →
(ρ₁ ∘ ρ₂) ↑₂ σ ≅-⇨ ρ₁ ↑₂ σ ∘ ρ₂ ↑₁
∘-↑ σ ρ₁ ρ₂ =
let ρ₂↑ = ρ₂ ↑₁ (σ / ρ₁)
lemma₁ = begin
[ wk-subst₂ (ρ₁ ∘ ρ₂) ] ≡⟨ P.refl ⟩
[ map weaken₂ (map (app ρ₂) ρ₁) ] ≡⟨ P.sym $ map-[∘] weaken₂ (app ρ₂) ρ₁ ⟩
[ map (weaken₂ [∘] app ρ₂) ρ₁ ] ≡⟨ map-cong-ext₁ P.refl
(λ t → begin
[ weaken₂ · (t /⊢ ρ₂) ] ≡⟨ P.sym $ /⊢-wk (t /⊢ ρ₂) ⟩
[ t /⊢ ρ₂ /⊢ wk₁ ] ≡⟨ /⊢-/⊢-wk (σ / ρ₁) t ρ₂ ⟩
[ t /⊢ wk₁ /⊢ ρ₂↑ ] ≡⟨ /⊢-cong (/⊢-wk t) P.refl ⟩
[ weaken₂ · t /⊢ ρ₂↑ ] ∎)
(P.refl {x = [ ρ₁ ]}) ⟩
[ map (app ρ₂↑ [∘] weaken₂) ρ₁ ] ≡⟨ map-[∘] (app ρ₂↑) weaken₂ ρ₁ ⟩
[ map (app ρ₂↑) (map (weaken₂) ρ₁) ] ∎
lemma₂ = begin
[ var₂ · zero ] ≡⟨ P.sym $ trans-var zero ⟩
[ trans · (var₁ · zero) ] ≡⟨ trans-cong (P.sym $ Simple.zero-/∋-↑ simple₁ (σ / ρ₁) ρ₂) ⟩
[ trans · (zero /∋ ρ₂↑) ] ≡⟨ P.sym $ var-/⊢ zero ρ₂↑ ⟩
[ var₂ · zero /⊢ ρ₂↑ ] ∎
in begin
[ (ρ₁ ∘ ρ₂) ↑₂ ] ≡⟨ Simple.unfold-↑ simple₂ (ρ₁ ∘ ρ₂) ⟩
[ wk-subst₂ (ρ₁ ∘ ρ₂) ▻ var₂ · zero ] ≡⟨ ▻⇨-cong P.refl lemma₁ lemma₂ ⟩
[ map (app ρ₂↑) (map weaken₂[ σ / ρ₁ ] ρ₁) ▻ var₂ · zero /⊢ ρ₂↑ ] ≡⟨ P.sym $
map-▻ (app ρ₂↑) (wk-subst₂[ σ / ρ₁ ] ρ₁) (var₂ · zero) ⟩
[ map (app ρ₂↑) (wk-subst₂[ σ / ρ₁ ] ρ₁ ▻ var₂ · zero) ] ≡⟨ map-cong (app ρ₂↑ ∎-⟶)
(P.sym $ Simple.unfold-↑ simple₂ ρ₁) ⟩
[ map (app ρ₂↑) (ρ₁ ↑₂) ] ≡⟨ P.refl ⟩
[ ρ₁ ↑₂ ∘ ρ₂ ↑₁ ] ∎
-- N-ary lifting distributes over composition.
∘-↑⁺ : ∀ {Γ Δ Ε} {ρ̂₁ : Γ ⇨̂ Δ} {ρ̂₂ : Δ ⇨̂ Ε}
(ρ₁ : Sub T₂ ρ̂₁) (ρ₂ : Sub T₁ ρ̂₂) Γ⁺ →
(ρ₁ ∘ ρ₂) ↑⁺₂ Γ⁺ ≅-⇨ ρ₁ ↑⁺₂ Γ⁺ ∘ ρ₂ ↑⁺₁ (Γ⁺ /⁺ ρ₁)
∘-↑⁺ ρ₁ ρ₂ ε = P.refl
∘-↑⁺ ρ₁ ρ₂ (Γ⁺ ▻ σ) = begin
[ ((ρ₁ ∘ ρ₂) ↑⁺₂ Γ⁺) ↑₂ ] ≡⟨ Simple.↑-cong simple₂ (∘-↑⁺ ρ₁ ρ₂ Γ⁺) P.refl ⟩
[ (ρ₁ ↑⁺₂ Γ⁺ ∘ ρ₂ ↑⁺₁ (Γ⁺ /⁺ ρ₁)) ↑₂ ] ≡⟨ ∘-↑ σ (ρ₁ ↑⁺₂ Γ⁺) (ρ₂ ↑⁺₁ (Γ⁺ /⁺ ρ₁)) ⟩
[ (ρ₁ ↑⁺₂ Γ⁺) ↑₂ ∘ (ρ₂ ↑⁺₁ (Γ⁺ /⁺ ρ₁)) ↑₁ ] ∎
∘-↑₊ : ∀ {Γ Δ Ε} {ρ̂₁ : Γ ⇨̂ Δ} {ρ̂₂ : Δ ⇨̂ Ε}
(ρ₁ : Sub T₂ ρ̂₁) (ρ₂ : Sub T₁ ρ̂₂) Γ₊ →
(ρ₁ ∘ ρ₂) ↑₊₂ Γ₊ ≅-⇨ ρ₁ ↑₊₂ Γ₊ ∘ ρ₂ ↑₊₁ (Γ₊ /₊ ρ₁)
∘-↑₊ ρ₁ ρ₂ ε = P.refl
∘-↑₊ ρ₁ ρ₂ (σ ◅ Γ₊) = begin
[ (ρ₁ ∘ ρ₂ ) ↑₂ σ ↑₊₂ Γ₊ ] ≡⟨ Simple.↑₊-cong simple₂ (∘-↑ σ ρ₁ ρ₂) (P.refl {x = [ Γ₊ ]}) ⟩
[ (ρ₁ ↑₂ σ ∘ ρ₂ ↑₁) ↑₊₂ Γ₊ ] ≡⟨ ∘-↑₊ (ρ₁ ↑₂ σ) (ρ₂ ↑₁) Γ₊ ⟩
[ ρ₁ ↑₊₂ (σ ◅ Γ₊) ∘ ρ₂ ↑₊₁ ((σ ◅ Γ₊) /₊ ρ₁) ] ∎
-- First weakening and then substituting something for the first
-- variable is equivalent to doing nothing.
/⊢-wk-/⊢-sub : ∀ {Γ σ τ} (t : Γ ⊢₂ τ) (t′ : Γ ⊢₁ σ) →
t /⊢ wk₁ /⊢ sub₁ t′ ≅-⊢₂ t
/⊢-wk-/⊢-sub t t′ = var-/⊢⋆-⇒-/⊢⋆ (ε ▻ wk₁ ▻ sub₁ t′) ε (λ x → begin
[ var₂ · x /⊢ wk₁ /⊢ sub₁ t′ ] ≡⟨ /⊢-cong (/∋-≅-⊢-var x wk₁ (Simple./∋-wk simple₁ x)) P.refl ⟩
[ var₂ · suc x /⊢ sub₁ t′ ] ≡⟨ suc-/⊢-sub x t′ ⟩
[ var₂ · x ] ∎) t
-- Weakening a substitution and composing with sub is the same as
-- doing nothing.
wk-subst-∘-sub : ∀ {Γ Δ σ} {ρ̂ : Γ ⇨̂ Δ} (ρ : Sub T₂ ρ̂) (t : Δ ⊢₁ σ) →
wk-subst₂ ρ ∘ sub₁ t ≅-⇨ ρ
wk-subst-∘-sub ρ t = extensionality P.refl λ x →
let lemma = begin
[ x /∋ wk-subst₂ ρ ] ≡⟨ Simple./∋-wk-subst simple₂ x ρ ⟩
[ weaken₂ · (x /∋ ρ) ] ≡⟨ P.sym $ /⊢-wk (x /∋ ρ) ⟩
[ x /∋ ρ /⊢ wk₁ ] ∎
in begin
[ x /∋ wk-subst₂ ρ ∘ sub₁ t ] ≡⟨ /∋-∘ x (wk-subst₂ ρ) (sub₁ t) ⟩
[ x /∋ wk-subst₂ ρ /⊢ sub₁ t ] ≡⟨ /⊢-cong lemma P.refl ⟩
[ x /∋ ρ /⊢ wk₁ /⊢ sub₁ t ] ≡⟨ /⊢-wk-/⊢-sub (x /∋ ρ) t ⟩
[ x /∋ ρ ] ∎
-- Unfolding lemma for wk⁺.
wk⁺-▻ : ∀ {Γ} (Γ⁺ : Ctxt⁺ Γ) {σ} →
wk⁺₂ (Γ⁺ ▻ σ) ≅-⇨ wk⁺₂ Γ⁺ ∘ wk₁[ σ ]
wk⁺-▻ Γ⁺ {σ = σ} = begin
[ wk⁺₂ (Γ⁺ ▻ σ) ] ≡⟨ P.refl ⟩
[ wk-subst₂ (wk⁺₂ Γ⁺) ] ≡⟨ P.sym $ ∘-wk (wk⁺₂ Γ⁺) ⟩
[ wk⁺₂ Γ⁺ ∘ wk₁ ] ∎
| {
"alphanum_fraction": 0.3792210483,
"avg_line_length": 44.6944444444,
"ext": "agda",
"hexsha": "3d36074668ea511cf749b4d817cb21d9cd0a8b19",
"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/Application/Application222.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/Application/Application222.agda",
"max_line_length": 134,
"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/Application/Application222.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": 5232,
"size": 9654
} |
------------------------------------------------------------------------
-- Convenient syntax for relational reasoning using transitive
-- relations
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module Relation.Binary.TransReasoning where
open import Level using (suc; _⊔_)
open import Data.Context using (Ctx)
open import Data.Fin.Substitution.Typed using (Typing)
open import Data.Fin.Substitution.TypedRelation using (TypedRel)
open import Data.Nat using (ℕ)
open import Data.Product using (_,_; proj₁; proj₂)
open import Relation.Binary.PropositionalEquality as P using (_≡_; subst)
open import Relation.Binary
open import Relation.Unary using (Pred)
------------------------------------------------------------------------
-- Transitive relations that are not necessarily reflexive
--
-- Following the convention used in the standard library, we define
-- transitive binary relations using a pair of records (see
-- Relation.Binary).
record IsTransRel {a ℓ₁ ℓ₂} {A : Set a}
(_≈_ : Rel A ℓ₁) -- The underlying equality.
(_∼_ : Rel A ℓ₂) -- The relation.
: Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
field
isEquivalence : IsEquivalence _≈_
trans : Transitive _∼_
-- _∼_ respects the underlying equality _≈_.
--
-- (This always true for preorders, but not necessarily for
-- irreflexive relations.)
∼-resp-≈ : _∼_ Respects₂ _≈_
module Eq = IsEquivalence isEquivalence
record TransRel c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
infix 4 _≈_ _∼_
field
Carrier : Set c
_≈_ : Rel Carrier ℓ₁ -- The underlying equality.
_∼_ : Rel Carrier ℓ₂ -- The relation.
isTransRel : IsTransRel _≈_ _∼_
open IsTransRel isTransRel public
-- Sanity check: every pre-order is a transitive relation in the above
-- sense...
preorderIsTransRel : ∀ {c ℓ₁ ℓ₂} → Preorder c ℓ₁ ℓ₂ → TransRel c ℓ₁ ℓ₂
preorderIsTransRel P = record
{ isTransRel = record
{ isEquivalence = isEquivalence
; trans = trans
; ∼-resp-≈ = ∼-resp-≈
}
}
where open IsPreorder (Preorder.isPreorder P)
-- ... and so is every strict partial order.
strictPartialOrderIsTransRel : ∀ {c ℓ₁ ℓ₂} →
StrictPartialOrder c ℓ₁ ℓ₂ → TransRel c ℓ₁ ℓ₂
strictPartialOrderIsTransRel SPO = record
{ isTransRel = record
{ isEquivalence = isEquivalence
; trans = trans
; ∼-resp-≈ = <-resp-≈
}
}
where open IsStrictPartialOrder (StrictPartialOrder.isStrictPartialOrder SPO)
-- A form of relational reasoning for transitive relations.
--
-- The structure of this module is adapted from the
-- Relation.Binary.PreorderReasoning module of the standard library.
-- It differs from the latter in that
--
-- 1. it allows reasoning about relations that are transitive but not
-- reflexive, and
--
-- 2. the _IsRelatedTo_ predicate is extended with an additional
-- index that tracks whether elements of the carrier are actually
-- related in the transitive relation _∼_ or just in the
-- underlying equality _≈_.
--
-- Proofs that elements x, y are related as (x IsRelatedTo y In rel)
-- can be converted back to proofs that x ∼ y using begin_, whereas
-- proofs of (x IsRelatedTo y In eq) are too weak to do so. Since the
-- relation _∼_ is not assumed to be reflexive (i.e. not necessarily a
-- preorder) _∎ can only construct proofs of the weaker form (x ∎ : x
-- IsRelatedTo x In eq). Consequently, at least one use of _∼⟨_⟩_ is
-- necessary to conclude a proof.
module TransRelReasoning {c ℓ₁ ℓ₂} (R : TransRel c ℓ₁ ℓ₂) where
open TransRel R
infix 4 _IsRelatedTo_In_
infix 3 _∎
infixr 2 _∼⟨_⟩_ _≈⟨_⟩_ _≈⟨⟩_
infix 1 begin_
-- Codes for the relation _∼_ and the underlying equality _≈_.
data RelC : Set where
rel eq : RelC
-- A generic relation combining _∼_ and equality.
data _IsRelatedTo_In_ (x y : Carrier) : RelC → Set (ℓ₁ ⊔ ℓ₂) where
relTo : (x∼y : x ∼ y) → x IsRelatedTo y In rel
eqTo : (x≈y : x ≈ y) → x IsRelatedTo y In eq
begin_ : ∀ {x y} → x IsRelatedTo y In rel → x ∼ y
begin (relTo x∼y) = x∼y
_∼⟨_⟩_ : ∀ x {y z c} → x ∼ y → y IsRelatedTo z In c → x IsRelatedTo z In rel
_ ∼⟨ x∼y ⟩ relTo y∼z = relTo (trans x∼y y∼z)
_ ∼⟨ x∼y ⟩ eqTo y≈z = relTo (proj₁ ∼-resp-≈ y≈z x∼y)
_≈⟨_⟩_ : ∀ x {y z c} → x ≈ y → y IsRelatedTo z In c → x IsRelatedTo z In c
x ≈⟨ x≈y ⟩ relTo y∼z = relTo (proj₂ ∼-resp-≈ (Eq.sym x≈y) y∼z)
x ≈⟨ x≈y ⟩ eqTo y≈z = eqTo (Eq.trans x≈y y≈z)
_≈⟨⟩_ : ∀ x {y c} → x IsRelatedTo y In c → x IsRelatedTo y In c
_ ≈⟨⟩ rt-x∼y = rt-x∼y
_∎ : ∀ x → x IsRelatedTo x In eq
_ ∎ = eqTo Eq.refl
------------------------------------------------------------------------
-- FIXME: the following should go into a different module (probably
-- into Data.Fin.Substitution.{Typed,TypedRel})
-- A form of pre-order reasoning for transitive relations in a context.
record TransCtxTermRelReasoning {t₁ t₂ ℓ} {T₁ : Pred ℕ t₁} {T₂ : Pred ℕ t₂}
(_⊢_∼_ : Typing T₁ T₂ T₂ ℓ)
: Set (t₁ ⊔ t₂ ⊔ ℓ) where
-- Transitivity of _⊢_∼_ for a given context.
field ∼-trans : ∀ {n} {Γ : Ctx T₁ n} → Transitive (Γ ⊢_∼_)
module _ {n} {Γ : Ctx T₁ n} where
∼-transRel : TransRel _ _ _
∼-transRel = record
{ Carrier = T₂ n
; _≈_ = _≡_
; _∼_ = Γ ⊢_∼_
; isTransRel = record
{ isEquivalence = P.isEquivalence
; trans = ∼-trans
; ∼-resp-≈ = subst (Γ ⊢ _ ∼_) , subst (Γ ⊢_∼ _)
}
}
open TransRelReasoning ∼-transRel public
renaming (_≈⟨_⟩_ to _≡⟨_⟩_; _≈⟨⟩_ to _≡⟨⟩_)
-- A form of pre-order reasoning for typed transitive relations.
record TypedTransRelReasoning {t₁ t₂ t₃ ℓ} {T₁ : Pred ℕ t₁}
{T₂ : Pred ℕ t₂} {T₃ : Pred ℕ t₃}
(_⊢_∼_∈_ : TypedRel T₁ T₂ T₂ T₃ ℓ)
: Set (t₁ ⊔ t₂ ⊔ t₃ ⊔ ℓ) where
-- Transitivity of _⊢_∼_∈_ for a given context and T₃-"type".
field ∼-trans : ∀ {n} {Γ : Ctx T₁ n} {t} → Transitive (Γ ⊢_∼_∈ t)
module _ {n} {Γ : Ctx T₁ n} {t : T₃ n} where
∼-transRel : TransRel _ _ _
∼-transRel = record
{ Carrier = T₂ n
; _≈_ = _≡_
; _∼_ = Γ ⊢_∼_∈ t
; isTransRel = record
{ isEquivalence = P.isEquivalence
; trans = ∼-trans
; ∼-resp-≈ = subst (Γ ⊢ _ ∼_∈ _) , subst (Γ ⊢_∼ _ ∈ _)
}
}
open TransRelReasoning ∼-transRel public
renaming (_≈⟨_⟩_ to _≡⟨_⟩_; _≈⟨⟩_ to _≡⟨⟩_)
| {
"alphanum_fraction": 0.5841898428,
"avg_line_length": 35.0052910053,
"ext": "agda",
"hexsha": "8904035eedaf80d652de762b5d103c9e5c939e7f",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2021-05-14T10:25:05.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-05-13T22:29:48.000Z",
"max_forks_repo_head_hexsha": "ae20dac2a5e0c18dff2afda4c19954e24d73a24f",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Blaisorblade/f-omega-int-agda",
"max_forks_repo_path": "src/Relation/Binary/TransReasoning.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "ae20dac2a5e0c18dff2afda4c19954e24d73a24f",
"max_issues_repo_issues_event_max_datetime": "2021-05-14T08:54:39.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-05-14T08:09:40.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Blaisorblade/f-omega-int-agda",
"max_issues_repo_path": "src/Relation/Binary/TransReasoning.agda",
"max_line_length": 78,
"max_stars_count": 12,
"max_stars_repo_head_hexsha": "ae20dac2a5e0c18dff2afda4c19954e24d73a24f",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Blaisorblade/f-omega-int-agda",
"max_stars_repo_path": "src/Relation/Binary/TransReasoning.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-27T05:53:06.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-06-13T16:05:35.000Z",
"num_tokens": 2269,
"size": 6616
} |
open import Relation.Binary using (Preorder)
open import Relation.Binary.PropositionalEquality
open import Level
module Category.Monad.Monotone.State {ℓ}(pre : Preorder ℓ ℓ ℓ)(H : Preorder.Carrier pre → Set ℓ) where
open Preorder pre renaming (Carrier to I; _∼_ to _≤_; refl to ≤-refl; trans to ≤-trans)
open import Data.Unit using (⊤; tt)
open import Relation.Unary
open import Relation.Unary.PredicateTransformer using (Pt)
open import Relation.Unary.Monotone pre
open import Data.Product
open import Data.List.All
open import Category.Monad
open import Category.Monad.Monotone pre
open import Category.Monad.Identity
MST : (Set ℓ → Set ℓ) → Pt I ℓ
MST M P = H ⇒ (λ i → M (∃ λ j → i ≤ j × H j × P j))
MSt : Pt I ℓ
MSt = MST Identity
record StateMonad (M : Pt I ℓ) : Set (suc ℓ) where
field
runState : ∀ {P} → (H ↗ H ∩ P) ⊆ M P
get : ∀ {i} → M H i
get = runState λ _ μ → μ , μ
module _ {M}⦃ Mon : RawMonad {ℓ} M ⦄ where
private module M = RawMonad Mon
instance
open RawMPMonad hiding (_>>=_; ts)
mst-monad : RawMPMonad (MST M)
return mst-monad px μ = M.return (_ , ≤-refl , μ , px)
_≥=_ mst-monad c f μ = c μ M.>>= λ where
(i₁ , ext₁ , μ₁ , pv) → (f ext₁ pv μ₁) M.>>= λ where
(i₂ , ext₂ , μ₂ , pw) → M.return (i₂ , ≤-trans ext₁ ext₂ , μ₂ , pw)
open StateMonad
mst-monad-ops : StateMonad (MST M)
runState (mst-monad-ops) f μ = let μ' , p = f ≤-refl μ in M.return (_ , ≤-refl , μ' , p)
| {
"alphanum_fraction": 0.641184573,
"avg_line_length": 31.5652173913,
"ext": "agda",
"hexsha": "b83da509865c98449e822daf3e5bcfaa6a24259e",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-12-28T17:38:05.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-12-28T17:38:05.000Z",
"max_forks_repo_head_hexsha": "0c096fea1716d714db0ff204ef2a9450b7a816df",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "metaborg/mj.agda",
"max_forks_repo_path": "src/Category/Monad/Monotone/State.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "0c096fea1716d714db0ff204ef2a9450b7a816df",
"max_issues_repo_issues_event_max_datetime": "2020-10-14T13:41:58.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-13T13:03:47.000Z",
"max_issues_repo_licenses": [
"Apache-2.0"
],
"max_issues_repo_name": "metaborg/mj.agda",
"max_issues_repo_path": "src/Category/Monad/Monotone/State.agda",
"max_line_length": 102,
"max_stars_count": 10,
"max_stars_repo_head_hexsha": "0c096fea1716d714db0ff204ef2a9450b7a816df",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "metaborg/mj.agda",
"max_stars_repo_path": "src/Category/Monad/Monotone/State.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-24T08:02:33.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-11-17T17:10:36.000Z",
"num_tokens": 519,
"size": 1452
} |
data Bool : Set where
true : Bool
false : Bool
record Eq (t : Set) : Set where
field _==_ : t → t → Bool
open Eq {{...}}
-- Now package this into a record type for "sets with boolean equality":
record EqSet : Set₁ where
field
set : Set
instance eq : Eq set
open EqSet
equality : {{A : EqSet}} (x y : set A) → Bool
equality x y = x == y
| {
"alphanum_fraction": 0.6072423398,
"avg_line_length": 17.0952380952,
"ext": "agda",
"hexsha": "d41d2730c5b57e0d5f9bd77bb06aa1a542caf19a",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "alhassy/agda",
"max_forks_repo_path": "test/Succeed/Issue1273.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/Issue1273.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/Succeed/Issue1273.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": 113,
"size": 359
} |
{-
Constant structure: _ ↦ A
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Structures.Relational.Constant where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Structure
open import Cubical.Foundations.RelationalStructure
open import Cubical.HITs.PropositionalTruncation
open import Cubical.HITs.SetQuotients
open import Cubical.Structures.Constant
private
variable
ℓ ℓ' : Level
-- Structured relations
module _ (A : hSet ℓ') where
ConstantRelStr : StrRel {ℓ = ℓ} (ConstantStructure (A .fst)) ℓ'
ConstantRelStr _ a₀ a₁ = a₀ ≡ a₁
constantSuitableRel : SuitableStrRel {ℓ = ℓ} (ConstantStructure (A .fst)) ConstantRelStr
constantSuitableRel .quo _ _ _ = isContrSingl _
constantSuitableRel .symmetric _ = sym
constantSuitableRel .transitive _ _ = _∙_
constantSuitableRel .set _ = A .snd
constantSuitableRel .prop _ = A .snd
constantRelMatchesEquiv : StrRelMatchesEquiv {ℓ = ℓ} ConstantRelStr (ConstantEquivStr (A .fst))
constantRelMatchesEquiv _ _ _ = idEquiv _
constantRelAction : StrRelAction {ℓ = ℓ} ConstantRelStr
constantRelAction .actStr _ a = a
constantRelAction .actStrId _ = refl
constantRelAction .actRel _ a a' p = p
constantPositiveRel : PositiveStrRel {ℓ = ℓ} constantSuitableRel
constantPositiveRel .act = constantRelAction
constantPositiveRel .reflexive a = refl
constantPositiveRel .detransitive R R' p = ∣ _ , p , refl ∣
constantPositiveRel .quo R = isoToIsEquiv isom
where
open Iso
isom : Iso _ _
isom .fun = _
isom .inv = [_]
isom .rightInv _ = refl
isom .leftInv = elimProp (λ _ → squash/ _ _) (λ a → refl)
| {
"alphanum_fraction": 0.7443693694,
"avg_line_length": 30.6206896552,
"ext": "agda",
"hexsha": "c853b4824a996fe99f95445fb4c8b28e4b5af7fa",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "dan-iel-lee/cubical",
"max_forks_repo_path": "Cubical/Structures/Relational/Constant.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/Structures/Relational/Constant.agda",
"max_line_length": 97,
"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/Structures/Relational/Constant.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 551,
"size": 1776
} |
{-# OPTIONS --without-K --exact-split --allow-unsolved-metas #-}
module 12-univalence where
import 11-function-extensionality
open 11-function-extensionality public
-- Section 10.1 Type extensionality
equiv-eq : {i : Level} {A : UU i} {B : UU i} → Id A B → A ≃ B
equiv-eq {A = A} refl = pair id (is-equiv-id A)
UNIVALENCE : {i : Level} (A B : UU i) → UU (lsuc i)
UNIVALENCE A B = is-equiv (equiv-eq {A = A} {B = B})
is-contr-total-equiv-UNIVALENCE : {i : Level} (A : UU i) →
((B : UU i) → UNIVALENCE A B) → is-contr (Σ (UU i) (λ X → A ≃ X))
is-contr-total-equiv-UNIVALENCE A UA =
fundamental-theorem-id' A
( pair id (is-equiv-id A))
( λ B → equiv-eq {B = B})
( UA)
UNIVALENCE-is-contr-total-equiv : {i : Level} (A : UU i) →
is-contr (Σ (UU i) (λ X → A ≃ X)) → (B : UU i) → UNIVALENCE A B
UNIVALENCE-is-contr-total-equiv A c =
fundamental-theorem-id A
( pair id (is-equiv-id A))
( c)
( λ B → equiv-eq {B = B})
ev-id : {i j : Level} {A : UU i} (P : (B : UU i) → (A ≃ B) → UU j) →
((B : UU i) (e : A ≃ B) → P B e) → P A (pair id (is-equiv-id A))
ev-id {A = A} P f = f A (pair id (is-equiv-id A))
IND-EQUIV : {i j : Level} {A : UU i} → ((B : UU i) (e : A ≃ B) → UU j) → UU _
IND-EQUIV P = sec (ev-id P)
triangle-ev-id : {i j : Level} {A : UU i}
(P : (Σ (UU i) (λ X → A ≃ X)) → UU j) →
(ev-pt (Σ (UU i) (λ X → A ≃ X)) (pair A (pair id (is-equiv-id A))) P)
~ ((ev-id (λ X e → P (pair X e))) ∘ (ev-pair {A = UU i} {B = λ X → A ≃ X} {C = P}))
triangle-ev-id P f = refl
abstract
IND-EQUIV-is-contr-total-equiv : {i j : Level} (A : UU i) →
is-contr (Σ (UU i) (λ X → A ≃ X)) →
(P : (Σ (UU i) (λ X → A ≃ X)) → UU j) → IND-EQUIV (λ B e → P (pair B e))
IND-EQUIV-is-contr-total-equiv {i} {j} A c P =
section-comp
( ev-pt (Σ (UU i) (λ X → A ≃ X)) (pair A (pair id (is-equiv-id A))) P)
( ev-id (λ X e → P (pair X e)))
( ev-pair {A = UU i} {B = λ X → A ≃ X} {C = P})
( triangle-ev-id P)
( sec-ev-pair (UU i) (λ X → A ≃ X) P)
( is-sing-is-contr (Σ (UU i) (λ X → A ≃ X))
( pair
( pair A (pair id (is-equiv-id A)))
( λ t →
( inv (contraction c (pair A (pair id (is-equiv-id A))))) ∙
( contraction c t)))
( P)
( pair A (equiv-id A)))
abstract
is-contr-total-equiv-IND-EQUIV : {i : Level} (A : UU i) →
( {j : Level} (P : (Σ (UU i) (λ X → A ≃ X)) → UU j) →
IND-EQUIV (λ B e → P (pair B e))) →
is-contr (Σ (UU i) (λ X → A ≃ X))
is-contr-total-equiv-IND-EQUIV {i} A ind =
is-contr-is-sing
( Σ (UU i) (λ X → A ≃ X))
( pair A (pair id (is-equiv-id A)))
( λ P → section-comp'
( ev-pt (Σ (UU i) (λ X → A ≃ X)) (pair A (pair id (is-equiv-id A))) P)
( ev-id (λ X e → P (pair X e)))
( ev-pair {A = UU i} {B = λ X → A ≃ X} {C = P})
( triangle-ev-id P)
( sec-ev-pair (UU i) (λ X → A ≃ X) P)
( ind P))
-- The univalence axiom
postulate univalence : {i : Level} (A B : UU i) → UNIVALENCE A B
eq-equiv : {i : Level} (A B : UU i) → (A ≃ B) → Id A B
eq-equiv A B = inv-is-equiv (univalence A B)
abstract
is-contr-total-equiv : {i : Level} (A : UU i) →
is-contr (Σ (UU i) (λ X → A ≃ X))
is-contr-total-equiv A = is-contr-total-equiv-UNIVALENCE A (univalence A)
abstract
Ind-equiv : {i j : Level} (A : UU i) (P : (B : UU i) (e : A ≃ B) → UU j) →
sec (ev-id P)
Ind-equiv A P =
IND-EQUIV-is-contr-total-equiv A
( is-contr-total-equiv A)
( λ t → P (pr1 t) (pr2 t))
ind-equiv : {i j : Level} (A : UU i) (P : (B : UU i) (e : A ≃ B) → UU j) →
P A (pair id (is-equiv-id A)) → {B : UU i} (e : A ≃ B) → P B e
ind-equiv A P p {B} = pr1 (Ind-equiv A P) p B
-- Subuniverses
is-subuniverse :
{l1 l2 : Level} (P : UU l1 → UU l2) → UU ((lsuc l1) ⊔ l2)
is-subuniverse P = is-subtype P
subuniverse :
(l1 l2 : Level) → UU ((lsuc l1) ⊔ (lsuc l2))
subuniverse l1 l2 = Σ (UU l1 → UU l2) is-subuniverse
{- By univalence, subuniverses are closed under equivalences. -}
in-subuniverse-equiv :
{l1 l2 : Level} (P : UU l1 → UU l2) {X Y : UU l1} → X ≃ Y → P X → P Y
in-subuniverse-equiv P e = tr P (eq-equiv _ _ e)
in-subuniverse-equiv' :
{l1 l2 : Level} (P : UU l1 → UU l2) {X Y : UU l1} → X ≃ Y → P Y → P X
in-subuniverse-equiv' P e = tr P (inv (eq-equiv _ _ e))
total-subuniverse :
{l1 l2 : Level} (P : subuniverse l1 l2) → UU ((lsuc l1) ⊔ l2)
total-subuniverse {l1} P = Σ (UU l1) (pr1 P)
{- We also introduce the notion of 'global subuniverse'. The handling of
universe levels is a bit more complicated here, since (l : Level) → A l are
kinds but not types. -}
is-global-subuniverse :
(α : Level → Level) (P : (l : Level) → subuniverse l (α l)) →
(l1 l2 : Level) → UU _
is-global-subuniverse α P l1 l2 =
(X : UU l1) (Y : UU l2) → X ≃ Y → (pr1 (P l1)) X → (pr1 (P l2)) Y
{- Next we characterize the identity type of a subuniverse. -}
Eq-total-subuniverse :
{l1 l2 : Level} (P : subuniverse l1 l2) →
(s t : total-subuniverse P) → UU l1
Eq-total-subuniverse (pair P H) (pair X p) t = X ≃ (pr1 t)
Eq-total-subuniverse-eq :
{l1 l2 : Level} (P : subuniverse l1 l2) →
(s t : total-subuniverse P) → Id s t → Eq-total-subuniverse P s t
Eq-total-subuniverse-eq (pair P H) (pair X p) .(pair X p) refl = equiv-id X
abstract
is-contr-total-Eq-total-subuniverse :
{l1 l2 : Level} (P : subuniverse l1 l2)
(s : total-subuniverse P) →
is-contr (Σ (total-subuniverse P) (λ t → Eq-total-subuniverse P s t))
is-contr-total-Eq-total-subuniverse (pair P H) (pair X p) =
is-contr-total-Eq-substructure (is-contr-total-equiv X) H X (equiv-id X) p
abstract
is-equiv-Eq-total-subuniverse-eq :
{l1 l2 : Level} (P : subuniverse l1 l2)
(s t : total-subuniverse P) → is-equiv (Eq-total-subuniverse-eq P s t)
is-equiv-Eq-total-subuniverse-eq (pair P H) (pair X p) =
fundamental-theorem-id
( pair X p)
( equiv-id X)
( is-contr-total-Eq-total-subuniverse (pair P H) (pair X p))
( Eq-total-subuniverse-eq (pair P H) (pair X p))
eq-Eq-total-subuniverse :
{l1 l2 : Level} (P : subuniverse l1 l2) →
{s t : total-subuniverse P} → Eq-total-subuniverse P s t → Id s t
eq-Eq-total-subuniverse P {s} {t} =
inv-is-equiv (is-equiv-Eq-total-subuniverse-eq P s t)
-- Section 12.2 Univalence implies function extensionality
is-equiv-postcomp-univalence :
{l1 l2 : Level} {X Y : UU l1} (A : UU l2) (e : X ≃ Y) →
is-equiv (postcomp A (map-equiv e))
is-equiv-postcomp-univalence {X = X} A =
ind-equiv X
( λ Y e → is-equiv (postcomp A (map-equiv e)))
( is-equiv-id (A → X))
weak-funext-univalence :
{l : Level} {A : UU l} {B : A → UU l} → WEAK-FUNEXT A B
weak-funext-univalence {A = A} {B} is-contr-B =
is-contr-retract-of
( fib (postcomp A (pr1 {B = B})) id)
( pair
( λ f → pair (λ x → pair x (f x)) refl)
( pair
( λ h x → tr B (htpy-eq (pr2 h) x) (pr2 (pr1 h x)))
( htpy-refl)))
( is-contr-map-is-equiv
( is-equiv-postcomp-univalence A (equiv-pr1 is-contr-B))
( id))
funext-univalence :
{l : Level} {A : UU l} {B : A → UU l} (f : (x : A) → B x) → FUNEXT f
funext-univalence {A = A} {B} f =
FUNEXT-WEAK-FUNEXT (λ A B → weak-funext-univalence) A B f
-- Section 12.3 Groups in univalent mathematics
{- We first introduce semi-groups, and then groups. We do this because the
category of groups is a full subcategory of the category of semi-groups.
In particular, it is a proposition for a semi-group to be a group. Therefore
this approach gives us in a straightforward way that equality of groups is
equality of semi-groups. This will be useful in showing that group
isomorphisms are equivalent to identifications of groups. -}
has-associative-mul :
{l : Level} (X : UU-Set l) → UU l
has-associative-mul X =
Σ ( ( type-Set X) →
( ( type-Set X) → (type-Set X))) (λ μ →
( x y z : type-Set X) → Id (μ (μ x y) z) (μ x (μ y z)))
Semi-Group :
(l : Level) → UU (lsuc l)
Semi-Group l = Σ (UU-Set l) has-associative-mul
{- Bureaucracy of semi-groups. -}
set-Semi-Group :
{l : Level} → Semi-Group l → UU-Set l
set-Semi-Group G = pr1 G
type-Semi-Group :
{l : Level} → Semi-Group l → UU l
type-Semi-Group G = pr1 (set-Semi-Group G)
is-set-type-Semi-Group :
{l : Level} (G : Semi-Group l) → is-set (type-Semi-Group G)
is-set-type-Semi-Group G = pr2 (set-Semi-Group G)
associative-mul-Semi-Group :
{l : Level} (G : Semi-Group l) →
has-associative-mul (set-Semi-Group G)
associative-mul-Semi-Group G = pr2 G
mul-Semi-Group :
{l : Level} (G : Semi-Group l) →
type-Semi-Group G →
type-Semi-Group G → type-Semi-Group G
mul-Semi-Group G = pr1 (associative-mul-Semi-Group G)
is-associative-mul-Semi-Group :
{l : Level} (G : Semi-Group l) (x y z : type-Semi-Group G) →
Id ( mul-Semi-Group G (mul-Semi-Group G x y) z)
( mul-Semi-Group G x (mul-Semi-Group G y z))
is-associative-mul-Semi-Group G = pr2 (associative-mul-Semi-Group G)
{- The property that a semi-group is a monoid is just that the semi-group
possesses a unit that satisfies the left and right unit laws. -}
is-unital :
{l : Level} → Semi-Group l → UU l
is-unital G =
Σ ( type-Semi-Group G)
( λ e →
( (y : type-Semi-Group G) → Id (mul-Semi-Group G e y) y) ×
( (x : type-Semi-Group G) → Id (mul-Semi-Group G x e) x))
{- We show that is-unital is a proposition. -}
abstract
is-prop-is-unital' :
{l : Level} (G : Semi-Group l) → is-prop' (is-unital G)
is-prop-is-unital' (pair (pair X is-set-X) (pair μ assoc-μ))
(pair e (pair left-unit-e right-unit-e))
(pair e' (pair left-unit-e' right-unit-e')) =
eq-subtype
( λ e → is-prop-prod
( is-prop-Π (λ y → is-set-X (μ e y) y))
( is-prop-Π (λ x → is-set-X (μ x e) x)))
( (inv (left-unit-e' e)) ∙ (right-unit-e e'))
abstract
is-prop-is-unital :
{l : Level} (G : Semi-Group l) → is-prop (is-unital G)
is-prop-is-unital G = is-prop-is-prop' (is-prop-is-unital' G)
{- The property that a monoid is a group is just the property that the monoid
that every element is invertible, i.e., it comes equipped with an inverse
operation that satisfies the left and right inverse laws. -}
is-group' :
{l : Level} (G : Semi-Group l) → is-unital G → UU l
is-group' G is-unital-G =
Σ ( type-Semi-Group G → type-Semi-Group G)
( λ i →
( (x : type-Semi-Group G) →
Id (mul-Semi-Group G (i x) x) (pr1 is-unital-G)) ×
( (x : type-Semi-Group G) →
Id (mul-Semi-Group G x (i x)) (pr1 is-unital-G)))
is-group :
{l : Level} (G : Semi-Group l) → UU l
is-group G =
Σ (is-unital G) (is-group' G)
Group :
(l : Level) → UU (lsuc l)
Group l = Σ (Semi-Group l) is-group
{- Some bureaucracy of Groups. -}
semi-group-Group :
{l : Level} → Group l → Semi-Group l
semi-group-Group G = pr1 G
set-Group :
{l : Level} → Group l → UU-Set l
set-Group G = pr1 (semi-group-Group G)
type-Group :
{l : Level} → Group l → UU l
type-Group G = pr1 (set-Group G)
is-set-type-Group :
{l : Level} (G : Group l) → is-set (type-Group G)
is-set-type-Group G = pr2 (set-Group G)
associative-mul-Group :
{l : Level} (G : Group l) → has-associative-mul (set-Group G)
associative-mul-Group G = pr2 (semi-group-Group G)
mul-Group :
{l : Level} (G : Group l) →
type-Group G → type-Group G → type-Group G
mul-Group G = pr1 (associative-mul-Group G)
is-associative-mul-Group :
{l : Level} (G : Group l) (x y z : type-Group G) →
Id (mul-Group G (mul-Group G x y) z) (mul-Group G x (mul-Group G y z))
is-associative-mul-Group G = pr2 (associative-mul-Group G)
is-group-Group :
{l : Level} (G : Group l) → is-group (semi-group-Group G)
is-group-Group G = pr2 G
is-unital-Group :
{l : Level} (G : Group l) → is-unital (semi-group-Group G)
is-unital-Group G = pr1 (is-group-Group G)
unit-Group :
{l : Level} (G : Group l) → type-Group G
unit-Group G = pr1 (is-unital-Group G)
left-unit-law-Group :
{l : Level} (G : Group l) (x : type-Group G) →
Id (mul-Group G (unit-Group G) x) x
left-unit-law-Group G = pr1 (pr2 (is-unital-Group G))
right-unit-law-Group :
{l : Level} (G : Group l) (x : type-Group G) →
Id (mul-Group G x (unit-Group G)) x
right-unit-law-Group G = pr2 (pr2 (is-unital-Group G))
has-inverses-Group :
{l : Level} (G : Group l) →
is-group' (semi-group-Group G) (is-unital-Group G)
has-inverses-Group G = pr2 (is-group-Group G)
inv-Group :
{l : Level} (G : Group l) →
type-Group G → type-Group G
inv-Group G = pr1 (has-inverses-Group G)
left-inverse-law-Group :
{l : Level} (G : Group l) (x : type-Group G) →
Id (mul-Group G (inv-Group G x) x) (unit-Group G)
left-inverse-law-Group G = pr1 (pr2 (has-inverses-Group G))
right-inverse-law-Group :
{l : Level} (G : Group l) (x : type-Group G) →
Id (mul-Group G x (inv-Group G x)) (unit-Group G)
right-inverse-law-Group G = pr2 (pr2 (has-inverses-Group G))
{- We show that being a group is a proposition. -}
abstract
is-prop-is-group' :
{l : Level} (G : Semi-Group l) (e : is-unital G) → is-prop' (is-group' G e)
is-prop-is-group'
( pair (pair G is-set-G) (pair μ assoc-G))
( pair e (pair left-unit-G right-unit-G))
( pair i (pair left-inv-i right-inv-i))
( pair i' (pair left-inv-i' right-inv-i')) =
eq-subtype
( λ i →
is-prop-prod
( is-prop-Π (λ x → is-set-G (μ (i x) x) e))
( is-prop-Π (λ x → is-set-G (μ x (i x)) e)))
( eq-htpy
( λ x → -- ix
( inv (left-unit-G (i x))) ∙ -- = 1·(ix)
( ( ap (λ y → μ y (i x)) (inv (left-inv-i' x))) ∙ -- = (i'x·x)·(ix)
( ( assoc-G (i' x) x (i x)) ∙ -- = (i'x)·(x·i'x)
( ( ap (μ (i' x)) (right-inv-i x)) ∙ -- = (i'x)·1
( right-unit-G (i' x))))))) -- = i'x
abstract
is-prop-is-group :
{l : Level} (G : Semi-Group l) → is-prop (is-group G)
is-prop-is-group G =
is-prop-Σ
( is-prop-is-unital G)
( λ e → is-prop-is-prop' (is-prop-is-group' G e))
{- We give two examples of groups. The first is the group ℤ of integers. The
second is the loop space of a pointed 1-type. -}
{- The group of integers. -}
semi-group-ℤ : Semi-Group lzero
semi-group-ℤ = pair set-ℤ (pair add-ℤ associative-add-ℤ)
group-ℤ : Group lzero
group-ℤ =
pair
( semi-group-ℤ)
( pair
( pair zero-ℤ (pair left-unit-law-add-ℤ right-unit-law-add-ℤ))
( pair neg-ℤ (pair left-inverse-law-add-ℤ right-inverse-law-add-ℤ)))
{- The loop space of a 1-type as a group. -}
loop-space :
{l : Level} {A : UU l} → A → UU l
loop-space a = Id a a
set-loop-space :
{l : Level} (A : UU l) (a : A) (is-set-Ω : is-set (Id a a)) → UU-Set l
set-loop-space A a is-set-Ω = pair (Id a a) is-set-Ω
semi-group-loop-space :
{l : Level} (A : UU l) (a : A) (is-set-Ω : is-set (Id a a)) → Semi-Group l
semi-group-loop-space A a is-set-Ω =
pair
( set-loop-space A a is-set-Ω)
( pair (λ p q → p ∙ q) assoc)
group-loop-space :
{l : Level} (A : UU l) (a : A) (is-set-Ω : is-set (Id a a)) → Group l
group-loop-space A a is-set-Ω =
pair
( semi-group-loop-space A a is-set-Ω)
( pair
( pair refl (pair (λ q → left-unit) (λ p → right-unit)))
( pair inv (pair left-inv right-inv)))
set-loop-space-1-type :
{l : Level} (A : 1-type l) (a : pr1 A) → UU-Set l
set-loop-space-1-type (pair A is-1-type-A) a =
set-loop-space A a (is-1-type-A a a)
semi-group-loop-space-1-type :
{l : Level} (A : 1-type l) (a : pr1 A) → Semi-Group l
semi-group-loop-space-1-type (pair A is-1-type-A) a =
semi-group-loop-space A a (is-1-type-A a a)
group-loop-space-1-type :
{l : Level} (A : 1-type l) (a : pr1 A) → Group l
group-loop-space-1-type (pair A is-1-type-A) a =
group-loop-space A a (is-1-type-A a a)
{- We introduce the automorphism group on a set X. -}
aut-Set :
{l : Level} (X : UU-Set l) → UU-Set l
aut-Set X = set-equiv X X
associative-comp-equiv :
{l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4} →
(e : A ≃ B) (f : B ≃ C) (g : C ≃ D) →
Id ((g ∘e f) ∘e e) (g ∘e (f ∘e e))
associative-comp-equiv e f g = eq-htpy-equiv htpy-refl
has-associative-mul-aut-Set :
{l : Level} (X : UU-Set l) → has-associative-mul (aut-Set X)
has-associative-mul-aut-Set X =
pair
( λ e f → f ∘e e)
( λ e f g → inv (associative-comp-equiv e f g))
aut-Semi-Group :
{l : Level} (X : UU-Set l) → Semi-Group l
aut-Semi-Group X =
pair
( aut-Set X)
( has-associative-mul-aut-Set X)
left-unit-law-equiv :
{l1 l2 : Level} {X : UU l1} {Y : UU l2} (e : X ≃ Y) →
Id ((equiv-id Y) ∘e e) e
left-unit-law-equiv e = eq-htpy-equiv htpy-refl
right-unit-law-equiv :
{l1 l2 : Level} {X : UU l1} {Y : UU l2} (e : X ≃ Y) →
Id (e ∘e (equiv-id X)) e
right-unit-law-equiv e = eq-htpy-equiv htpy-refl
is-unital-aut-Semi-Group :
{l : Level} (X : UU-Set l) → is-unital (aut-Semi-Group X)
is-unital-aut-Semi-Group X =
pair
( equiv-id (type-Set X))
( pair
( right-unit-law-equiv)
( left-unit-law-equiv))
left-inverse-law-equiv :
{l1 l2 : Level} {X : UU l1} {Y : UU l2} (e : X ≃ Y) →
Id ((inv-equiv e) ∘e e) (equiv-id X)
left-inverse-law-equiv e =
eq-htpy-equiv (isretr-inv-is-equiv (is-equiv-map-equiv e))
right-inverse-law-equiv :
{l1 l2 : Level} {X : UU l1} {Y : UU l2} (e : X ≃ Y) →
Id (e ∘e (inv-equiv e)) (equiv-id Y)
right-inverse-law-equiv e =
eq-htpy-equiv (issec-inv-is-equiv (is-equiv-map-equiv e))
is-group-aut-Semi-Group' :
{l : Level} (X : UU-Set l) →
is-group' (aut-Semi-Group X) (is-unital-aut-Semi-Group X)
is-group-aut-Semi-Group' X =
pair
( inv-equiv)
( pair right-inverse-law-equiv left-inverse-law-equiv)
aut-Group :
{l : Level} → UU-Set l → Group l
aut-Group X =
pair
( aut-Semi-Group X)
( pair (is-unital-aut-Semi-Group X) (is-group-aut-Semi-Group' X))
{- Now we introduce homomorphisms of semi-groups. Group homomorphisms are just
homomorphisms between their underlying semi-groups. -}
preserves-mul :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
(type-Semi-Group G → type-Semi-Group H) → UU (l1 ⊔ l2)
preserves-mul G H f =
(x y : type-Semi-Group G) →
Id (f (mul-Semi-Group G x y)) (mul-Semi-Group H (f x) (f y))
abstract
is-prop-preserves-mul :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
( f : type-Semi-Group G → type-Semi-Group H) →
is-prop (preserves-mul G H f)
is-prop-preserves-mul G (pair (pair H is-set-H) (pair μ-H assoc-H)) f =
is-prop-Π (λ x →
is-prop-Π (λ y →
is-set-H (f (mul-Semi-Group G x y)) (μ-H (f x) (f y))))
hom-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) → UU (l1 ⊔ l2)
hom-Semi-Group G H =
Σ ( type-Semi-Group G → type-Semi-Group H)
( preserves-mul G H)
{- Bureaucracy of homomorphisms of semi-groups. -}
map-hom-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
( hom-Semi-Group G H) →
( type-Semi-Group G) → (type-Semi-Group H)
map-hom-Semi-Group G H f = pr1 f
preserves-mul-hom-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
( f : hom-Semi-Group G H) →
preserves-mul G H (map-hom-Semi-Group G H f)
preserves-mul-hom-Semi-Group G H f = pr2 f
{- We characterize the identity type of the semi-group homomorphisms. -}
htpy-hom-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2)
(f g : hom-Semi-Group G H) → UU (l1 ⊔ l2)
htpy-hom-Semi-Group G H f g =
(map-hom-Semi-Group G H f) ~ (map-hom-Semi-Group G H g)
reflexive-htpy-hom-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
( f : hom-Semi-Group G H) → htpy-hom-Semi-Group G H f f
reflexive-htpy-hom-Semi-Group G H f = htpy-refl
htpy-hom-Semi-Group-eq :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
( f g : hom-Semi-Group G H) → Id f g → htpy-hom-Semi-Group G H f g
htpy-hom-Semi-Group-eq G H f .f refl = reflexive-htpy-hom-Semi-Group G H f
abstract
is-contr-total-htpy-hom-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
( f : hom-Semi-Group G H) →
is-contr (Σ (hom-Semi-Group G H) (htpy-hom-Semi-Group G H f))
is-contr-total-htpy-hom-Semi-Group G H f =
is-contr-total-Eq-substructure
( is-contr-total-htpy (map-hom-Semi-Group G H f))
( is-prop-preserves-mul G H)
( map-hom-Semi-Group G H f)
( htpy-refl)
( preserves-mul-hom-Semi-Group G H f)
abstract
is-equiv-htpy-hom-Semi-Group-eq :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
( f g : hom-Semi-Group G H) → is-equiv (htpy-hom-Semi-Group-eq G H f g)
is-equiv-htpy-hom-Semi-Group-eq G H f =
fundamental-theorem-id f
( reflexive-htpy-hom-Semi-Group G H f)
( is-contr-total-htpy-hom-Semi-Group G H f)
( htpy-hom-Semi-Group-eq G H f)
eq-htpy-hom-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
{ f g : hom-Semi-Group G H} → htpy-hom-Semi-Group G H f g → Id f g
eq-htpy-hom-Semi-Group G H {f} {g} =
inv-is-equiv (is-equiv-htpy-hom-Semi-Group-eq G H f g)
{- We show that the type of semi-group homomorphisms between two semi-groups is
a set. -}
is-set-hom-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
is-set (hom-Semi-Group G H)
is-set-hom-Semi-Group G H (pair f μ-f) (pair g μ-g) =
is-prop-is-equiv
( htpy-hom-Semi-Group G H (pair f μ-f) (pair g μ-g))
( htpy-hom-Semi-Group-eq G H (pair f μ-f) (pair g μ-g))
( is-equiv-htpy-hom-Semi-Group-eq G H (pair f μ-f) (pair g μ-g))
( is-prop-Π (λ x → is-set-type-Semi-Group H (f x) (g x)))
{- We introduce group homomorphisms. -}
hom-Group :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) → UU (l1 ⊔ l2)
hom-Group G H =
hom-Semi-Group
( semi-group-Group G)
( semi-group-Group H)
{- Bureaucracy of group homomorphisms. -}
map-hom-Group :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) →
( hom-Group G H) →
( type-Group G) → (type-Group H)
map-hom-Group G H f = pr1 f
preserves-mul-hom-Group :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) →
( f : hom-Group G H) →
preserves-mul
( semi-group-Group G)
( semi-group-Group H)
( map-hom-Group G H f)
preserves-mul-hom-Group G H f = pr2 f
{- We characterize the identity type of the group homomorphisms. -}
htpy-hom-Group :
{ l1 l2 : Level} (G : Group l1) (H : Group l2)
(f g : hom-Group G H) → UU (l1 ⊔ l2)
htpy-hom-Group G H =
htpy-hom-Semi-Group
( semi-group-Group G)
( semi-group-Group H)
reflexive-htpy-hom-Group :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) →
( f : hom-Group G H) → htpy-hom-Group G H f f
reflexive-htpy-hom-Group G H =
reflexive-htpy-hom-Semi-Group
( semi-group-Group G)
( semi-group-Group H)
htpy-hom-Group-eq :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) →
( f g : hom-Group G H) → Id f g → htpy-hom-Group G H f g
htpy-hom-Group-eq G H =
htpy-hom-Semi-Group-eq
( semi-group-Group G)
( semi-group-Group H)
abstract
is-contr-total-htpy-hom-Group :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) →
( f : hom-Group G H) →
is-contr (Σ (hom-Group G H) (htpy-hom-Group G H f))
is-contr-total-htpy-hom-Group G H =
is-contr-total-htpy-hom-Semi-Group
( semi-group-Group G)
( semi-group-Group H)
abstract
is-equiv-htpy-hom-Group-eq :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) →
( f g : hom-Group G H) → is-equiv (htpy-hom-Group-eq G H f g)
is-equiv-htpy-hom-Group-eq G H =
is-equiv-htpy-hom-Semi-Group-eq
( semi-group-Group G)
( semi-group-Group H)
eq-htpy-hom-Group :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) →
{ f g : hom-Group G H} → htpy-hom-Group G H f g → Id f g
eq-htpy-hom-Group G H =
eq-htpy-hom-Semi-Group (semi-group-Group G) (semi-group-Group H)
{- Next, we construct the identity group homomorphism, and we show that
compositions of group homomorphisms are again group homomorphisms. -}
preserves-mul-id :
{l : Level} (G : Semi-Group l) → preserves-mul G G id
preserves-mul-id (pair (pair G is-set-G) (pair μ-G assoc-G)) x y = refl
id-Semi-Group :
{l : Level} (G : Semi-Group l) → hom-Semi-Group G G
id-Semi-Group G =
pair id (preserves-mul-id G)
id-Group :
{l : Level} (G : Group l) → hom-Group G G
id-Group G = id-Semi-Group (semi-group-Group G)
composition-Semi-Group :
{l1 l2 l3 : Level} →
(G : Semi-Group l1) (H : Semi-Group l2) (K : Semi-Group l3) →
(hom-Semi-Group H K) → (hom-Semi-Group G H) → (hom-Semi-Group G K)
composition-Semi-Group G H K (pair g μ-g) (pair f μ-f) =
pair
( g ∘ f)
( λ x y → (ap g (μ-f x y)) ∙ (μ-g (f x) (f y)))
composition-Group :
{l1 l2 l3 : Level} (G : Group l1) (H : Group l2) (K : Group l3) →
(hom-Group H K) → (hom-Group G H) → (hom-Group G K)
composition-Group G H K =
composition-Semi-Group
( semi-group-Group G)
( semi-group-Group H)
( semi-group-Group K)
{- Next, we prove the that the laws for a category hold for group homomorphisms,
i.e., we show that composition is associative and satisfies the left and
right unit laws. Before we show that these laws hold, we will characterize
the identity type of the types of semi-group homomorphisms and group
homomorphisms. -}
associative-Semi-Group :
{ l1 l2 l3 l4 : Level} (G : Semi-Group l1) (H : Semi-Group l2)
( K : Semi-Group l3) (L : Semi-Group l4) (h : hom-Semi-Group K L) →
( g : hom-Semi-Group H K) (f : hom-Semi-Group G H) →
Id ( composition-Semi-Group G H L
( composition-Semi-Group H K L h g) f)
( composition-Semi-Group G K L h
( composition-Semi-Group G H K g f))
associative-Semi-Group G H K L (pair h μ-h) (pair g μ-g) (pair f μ-f) =
eq-htpy-hom-Semi-Group G L htpy-refl
left-unit-law-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2)
( f : hom-Semi-Group G H) →
Id ( composition-Semi-Group G H H (id-Semi-Group H) f) f
left-unit-law-Semi-Group G
(pair (pair H is-set-H) (pair μ-H assoc-H)) (pair f μ-f) =
eq-htpy-hom-Semi-Group G
( pair (pair H is-set-H) (pair μ-H assoc-H))
( htpy-refl)
right-unit-law-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2)
( f : hom-Semi-Group G H) →
Id ( composition-Semi-Group G G H f (id-Semi-Group G)) f
right-unit-law-Semi-Group
(pair (pair G is-set-G) (pair μ-G assoc-G)) H (pair f μ-f) =
eq-htpy-hom-Semi-Group
( pair (pair G is-set-G) (pair μ-G assoc-G)) H htpy-refl
{- Now we introduce the notion of group isomorphism. Finally, we will show that
isomorphic groups are equal. -}
is-iso-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
( f : hom-Semi-Group G H) → UU (l1 ⊔ l2)
is-iso-Semi-Group G H f =
Σ ( hom-Semi-Group H G) (λ g →
( Id (composition-Semi-Group H G H f g) (id-Semi-Group H)) ×
( Id (composition-Semi-Group G H G g f) (id-Semi-Group G)))
iso-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) → UU (l1 ⊔ l2)
iso-Semi-Group G H =
Σ (hom-Semi-Group G H) (is-iso-Semi-Group G H)
abstract
is-prop-is-iso-Semi-Group' :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
( f : hom-Semi-Group G H) → is-prop' (is-iso-Semi-Group G H f)
is-prop-is-iso-Semi-Group' G H f
(pair g (pair issec isretr)) (pair g' (pair issec' isretr')) =
eq-subtype
( λ h →
is-prop-prod
( is-set-hom-Semi-Group H H
( composition-Semi-Group H G H f h)
( id-Semi-Group H))
( is-set-hom-Semi-Group G G
( composition-Semi-Group G H G h f)
( id-Semi-Group G)))
( ( inv (left-unit-law-Semi-Group H G g)) ∙
( ( inv (ap (λ h → composition-Semi-Group H G G h g) isretr')) ∙
( ( associative-Semi-Group H G H G g' f g) ∙
( ( ap (composition-Semi-Group H H G g') issec) ∙
( right-unit-law-Semi-Group H G g')))))
abstract
is-prop-is-iso-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
( f : hom-Semi-Group G H) → is-prop (is-iso-Semi-Group G H f)
is-prop-is-iso-Semi-Group G H f =
is-prop-is-prop' (is-prop-is-iso-Semi-Group' G H f)
abstract
preserves-mul-inv-is-equiv-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
( f : hom-Semi-Group G H)
( is-equiv-f : is-equiv (map-hom-Semi-Group G H f)) →
preserves-mul H G (inv-is-equiv is-equiv-f)
preserves-mul-inv-is-equiv-Semi-Group
( pair (pair G is-set-G) (pair μ-G assoc-G))
( pair (pair H is-set-H) (pair μ-H assoc-H))
( pair f μ-f) is-equiv-f x y =
inv-is-equiv
( is-emb-is-equiv f is-equiv-f
( inv-is-equiv is-equiv-f (μ-H x y))
( μ-G (inv-is-equiv is-equiv-f x) (inv-is-equiv is-equiv-f y)))
( ( ( issec-inv-is-equiv is-equiv-f (μ-H x y)) ∙
( ( ap (λ t → μ-H t y) (inv (issec-inv-is-equiv is-equiv-f x))) ∙
( ap
( μ-H (f (inv-is-equiv is-equiv-f x)))
( inv (issec-inv-is-equiv is-equiv-f y))))) ∙
( inv (μ-f (inv-is-equiv is-equiv-f x) (inv-is-equiv is-equiv-f y))))
abstract
is-iso-is-equiv-hom-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
( f : hom-Semi-Group G H) (is-equiv-f : is-equiv (pr1 f)) →
is-iso-Semi-Group G H f
is-iso-is-equiv-hom-Semi-Group
( pair (pair G is-set-G) (pair μ-G assoc-G))
( pair (pair H is-set-H) (pair μ-H assoc-H))
( pair f μ-f) is-equiv-f =
pair
( pair
( inv-is-equiv is-equiv-f)
( preserves-mul-inv-is-equiv-Semi-Group
( pair (pair G is-set-G) (pair μ-G assoc-G))
( pair (pair H is-set-H) (pair μ-H assoc-H))
( pair f μ-f) is-equiv-f))
( pair
( eq-htpy-hom-Semi-Group
( pair (pair H is-set-H) (pair μ-H assoc-H))
( pair (pair H is-set-H) (pair μ-H assoc-H))
( issec-inv-is-equiv is-equiv-f))
( eq-htpy-hom-Semi-Group
( pair (pair G is-set-G) (pair μ-G assoc-G))
( pair (pair G is-set-G) (pair μ-G assoc-G))
( isretr-inv-is-equiv is-equiv-f)))
abstract
is-equiv-hom-is-iso-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
( f : hom-Semi-Group G H) (is-iso-f : is-iso-Semi-Group G H f) →
( is-equiv (pr1 f))
is-equiv-hom-is-iso-Semi-Group
( pair (pair G is-set-G) (pair μ-G assoc-G))
( pair (pair H is-set-H) (pair μ-H assoc-H))
( pair f μ-f)
( pair (pair g μ-g) (pair issec isretr)) =
is-equiv-has-inverse g
( htpy-eq (ap pr1 issec))
( htpy-eq (ap pr1 isretr))
equiv-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) → UU (l1 ⊔ l2)
equiv-Semi-Group G H =
Σ ( type-Semi-Group G ≃ type-Semi-Group H)
( λ e → preserves-mul G H (map-equiv e))
total-is-equiv-hom-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) → UU (l1 ⊔ l2)
total-is-equiv-hom-Semi-Group G H =
Σ (hom-Semi-Group G H) (λ f → is-equiv (map-hom-Semi-Group G H f))
preserves-mul' :
{ l1 l2 : Level} (G : Semi-Group l1) (H : UU-Set l2)
( μ-H : has-associative-mul H) →
( e : (type-Semi-Group G) ≃ (type-Set H)) →
UU (l1 ⊔ l2)
preserves-mul' G H μ-H e = preserves-mul G (pair H μ-H) (map-equiv e)
equiv-Semi-Group' :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) → UU (l1 ⊔ l2)
equiv-Semi-Group' G H = equiv-Semi-Group G (pair (pr1 H) (pr2 H))
abstract
equiv-iso-Semi-Group-equiv-Semi-Group :
{ l1 l2 : Level} (G : Semi-Group l1) (H : Semi-Group l2) →
equiv-Semi-Group' G H ≃ iso-Semi-Group G H
equiv-iso-Semi-Group-equiv-Semi-Group G H =
( ( ( equiv-total-subtype
( λ f → is-subtype-is-equiv (map-hom-Semi-Group G H f))
( is-prop-is-iso-Semi-Group G H)
( is-iso-is-equiv-hom-Semi-Group G H)
( is-equiv-hom-is-iso-Semi-Group G H)) ∘e
( ( inv-equiv
( equiv-Σ-assoc
( type-Semi-Group G → type-Semi-Group H)
( preserves-mul G H)
( λ f → is-equiv (map-hom-Semi-Group G H f)))) ∘e
( equiv-tot
( λ f → equiv-swap-prod (is-equiv f) (preserves-mul G H f))))) ∘e
( equiv-Σ-assoc
( type-Semi-Group G → type-Semi-Group H)
( is-equiv)
( λ e → preserves-mul G H (map-equiv e)))) ∘e
( equiv-tr (equiv-Semi-Group G) (η-pair H))
center-total-preserves-mul-id :
{ l1 : Level} (G : Semi-Group l1) →
Σ (has-associative-mul (pr1 G)) (λ μ → preserves-mul G (pair (pr1 G) μ) id)
center-total-preserves-mul-id (pair (pair G is-set-G) (pair μ-G assoc-G)) =
pair (pair μ-G assoc-G) (λ x y → refl)
contraction-total-preserves-mul-id :
{ l1 : Level} (G : Semi-Group l1) →
( t : Σ ( has-associative-mul (pr1 G))
( λ μ → preserves-mul G (pair (pr1 G) μ) id)) →
Id (center-total-preserves-mul-id G) t
contraction-total-preserves-mul-id
( pair (pair G is-set-G) (pair μ-G assoc-G))
( pair (pair μ-G' assoc-G') μ-id) =
eq-subtype
( λ μ →
is-prop-preserves-mul
( pair (pair G is-set-G) (pair μ-G assoc-G))
( pair (pair G is-set-G) μ) id)
( eq-subtype
( λ μ →
is-prop-Π (λ x →
is-prop-Π (λ y →
is-prop-Π (λ z →
is-set-G (μ (μ x y) z) (μ x (μ y z))))))
( eq-htpy (λ x → eq-htpy (λ y → μ-id x y))))
is-contr-total-preserves-mul-id :
{ l1 : Level} (G : Semi-Group l1) →
is-contr (Σ (has-associative-mul (pr1 G)) (λ μ → preserves-mul G (pair (pr1 G) μ) id))
is-contr-total-preserves-mul-id G =
pair
( center-total-preserves-mul-id G)
( contraction-total-preserves-mul-id G)
is-contr-total-equiv-Semi-Group :
{ l1 : Level} (G : Semi-Group l1) →
is-contr (Σ (Semi-Group l1) (λ H → equiv-Semi-Group' G H))
is-contr-total-equiv-Semi-Group {l1} G =
is-contr-total-Eq-structure
( preserves-mul' G)
( is-contr-total-Eq-substructure
( is-contr-total-equiv (type-Semi-Group G))
( is-prop-is-set)
( type-Semi-Group G)
( equiv-id (type-Semi-Group G))
( is-set-type-Semi-Group G))
( pair (pr1 G) (equiv-id (type-Semi-Group G)))
( is-contr-total-preserves-mul-id G)
is-contr-total-iso-Semi-Group :
{ l1 : Level} (G : Semi-Group l1) →
is-contr (Σ (Semi-Group l1) (iso-Semi-Group G))
is-contr-total-iso-Semi-Group {l1} G =
is-contr-equiv'
( Σ (Semi-Group l1) (λ H → equiv-Semi-Group' G H))
( equiv-tot (λ H → equiv-iso-Semi-Group-equiv-Semi-Group G H))
( is-contr-total-equiv-Semi-Group G)
iso-id-Semi-Group :
{ l1 : Level} (G : Semi-Group l1) → iso-Semi-Group G G
iso-id-Semi-Group G =
pair
( id-Semi-Group G)
( pair
( id-Semi-Group G)
( pair
( left-unit-law-Semi-Group G G (id-Semi-Group G))
( right-unit-law-Semi-Group G G (id-Semi-Group G))))
iso-eq-Semi-Group :
{ l1 : Level} (G H : Semi-Group l1) → Id G H → iso-Semi-Group G H
iso-eq-Semi-Group G .G refl = iso-id-Semi-Group G
is-equiv-iso-eq-Semi-Group :
{ l1 : Level} (G H : Semi-Group l1) → is-equiv (iso-eq-Semi-Group G H)
is-equiv-iso-eq-Semi-Group G =
fundamental-theorem-id G
( iso-id-Semi-Group G)
( is-contr-total-iso-Semi-Group G)
( iso-eq-Semi-Group G)
equiv-iso-eq-Semi-Group :
{ l1 : Level} (G H : Semi-Group l1) → Id G H ≃ iso-Semi-Group G H
equiv-iso-eq-Semi-Group G H =
pair (iso-eq-Semi-Group G H) (is-equiv-iso-eq-Semi-Group G H)
eq-iso-Semi-Group :
{ l1 : Level} (G H : Semi-Group l1) → iso-Semi-Group G H → Id G H
eq-iso-Semi-Group G H = inv-is-equiv (is-equiv-iso-eq-Semi-Group G H)
{- Finally we show that isomorphic groups are equal. -}
iso-Group :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) → UU (l1 ⊔ l2)
iso-Group G H =
iso-Semi-Group
( semi-group-Group G)
( semi-group-Group H)
iso-id-Group :
{ l1 : Level} (G : Group l1) → iso-Group G G
iso-id-Group G = iso-id-Semi-Group (semi-group-Group G)
iso-eq-Group :
{ l1 : Level} (G H : Group l1) → Id G H → iso-Group G H
iso-eq-Group G .G refl = iso-id-Group G
abstract
equiv-iso-eq-Group' :
{ l1 : Level} (G H : Group l1) → Id G H ≃ iso-Group G H
equiv-iso-eq-Group' G H =
( equiv-iso-eq-Semi-Group
( semi-group-Group G)
( semi-group-Group H)) ∘e
( equiv-ap-pr1-is-subtype is-prop-is-group {s = G} {t = H})
abstract
is-contr-total-iso-Group :
{ l1 : Level} (G : Group l1) → is-contr (Σ (Group l1) (iso-Group G))
is-contr-total-iso-Group {l1} G =
is-contr-equiv'
( Σ (Group l1) (Id G))
( equiv-tot (λ H → equiv-iso-eq-Group' G H))
( is-contr-total-path G)
is-equiv-iso-eq-Group :
{ l1 : Level} (G H : Group l1) → is-equiv (iso-eq-Group G H)
is-equiv-iso-eq-Group G =
fundamental-theorem-id G
( iso-id-Group G)
( is-contr-total-iso-Group G)
( iso-eq-Group G)
eq-iso-Group :
{ l1 : Level} (G H : Group l1) → iso-Group G H → Id G H
eq-iso-Group G H = inv-is-equiv (is-equiv-iso-eq-Group G H)
-- Exercises
-- Exercise 10.1
tr-equiv-eq-ap : {l1 l2 : Level} {A : UU l1} {B : A → UU l2} {x y : A}
(p : Id x y) → (map-equiv (equiv-eq (ap B p))) ~ tr B p
tr-equiv-eq-ap refl = htpy-refl
-- Exercise 10.2
subuniverse-is-contr :
{i : Level} → subuniverse i i
subuniverse-is-contr {i} = pair is-contr is-subtype-is-contr
unit' :
(i : Level) → UU i
unit' i = pr1 (Raise i unit)
abstract
is-contr-unit' :
(i : Level) → is-contr (unit' i)
is-contr-unit' i =
is-contr-equiv' unit (pr2 (Raise i unit)) is-contr-unit
abstract
center-UU-contr :
(i : Level) → total-subuniverse (subuniverse-is-contr {i})
center-UU-contr i =
pair (unit' i) (is-contr-unit' i)
contraction-UU-contr :
{i : Level} (A : Σ (UU i) is-contr) →
Id (center-UU-contr i) A
contraction-UU-contr (pair A is-contr-A) =
eq-Eq-total-subuniverse subuniverse-is-contr
( equiv-is-contr (is-contr-unit' _) is-contr-A)
abstract
is-contr-UU-contr : (i : Level) → is-contr (Σ (UU i) is-contr)
is-contr-UU-contr i =
pair (center-UU-contr i) (contraction-UU-contr)
is-trunc-UU-trunc :
(k : 𝕋) (i : Level) → is-trunc (succ-𝕋 k) (Σ (UU i) (is-trunc k))
is-trunc-UU-trunc k i X Y =
is-trunc-is-equiv k
( Id (pr1 X) (pr1 Y))
( ap pr1)
( is-emb-pr1-is-subtype
( is-prop-is-trunc k) X Y)
( is-trunc-is-equiv k
( (pr1 X) ≃ (pr1 Y))
( equiv-eq)
( univalence (pr1 X) (pr1 Y))
( is-trunc-equiv-is-trunc k (pr2 X) (pr2 Y)))
ev-true-false :
{l : Level} (A : UU l) → (f : bool → A) → A × A
ev-true-false A f = pair (f true) (f false)
map-universal-property-bool :
{l : Level} {A : UU l} →
A × A → (bool → A)
map-universal-property-bool (pair x y) true = x
map-universal-property-bool (pair x y) false = y
issec-map-universal-property-bool :
{l : Level} {A : UU l} →
((ev-true-false A) ∘ map-universal-property-bool) ~ id
issec-map-universal-property-bool (pair x y) =
eq-pair-triv (pair refl refl)
isretr-map-universal-property-bool' :
{l : Level} {A : UU l} (f : bool → A) →
(map-universal-property-bool (ev-true-false A f)) ~ f
isretr-map-universal-property-bool' f true = refl
isretr-map-universal-property-bool' f false = refl
isretr-map-universal-property-bool :
{l : Level} {A : UU l} →
(map-universal-property-bool ∘ (ev-true-false A)) ~ id
isretr-map-universal-property-bool f =
eq-htpy (isretr-map-universal-property-bool' f)
universal-property-bool :
{l : Level} (A : UU l) →
is-equiv (λ (f : bool → A) → pair (f true) (f false))
universal-property-bool A =
is-equiv-has-inverse
map-universal-property-bool
issec-map-universal-property-bool
isretr-map-universal-property-bool
ev-true :
{l : Level} {A : UU l} → (bool → A) → A
ev-true f = f true
triangle-ev-true :
{l : Level} (A : UU l) →
(ev-true) ~ (pr1 ∘ (ev-true-false A))
triangle-ev-true A = htpy-refl
aut-bool-bool :
bool → (bool ≃ bool)
aut-bool-bool true = equiv-id bool
aut-bool-bool false = equiv-neg-𝟚
bool-aut-bool :
(bool ≃ bool) → bool
bool-aut-bool e = map-equiv e true
decide-true-false :
(b : bool) → coprod (Id b true) (Id b false)
decide-true-false true = inl refl
decide-true-false false = inr refl
eq-false :
(b : bool) → (¬ (Id b true)) → (Id b false)
eq-false true p = ind-empty (p refl)
eq-false false p = refl
eq-true :
(b : bool) → (¬ (Id b false)) → Id b true
eq-true true p = refl
eq-true false p = ind-empty (p refl)
eq-false-equiv' :
(e : bool ≃ bool) → Id (map-equiv e true) true →
is-decidable (Id (map-equiv e false) false) → Id (map-equiv e false) false
eq-false-equiv' e p (inl q) = q
eq-false-equiv' e p (inr x) =
ind-empty
( Eq-𝟚-eq true false
( ap pr1
( is-prop-is-contr'
( is-contr-map-is-equiv (is-equiv-map-equiv e) true)
( pair true p)
( pair false (eq-true (map-equiv e false) x)))))
eq-false-equiv :
(e : bool ≃ bool) → Id (map-equiv e true) true → Id (map-equiv e false) false
eq-false-equiv e p =
eq-false-equiv' e p (has-decidable-equality-𝟚 (map-equiv e false) false)
{-
eq-true-equiv :
(e : bool ≃ bool) →
¬ (Id (map-equiv e true) true) → Id (map-equiv e false) true
eq-true-equiv e f = {!!}
issec-bool-aut-bool' :
( e : bool ≃ bool) (d : is-decidable (Id (map-equiv e true) true)) →
htpy-equiv (aut-bool-bool (bool-aut-bool e)) e
issec-bool-aut-bool' e (inl p) true =
( htpy-equiv-eq (ap aut-bool-bool p) true) ∙ (inv p)
issec-bool-aut-bool' e (inl p) false =
( htpy-equiv-eq (ap aut-bool-bool p) false) ∙
( inv (eq-false-equiv e p))
issec-bool-aut-bool' e (inr f) true =
( htpy-equiv-eq
( ap aut-bool-bool (eq-false (map-equiv e true) f)) true) ∙
( inv (eq-false (map-equiv e true) f))
issec-bool-aut-bool' e (inr f) false =
( htpy-equiv-eq (ap aut-bool-bool {!eq-true-equiv e ?!}) {!!}) ∙
( inv {!!})
issec-bool-aut-bool :
(aut-bool-bool ∘ bool-aut-bool) ~ id
issec-bool-aut-bool e =
eq-htpy-equiv
( issec-bool-aut-bool' e
( has-decidable-equality-𝟚 (map-equiv e true) true))
-}
-- Exercise
unit-classical-Prop : classical-Prop lzero
unit-classical-Prop =
pair (pair {!!} {!!}) {!!}
raise-unit-classical-Prop :
(l : Level) → classical-Prop l
raise-unit-classical-Prop l =
pair
( pair
( raise l unit)
( is-prop-is-equiv' unit
( map-raise l unit)
( is-equiv-map-raise l unit)
( is-prop-unit)))
( inl (map-raise l unit star))
bool-classical-Prop :
(l : Level) → classical-Prop l → bool
bool-classical-Prop l (pair P (inl x)) = true
bool-classical-Prop l (pair P (inr x)) = false
classical-Prop-bool :
(l : Level) → bool → classical-Prop l
classical-Prop-bool l true = raise-unit-classical-Prop l
classical-Prop-bool l false = {!!}
-- Exercise
{- We show that group homomorphisms preserve the unit. -}
preserves-unit :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) →
( f : hom-Semi-Group
( semi-group-Group G)
( semi-group-Group H)) →
UU l2
preserves-unit G H f =
Id (map-hom-Group G H f (unit-Group G)) (unit-Group H)
abstract
preserves-unit-group-hom :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) →
( f : hom-Group G H) → preserves-unit G H f
preserves-unit-group-hom
( pair ( pair (pair G is-set-G) (pair μ-G assoc-G))
( pair ( pair e-G (pair left-unit-G right-unit-G))
( pair i-G (pair left-inv-G right-inv-G))))
( pair ( pair (pair H is-set-H) (pair μ-H assoc-H))
( pair ( pair e-H (pair left-unit-H right-unit-H))
( pair i-H (pair left-inv-H right-inv-H))))
( pair f μ-f) =
( inv (left-unit-H (f e-G))) ∙
( ( ap (λ x → μ-H x (f e-G)) (inv (left-inv-H (f e-G)))) ∙
( ( assoc-H (i-H (f e-G)) (f e-G) (f e-G)) ∙
( ( ap (μ-H (i-H (f e-G))) (inv (μ-f e-G e-G))) ∙
( ( ap (λ x → μ-H (i-H (f e-G)) (f x)) (left-unit-G e-G)) ∙
( left-inv-H (f e-G))))))
{- We show that group homomorphisms preserve inverses. -}
preserves-inverses :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) →
( f : hom-Group G H) → UU (l1 ⊔ l2)
preserves-inverses G H f =
( x : type-Group G) →
Id ( map-hom-Group G H f (inv-Group G x))
( inv-Group H (map-hom-Group G H f x))
abstract
preserves-inverses-group-hom' :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) →
( f : hom-Group G H) →
preserves-unit G H f → preserves-inverses G H f
preserves-inverses-group-hom'
( pair ( pair (pair G is-set-G) (pair μ-G assoc-G))
( pair ( pair e-G (pair left-unit-G right-unit-G))
( pair i-G (pair left-inv-G right-inv-G))))
( pair ( pair (pair H is-set-H) (pair μ-H assoc-H))
( pair ( pair e-H (pair left-unit-H right-unit-H))
( pair i-H (pair left-inv-H right-inv-H))))
( pair f μ-f) preserves-unit-f x =
( inv ( right-unit-H (f (i-G x)))) ∙
( ( ap (μ-H (f (i-G x))) (inv (right-inv-H (f x)))) ∙
( ( inv (assoc-H (f (i-G x)) (f x) (i-H (f x)))) ∙
( ( inv (ap (λ y → μ-H y (i-H (f x))) (μ-f (i-G x) x))) ∙
( ( ap (λ y → μ-H (f y) (i-H (f x))) (left-inv-G x)) ∙
( ( ap
( λ y → μ-H y (i-H (f x)))
( preserves-unit-f)) ∙
( left-unit-H (i-H (f x))))))))
abstract
preserves-inverses-group-hom :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) →
( f : hom-Group G H) → preserves-inverses G H f
preserves-inverses-group-hom G H f =
preserves-inverses-group-hom' G H f (preserves-unit-group-hom G H f)
hom-Group' :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) → UU (l1 ⊔ l2)
hom-Group' G H =
Σ ( hom-Group G H) (λ f →
( preserves-unit G H f) × (preserves-inverses G H f))
preserves-all-hom-Group :
{ l1 l2 : Level} (G : Group l1) (H : Group l2) →
hom-Group G H → hom-Group' G H
preserves-all-hom-Group G H f =
pair f
( pair
( preserves-unit-group-hom G H f)
( preserves-inverses-group-hom G H f))
-- Exercise
{-
hom-mul-Group :
{l : Level} (G : Group l) →
hom-Group G Aut
-}
| {
"alphanum_fraction": 0.5818197657,
"avg_line_length": 33.3949090909,
"ext": "agda",
"hexsha": "5810f36bef84e7575a68447fabfd24afd1956b71",
"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": "f4228d6ecfc6cdb119c6e8b0e711fea05b98b2d5",
"max_forks_repo_licenses": [
"CC-BY-4.0"
],
"max_forks_repo_name": "tadejpetric/HoTT-Intro",
"max_forks_repo_path": "Agda/12-univalence.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "f4228d6ecfc6cdb119c6e8b0e711fea05b98b2d5",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"CC-BY-4.0"
],
"max_issues_repo_name": "tadejpetric/HoTT-Intro",
"max_issues_repo_path": "Agda/12-univalence.agda",
"max_line_length": 88,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "f4228d6ecfc6cdb119c6e8b0e711fea05b98b2d5",
"max_stars_repo_licenses": [
"CC-BY-4.0"
],
"max_stars_repo_name": "tadejpetric/HoTT-Intro",
"max_stars_repo_path": "Agda/12-univalence.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 17474,
"size": 45918
} |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Group.MorphismProperties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.SIP
open import Cubical.Foundations.Function using (_∘_; id)
open import Cubical.Foundations.GroupoidLaws hiding (_⁻¹)
open import Cubical.Functions.Embedding
open import Cubical.Data.Sigma
open import Cubical.Data.Prod using (isPropProd)
open import Cubical.Algebra
open import Cubical.Algebra.Properties
open import Cubical.Algebra.Group.Morphism
open import Cubical.Structures.Axioms
open import Cubical.Structures.Auto
open import Cubical.Structures.Record
open import Cubical.Algebra.Monoid.Properties using (isPropIsMonoid)
open import Cubical.Relation.Binary.Reasoning.Equality
open Iso
private
variable
ℓ ℓ′ ℓ′′ : Level
F : Group ℓ
G : Group ℓ′
H : Group ℓ′′
isPropIsGroupHom : ∀ (G : Group ℓ) (H : Group ℓ′) f → isProp (IsGroupHom G H f)
isPropIsGroupHom G H f (isgrouphom aHom) (isgrouphom bHom) =
cong isgrouphom
(isPropHomomorphic₂ (Group.is-set H) f (Group._•_ G) (Group._•_ H) aHom bHom)
isSetGroupHom : isSet (G ⟶ᴴ H)
isSetGroupHom {G = G} {H = H} = isOfHLevelRespectEquiv 2 equiv
(isSetΣ (isSetΠ λ _ → is-set H)
(λ f → isProp→isSet (isPropIsGroupHom G H f)))
where
open Group
equiv : (Σ[ g ∈ (⟨ G ⟩ → ⟨ H ⟩) ] IsGroupHom G H g) ≃ GroupHom G H
equiv = isoToEquiv (iso (λ (g , m) → grouphom g m)
(λ (grouphom g m) → g , m)
(λ _ → refl) λ _ → refl)
isGroupHomComp : {f : ⟨ F ⟩ → ⟨ G ⟩} {g : ⟨ G ⟩ → ⟨ H ⟩}
→ IsGroupHom F G f → IsGroupHom G H g → IsGroupHom F H (g ∘ f)
isGroupHomComp {g = g} (isgrouphom fHom) (isgrouphom gHom) =
isgrouphom (λ _ _ → cong g (fHom _ _) ∙ gHom _ _)
private
isGroupHomComp′ : (f : F ⟶ᴴ G) (g : G ⟶ᴴ H)
→ IsGroupHom F H (GroupHom.fun g ∘ GroupHom.fun f)
isGroupHomComp′ (grouphom f (isgrouphom fHom)) (grouphom g (isgrouphom gHom)) =
isgrouphom (λ _ _ → cong g (fHom _ _) ∙ gHom _ _)
compGroupHom : (F ⟶ᴴ G) → (G ⟶ᴴ H) → (F ⟶ᴴ H)
compGroupHom f g = grouphom _ (isGroupHomComp′ f g)
compGroupEquiv : F ≃ᴴ G → G ≃ᴴ H → F ≃ᴴ H
compGroupEquiv f g = groupequiv (compEquiv f.eq g.eq) (isGroupHomComp′ f.hom g.hom)
where
module f = GroupEquiv f
module g = GroupEquiv g
isGroupHomId : (G : Group ℓ) → IsGroupHom G G id
isGroupHomId G = record
{ preservesOp = λ _ _ → refl
}
idGroupHom : (G : Group ℓ) → (G ⟶ᴴ G)
idGroupHom G = record
{ fun = id
; isHom = isGroupHomId G
}
idGroupEquiv : (G : Group ℓ) → G ≃ᴴ G
idGroupEquiv G = record
{ eq = idEquiv ⟨ G ⟩
; isHom = isGroupHomId G
}
-- Isomorphism inversion
isGroupHomInv : (eqv : G ≃ᴴ H) → IsGroupHom H G (invEq (GroupEquiv.eq eqv))
isGroupHomInv {G = G} {H = H} (groupequiv eq (isgrouphom hom)) = isgrouphom (λ x y → isInj-f (
f (f⁻¹ (x H.• y)) ≡⟨ retEq eq _ ⟩
x H.• y ≡˘⟨ cong₂ H._•_ (retEq eq x) (retEq eq y) ⟩
f (f⁻¹ x) H.• f (f⁻¹ y) ≡˘⟨ hom (f⁻¹ x) (f⁻¹ y) ⟩
f (f⁻¹ x G.• f⁻¹ y) ∎))
where
module G = Group G
module H = Group H
f = equivFun eq
f⁻¹ = invEq eq
isInj-f : {x y : ⟨ G ⟩} → f x ≡ f y → x ≡ y
isInj-f {x} {y} = invEq (_ , isEquiv→isEmbedding (eq .snd) x y)
invGroupHom : G ≃ᴴ H → (H ⟶ᴴ G)
invGroupHom eq = record { isHom = isGroupHomInv eq }
invGroupEquiv : G ≃ᴴ H → H ≃ᴴ G
invGroupEquiv eq = record
{ eq = invEquiv (GroupEquiv.eq eq)
; isHom = isGroupHomInv eq
}
groupHomEq : {f g : G ⟶ᴴ H} → (GroupHom.fun f ≡ GroupHom.fun g) → f ≡ g
groupHomEq {G = G} {H = H} {grouphom f fm} {grouphom g gm} p i =
grouphom (p i) (p-hom i)
where
p-hom : PathP (λ i → IsGroupHom G H (p i)) fm gm
p-hom = toPathP (isPropIsGroupHom G H _ _ _)
groupEquivEq : {f g : G ≃ᴴ H} → (GroupEquiv.eq f ≡ GroupEquiv.eq g) → f ≡ g
groupEquivEq {G = G} {H = H} {groupequiv f fm} {groupequiv g gm} p i =
groupequiv (p i) (p-hom i)
where
p-hom : PathP (λ i → IsGroupHom G H (p i .fst)) fm gm
p-hom = toPathP (isPropIsGroupHom G H _ _ _)
module GroupΣTheory {ℓ} where
RawGroupStructure : Type ℓ → Type ℓ
RawGroupStructure X = (X → X → X) × X × (X → X)
RawGroupEquivStr = AutoEquivStr RawGroupStructure
rawGroupUnivalentStr : UnivalentStr _ RawGroupEquivStr
rawGroupUnivalentStr = autoUnivalentStr RawGroupStructure
GroupAxioms : (G : Type ℓ) → RawGroupStructure G → Type ℓ
GroupAxioms G (_•_ , ε , _⁻¹) = IsMonoid G _•_ ε × Inverse ε _⁻¹ _•_
GroupStructure : Type ℓ → Type ℓ
GroupStructure = AxiomsStructure RawGroupStructure GroupAxioms
GroupΣ : Type (ℓ-suc ℓ)
GroupΣ = TypeWithStr ℓ GroupStructure
isPropGroupAxioms : (G : Type ℓ) (s : RawGroupStructure G) → isProp (GroupAxioms G s)
isPropGroupAxioms G (_•_ , ε , _⁻¹) = isPropΣ isPropIsMonoid
λ isMonG → isPropInverse (IsMonoid.is-set isMonG) _•_ _⁻¹ ε
GroupEquivStr : StrEquiv GroupStructure ℓ
GroupEquivStr = AxiomsEquivStr RawGroupEquivStr GroupAxioms
GroupAxiomsIsoIsGroup : {G : Type ℓ} (s : RawGroupStructure G) →
Iso (GroupAxioms G s) (IsGroup G (s .fst) (s .snd .fst) (s .snd .snd))
fun (GroupAxiomsIsoIsGroup s) (x , y) = isgroup x y
inv (GroupAxiomsIsoIsGroup s) (isgroup x y) = (x , y)
rightInv (GroupAxiomsIsoIsGroup s) _ = refl
leftInv (GroupAxiomsIsoIsGroup s) _ = refl
GroupAxioms≡IsGroup : {G : Type ℓ} (s : RawGroupStructure G) →
GroupAxioms G s ≡ IsGroup G (s .fst) (s .snd .fst) (s .snd .snd)
GroupAxioms≡IsGroup s = isoToPath (GroupAxiomsIsoIsGroup s)
Group→GroupΣ : Group ℓ → GroupΣ
Group→GroupΣ (mkgroup G _•_ ε _⁻¹ isGroup) =
G , (_•_ , ε , _⁻¹) , GroupAxiomsIsoIsGroup (_•_ , ε , _⁻¹) .inv isGroup
GroupΣ→Group : GroupΣ → Group ℓ
GroupΣ→Group (G , (_•_ , ε , _⁻¹) , isGroupG) =
mkgroup G _•_ ε _⁻¹ (GroupAxiomsIsoIsGroup (_•_ , ε , _⁻¹) .fun isGroupG)
GroupIsoGroupΣ : Iso (Group ℓ) GroupΣ
GroupIsoGroupΣ =
iso Group→GroupΣ GroupΣ→Group (λ _ → refl) (λ _ → refl)
groupUnivalentStr : UnivalentStr GroupStructure GroupEquivStr
groupUnivalentStr = axiomsUnivalentStr _ isPropGroupAxioms rawGroupUnivalentStr
GroupΣPath : (G H : GroupΣ) → (G ≃[ GroupEquivStr ] H) ≃ (G ≡ H)
GroupΣPath = SIP groupUnivalentStr
GroupEquivΣ : (G H : Group ℓ) → Type ℓ
GroupEquivΣ G H = Group→GroupΣ G ≃[ GroupEquivStr ] Group→GroupΣ H
GroupIsoΣPath : {G H : Group ℓ} → Iso (GroupEquiv G H) (GroupEquivΣ G H)
fun GroupIsoΣPath (groupequiv eq hom) = eq , IsGroupHom.preservesOp hom , IsGroupHom.preservesId hom , IsGroupHom.preservesInv hom
inv GroupIsoΣPath (eq , hom , _) = groupequiv eq (isgrouphom hom)
rightInv (GroupIsoΣPath {H = H}) _ = ΣPathTransport→PathΣ _ _ (refl ,
ΣPathTransport→PathΣ _ _ (transportRefl _ ,
ΣPathTransport→PathΣ _ _
(Group.is-set H _ _ _ _ ,
isPropΠ (λ _ → Group.is-set H _ _) _ _ )
))
leftInv (GroupIsoΣPath {H = H}) _ = refl
GroupPath : (G H : Group ℓ) → (GroupEquiv G H) ≃ (G ≡ H)
GroupPath G H =
GroupEquiv G H ≃⟨ isoToEquiv GroupIsoΣPath ⟩
GroupEquivΣ G H ≃⟨ GroupΣPath _ _ ⟩
Group→GroupΣ G ≡ Group→GroupΣ H ≃⟨ isoToEquiv (invIso (congIso GroupIsoGroupΣ)) ⟩
G ≡ H ■
RawGroupΣ : Type (ℓ-suc ℓ)
RawGroupΣ = TypeWithStr ℓ RawGroupStructure
Group→RawGroupΣ : Group ℓ → RawGroupΣ
Group→RawGroupΣ (mkgroup A _•_ ε _⁻¹ _) = A , _•_ , ε , _⁻¹
InducedGroup : (G : Group ℓ) (H : RawGroupΣ) (e : G .Group.Carrier ≃ H .fst)
→ RawGroupEquivStr (Group→RawGroupΣ G) H e → Group ℓ
InducedGroup G H e r =
GroupΣ→Group (inducedStructure rawGroupUnivalentStr (Group→GroupΣ G) H (e , r))
InducedGroupPath : (G : Group ℓ) (H : RawGroupΣ) (e : G .Group.Carrier ≃ H .fst)
(E : RawGroupEquivStr (Group→RawGroupΣ G) H e) →
G ≡ InducedGroup G H e E
InducedGroupPath G H e E =
GroupPath G (InducedGroup G H e E) .fst (groupequiv e (isgrouphom (E .fst)))
-- We now extract the important results from the above module
open GroupΣTheory public using (InducedGroup; InducedGroupPath)
isPropIsGroup : {G : Type ℓ} {_•_ : Op₂ G} {ε : G} {_⁻¹ : Op₁ G} → isProp (IsGroup G _•_ ε _⁻¹)
isPropIsGroup =
subst isProp (GroupΣTheory.GroupAxioms≡IsGroup (_ , _ , _))
(GroupΣTheory.isPropGroupAxioms _ (_ , _ , _))
GroupPath : (G ≃ᴴ H) ≃ (G ≡ H)
GroupPath = GroupΣTheory.GroupPath _ _
open Group
uaGroup : G ≃ᴴ H → G ≡ H
uaGroup = equivFun GroupPath
carac-uaGroup : {G H : Group ℓ} (f : G ≃ᴴ H) → cong Carrier (uaGroup f) ≡ ua (GroupEquiv.eq f)
carac-uaGroup (groupequiv f m) =
(refl ∙∙ ua f ∙∙ refl) ≡˘⟨ rUnit (ua f) ⟩
ua f ∎
Group≡ : (G H : Group ℓ) → (
Σ[ p ∈ ⟨ G ⟩ ≡ ⟨ H ⟩ ]
Σ[ q ∈ PathP (λ i → p i → p i → p i) (_•_ G) (_•_ H) ]
Σ[ r ∈ PathP (λ i → p i) (ε G) (ε H) ]
Σ[ s ∈ PathP (λ i → p i → p i) (_⁻¹ G) (_⁻¹ H) ]
PathP (λ i → IsGroup (p i) (q i) (r i) (s i)) (isGroup G) (isGroup H))
≃ (G ≡ H)
Group≡ G H = isoToEquiv (iso
(λ (p , q , r , s , t) i → mkgroup (p i) (q i) (r i) (s i) (t i))
(λ p → cong Carrier p , cong _•_ p , cong ε p , cong _⁻¹ p , cong isGroup p)
(λ _ → refl) (λ _ → refl))
caracGroup≡ : {G H : Group ℓ} (p q : G ≡ H) → cong Carrier p ≡ cong Carrier q → p ≡ q
caracGroup≡ {G = G} {H} p q t = cong (fst (Group≡ G H)) (Σ≡Prop (λ _ → isPropΣ
(isOfHLevelPathP' 1 (isSetΠ2 λ _ _ → is-set H) _ _) λ _ → isPropΣ
(isOfHLevelPathP' 1 (is-set H) _ _) λ _ → isPropΣ
(isOfHLevelPathP' 1 (isSetΠ λ _ → is-set H) _ _) λ _ →
isOfHLevelPathP 1 isPropIsGroup _ _)
t)
uaGroupId : (G : Group ℓ) → uaGroup (idGroupEquiv G) ≡ refl
uaGroupId G = caracGroup≡ _ _ (carac-uaGroup (idGroupEquiv G) ∙ uaIdEquiv)
uaCompGroupEquiv : {F G H : Group ℓ} (f : GroupEquiv F G) (g : GroupEquiv G H) → uaGroup (compGroupEquiv f g) ≡ uaGroup f ∙ uaGroup g
uaCompGroupEquiv f g = caracGroup≡ _ _ (
cong Carrier (uaGroup (compGroupEquiv f g))
≡⟨ carac-uaGroup (compGroupEquiv f g) ⟩
ua (eq (compGroupEquiv f g))
≡⟨ uaCompEquiv _ _ ⟩
ua (eq f) ∙ ua (eq g)
≡˘⟨ cong (_∙ ua (eq g)) (carac-uaGroup f) ⟩
cong Carrier (uaGroup f) ∙ ua (eq g)
≡˘⟨ cong (cong Carrier (uaGroup f) ∙_) (carac-uaGroup g) ⟩
cong Carrier (uaGroup f) ∙ cong Carrier (uaGroup g)
≡˘⟨ cong-∙ Carrier (uaGroup f) (uaGroup g) ⟩
cong Carrier (uaGroup f ∙ uaGroup g) ∎)
where open GroupEquiv
| {
"alphanum_fraction": 0.6110299489,
"avg_line_length": 38.975088968,
"ext": "agda",
"hexsha": "228a0433738d024bd252b33f998d3b871395f288",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "737f922d925da0cd9a875cb0c97786179f1f4f61",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "bijan2005/univalent-foundations",
"max_forks_repo_path": "Cubical/Algebra/Group/MorphismProperties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "737f922d925da0cd9a875cb0c97786179f1f4f61",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "bijan2005/univalent-foundations",
"max_issues_repo_path": "Cubical/Algebra/Group/MorphismProperties.agda",
"max_line_length": 133,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "737f922d925da0cd9a875cb0c97786179f1f4f61",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "bijan2005/univalent-foundations",
"max_stars_repo_path": "Cubical/Algebra/Group/MorphismProperties.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 4291,
"size": 10952
} |
module Bad where
data Bool : Set where
false : Bool
true : Bool
data Nat : Set where
zero : Nat
suc : Nat -> Nat
F : Bool -> Set
F false = Bool
F true = Nat
cast : {x : Bool} -> F x -> F x
cast a = a
not : Bool -> Bool
not true = false
not false = true
oops : Bool
oops = not (cast zero)
| {
"alphanum_fraction": 0.5876623377,
"avg_line_length": 11.8461538462,
"ext": "agda",
"hexsha": "1bd5c6fbe17d7c67815144391ada6ddebe100832",
"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": "notes/talks/Types07/Bad.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": "notes/talks/Types07/Bad.agda",
"max_line_length": 31,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "notes/talks/Types07/Bad.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": 105,
"size": 308
} |
module _ where
open import Agda.Builtin.Reflection
open import Agda.Builtin.Bool
open import Agda.Builtin.Unit
open import Agda.Builtin.String
open import Common.Prelude
_<_ = primQNameLess
True : Bool → Set
True true = ⊤
True false = ⊥
zzz aaa : ⊤
zzz = _
aaa = _
⊥-elim : {A : Set} → ⊥ → A
⊥-elim ()
check : (x y : Name) → True (x < y) → String
check x y prf with x < y
check x y prf | true = "A-ok"
check x y prf | false = ⊥-elim prf
main : IO Unit
main = putStrLn (check (quote zzz) (quote aaa) _)
| {
"alphanum_fraction": 0.6555772994,
"avg_line_length": 17.0333333333,
"ext": "agda",
"hexsha": "30e2e1725fb4bd4d1e22d6351e484dfc2193293e",
"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/Compiler/simple/QNameOrder.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/Compiler/simple/QNameOrder.agda",
"max_line_length": 49,
"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/Compiler/simple/QNameOrder.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": 183,
"size": 511
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- The reflexive, symmetric and transitive closure of a binary
-- relation (aka the equivalence closure).
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Relation.Binary.Construct.Closure.Equivalence where
open import Function using (flip; id; _∘_)
open import Level using (_⊔_)
open import Relation.Binary
open import Relation.Binary.Construct.Closure.ReflexiveTransitive as Star
using (Star; ε; _◅◅_; reverse)
open import Relation.Binary.Construct.Closure.Symmetric as SC using (SymClosure)
------------------------------------------------------------------------
-- Definition
EqClosure : ∀ {a ℓ} {A : Set a} → Rel A ℓ → Rel A (a ⊔ ℓ)
EqClosure _∼_ = Star (SymClosure _∼_)
------------------------------------------------------------------------
-- Equivalence closures are equivalences.
module _ {a ℓ} {A : Set a} (_∼_ : Rel A ℓ) where
reflexive : Reflexive (EqClosure _∼_)
reflexive = ε
transitive : Transitive (EqClosure _∼_)
transitive = _◅◅_
symmetric : Symmetric (EqClosure _∼_)
symmetric = reverse (SC.symmetric _∼_)
isEquivalence : IsEquivalence (EqClosure _∼_)
isEquivalence = record
{ refl = reflexive
; sym = symmetric
; trans = transitive
}
setoid : Setoid a (a ⊔ ℓ)
setoid = record
{ _≈_ = EqClosure _∼_
; isEquivalence = isEquivalence
}
------------------------------------------------------------------------
-- Operations
module _ {a ℓ₁ ℓ₂} {A : Set a} where
-- A generalised variant of map which allows the index type to change.
gmap : ∀ {b} {B : Set b} {P : Rel A ℓ₁} {Q : Rel B ℓ₂} →
(f : A → B) → P =[ f ]⇒ Q → EqClosure P =[ f ]⇒ EqClosure Q
gmap {Q = Q} f = Star.gmap f ∘ SC.gmap {Q = Q} f
map : ∀ {P : Rel A ℓ₁} {Q : Rel A ℓ₂} →
P ⇒ Q → EqClosure P ⇒ EqClosure Q
map = gmap id
| {
"alphanum_fraction": 0.5252270434,
"avg_line_length": 30.0303030303,
"ext": "agda",
"hexsha": "9c1167ba912b65ba9a517076168cbc0fa1c953d2",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-04T06:54:45.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-04T06:54:45.000Z",
"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/Construct/Closure/Equivalence.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/Construct/Closure/Equivalence.agda",
"max_line_length": 80,
"max_stars_count": 5,
"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/Construct/Closure/Equivalence.agda",
"max_stars_repo_stars_event_max_datetime": "2020-10-10T21:41:32.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-10-07T12:07:53.000Z",
"num_tokens": 548,
"size": 1982
} |
module Prelude.Int.Properties where
open import Prelude.Unit
open import Prelude.Nat
open import Prelude.Nat.Properties
open import Prelude.Number
open import Prelude.Equality
open import Prelude.Int.Core
open import Prelude.Smashed
open import Prelude.Ord
open import Prelude.Semiring
open import Prelude.Function
--- Specification functions ---
--- sucInt a = 1 + a
--- predInt a = -1 + a
--- sucsInt n a = pos n + a
--- predsInt n a = neg n + a
--- diffNat a b = a -NZ b
sucInt : Int → Int
sucInt (pos n) = pos (suc n)
sucInt (negsuc zero) = pos zero
sucInt (negsuc (suc n)) = negsuc n
predInt : Int → Int
predInt (pos zero) = negsuc zero
predInt (pos (suc n)) = pos n
predInt (negsuc n) = negsuc (suc n)
sucsInt : Nat → Int → Int
sucsInt zero b = b
sucsInt (suc a) b = sucInt (sucsInt a b)
predsInt : Nat → Int → Int
predsInt zero b = b
predsInt (suc a) b = predInt (predsInt a b)
diffNat : Nat → Nat → Int
diffNat a zero = pos a
diffNat zero (suc b) = negsuc b
diffNat (suc a) (suc b) = diffNat a b
--- Injectivity proofs ---
pos-inj : ∀ {a b} → pos a ≡ pos b → a ≡ b
pos-inj refl = refl
negsuc-inj : ∀ {a b} → negsuc a ≡ negsuc b → a ≡ b
negsuc-inj refl = refl
neg-inj : ∀ {a b} → neg a ≡ neg b → a ≡ b
neg-inj {zero} {zero} eq = refl
neg-inj {zero} {suc b} ()
neg-inj {suc a} {zero} ()
neg-inj {suc a} {suc b} eq = suc $≡ negsuc-inj eq
negate-inj : {a b : Int} → negate a ≡ negate b → a ≡ b
negate-inj {pos a} {pos b} eq = pos $≡ neg-inj eq
negate-inj {pos zero} {negsuc b} ()
negate-inj {pos (suc a)} {negsuc b} ()
negate-inj {negsuc a} {pos zero} ()
negate-inj {negsuc a} {pos (suc _)} ()
negate-inj {negsuc a} {negsuc b} eq = negsuc $≡ suc-inj (pos-inj eq)
sucInt-inj : ∀ a b → sucInt a ≡ sucInt b → a ≡ b
sucInt-inj (pos a) (pos a) refl = refl
sucInt-inj (pos a) (negsuc zero) ()
sucInt-inj (pos a) (negsuc (suc b)) ()
sucInt-inj (negsuc zero) (pos b) ()
sucInt-inj (negsuc (suc a)) (pos b) ()
sucInt-inj (negsuc zero) (negsuc zero) eq = refl
sucInt-inj (negsuc zero) (negsuc (suc b)) ()
sucInt-inj (negsuc (suc a)) (negsuc zero) ()
sucInt-inj (negsuc (suc a)) (negsuc (suc a)) refl = refl
predInt-inj : ∀ a b → predInt a ≡ predInt b → a ≡ b
predInt-inj (pos zero) (pos zero) eq = refl
predInt-inj (pos zero) (pos (suc b)) ()
predInt-inj (pos (suc a)) (pos zero) ()
predInt-inj (pos (suc a)) (pos (suc a)) refl = refl
predInt-inj (pos zero) (negsuc b) ()
predInt-inj (pos (suc a)) (negsuc b) ()
predInt-inj (negsuc a) (pos zero) ()
predInt-inj (negsuc a) (pos (suc b)) ()
predInt-inj (negsuc a) (negsuc a) refl = refl
--- sucInt and predInt are inverses --
sucInt-predInt : ∀ a → sucInt (predInt a) ≡ a
sucInt-predInt (pos zero) = refl
sucInt-predInt (pos (suc n)) = refl
sucInt-predInt (negsuc n) = refl
predInt-sucInt : ∀ a → predInt (sucInt a) ≡ a
predInt-sucInt (pos n) = refl
predInt-sucInt (negsuc zero) = refl
predInt-sucInt (negsuc (suc n)) = refl
--- Commutativity of _+_ is easy
addInt-commute : (a b : Int) → a + b ≡ b + a
addInt-commute (pos a) (pos b) = pos $≡ add-commute a b
addInt-commute (pos a) (negsuc b) = refl
addInt-commute (negsuc a) (pos b) = refl
addInt-commute (negsuc a) (negsuc b) = negsuc ∘ suc $≡ add-commute a b
--- Proving _-NZ_ == diffNat
-NZ-suc : ∀ a b → suc a -NZ suc b ≡ a -NZ b
-NZ-suc a b rewrite smashed {x = compare (suc a) (suc b)} {suc-comparison (compare a b)}
with compare a b
... | less (diff! k) = refl
... | equal eq = refl
... | greater (diff! k) = refl
-NZ-spec : ∀ a b → a -NZ b ≡ diffNat a b
-NZ-spec zero zero = refl
-NZ-spec (suc a) zero = refl
-NZ-spec zero (suc b) = refl
-NZ-spec (suc a) (suc b) = -NZ-suc a b ⟨≡⟩ -NZ-spec a b
--- diffNat distributes over suc in both arguments...
diffNat-suc-l : ∀ a b → diffNat (suc a) b ≡ sucInt (diffNat a b)
diffNat-suc-l a 0 = refl
diffNat-suc-l 0 1 = refl
diffNat-suc-l 0 (suc (suc b)) = refl
diffNat-suc-l (suc a) (suc b) = diffNat-suc-l a b
diffNat-suc-r : ∀ a b → diffNat a (suc b) ≡ predInt (diffNat a b)
diffNat-suc-r zero zero = refl
diffNat-suc-r zero (suc b) = refl
diffNat-suc-r (suc a) zero = refl
diffNat-suc-r (suc a) (suc b) = diffNat-suc-r a b
--- ...and thus so does _-NZ_
-NZ-suc-l : ∀ a b → suc a -NZ b ≡ sucInt (a -NZ b)
-NZ-suc-l a b = -NZ-spec (suc a) b ⟨≡⟩ diffNat-suc-l a b ⟨≡⟩ʳ sucInt $≡ -NZ-spec a b
-NZ-suc-r : ∀ a b → a -NZ suc b ≡ predInt (a -NZ b)
-NZ-suc-r a b = -NZ-spec a (suc b) ⟨≡⟩ diffNat-suc-r a b ⟨≡⟩ʳ predInt $≡ -NZ-spec a b
--- We need some lemmas about how sucInt and predInt relates to _+_.
--- These are special cases of the computation rules below, so we make them private.
private
sucInt-spec : ∀ a → 1 + a ≡ sucInt a
sucInt-spec (pos n) = refl
sucInt-spec (negsuc zero) = refl
sucInt-spec (negsuc (suc n)) = refl
predInt-spec : ∀ a → -1 + a ≡ predInt a
predInt-spec (pos zero) = refl
predInt-spec (pos (suc n)) = -NZ-spec (suc n) 1
predInt-spec (negsuc n) = refl
addInt-suc : ∀ a b → pos (suc a) + b ≡ sucInt (pos a + b)
addInt-suc a (pos b) = refl
addInt-suc a (negsuc b) = -NZ-suc-l a (suc b)
addInt-negsuc : ∀ a b → negsuc (suc a) + b ≡ predInt (negsuc a + b)
addInt-negsuc a (pos b) = -NZ-suc-r b (suc a)
addInt-negsuc a (negsuc b) = refl
--- Now we can prove some "computation" rules for _+_
addInt-zero-l : (a : Int) → 0 + a ≡ a
addInt-zero-l (pos a) = refl
addInt-zero-l (negsuc a) = -NZ-spec 0 (suc a)
addInt-zero-r : (a : Int) → a + 0 ≡ a
addInt-zero-r (pos a) = pos $≡ add-zero-r a
addInt-zero-r (negsuc a) = -NZ-spec 0 (suc a)
addInt-sucInt-l : ∀ a b → sucInt a + b ≡ sucInt (a + b)
addInt-sucInt-l (pos a) b = addInt-suc a b
addInt-sucInt-l (negsuc zero) b = addInt-zero-l b ⟨≡⟩ʳ sucInt $≡ predInt-spec b ⟨≡⟩ sucInt-predInt b
addInt-sucInt-l (negsuc (suc a)) b = sucInt-predInt (negsuc a + b) ʳ⟨≡⟩ʳ sucInt $≡ addInt-negsuc a b
addInt-predInt-l : ∀ a b → predInt a + b ≡ predInt (a + b)
addInt-predInt-l (pos zero) b = predInt-spec b ⟨≡⟩ʳ predInt $≡ addInt-zero-l b
addInt-predInt-l (pos (suc a)) b = predInt-sucInt (pos a + b) ʳ⟨≡⟩ʳ predInt $≡ addInt-suc a b
addInt-predInt-l (negsuc a) b = addInt-negsuc a b
--- Adding a non-negative number is equivalent to sucsInt and adding a negative number
--- to predsInt.
addInt-pos : ∀ a b → pos a + b ≡ sucsInt a b
addInt-pos zero b = addInt-zero-l b
addInt-pos (suc a) b = addInt-suc a b ⟨≡⟩ sucInt $≡ addInt-pos a b
addInt-neg : ∀ a b → neg a + b ≡ predsInt a b
addInt-neg zero b = addInt-zero-l b
addInt-neg (suc zero) b = addInt-predInt-l 0 b ⟨≡⟩ predInt $≡ addInt-zero-l b -- predInt-spec b
addInt-neg (suc (suc a)) b = addInt-predInt-l (negsuc a) b ⟨≡⟩ predInt $≡ addInt-neg (suc a) b
--- sucsInt and predsInt have the appropriate associativity properties
private
sucsInt-assoc : ∀ a b c → sucsInt a (b + c) ≡ sucsInt a b + c
sucsInt-assoc zero b c = refl
sucsInt-assoc (suc a) b c = sucInt $≡ sucsInt-assoc a b c ⟨≡⟩ʳ
addInt-sucInt-l (sucsInt a b) c
predsInt-assoc : ∀ a b c → predsInt a (b + c) ≡ predsInt a b + c
predsInt-assoc zero b c = refl
predsInt-assoc (suc a) b c = predInt $≡ predsInt-assoc a b c ⟨≡⟩ʳ
addInt-predInt-l (predsInt a b) c
--- Finally we can prove associativity of _+_
addInt-assoc : (a b c : Int) → a + (b + c) ≡ (a + b) + c
addInt-assoc (pos a) b c = addInt-pos a (b + c) ⟨≡⟩ sucsInt-assoc a b c ⟨≡⟩ʳ _+ c $≡ addInt-pos a b
addInt-assoc (negsuc a) b c = addInt-neg (suc a) (b + c) ⟨≡⟩ predsInt-assoc (suc a) b c ⟨≡⟩ʳ _+ c $≡ addInt-neg (suc a) b
--- Injectivity of _+_
private
sucsInt-inj : ∀ a b c → sucsInt a b ≡ sucsInt a c → b ≡ c
sucsInt-inj zero b c eq = eq
sucsInt-inj (suc a) b c eq = sucsInt-inj a b c (sucInt-inj _ _ eq)
predsInt-inj : ∀ a b c → predsInt a b ≡ predsInt a c → b ≡ c
predsInt-inj zero b c eq = eq
predsInt-inj (suc a) b c eq = predsInt-inj a b c (predInt-inj _ _ eq)
addInt-inj₂ : (a b c : Int) → a + b ≡ a + c → b ≡ c
addInt-inj₂ (pos a) b c eq = sucsInt-inj a b c (addInt-pos a b ʳ⟨≡⟩ eq ⟨≡⟩ addInt-pos a c)
addInt-inj₂ (negsuc a) b c eq = predsInt-inj a b c (predInt-inj _ _ (addInt-neg (suc a) b ʳ⟨≡⟩ eq ⟨≡⟩ addInt-neg (suc a) c))
addInt-inj₁ : (a b c : Int) → a + c ≡ b + c → a ≡ b
addInt-inj₁ a b c eq = addInt-inj₂ c a b (addInt-commute c a ⟨≡⟩ eq ⟨≡⟩ addInt-commute b c)
--- Properties of negate ---
negate-idempotent : (a : Int) → negate (negate a) ≡ a
negate-idempotent (pos zero) = refl
negate-idempotent (pos (suc n)) = refl
negate-idempotent (negsuc n) = refl
private
neg-add : ∀ a b → neg (a + b) ≡ neg a + neg b
neg-add zero b = sym (addInt-zero-l (neg b))
neg-add (suc a) zero = negsuc $≡ add-zero-r a ⟨≡⟩ʳ -NZ-spec 0 (suc a)
neg-add (suc a) (suc b) = negsuc $≡ add-suc-r a b
negate-diffNat : ∀ a b → negate (diffNat a b) ≡ diffNat b a
negate-diffNat zero zero = refl
negate-diffNat zero (suc b) = refl
negate-diffNat (suc a) zero = refl
negate-diffNat (suc a) (suc b) = negate-diffNat a b
negate-NZ : ∀ a b → negate (a -NZ b) ≡ b -NZ a
negate-NZ a b = negate $≡ -NZ-spec a b ⟨≡⟩ negate-diffNat a b ⟨≡⟩ʳ -NZ-spec b a
negate-addInt : (a b : Int) → negate (a + b) ≡ negate a + negate b
negate-addInt (pos a) (pos b) = neg-add a b
negate-addInt (pos zero) (negsuc b) = refl
negate-addInt (pos (suc a)) (negsuc b) = negate-NZ (suc a) (suc b)
negate-addInt (negsuc a) (pos zero) = pos ∘ suc $≡ sym (add-zero-r a)
negate-addInt (negsuc a) (pos (suc b)) = negate-NZ (suc b) (suc a)
negate-addInt (negsuc a) (negsuc b) = pos $≡ sym (add-suc-r (suc a) b)
negate-subInt : (a b : Int) → negate (a - b) ≡ b - a
negate-subInt a b = negate-addInt a (negate b) ⟨≡⟩
negate a +_ $≡ negate-idempotent b ⟨≡⟩
addInt-commute (negate a) b
--- Properties of subtraction ---
private
diffNat-equal : ∀ a → diffNat a a ≡ 0
diffNat-equal zero = refl
diffNat-equal (suc a) = diffNat-equal a
subInt-equal : (a b : Int) → a ≡ b → a - b ≡ 0
subInt-equal (pos zero) _ refl = refl
subInt-equal (pos (suc n)) _ refl = -NZ-spec (suc n) (suc n) ⟨≡⟩ diffNat-equal n
subInt-equal (negsuc n) _ refl = -NZ-spec (suc n) (suc n) ⟨≡⟩ diffNat-equal n
| {
"alphanum_fraction": 0.5908270819,
"avg_line_length": 37.2120141343,
"ext": "agda",
"hexsha": "89fbc56288c875c695f33ab7190529d1cd23f06e",
"lang": "Agda",
"max_forks_count": 24,
"max_forks_repo_forks_event_max_datetime": "2021-04-22T06:10:41.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-03-12T18:03:45.000Z",
"max_forks_repo_head_hexsha": "158d299b1b365e186f00d8ef5b8c6844235ee267",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "L-TChen/agda-prelude",
"max_forks_repo_path": "src/Prelude/Int/Properties.agda",
"max_issues_count": 59,
"max_issues_repo_head_hexsha": "158d299b1b365e186f00d8ef5b8c6844235ee267",
"max_issues_repo_issues_event_max_datetime": "2022-01-14T07:32:36.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-02-09T05:36:44.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "L-TChen/agda-prelude",
"max_issues_repo_path": "src/Prelude/Int/Properties.agda",
"max_line_length": 124,
"max_stars_count": 111,
"max_stars_repo_head_hexsha": "158d299b1b365e186f00d8ef5b8c6844235ee267",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "L-TChen/agda-prelude",
"max_stars_repo_path": "src/Prelude/Int/Properties.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-12T23:29:26.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-05T11:28:15.000Z",
"num_tokens": 4305,
"size": 10531
} |
module Luau.Type where
open import FFI.Data.Maybe using (Maybe; just; nothing)
data Type : Set where
nil : Type
_⇒_ : Type → Type → Type
none : Type
any : Type
number : Type
_∪_ : Type → Type → Type
_∩_ : Type → Type → Type
src : Type → Type
src nil = none
src (S ⇒ T) = S
src none = none
src any = any
src number = none
src (S ∪ T) = (src S) ∪ (src T)
src (S ∩ T) = (src S) ∩ (src T)
tgt : Type → Type
tgt nil = none
tgt (S ⇒ T) = T
tgt none = none
tgt any = any
tgt number = none
tgt (S ∪ T) = (tgt S) ∪ (tgt T)
tgt (S ∩ T) = (tgt S) ∩ (tgt T)
optional : Type → Type
optional nil = nil
optional (T ∪ nil) = (T ∪ nil)
optional T = (T ∪ nil)
normalizeOptional : Type → Type
normalizeOptional (S ∪ T) with normalizeOptional S | normalizeOptional T
normalizeOptional (S ∪ T) | (S′ ∪ nil) | (T′ ∪ nil) = (S′ ∪ T′) ∪ nil
normalizeOptional (S ∪ T) | S′ | (T′ ∪ nil) = (S′ ∪ T′) ∪ nil
normalizeOptional (S ∪ T) | (S′ ∪ nil) | T′ = (S′ ∪ T′) ∪ nil
normalizeOptional (S ∪ T) | S′ | nil = optional S′
normalizeOptional (S ∪ T) | nil | T′ = optional T′
normalizeOptional (S ∪ T) | S′ | T′ = S′ ∪ T′
normalizeOptional T = T
| {
"alphanum_fraction": 0.5548117155,
"avg_line_length": 25.9782608696,
"ext": "agda",
"hexsha": "af5f857cbdb76050fe4d8cb4ee853eb7694262b7",
"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": "cd18adc20ecb805b8eeb770a9e5ef8e0cd123734",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Tr4shh/Roblox-Luau",
"max_forks_repo_path": "prototyping/Luau/Type.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "cd18adc20ecb805b8eeb770a9e5ef8e0cd123734",
"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": "Tr4shh/Roblox-Luau",
"max_issues_repo_path": "prototyping/Luau/Type.agda",
"max_line_length": 72,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "cd18adc20ecb805b8eeb770a9e5ef8e0cd123734",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Tr4shh/Roblox-Luau",
"max_stars_repo_path": "prototyping/Luau/Type.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 456,
"size": 1195
} |
module NumeralNaturalProofs where
open NumeralNatural
open Structure
open Structure.Function'.Properties
open Structure.Relator
open Structure.Relator.Properties
[∩]-inductive : Proof(∀ₗ(a ↦ ∀ₗ(b ↦ (Inductive(a) ∧ Inductive(b)) ⟶ Inductive(a ∩ b))))
[∩]-inductive =
([∀].intro (\{a} →
([∀].intro (\{b} →
([→].intro(indaindb ↦
([∧].intro
-- ∅ is in
([↔].elimₗ
([∀].elim([∀].elim([∀].elim([∩]-membership){a}){b}){∅})
([∧].intro
([∧].elimₗ([∧].elimₗ indaindb))
([∧].elimₗ([∧].elimᵣ indaindb))
)
)
-- 𝐒 is in
([∀].intro (\{x} →
([→].intro(x∈a∩b ↦
([↔].elimₗ
([∀].elim([∀].elim([∀].elim([∩]-membership){a}){b}){𝐒(x)})
([∧].intro
-- 𝐒(x) ∈ a
([→].elim([∀].elim([∧].elimᵣ([∧].elimₗ indaindb)){x})(
-- x ∈ a
[∧].elimₗ([↔].elimᵣ
([∀].elim([∀].elim([∀].elim([∩]-membership){a}){b}){x})
(x∈a∩b)
)
))
-- 𝐒(x) ∈ b
([→].elim([∀].elim([∧].elimᵣ([∧].elimᵣ indaindb)){x})(
-- x ∈ b
[∧].elimᵣ([↔].elimᵣ
([∀].elim([∀].elim([∀].elim([∩]-membership){a}){b}){x})
(x∈a∩b)
)
))
)
)
))
))
)
))
))
))
-- postulate [⋂]-property : ∀{φ} → Proof(∀ₗ(s ↦ ∀ₗ(x ↦ (x ∈ s) ⟶ φ(x)) ⟶ φ(⋂ s))) TODO: MAybe not true
[⋂]-inductive : Proof(∀ₗ(s ↦ ∀ₗ(x ↦ (x ∈ s) ⟶ Inductive(x)) ⟶ Inductive(⋂ s)))
[⋂]-inductive =
([∀].intro (\{s} →
([→].intro(allxxsindx ↦
([∧].intro
-- ∅ is in
proof
-- 𝐒 is in
proof
)
))
))
where postulate proof : ∀{a} → a
[ℕ]-inductive : Proof(Inductive(ℕ))
[ℕ]-inductive =
([→].elim
([∀].elim
[⋂]-inductive
{filter(℘(inductiveSet)) Inductive}
)
([∀].intro(\{x} →
([→].intro(x∈filter ↦
[∧].elimᵣ(([↔].elimᵣ([∀].elim([∀].elim filter-membership{℘(inductiveSet)}){x})) (x∈filter))
))
))
)
module _ where
open FunctionSet
open FunctionProofs
postulate [ℕ]-recursive-function : ∀{z : Domain}{s : Domain → Domain → Domain} → Proof(∃ₛ!(ℕ →ₛₑₜ ℕ)(f ↦ ((𝟎 , z) ∈ f) ∧ (∀ₗ(n ↦ ∀ₗ(fn ↦ ((n , fn) ∈ f) ⟶ ((𝐒(n) , s(n)(fn)) ∈ f))))))
[ℕ]-recursive-function-witness : Domain → BinaryOperator → Function
[ℕ]-recursive-function-witness z s = [→ₛₑₜ]-witness([∃ₛ!]-witness ⦃ f ⦄ ) ⦃ [∃ₛ!]-domain ⦃ f ⦄ ⦄ where
f = [ℕ]-recursive-function{z}{s}
postulate [ℕ]-recursive-function-of-zero : ∀{z : Domain}{s : Domain → Domain → Domain} → Proof(([ℕ]-recursive-function-witness z s)(𝟎) ≡ z)
postulate [ℕ]-recursive-function-of-successor : ∀{z : Domain}{s : Domain → Domain → Domain} → Proof(∀ₛ(ℕ) (n ↦ ([ℕ]-recursive-function-witness z s)(𝐒(n)) ≡ s(n)(([ℕ]-recursive-function-witness z s)(n))))
_+_ : Domain → Domain → Domain
_+_ a b = [ℕ]-recursive-function-witness z s b where
z : Domain
z = a
s : Domain → Domain → Domain
s(n)(sn) = 𝐒(sn)
_⋅_ : Domain → Domain → Domain
_⋅_ a b = [ℕ]-recursive-function-witness z s b where
z : Domain
z = 𝟎
s : Domain → Domain → Domain
s(n)(sn) = sn + a
_^'_ : Domain → Domain → Domain -- TODO: Temporary name collision fix
_^'_ a b = [ℕ]-recursive-function-witness z s b where
z : Domain
z = 𝐒(𝟎)
s : Domain → Domain → Domain
s(n)(sn) = sn ⋅ a
module _ where
open Structure.Operator.Properties
postulate [+]-commutativity : Proof(Commutativity(ℕ)(_+_))
postulate [+]-associativity : Proof(Associativity(ℕ)(_+_))
postulate [+]-identity : Proof(Identity(ℕ)(_+_)(𝟎))
postulate [⋅]-commutativity : Proof(Commutativity(ℕ)(_⋅_))
postulate [⋅]-associativity : Proof(Associativity(ℕ)(_⋅_))
postulate [⋅]-identity : Proof(Identity(ℕ)(_⋅_)(𝐒(𝟎)))
postulate [⋅][+]-distributivity : Proof(Distributivity(ℕ)(_⋅_)(_+_))
postulate [ℕ]-elements : Proof(∀ₛ(ℕ)(n ↦ (n ≡ 𝟎) ∨ ∃ₛ(ℕ)(p ↦ n ≡ 𝐒(p))))
postulate [<]-irreflexivity : Proof(Irreflexivity(ℕ)(_<_))
postulate [<]-asymmetry : Proof(Antisymmetry(ℕ)(_<_))
postulate [<]-transitivity : Proof(Transitivity(ℕ)(_<_))
postulate [≤]-reflexivity : Proof(Irreflexivity(ℕ)(_≤_))
postulate [≤]-antisymmetry : Proof(Antisymmetry(ℕ)(_≤_))
postulate [≤]-transitivity : Proof(Transitivity(ℕ)(_≤_))
-- instance
-- [𝐒]-type : Function.Type(𝐒)
-- [𝐒]-type = Function.Type.intro ℕ ℕ proof where
-- postulate proof : ∀{a} → a
-- postulate [𝐒]-injective : Proof(Injective(ℕ)(𝐒))
-- ∀ₛ(ℕ)(a ↦ ∀ₛ(ℕ)(b ↦ (a < b) ⟶ (𝐒(a) < 𝐒(b))))
-- ∀ₛ(ℕ)(n ↦ 𝟎 ≢ 𝐒(n))
-- A model of the integers expressed in set theory (using only sets).
module NumeralInteger where
open Structure.Function'.Properties
open Structure.Relator.Properties
private
module Nat where
open NumeralNatural ⦃ signature ⦄ public
open NumeralNaturalProofs public
EqualDistance : Domain → Domain → Formula
EqualDistance x y = ∃ₗ(x₁ ↦ ∃ₗ(x₂ ↦ (x ≡ (x₁ , x₂)) ∧ ∃ₗ(y₁ ↦ ∃ₗ(y₂ ↦ (y ≡ (y₁ , y₂)) ∧ ((x₁ Nat.+ y₂) ≡ (x₂ Nat.+ y₁))))))
postulate EqualDistance-equivalence : Proof(Equivalence(Nat.ℕ ⨯ Nat.ℕ)(EqualDistance))
ℤ : Domain
ℤ = (Nat.ℕ ⨯ Nat.ℕ) / EqualDistance
nat : Domain → Domain
nat(n) = map(N ↦ (N , (N Nat.+ n))) Nat.ℕ
postulate nat-type : Proof(Type(Nat.ℕ)(ℤ)(nat))
𝟎 : Domain
𝟎 = nat(Nat.𝟎)
postulate _<_ : Domain → Domain → Formula -- TODO
_≤_ : Domain → Domain → Formula
a ≤ b = (a < b) ∨ (a ≡ b)
_>_ : Domain → Domain → Formula
_>_ = swap _<_
_≥_ : Domain → Domain → Formula
_≥_ = swap _≤_
ℕ : Domain
ℕ = filter(ℤ) (_≥ 𝟎)
ℤ₊ : Domain
ℤ₊ = filter(ℤ) (_> 𝟎)
ℤ₋ : Domain
ℤ₋ = filter(ℤ) (_< 𝟎)
postulate 𝐒 : Domain → Domain -- TODO
postulate 𝐏 : Domain → Domain -- TODO
postulate _+_ : Domain → Domain → Domain -- TODO
postulate −_ : Domain → Domain -- TODO
_−_ : Domain → Domain → Domain
a − b = a + (− b)
postulate _⋅_ : Domain → Domain → Domain -- TODO
-- A model of the rational numbers expressed in set theory (using only sets).
module NumeralRational where
open Structure.Function'.Properties
open Structure.Relator.Properties
private module Nat = NumeralNatural
private module Int = NumeralInteger
open Structure.Ordering.Strict
EqualRatio : Domain → Domain → Formula
EqualRatio x y = ∃ₗ(x₁ ↦ ∃ₗ(x₂ ↦ (x ≡ (x₁ , x₂)) ∧ ∃ₗ(y₁ ↦ ∃ₗ(y₂ ↦ (y ≡ (y₁ , y₂)) ∧ ((x₁ Int.⋅ y₂) ≡ (x₂ Int.⋅ y₁))))))
postulate EqualRatio-equivalence : Proof(Equivalence(Int.ℤ ⨯ Int.ℤ₊)(EqualRatio))
ℚ : Domain
ℚ = (Int.ℤ ⨯ Int.ℤ₊) / EqualRatio
postulate int : Domain → Domain -- TODO
-- int(n) = map(N ↦ (N , (N Int.⋅ n))) Int.ℤ
postulate int-type : Proof(Type(Int.ℤ)(ℚ)(int))
nat : Domain → Domain
nat(n) = int(Int.nat(n))
postulate nat-type : Proof(Type(Nat.ℕ)(ℚ)(nat))
𝟎 : Domain
𝟎 = nat(Nat.𝟎)
-- TODO: These are incorrect because elements in ℚ are sets of tuples
_≤_ : Domain → Domain → Formula
_≤_ x y = ∃ₗ(x₁ ↦ ∃ₗ(x₂ ↦ (x ≡ (x₁ , x₂)) ∧ ∃ₗ(y₁ ↦ ∃ₗ(y₂ ↦ (y ≡ (y₁ , y₂)) ∧ ((x₁ Int.⋅ y₂) Int.≤ (x₂ Int.⋅ y₁))))))
_<_ : Domain → Domain → Formula
_<_ x y = ∃ₗ(x₁ ↦ ∃ₗ(x₂ ↦ (x ≡ (x₁ , x₂)) ∧ ∃ₗ(y₁ ↦ ∃ₗ(y₂ ↦ (y ≡ (y₁ , y₂)) ∧ ((x₁ Int.⋅ y₂) Int.< (x₂ Int.⋅ y₁))))))
_>_ : Domain → Domain → Formula
_>_ = swap _<_
_≥_ : Domain → Domain → Formula
_≥_ = swap _≤_
postulate [<]-dense : Proof(Dense(ℚ)(_<_)) -- TODO
postulate _+_ : Domain → Domain → Domain -- TODO
postulate −_ : Domain → Domain -- TODO
_−_ : Domain → Domain → Domain
a − b = a + (− b)
postulate _⋅_ : Domain → Domain → Domain -- TODO
postulate ⅟_ : Domain → Domain -- TODO
_/'_ : Domain → Domain → Domain
a /' b = a ⋅ (⅟ b)
postulate abs : Domain → Domain
_𝄩_ : Domain → Domain → Domain
a 𝄩 b = abs(a − b)
-- A model of the real numbers expressed in set theory (using only sets).
module NumeralReal where
private module Rat = NumeralRational
-- TODO: https://math.stackexchange.com/questions/1076806/proof-that-the-floor-and-ceiling-functions-exist
| {
"alphanum_fraction": 0.4962296005,
"avg_line_length": 31.2852112676,
"ext": "agda",
"hexsha": "51168828ed2fecddf597987c72a4ae1351fb8d03",
"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/Structure/Logic/Classical/SetTheory/ZFC/Numeral.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/Structure/Logic/Classical/SetTheory/ZFC/Numeral.agda",
"max_line_length": 209,
"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/Structure/Logic/Classical/SetTheory/ZFC/Numeral.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": 3259,
"size": 8885
} |
module Cats.Category.Sets where
open import Data.Product using (Σ ; _×_ ; proj₁ ; proj₂)
open import Level
open import Relation.Binary using (Rel ; IsEquivalence ; _Preserves₂_⟶_⟶_)
open import Relation.Binary.PropositionalEquality as ≡ using (_≡_)
open import Cats.Category.Base
open import Cats.Util.Function
open import Cats.Util.Logic.Constructive
module _ {l} {A B : Set l} where
infixr 4 _≈_
_≈_ : (f g : A → B) → Set l
f ≈ g = ∀ x → f x ≡ g x
equiv : IsEquivalence _≈_
equiv = record
{ refl = λ x → ≡.refl
; sym = λ eq x → ≡.sym (eq x)
; trans = λ eq₁ eq₂ x → ≡.trans (eq₁ x) (eq₂ x)
}
instance Sets : ∀ l → Category (suc l) l l
Sets l = record
{ Obj = Set l
; _⇒_ = λ A B → A → B
; _≈_ = _≈_
; id = id
; _∘_ = _∘_
; equiv = equiv
; ∘-resp = λ {_} {_} {_} {f} eq₁ eq₂ x
→ ≡.trans (≡.cong f (eq₂ _)) (eq₁ _)
; id-r = λ _ → ≡.refl
; id-l = λ _ → ≡.refl
; assoc = λ _ → ≡.refl
}
| {
"alphanum_fraction": 0.5540816327,
"avg_line_length": 22.2727272727,
"ext": "agda",
"hexsha": "7c77a2c22b5d71dc754fd6417bf5021c61d4b241",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "a3b69911c4c6ec380ddf6a0f4510d3a755734b86",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "alessio-b-zak/cats",
"max_forks_repo_path": "Cats/Category/Sets.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "a3b69911c4c6ec380ddf6a0f4510d3a755734b86",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "alessio-b-zak/cats",
"max_issues_repo_path": "Cats/Category/Sets.agda",
"max_line_length": 74,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "a3b69911c4c6ec380ddf6a0f4510d3a755734b86",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "alessio-b-zak/cats",
"max_stars_repo_path": "Cats/Category/Sets.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 386,
"size": 980
} |
module Bughunting2 where
data Nat : Set where zero : Nat -- Comment which gets eaten
suc : Nat -> Nat --Comment which is preserved
plus :
Nat -> Nat -> Nat
plus2 : Nat -> Nat -> Nat
plus2 = plus
plus zero m = m
plus m n = {! !}
| {
"alphanum_fraction": 0.5730769231,
"avg_line_length": 18.5714285714,
"ext": "agda",
"hexsha": "b32bbe4a329a3db437f07388cefbbf8291a9d98a",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-01-31T08:40:41.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-01-31T08:40:41.000Z",
"max_forks_repo_head_hexsha": "52d1034aed14c578c9e077fb60c3db1d0791416b",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "omega12345/RefactorAgda",
"max_forks_repo_path": "RefactorAgdaEngine/Test/Tests/input/Bughunting2.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "52d1034aed14c578c9e077fb60c3db1d0791416b",
"max_issues_repo_issues_event_max_datetime": "2019-02-05T12:53:36.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-31T08:03:07.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "omega12345/RefactorAgda",
"max_issues_repo_path": "RefactorAgdaEngine/Test/Tests/input/Bughunting2.agda",
"max_line_length": 67,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "52d1034aed14c578c9e077fb60c3db1d0791416b",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "omega12345/RefactorAgda",
"max_stars_repo_path": "RefactorAgdaEngine/Test/Tests/input/Bughunting2.agda",
"max_stars_repo_stars_event_max_datetime": "2019-05-03T10:03:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-01-31T14:10:18.000Z",
"num_tokens": 73,
"size": 260
} |
module Categories.WithFamilies where
open import Level
import Relation.Binary.HeterogeneousEquality as Het
open Het using (_≅_)
open import Categories.Support.PropositionalEquality
open import Categories.Support.Experimental
open import Categories.Category
open import Categories.Functor
open import Categories.NaturalIsomorphism
open import Categories.Object.Terminal
open import Categories.Fam
module UnpackFam {o ℓ e a b} (C : Category o ℓ e)
(T : Functor (Category.op C) (Fam a b)) where
private module C = Category C
private module T = Functor T
Context = C.Obj
Ty : C.Obj → Set a
Ty Γ = Fam.U (T.F₀ Γ)
_[_] : ∀ {Γ Δ} → Ty Γ → Δ C.⇒ Γ → Ty Δ
_[_] A f = Fam.Hom.f (T.F₁ f) A
Tm : ∀ Γ → Ty Γ → Set b
Tm Γ = Fam.T (T.F₀ Γ)
_[_⁺] : ∀ {Γ Δ A} → Tm Γ A → (f : Δ C.⇒ Γ) → Tm Δ (A [ f ])
_[_⁺] M f = Fam.Hom.φ (T.F₁ f) _ M
record CwF {o ℓ e a b} : Set (suc e ⊔ (suc ℓ ⊔ suc o) ⊔ suc a ⊔ suc b) where
field
C : Category o ℓ e
T : Functor (Category.op C) (Fam a b)
Empty : Terminal C
module C = Category C
module T = Functor T
open UnpackFam C T
module Empty = Terminal C Empty
field
-- context snoc
_>_ : ∀ Γ → Ty Γ → C.Obj
-- projections
p : ∀ {Γ A} → (Γ > A) C.⇒ Γ
v : ∀ {Γ A} → Tm (Γ > A) (A [ p ])
-- constructor
<_,_> : ∀ {Γ A} → ∀ {Δ} (γ : Δ C.⇒ Γ) (a : Tm Δ (A [ γ ])) → Δ C.⇒ (Γ > A)
.p∘<γ,a>≡γ : ∀ {Γ A} → ∀ {Δ} {γ : Δ C.⇒ Γ} {a : Tm Δ (A [ γ ])} → p C.∘ < γ , a > C.≡ γ
.v[<γ,a>]≡a : ∀ {Γ A} → ∀ {Δ} {γ : Δ C.⇒ Γ} {a : Tm Δ (A [ γ ])} → v [ < γ , a > ⁺] ≅ a
.<γ,a>-unique : ∀ {Γ A} → ∀ {Δ} {γ : Δ C.⇒ Γ} {a : Tm Δ (A [ γ ])} →
(δ : Δ C.⇒ (Γ > A)) → .(p C.∘ δ C.≡ γ) → .(v [ δ ⁺] ≅ a) → δ C.≡ < γ , a >
v[_] : ∀ {Γ A Δ} → (γ : Δ C.⇒ Γ) -> Tm (Δ > A [ γ ]) (A [ γ C.∘ p ])
v[_] {Γ} {A} {Δ} γ = ≣-subst′ (Tm (Δ > A [ γ ])) (≣-sym (Fam.Eq.f≡g (T.homomorphism {Γ}) {A})) (v {Δ} {A [ γ ]})
_[id] : ∀ {Γ A} -> Tm Γ A -> Tm Γ (A [ C.id ])
_[id] {Γ} {A} x = ≣-subst′ (Tm Γ) (≣-sym (Fam.Eq.f≡g (T.identity {Γ}) {A})) x
open UnpackFam C T public
open Empty public using () renaming (⊤ to <>)
record Pi {o ℓ e a b} (Cwf : CwF {o} {ℓ} {e} {a} {b}) : Set (o ⊔ ℓ ⊔ a ⊔ b) where
open CwF Cwf
field
Π : ∀ {Γ} -> (A : Ty Γ) (B : Ty (Γ > A)) -> Ty Γ
lam : ∀ {Γ} {A : Ty Γ} {B : Ty (Γ > A)} -> (b : Tm (Γ > A) B) -> Tm Γ (Π A B)
_$_ : ∀ {Γ} {A : Ty Γ} {B : Ty (Γ > A)} ->
(f : Tm Γ (Π A B)) (x : Tm Γ A) -> Tm Γ (B [ < C.id , x [id] > ])
-- naturality laws
.Π-nat : ∀ {Γ} -> (A : Ty Γ) (B : Ty (Γ > A)) -> ∀ {Δ} (γ : Δ C.⇒ Γ)
-> Π A B [ γ ] ≣ Π (A [ γ ]) (B [ < (γ C.∘ p) , v[ γ ] > ])
.lam-nat : ∀ {Γ} {A : Ty Γ} {B : Ty (Γ > A)} -> (b : Tm (Γ > A) B) -> ∀ {Δ} (γ : Δ C.⇒ Γ)
-> lam b [ γ ⁺] ≅ lam {A = A [ γ ]} (b [ < γ C.∘ p , v[ γ ] > ⁺])
.app-nat : ∀ {Γ} {A : Ty Γ} {B : Ty (Γ > A)} -> (f : Tm Γ (Π A B)) (x : Tm Γ A) -> ∀ {Δ} (γ : Δ C.⇒ Γ)
-> (f $ x) [ γ ⁺] ≅ ≣-subst′ (Tm Δ) (Π-nat A B γ) (f [ γ ⁺]) $ (x [ γ ⁺])
-- proofs of the lam/_$_ isomorphism
.β : ∀ {Γ} {A : Ty Γ} {B : Ty (Γ > A)} -> (b : Tm (Γ > A) B) (x : Tm Γ A)
-> (lam b $ x) ≣ b [ < C.id , x [id] > ⁺]
.η : ∀ {Γ} {A : Ty Γ} {B : Ty (Γ > A)} -> (f : Tm Γ (Π A B))
-> lam (≣-subst′ (Tm (Γ > A)) (Π-nat A B p) (f [ p ⁺]) $ v) ≅ f
| {
"alphanum_fraction": 0.420590816,
"avg_line_length": 35.9894736842,
"ext": "agda",
"hexsha": "acb0da69d652b8c08aee6af0c6e110d4c0eb070b",
"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/WithFamilies.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/WithFamilies.agda",
"max_line_length": 114,
"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/WithFamilies.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": 1649,
"size": 3419
} |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Concrete where
open import Level
open import Categories.Category.Core using (Category)
open import Categories.Category.Instance.Setoids using (Setoids)
open import Categories.Functor.Core using (Functor)
open import Categories.Functor.Representable using (Representable)
open import Categories.Functor.Properties using (Faithful)
-- A Concrete Category is a category along with a faithful
-- functor to Setoid.
-- [Normally Set, but that doesn't work so well here]
private
variable
o ℓ e : Level
record Concrete (C : Category o ℓ e) (ℓ′ e′ : Level) : Set (o ⊔ ℓ ⊔ e ⊔ suc (ℓ′ ⊔ e′)) where
field
concretize : Functor C (Setoids ℓ′ e′)
conc-faithful : Faithful concretize
-- Because of the use of the Hom functor, some levels collapse
record RepresentablyConcrete (C : Category o ℓ e) : Set (o ⊔ suc (e ⊔ ℓ)) where
open Concrete
field
conc : Concrete C ℓ e
representable : Representable (concretize conc)
| {
"alphanum_fraction": 0.728,
"avg_line_length": 31.25,
"ext": "agda",
"hexsha": "7ad4fcb3e919494ce301d0866388e87c43b83591",
"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/Concrete.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/Concrete.agda",
"max_line_length": 92,
"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/Concrete.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": 272,
"size": 1000
} |
{- Name: Bowornmet (Ben) Hudson
--Complexity : "Playing The Game"--
-}
open import Preliminaries
open import Preorder-withmax
module Complexity-lang where
data Typ : Set where
nat : Typ
_×'_ : Typ → Typ → Typ
_⇒_ : Typ → Typ → Typ
unit : Typ
------------------------------------------
-- represent a context as a list of types
Ctx = List Typ
-- de Bruijn indices (for free variables)
data _∈_ : Typ → Ctx → Set where
i0 : ∀ {Γ T}
→ T ∈ (T :: Γ)
iS : ∀ {Γ T T1}
→ T ∈ Γ
→ T ∈ (T1 :: Γ)
------------------------------------------
-- some syntax
data _|-_ : Ctx → Typ → Set where
var : ∀ {Γ T}
→ (x : T ∈ Γ) → Γ |- T
z : ∀ {Γ}
→ Γ |- nat
suc : ∀ {Γ}
→ (e : Γ |- nat)
→ Γ |- nat
rec : ∀ {Γ T}
→ (e : Γ |- nat)
→ (e0 : Γ |- T)
→ (e1 : (nat :: (T :: Γ)) |- T)
→ Γ |- T
lam : ∀ {Γ T Ρ}
→ (x : (Ρ :: Γ) |- T)
→ Γ |- (Ρ ⇒ T)
app : ∀ {Γ T1 T2}
→ (e1 : Γ |- (T2 ⇒ T1)) → (e2 : Γ |- T2)
→ Γ |- T1
unit : ∀ {Γ}
→ Γ |- unit
prod : ∀ {Γ T1 T2}
→ (e1 : Γ |- T1) → (e2 : Γ |- T2)
→ Γ |- (T1 ×' T2)
l-proj : ∀ {Γ T1 T2}
→ (e : Γ |- (T1 ×' T2))
→ Γ |- T1
r-proj : ∀ {Γ T1 T2}
→ (e : Γ |- (T1 ×' T2))
→ Γ |- T2
------------------------------------------
-- renaming function
rctx : Ctx → Ctx → Set
rctx Γ Γ' = ∀ {τ} → τ ∈ Γ' → τ ∈ Γ
lem1 : ∀ {Γ Γ' τ} → rctx Γ Γ' → rctx (τ :: Γ) (τ :: Γ')
lem1 d i0 = i0
lem1 d (iS x) = iS (d x)
ren : ∀ {Γ Γ' τ} → Γ' |- τ → rctx Γ Γ' → Γ |- τ
ren (var x) d = var (d x)
ren z d = z
ren (suc e) d = suc (ren e d)
ren (rec e0 e1 e2) d = rec (ren e0 d) (ren e1 d) (ren e2 (lem1 (lem1 d)))
ren (lam x) d = lam (ren x (lem1 d))
ren (app e1 e2) d = app (ren e1 d) (ren e2 d)
ren unit d = unit
ren (prod e1 e2) d = prod (ren e1 d) (ren e2 d)
ren (l-proj e) d = l-proj (ren e d)
ren (r-proj e) d = r-proj (ren e d)
------------------------------------------
-- substitution
sctx : Ctx → Ctx → Set
sctx Γ Γ' = ∀ {τ} → τ ∈ Γ' → Γ |- τ
-- weakening
wkn : ∀ {Γ τ1 τ2} → Γ |- τ2 → (τ1 :: Γ) |- τ2
wkn e = ren e iS
-- lemmas everywhere
wkn-s : ∀ {Γ τ1 Γ'} → sctx Γ Γ' → sctx (τ1 :: Γ) Γ'
wkn-s d = λ f → wkn (d f)
wkn-r : ∀ {Γ τ1 Γ'} → rctx Γ Γ' → rctx (τ1 :: Γ) Γ'
wkn-r d = λ x → iS (d x)
lem2 : ∀ {Γ Γ' τ} → sctx Γ Γ' → sctx (τ :: Γ) (τ :: Γ')
lem2 d i0 = var i0
lem2 d (iS i) = wkn (d i)
lem3 : ∀ {Γ τ} → Γ |- τ → sctx Γ (τ :: Γ)
lem3 e i0 = e
lem3 e (iS i) = var i
lem4 : ∀ {Γ τ1 τ2} → Γ |- τ1 → Γ |- τ2 → sctx Γ (τ1 :: (τ2 :: Γ))
lem4 e1 e2 i0 = e1
lem4 e1 e2 (iS i0) = e2
lem4 e1 e2 (iS (iS i)) = var i
subst : ∀ {Γ Γ' τ} → sctx Γ Γ' → Γ' |- τ → Γ |- τ
subst d (var x) = d x
subst d z = z
subst d (suc e) = suc (subst d e)
subst d (rec e0 e1 e2) = rec (subst d e0) (subst d e1) (subst (lem2 (lem2 d)) e2)
subst d (lam e) = lam (subst (lem2 d) e)
subst d (app e1 e2) = app (subst d e1) (subst d e2)
subst d unit = unit
subst d (prod e1 e2) = prod (subst d e1) (subst d e2)
subst d (l-proj e) = l-proj (subst d e)
subst d (r-proj e) = r-proj (subst d e)
------------------------------------------
-- define 'stepping' as a datatype (fig. 1 of proof)
data _≤s_ : ∀ {Γ T} → Γ |- T → Γ |- T → Set where
refl-s : ∀ {Γ T}
→ (e : Γ |- T)
→ e ≤s e
trans-s : ∀ {Γ T}
→ (e e' e'' : Γ |- T)
→ e ≤s e' → e' ≤s e''
→ e ≤s e''
cong-s : ∀ {Γ T T'}
→ (e : (T :: Γ) |- T')
→ (e1 e2 : Γ |- T)
→ e1 ≤s e2
→ subst (lem3 e1) e ≤s subst (lem3 e2) e
lam-s : ∀ {Γ T T'}
→ (e : (T :: Γ) |- T')
→ (e2 : Γ |- T)
→ subst (lem3 e2) e ≤s app (lam e) e2
l-proj-s : ∀ {Γ T1 T2}
→ (e1 : Γ |- T1) → (e2 : Γ |- T2)
→ e1 ≤s (l-proj (prod e1 e2))
r-proj-s : ∀ {Γ T1 T2}
→ (e1 : Γ |- T1) → (e2 : Γ |- T2)
→ e2 ≤s (r-proj (prod e1 e2))
rec-steps-s : ∀ {Γ T}
→ (e : Γ |- nat)
→ (e0 : Γ |- T)
→ (e1 : (nat :: (T :: Γ)) |- T)
→ subst (lem4 e (rec e e0 e1)) e1 ≤s (rec (suc e) e0 e1)
rec-steps-z : ∀ {Γ T}
→ (e0 : Γ |- T)
→ (e1 : (nat :: (T :: Γ)) |- T)
→ e0 ≤s (rec z e0 e1)
------------------------------------------
el : PREORDER → Set
el = fst
PREORDER≤ : (PA : PREORDER) → el PA → el PA → Set
PREORDER≤ PA = Preorder-max-str.≤ (snd PA)
interp : Typ → PREORDER
interp nat = Nat , nat-p
interp (A ×' B) = interp A ×p interp B
interp (A ⇒ B) = interp A ->p interp B
interp unit = unit-p
interpC : Ctx → PREORDER
interpC [] = unit-p
interpC (A :: Γ) = interpC Γ ×p interp A
-- look up a variable in context
lookup : ∀{Γ τ} → τ ∈ Γ → el (interpC Γ ->p interp τ)
lookup (i0 {Γ} {τ}) = snd' {interpC (τ :: Γ)} {interpC Γ} {_} id
lookup (iS {Γ} {τ} {τ1} x) = comp {interpC (τ1 :: Γ)} {_} {_} (fst' {interpC (τ1 :: Γ)} {_} {interp τ1} id) (lookup x)
interpE : ∀{Γ τ} → Γ |- τ → el (interpC Γ ->p interp τ)
interpE (var x) = lookup x
interpE z = monotone (λ x → Z) (λ x y _ → <>)
interpE (suc e) = {!!} --monotone (λ x → S {!!}) {!!}
interpE (rec e0 e1 e2) = mnatrec {!!} (interpE e1) (λ x x₁ → {!!}) {!!} --mnatrec {!!} (λ x x₁ → interpE e1) {!!}
interpE (lam e) = lam' (interpE e)
interpE (app e1 e2) = app' (interpE e1) (interpE e2)
interpE unit = monotone (λ _ → <>) (λ x y _ → <>)
interpE (prod e1 e2) = pair' (interpE e1) (interpE e2)
interpE (l-proj {Γ} {τ1} {τ2} e) = fst' {_} {_} {interp τ2} (interpE e)
interpE (r-proj {Γ} {τ1} {τ2} e) = snd' {_} {interp τ1} {_} (interpE e)
sound : ∀ {Γ τ} (e e' : Γ |- τ) → e ≤s e' → PREORDER≤ (interpC Γ ->p interp τ) (interpE e) (interpE e')
sound {_} {τ} .e' e' (refl-s .e') k = Preorder-max-str.refl (snd (interp τ)) (Monotone.f (interpE e') k)
sound {_} {τ} e e' (trans-s .e e'' .e' p p₁) k = Preorder-max-str.trans (snd (interp τ)) (Monotone.f (interpE e) k)
(Monotone.f (interpE e'') k) (Monotone.f (interpE e') k)
(sound e e'' p k) (sound e'' e' p₁ k)
sound .(subst (lem3 e1) e) .(subst (lem3 e2) e) (cong-s e e1 e2 p) k = {!!}
sound .(subst (lem3 e2) e) .(app (lam e) e2) (lam-s e e2) k = {!!}
sound {_} {τ} e .(l-proj (prod e e2)) (l-proj-s .e e2) k = Preorder-max-str.refl (snd (interp τ)) (Monotone.f (interpE e) k)
sound {_} {τ} e .(r-proj (prod e1 e)) (r-proj-s e1 .e) k = Preorder-max-str.refl (snd (interp τ)) (Monotone.f (interpE e) k)
sound .(subst (lem4 e (rec e e0 e1)) e1) .(rec (suc e) e0 e1) (rec-steps-s e e0 e1) k = {!!}
sound e .(rec z e e1) (rec-steps-z .e e1) k = {!!}
| {
"alphanum_fraction": 0.4256335988,
"avg_line_length": 32.7251184834,
"ext": "agda",
"hexsha": "dde258f525e5d9e2ba0aff18342b8dc6db83ac95",
"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": "2404a6ef2688f879bda89860bb22f77664ad813e",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "benhuds/Agda",
"max_forks_repo_path": "ug/Complexity-lang.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "2404a6ef2688f879bda89860bb22f77664ad813e",
"max_issues_repo_issues_event_max_datetime": "2020-05-12T00:32:45.000Z",
"max_issues_repo_issues_event_min_datetime": "2020-03-23T08:39:04.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "benhuds/Agda",
"max_issues_repo_path": "ug/Complexity-lang.agda",
"max_line_length": 126,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "2404a6ef2688f879bda89860bb22f77664ad813e",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "benhuds/Agda",
"max_stars_repo_path": "ug/Complexity-lang.agda",
"max_stars_repo_stars_event_max_datetime": "2019-08-08T12:27:18.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-04-26T20:22:22.000Z",
"num_tokens": 2879,
"size": 6905
} |
------------------------------------------------------------------------------
-- Well-founded induction on natural numbers
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
-- Adapted from
-- http://www.iis.sinica.edu.tw/~scm/2008/well-founded-recursion-and-accessibility/
-- and the Agda standard library 0.8.1.
module FOTC.Induction.WF where
open import Common.Relation.Unary
open import FOTC.Base
------------------------------------------------------------------------------
-- The accessibility predicate: x is accessible if everything which is
-- smaller than x is also accessible (inductively).
data Acc (P : D → Set)(_<_ : D → D → Set)(x : D) : Set where
acc : (∀ {y} → P y → y < x → Acc P _<_ y) → Acc P _<_ x
accFold : {P Q : D → Set}(_<_ : D → D → Set) →
(∀ {x} → Q x → (∀ {y} → Q y → y < x → P y) → P x) →
∀ {x} → Q x → Acc Q _<_ x → P x
accFold _<_ f Qx (acc h) = f Qx (λ Qy y<x → accFold _<_ f Qy (h Qy y<x))
-- The accessibility predicate encodes what it means to be
-- well-founded; if all elements are accessible, then _<_ is
-- well-founded.
WellFounded : {P : D → Set} → (D → D → Set) → Set
WellFounded {P} _<_ = ∀ {x} → P x → Acc P _<_ x
WellFoundedInduction : {P Q : D → Set}
{_<_ : D → D → Set} →
WellFounded _<_ →
(∀ {x} → Q x → (∀ {y} → Q y → y < x → P y) → P x) →
∀ {x} → Q x → P x
WellFoundedInduction {_<_ = _<_} wf f Qx = accFold _<_ f Qx (wf Qx)
module Subrelation {P : D → Set}
{_<_ _<'_ : D → D → Set}
(<⇒<' : ∀ {x y} → P x → x < y → x <' y)
where
accessible : Acc P _<'_ ⊆ Acc P _<_
accessible (acc h) = acc (λ Py y<x → accessible (h Py (<⇒<' Py y<x)))
well-founded : WellFounded _<'_ → WellFounded _<_
well-founded wf = λ Px → accessible (wf Px)
module InverseImage {P Q : D → Set}
{_<_ : D → D → Set}
{f : D → D}
(f-Q : ∀ {x} → P x → Q (f x))
where
accessible : ∀ {x} → P x →
Acc Q _<_ (f x) → Acc P (λ x' y' → f x' < f y') x
accessible Px (acc h) =
acc (λ {y} Py fy<fx → accessible Py (h (f-Q Py) fy<fx))
wellFounded : WellFounded _<_ → WellFounded (λ x y → f x < f y)
wellFounded wf = λ Px → accessible Px (wf (f-Q Px))
| {
"alphanum_fraction": 0.4507973551,
"avg_line_length": 37.8088235294,
"ext": "agda",
"hexsha": "5e1f15d99ac87c14ada167d22984b37455ec3358",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z",
"max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/fotc",
"max_forks_repo_path": "src/fot/FOTC/Induction/WF.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/fotc",
"max_issues_repo_path": "src/fot/FOTC/Induction/WF.agda",
"max_line_length": 83,
"max_stars_count": 11,
"max_stars_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/fotc",
"max_stars_repo_path": "src/fot/FOTC/Induction/WF.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-12T16:09:54.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:53:42.000Z",
"num_tokens": 766,
"size": 2571
} |
module Golden.Constructor where
open import Agda.Builtin.Nat
f : (Nat -> Nat) -> Nat
f g = g zero
fsuc = suc
fzero = zero
one = f suc
a = fsuc fzero
| {
"alphanum_fraction": 0.6666666667,
"avg_line_length": 11.7692307692,
"ext": "agda",
"hexsha": "d7689c973a142218c45866e1a271b87b566b9056",
"lang": "Agda",
"max_forks_count": 7,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:39:48.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-05-24T10:45:59.000Z",
"max_forks_repo_head_hexsha": "e38b699870ba638221828b07b12948d70a1bdaec",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "agda/agda-ocaml",
"max_forks_repo_path": "test/agda-ocaml/Golden/Constructor.agda",
"max_issues_count": 8,
"max_issues_repo_head_hexsha": "e38b699870ba638221828b07b12948d70a1bdaec",
"max_issues_repo_issues_event_max_datetime": "2018-11-05T21:28:57.000Z",
"max_issues_repo_issues_event_min_datetime": "2017-03-29T13:37:52.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "agda/agda-ocaml",
"max_issues_repo_path": "test/agda-ocaml/Golden/Constructor.agda",
"max_line_length": 31,
"max_stars_count": 48,
"max_stars_repo_head_hexsha": "e38b699870ba638221828b07b12948d70a1bdaec",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "agda/agda-ocaml",
"max_stars_repo_path": "test/agda-ocaml/Golden/Constructor.agda",
"max_stars_repo_stars_event_max_datetime": "2021-08-15T09:08:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-03-29T14:19:31.000Z",
"num_tokens": 53,
"size": 153
} |
{-# OPTIONS --safe --cubical #-}
module Data.Product.NAry where
open import Data.Sigma
open import Prelude hiding (⊤; tt)
open import Data.Unit.UniversePolymorphic
open import Path.Reasoning
private
variable
n : ℕ
ℓ : Level
Levels : ℕ → Type
Levels zero = ⊤
Levels (suc n) = Level × Levels n
private
variable
ls : Levels n
max-level : Levels n → Level
max-level {zero} _ = ℓzero
max-level {suc n} (x , xs) =
x ℓ⊔ max-level xs
Types : ∀ n → (ls : Levels n) → Type (ℓsuc (max-level ls))
Types zero ls = ⊤
Types (suc n) (l , ls) = Type l × Types n ls
⦅_⦆⁺ : Types (suc n) ls →
Type (max-level ls)
⦅_⦆⁺ {n = zero } (X , Xs) = X
⦅_⦆⁺ {n = suc n} (X , Xs) = X × ⦅ Xs ⦆⁺
⦅_⦆ : Types n ls →
Type (max-level ls)
⦅_⦆ {n = zero} _ = ⊤
⦅_⦆ {n = suc n} = ⦅_⦆⁺ {n = n}
map-types : (fn : ∀ {ℓ} → Type ℓ → Type ℓ) → ∀ {n ls} → Types n ls → Types n ls
map-types fn {zero} xs = xs
map-types fn {suc n} (x , xs) = fn x , map-types fn xs
data ArgForm : Type where expl impl inst : ArgForm
infixr 0 _[_]→_
_[_]→_ : Type a → ArgForm → Type b → Type (a ℓ⊔ b)
A [ expl ]→ B = A → B
A [ impl ]→ B = { _ : A } → B
A [ inst ]→ B = ⦃ _ : A ⦄ → B
[_$] : ∀ form → (A [ form ]→ B) ⇔ (A → B)
[ expl $] .fun f = f
[ impl $] .fun f x = f {x}
[ inst $] .fun f x = f ⦃ x ⦄
[ expl $] .inv f = f
[ impl $] .inv f {x} = f x
[ inst $] .inv f ⦃ x ⦄ = f x
[ expl $] .leftInv f = refl
[ impl $] .leftInv f = refl
[ inst $] .leftInv f = refl
[ expl $] .rightInv f = refl
[ impl $] .rightInv f = refl
[ inst $] .rightInv f = refl
infixr 0 pi-arr
pi-arr : (A : Type a) → ArgForm → (A → Type b) → Type (a ℓ⊔ b)
pi-arr A expl B = (x : A) → B x
pi-arr A impl B = {x : A} → B x
pi-arr A inst B = ⦃ x : A ⦄ → B x
syntax pi-arr a f (λ x → b ) = x ⦂ a Π[ f ]→ b
Π[_$] : ∀ {B : A → Type b} fr → (x ⦂ A Π[ fr ]→ B x) ⇔ ((x : A) → B x)
Π[ expl $] .fun f = f
Π[ impl $] .fun f x = f {x}
Π[ inst $] .fun f x = f ⦃ x ⦄
Π[ expl $] .inv f x = f x
Π[ impl $] .inv f {x} = f x
Π[ inst $] .inv f ⦃ x ⦄ = f x
Π[ expl $] .leftInv f = refl
Π[ impl $] .leftInv f = refl
Π[ inst $] .leftInv f = refl
Π[ expl $] .rightInv f = refl
Π[ impl $] .rightInv f = refl
Π[ inst $] .rightInv f = refl
infixr 0 ⦅_⦆[_]→_
⦅_⦆[_]→_ : Types n ls → ArgForm → Type ℓ → Type (max-level ls ℓ⊔ ℓ)
⦅_⦆[_]→_ {n = zero} Xs fr Y = Y
⦅_⦆[_]→_ {n = suc n} (X , Xs) fr Y = X [ fr ]→ ⦅ Xs ⦆[ fr ]→ Y
infixr 0 pi-arrs-plus
pi-arrs-plus :
(Xs : Types (suc n) ls) →
ArgForm →
(y : ⦅ Xs ⦆⁺ → Type ℓ) →
Type (max-level ls ℓ⊔ ℓ)
pi-arrs-plus {n = zero } (X , Xs) fr Y = x ⦂ X Π[ fr ]→ Y x
pi-arrs-plus {n = suc n } (X , Xs) fr Y =
x ⦂ X Π[ fr ]→ xs ⦂⦅ Xs ⦆⁺Π[ fr ]→ Y (x , xs)
syntax pi-arrs-plus Xs fr (λ xs → Y) = xs ⦂⦅ Xs ⦆⁺Π[ fr ]→ Y
pi-arrs : ∀ {n ls ℓ} → (Xs : Types n ls) → ArgForm → (y : ⦅ Xs ⦆ → Type ℓ) → Type (max-level ls ℓ⊔ ℓ)
pi-arrs {n = zero} xs fr Y = Y tt
pi-arrs {n = suc n} = pi-arrs-plus
syntax pi-arrs Xs fr (λ xs → Y) = xs ⦂⦅ Xs ⦆Π[ fr ]→ Y
[_^_$]⁺↓ : ∀ n {ls ℓ} f {Xs : Types (suc n) ls} {y : Type ℓ} → (⦅ Xs ⦆⁺ → y) → ⦅ Xs ⦆[ f ]→ y
[ zero ^ fr $]⁺↓ f = [ fr $] .inv f
[ suc n ^ fr $]⁺↓ f = [ fr $] .inv ([ n ^ fr $]⁺↓ ∘ (f ∘_) ∘ _,_)
[_^_$]↓ : ∀ n {ls ℓ} f {xs : Types n ls} {y : Type ℓ} → (⦅ xs ⦆ → y) → ⦅ xs ⦆[ f ]→ y
[ zero ^ fr $]↓ f = f tt
[ suc n ^ fr $]↓ f = [ n ^ fr $]⁺↓ f
[_^_$]⁺↑ : ∀ n {ls ℓ} f {xs : Types (suc n) ls} {y : Type ℓ} → (⦅ xs ⦆[ f ]→ y) → (⦅ xs ⦆⁺ → y)
[ zero ^ fr $]⁺↑ f = [ fr $] .fun f
[ suc n ^ fr $]⁺↑ f = uncurry ([ n ^ fr $]⁺↑ ∘ [ fr $] .fun f)
[_^_$]↑ : ∀ n {ls ℓ} f {xs : Types n ls} {y : Type ℓ} → (⦅ xs ⦆[ f ]→ y) → (⦅ xs ⦆ → y)
[ zero ^ fr $]↑ f _ = f
[ suc n ^ fr $]↑ f = [ n ^ fr $]⁺↑ f
leftInvCurry⁺ : ∀ n {ls ℓ} fr {Xs : Types (suc n) ls} {Y : Type ℓ}
→ (f : ⦅ Xs ⦆[ fr ]→ Y ) → [ n ^ fr $]⁺↓ ([ n ^ fr $]⁺↑ f) ≡ f
leftInvCurry⁺ zero fr f = [ fr $] .leftInv f
leftInvCurry⁺ (suc n) fr f =
[ fr $] .inv ([ n ^ fr $]⁺↓ ∘ [ n ^ fr $]⁺↑ ∘ [ fr $] .fun f) ≡⟨ cong (λ r → [ fr $] .inv (r ∘ [ fr $] .fun f)) (funExt (leftInvCurry⁺ n fr)) ⟩
[ fr $] .inv ([ fr $] .fun f) ≡⟨ [ fr $] .leftInv f ⟩
f ∎
leftInvCurry : ∀ n {ls ℓ} fr {Xs : Types n ls} {Y : Type ℓ}
→ (f : ⦅ Xs ⦆[ fr ]→ Y ) → [ n ^ fr $]↓ ([ n ^ fr $]↑ f) ≡ f
leftInvCurry zero fr f = refl
leftInvCurry (suc n) fr f = leftInvCurry⁺ n fr f
rightInvCurry⁺ : ∀ n {ls ℓ} fr {Xs : Types (suc n) ls} {Y : Type ℓ} (f : ⦅ Xs ⦆ → Y)
→ [ n ^ fr $]⁺↑ ([ n ^ fr $]⁺↓ f) ≡ f
rightInvCurry⁺ zero fr f = [ fr $] .rightInv f
rightInvCurry⁺ (suc n) fr f =
uncurry ([ n ^ fr $]⁺↑ ∘ [ fr $] .fun ([ fr $] .inv ([ n ^ fr $]⁺↓ ∘ ((f ∘_) ∘ _,_)))) ≡⟨ cong (λ h → uncurry ([ n ^ fr $]⁺↑ ∘ h)) ([ fr $] .rightInv _) ⟩
uncurry ([ n ^ fr $]⁺↑ ∘ [ n ^ fr $]⁺↓ ∘ ((f ∘_) ∘ _,_)) ≡⟨ cong (λ r → uncurry (r ∘ ((f ∘_) ∘ _,_))) (funExt (rightInvCurry⁺ n fr)) ⟩
f ∎
rightInvCurry : ∀ n {ls ℓ} fr {Xs : Types n ls} {Y : Type ℓ} (f : ⦅ Xs ⦆ → Y)
→ [ n ^ fr $]↑ ([ n ^ fr $]↓ f) ≡ f
rightInvCurry zero fr f = refl
rightInvCurry (suc n) fr f = rightInvCurry⁺ n fr f
[_^_$] : ∀ n {ls ℓ} fr {Xs : Types n ls} {Y : Type ℓ}
→ (⦅ Xs ⦆[ fr ]→ Y) ⇔ (⦅ Xs ⦆ → Y)
[ n ^ fr $] .fun = [ n ^ fr $]↑
[ n ^ fr $] .inv = [ n ^ fr $]↓
[ n ^ fr $] .leftInv = leftInvCurry n fr
[ n ^ fr $] .rightInv = rightInvCurry n fr
↓Π[_^_$]⁺ : ∀ n {ls ℓ} fr {Xs : Types (suc n) ls} {Y : ⦅ Xs ⦆ → Type ℓ} → ((xs : ⦅ Xs ⦆) → Y xs) → xs ⦂⦅ Xs ⦆⁺Π[ fr ]→ Y xs
↓Π[ zero ^ fr $]⁺ f = Π[ fr $] .inv f
↓Π[ suc n ^ fr $]⁺ f = Π[ fr $] .inv (↓Π[ n ^ fr $]⁺ ∘ (f ∘_) ∘ _,_)
↓Π[_^_$] : ∀ n {ls ℓ} fr {Xs : Types n ls} {Y : ⦅ Xs ⦆ → Type ℓ} → ((xs : ⦅ Xs ⦆) → Y xs) → xs ⦂⦅ Xs ⦆Π[ fr ]→ Y xs
↓Π[ zero ^ fr $] f = f tt
↓Π[ suc n ^ fr $] f = ↓Π[ n ^ fr $]⁺ f
↑Π[_^_$]⁺ : ∀ n {ls ℓ} fr {Xs : Types (suc n) ls} {Y : ⦅ Xs ⦆ → Type ℓ} → (xs ⦂⦅ Xs ⦆⁺Π[ fr ]→ Y xs) → ((xs : ⦅ Xs ⦆) → Y xs)
↑Π[ zero ^ fr $]⁺ f = Π[ fr $] .fun f
↑Π[ suc n ^ fr $]⁺ f = uncurry (↑Π[ n ^ fr $]⁺ ∘ Π[ fr $] .fun f)
↑Π[_^_$] : ∀ n {ls ℓ} fr {Xs : Types n ls} {Y : ⦅ Xs ⦆ → Type ℓ} → (xs ⦂⦅ Xs ⦆Π[ fr ]→ Y xs) → ((xs : ⦅ Xs ⦆) → Y xs)
↑Π[ zero ^ fr $] f _ = f
↑Π[ suc n ^ fr $] f = ↑Π[ n ^ fr $]⁺ f
leftInvCurryΠ⁺ : ∀ n {ls ℓ} fr {Xs : Types (suc n) ls} {Y : ⦅ Xs ⦆ → Type ℓ}
→ (f : xs ⦂⦅ Xs ⦆⁺Π[ fr ]→ Y xs) → ↓Π[ n ^ fr $]⁺ (↑Π[ n ^ fr $]⁺ f) ≡ f
leftInvCurryΠ⁺ zero fr f = Π[ fr $] .leftInv f
leftInvCurryΠ⁺ (suc n) fr f =
Π[ fr $] .inv (↓Π[ n ^ fr $]⁺ ∘ ↑Π[ n ^ fr $]⁺ ∘ Π[ fr $] .fun f) ≡⟨ cong (Π[ fr $] .inv ∘ flip _∘_ (Π[ fr $] .fun f)) (λ i x → leftInvCurryΠ⁺ n fr x i) ⟩
Π[ fr $] .inv (Π[ fr $] .fun f) ≡⟨ Π[ fr $] .leftInv f ⟩
f ∎
leftInvCurryΠ : ∀ n {ls ℓ} fr {Xs : Types n ls} {Y : ⦅ Xs ⦆ → Type ℓ}
→ (f : xs ⦂⦅ Xs ⦆Π[ fr ]→ Y xs) → ↓Π[ n ^ fr $] (↑Π[ n ^ fr $] f) ≡ f
leftInvCurryΠ zero fr f = refl
leftInvCurryΠ (suc n) fr f = leftInvCurryΠ⁺ n fr f
rightInvCurryΠ⁺ : ∀ n {ls ℓ} fr {Xs : Types (suc n) ls} {Y : ⦅ Xs ⦆ → Type ℓ} (f : (xs : ⦅ Xs ⦆) → Y xs)
→ ↑Π[ n ^ fr $]⁺ (↓Π[ n ^ fr $]⁺ f) ≡ f
rightInvCurryΠ⁺ zero fr f = Π[ fr $] .rightInv f
rightInvCurryΠ⁺ (suc n) fr f =
uncurry (↑Π[ n ^ fr $]⁺ ∘ (Π[ fr $] .fun (Π[ fr $] .inv (↓Π[ n ^ fr $]⁺ ∘ (f ∘_) ∘ _,_)))) ≡⟨ cong (λ h → uncurry (↑Π[ n ^ fr $]⁺ ∘ h)) (Π[ fr $] .rightInv _) ⟩
uncurry (↑Π[ n ^ fr $]⁺ ∘ ↓Π[ n ^ fr $]⁺ ∘ (f ∘_) ∘ _,_) ≡⟨ cong (uncurry ∘ flip _∘_ ((f ∘_) ∘ _,_)) (λ i x → rightInvCurryΠ⁺ n fr x i) ⟩
f ∎
rightInvCurryΠ : ∀ n {ls ℓ} fr {Xs : Types n ls} {Y : ⦅ Xs ⦆ → Type ℓ} (f : (xs : ⦅ Xs ⦆) → Y xs)
→ ↑Π[ n ^ fr $] (↓Π[ n ^ fr $] f) ≡ f
rightInvCurryΠ zero fr f = refl
rightInvCurryΠ (suc n) fr f = rightInvCurryΠ⁺ n fr f
Π[_^_$] : ∀ n {ls ℓ} fr {Xs : Types n ls} {Y : ⦅ Xs ⦆ → Type ℓ} →
(xs ⦂⦅ Xs ⦆Π[ fr ]→ Y xs) ⇔ ((xs : ⦅ Xs ⦆) → Y xs)
Π[ n ^ fr $] .fun = ↑Π[ n ^ fr $]
Π[ n ^ fr $] .inv = ↓Π[ n ^ fr $]
Π[ n ^ fr $] .leftInv = leftInvCurryΠ n fr
Π[ n ^ fr $] .rightInv = rightInvCurryΠ n fr
| {
"alphanum_fraction": 0.4516211062,
"avg_line_length": 37.6315789474,
"ext": "agda",
"hexsha": "9eff3db70f05746daa985caee00dc9cadaf00fb4",
"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/Product/NAry.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/Product/NAry.agda",
"max_line_length": 162,
"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/Product/NAry.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": 4274,
"size": 7865
} |
-- Andreas, 2017-04-10, issue #2537 reported by xekoukou
-- Preserve named args when splitting in a where clause.
-- {-# OPTIONS -v reify:100 #-}
data Bool : Set where
true false : Bool
fun : {a b c d e f g : Bool} → Bool → Bool
fun {g = g} x with x
... | r = {!g!} -- C-c C-c g
-- Expected result:
-- fun {g = true} x | r = ?
-- fun {g = false} x | r = ?
| {
"alphanum_fraction": 0.5690607735,
"avg_line_length": 22.625,
"ext": "agda",
"hexsha": "fb8fa29be8724704d44f828758163bdb91a475e3",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/interaction/Issue2537.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/interaction/Issue2537.agda",
"max_line_length": 56,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/interaction/Issue2537.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": 128,
"size": 362
} |
module Numeral.Natural.Oper.Comparisons.Proofs where
open import Data.Boolean.Stmt
open import Data.Boolean
open import Logic.Propositional
open import Numeral.Natural
open import Numeral.Natural.Oper.Comparisons
open import Numeral.Natural.Oper.Proofs
open import Relator.Equals
[≤?]-𝟎 : ∀{n} → IsTrue(𝟎 ≤? n)
[≤?]-𝟎 = [⊤]-intro
[≤?]-𝐒 : ∀{n} → IsTrue(n ≤? 𝐒(n))
[≤?]-𝐒 {𝟎} = [⊤]-intro
[≤?]-𝐒 {𝐒 n} = [≤?]-𝐒 {n}
[<?]-𝟎 : ∀{n} → IsTrue(𝟎 <? 𝐒(n))
[<?]-𝟎 {𝟎} = [⊤]-intro
[<?]-𝟎 {𝐒 n} = [<?]-𝟎 {n}
[<?]-𝐒 : ∀{n} → IsTrue(n <? 𝐒(n))
[<?]-𝐒 {𝟎} = [⊤]-intro
[<?]-𝐒 {𝐒 n} = [<?]-𝐒 {n}
[≤?]-reflexivity : ∀{n} → IsTrue(n ≤? n)
[≤?]-reflexivity {𝟎} = [⊤]-intro
[≤?]-reflexivity {𝐒(n)} = [≤?]-reflexivity {n}
[<?]-positive : ∀{n} → (𝟎 <? n) ≡ positive?(n)
[<?]-positive {𝟎} = [≡]-intro
[<?]-positive {𝐒(_)} = [≡]-intro
{-# REWRITE [<?]-positive #-}
[<?]-positive-any : ∀{m n} → ⦃ _ : IsTrue(m <? n) ⦄ → IsTrue(positive?(n))
[<?]-positive-any {𝟎} {n} ⦃ p ⦄ = p
[<?]-positive-any {𝐒 m} {𝐒 n} ⦃ p ⦄ = [⊤]-intro
[≤?]-positive : ∀{n} → (𝐒(𝟎) ≤? n) ≡ positive?(n)
[≤?]-positive {𝟎} = [≡]-intro
[≤?]-positive {𝐒(_)} = [≡]-intro
[≢?]-positive : ∀{n} → (n ≢? 𝟎) ≡ positive?(n)
[≢?]-positive {𝟎} = [≡]-intro
[≢?]-positive {𝐒(_)} = [≡]-intro
[<?]-to-[≤?] : ∀{a b} → ((a <? b) ≡ (𝐒(a) ≤? b))
[<?]-to-[≤?] {𝟎} {𝟎} = [≡]-intro
[<?]-to-[≤?] {𝟎} {𝐒(_)} = [≡]-intro
[<?]-to-[≤?] {𝐒(_)}{𝟎} = [≡]-intro
[<?]-to-[≤?] {𝐒(a)}{𝐒(b)} = [<?]-to-[≤?] {a}{b}
[≡?]-zero : ∀{n} → (n ≡? 𝟎) ≡ zero?(n)
[≡?]-zero {𝟎} = [≡]-intro
[≡?]-zero {𝐒(_)} = [≡]-intro
| {
"alphanum_fraction": 0.4501278772,
"avg_line_length": 27.9285714286,
"ext": "agda",
"hexsha": "7452b514231d212bcfad2465f51e6c6cac503ad0",
"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": "Numeral/Natural/Oper/Comparisons/Proofs.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": "Numeral/Natural/Oper/Comparisons/Proofs.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": "Numeral/Natural/Oper/Comparisons/Proofs.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": 883,
"size": 1564
} |
open import Relation.Binary.Core
module InsertSort.Impl1.Correctness.Permutation.Alternative {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_) where
open import Data.List
open import Data.Sum
open import Function
open import InsertSort.Impl1 _≤_ tot≤
open import List.Permutation.Alternative A renaming (_∼_ to _∼′_)
open import List.Permutation.Alternative.Correctness A
open import List.Permutation.Base A
lemma-insert∼′ : (x : A)(xs : List A) → (x ∷ xs) ∼′ insert x xs
lemma-insert∼′ x [] = ∼refl
lemma-insert∼′ x (y ∷ ys)
with tot≤ x y
... | inj₁ x≤y = ∼refl
... | inj₂ y≤x = ∼trans (∼swap ∼refl) (∼head y (lemma-insert∼′ x ys))
lemma-insertSort∼′ : (xs : List A) → xs ∼′ insertSort xs
lemma-insertSort∼′ [] = ∼refl
lemma-insertSort∼′ (x ∷ xs) = ∼trans (∼head x (lemma-insertSort∼′ xs)) (lemma-insert∼′ x (insertSort xs))
theorem-insertSort∼ : (xs : List A) → xs ∼ insertSort xs
theorem-insertSort∼ = lemma-∼′-∼ ∘ lemma-insertSort∼′
| {
"alphanum_fraction": 0.6493902439,
"avg_line_length": 35.1428571429,
"ext": "agda",
"hexsha": "32316d4e54fa16148b68b7d64ec1db86a983e217",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "bgbianchi/sorting",
"max_forks_repo_path": "agda/InsertSort/Impl1/Correctness/Permutation/Alternative.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "bgbianchi/sorting",
"max_issues_repo_path": "agda/InsertSort/Impl1/Correctness/Permutation/Alternative.agda",
"max_line_length": 105,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "bgbianchi/sorting",
"max_stars_repo_path": "agda/InsertSort/Impl1/Correctness/Permutation/Alternative.agda",
"max_stars_repo_stars_event_max_datetime": "2021-08-24T22:11:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-05-21T12:50:35.000Z",
"num_tokens": 355,
"size": 984
} |
module NF.Sum where
open import NF
open import Data.Sum
open import Relation.Binary.PropositionalEquality
instance
nfInj₁ : {A B : Set}{a : A}{{nfa : NF a}} -> NF {A ⊎ B} (inj₁ a)
Sing.unpack (NF.!! (nfInj₁ {a = a})) = inj₁ (nf a)
Sing.eq (NF.!! (nfInj₁ {{nfa}})) rewrite nf≡ {{nfa}} = refl
{-# INLINE nfInj₁ #-}
nfInj₂ : {A B : Set}{b : B}{{nfb : NF b}} -> NF {A ⊎ B} (inj₂ b)
Sing.unpack (NF.!! (nfInj₂ {b = b})) = inj₂ (nf b)
Sing.eq (NF.!! (nfInj₂ {{nfb}})) rewrite nf≡ {{nfb}} = refl
{-# INLINE nfInj₂ #-} | {
"alphanum_fraction": 0.5612052731,
"avg_line_length": 29.5,
"ext": "agda",
"hexsha": "1fd7158f2748c69f40c36489b0e3dece652ae55c",
"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": "4f037dad109a5d080023557f0869418ed9fc11c1",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "yanok/normalize-via-instances",
"max_forks_repo_path": "src/NF/Sum.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "4f037dad109a5d080023557f0869418ed9fc11c1",
"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": "yanok/normalize-via-instances",
"max_issues_repo_path": "src/NF/Sum.agda",
"max_line_length": 66,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "4f037dad109a5d080023557f0869418ed9fc11c1",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "yanok/normalize-via-instances",
"max_stars_repo_path": "src/NF/Sum.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 222,
"size": 531
} |
module Category.Universality where
open import Level
open import Category.Core
open import Category.Comma
open import Category.Instance
-- something is universal from c to S when it's an initial object in c / S
universal : {𝒸₀ ℓ₀ 𝒸₁ ℓ₁ : Level}
→ {C : Category 𝒸₀ ℓ₀} {D : Category 𝒸₁ ℓ₁}
→ {c : Category.Object C} → {S : Functor D C}
→ (init : Category.Object (point c ↓ S))
→ Set (𝒸₁ ⊔ (ℓ₀ ⊔ 𝒸₀))
universal {c = c} {S = S} init = initial (point c ↓ S) init
where
initial : ∀ {𝒸 ℓ} → (C : Category 𝒸 ℓ) → Category.Object C → Set 𝒸
initial C init = ∀ (other : Object) → init ⇒ other
where
open Category C
initial : ∀ {𝒸 ℓ} (C : Category 𝒸 ℓ) → Category.Object C → Set (𝒸 ⊔ (ℓ ⊔ 𝒸))
initial C c = universal {C = C} {D = C} {c} {identity C} (record
{ source = tt
; target = c
; morphism = id c
})
where
open import Data.Unit
open Category C
initial-prop : ∀ {𝒸 ℓ} {C : Category 𝒸 ℓ}
→ (init : Category.Object C)
→ initial C init
→ (other : Category.Object C)
→ Category._⇒_ C init other
initial-prop {C = C} obj obj-init other = Comma.morphismBetweenSources {! !}
where
open Category C
-- prop1 : {! !}
-- prop1 = {! initial !}
| {
"alphanum_fraction": 0.5681114551,
"avg_line_length": 30.7619047619,
"ext": "agda",
"hexsha": "f2356f7101df2be976bc21daf0af78b05ee4220b",
"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": "9f6d933b227aecab338ecaef1d86566a54fdac68",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "banacorn/categories",
"max_forks_repo_path": "src/Category/Universality.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "9f6d933b227aecab338ecaef1d86566a54fdac68",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "banacorn/categories",
"max_issues_repo_path": "src/Category/Universality.agda",
"max_line_length": 78,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "9f6d933b227aecab338ecaef1d86566a54fdac68",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "banacorn/categories",
"max_stars_repo_path": "src/Category/Universality.agda",
"max_stars_repo_stars_event_max_datetime": "2018-01-04T23:19:30.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-01-04T23:19:30.000Z",
"num_tokens": 430,
"size": 1292
} |
------------------------------------------------------------------------------
-- Operations on and with functions
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module Common.Function where
-- From Funcion.agda (Agda standard library 0.8.1).
-- infixr 0 _$_
------------------------------------------------------------------------------
-- The right associative application operator.
--
-- N.B. The operator is not first-order, so it cannot be used with
-- types/terms which will be translated to FOL.
-- _$_ : {A : Set}{B : A → Set} → ((x : A) → B x) → (x : A) → B x
-- f $ x = f x
-- N.B. The function is not first-order, so it cannot be used with
-- types/terms which will be translated to FOL.
-- flip : {A : Set} → (A → A → A) → A → A → A
-- flip f y x = f x y
| {
"alphanum_fraction": 0.4426229508,
"avg_line_length": 36.1481481481,
"ext": "agda",
"hexsha": "55e20efc9b769d0436c527dca504f2f9330c3732",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z",
"max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/fotc",
"max_forks_repo_path": "src/old/Function.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/fotc",
"max_issues_repo_path": "src/old/Function.agda",
"max_line_length": 78,
"max_stars_count": 11,
"max_stars_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/fotc",
"max_stars_repo_path": "src/old/Function.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-12T16:09:54.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:53:42.000Z",
"num_tokens": 218,
"size": 976
} |
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.Truncation.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.PathSplitEquiv
open isPathSplitEquiv
open import Cubical.Modalities.Everything
open Modality
open import Cubical.Data.Empty as ⊥ using (⊥)
open import Cubical.Data.Nat hiding (elim)
open import Cubical.Data.NatMinusOne as ℕ₋₁ hiding (1+_)
open import Cubical.Data.NatMinusTwo as ℕ₋₂ hiding (-1+_)
open import Cubical.HITs.Sn
open import Cubical.HITs.Susp
open import Cubical.HITs.Nullification as Null hiding (rec; elim)
open import Cubical.HITs.Truncation.Base
open import Cubical.HITs.PropositionalTruncation as PropTrunc
renaming (∥_∥ to ∥_∥₋₁; ∣_∣ to ∣_∣₋₁; squash to squash₋₁) using ()
open import Cubical.HITs.SetTruncation as SetTrunc using (∥_∥₀; ∣_∣₀; squash₀)
open import Cubical.HITs.GroupoidTruncation as GpdTrunc using (∥_∥₁; ∣_∣₁; squash₁)
open import Cubical.HITs.2GroupoidTruncation as 2GpdTrunc using (∥_∥₂; ∣_∣₂; squash₂)
private
variable
ℓ ℓ' : Level
A : Type ℓ
sphereFill : (n : ℕ₋₁) (f : S n → A) → Type _
sphereFill {A = A} n f = Σ[ top ∈ A ] ((x : S n) → top ≡ f x)
isSphereFilled : ℕ₋₁ → Type ℓ → Type ℓ
isSphereFilled n A = (f : S n → A) → sphereFill n f
isSphereFilledTrunc : {n : ℕ} → isSphereFilled (-1+ n) (hLevelTrunc n A)
isSphereFilledTrunc {n = zero} f = hub f , ⊥.elim
isSphereFilledTrunc {n = suc n} f = hub f , spoke f
isSphereFilled→isOfHLevelSuc : {n : ℕ} → isSphereFilled (ℕ→ℕ₋₁ n) A → isOfHLevel (suc n) A
isSphereFilled→isOfHLevelSuc {A = A} {zero} h x y = sym (snd (h f) north) ∙ snd (h f) south
where
f : Susp ⊥ → A
f north = x
f south = y
f (merid () i)
isSphereFilled→isOfHLevelSuc {A = A} {suc n} h x y = isSphereFilled→isOfHLevelSuc (helper h x y)
where
helper : isSphereFilled (ℕ→ℕ₋₁ (suc n)) A → (x y : A) → isSphereFilled (ℕ→ℕ₋₁ n) (x ≡ y)
helper h x y f = l , r
where
f' : Susp (S (ℕ→ℕ₋₁ n)) → A
f' north = x
f' south = y
f' (merid u i) = f u i
u : sphereFill (ℕ→ℕ₋₁ (suc n)) f'
u = h f'
z : A
z = fst u
p : z ≡ x
p = snd u north
q : z ≡ y
q = snd u south
l : x ≡ y
l = sym p ∙ q
r : (s : S (ℕ→ℕ₋₁ n)) → l ≡ f s
r s i j = hcomp
(λ k →
λ { (i = i0) → compPath-filler (sym p) q k j
; (i = i1) → snd u (merid s j) k
; (j = i0) → p (k ∨ (~ i))
; (j = i1) → q k
})
(p ((~ i) ∧ (~ j)))
isOfHLevel→isSphereFilled : {n : ℕ} → isOfHLevel n A → isSphereFilled (-1+ n) A
isOfHLevel→isSphereFilled {A = A} {zero} h f = fst h , λ _ → snd h _
isOfHLevel→isSphereFilled {A = A} {suc zero} h f = f north , λ _ → h _ _
isOfHLevel→isSphereFilled {A = A} {suc (suc n)} h = helper λ x y → isOfHLevel→isSphereFilled (h x y)
where
helper : {n : ℕ} → ((x y : A) → isSphereFilled (-1+ n) (x ≡ y)) → isSphereFilled (suc₋₁ (-1+ n)) A
helper {n = n} h f = l , r
where
l : A
l = f north
f' : S (-1+ n) → f north ≡ f south
f' x i = f (merid x i)
h' : sphereFill (-1+ n) f'
h' = h (f north) (f south) f'
r : (x : S (suc₋₁ (-1+ n))) → l ≡ f x
r north = refl
r south = h' .fst
r (merid x i) j = hcomp (λ k → λ { (i = i0) → f north
; (i = i1) → h' .snd x (~ k) j
; (j = i0) → f north
; (j = i1) → f (merid x i) }) (f (merid x (i ∧ j)))
-- isNull (S n) A ≃ (isSphereFilled n A) × (∀ (x y : A) → isSphereFilled n (x ≡ y))
isOfHLevel→isSnNull : {n : ℕ} → isOfHLevel n A → isNull (S (-1+ n)) A
fst (sec (isOfHLevel→isSnNull h)) f = fst (isOfHLevel→isSphereFilled h f)
snd (sec (isOfHLevel→isSnNull h)) f i s = snd (isOfHLevel→isSphereFilled h f) s i
fst (secCong (isOfHLevel→isSnNull h) x y) p = fst (isOfHLevel→isSphereFilled (isOfHLevelPath _ h x y) (funExt⁻ p))
snd (secCong (isOfHLevel→isSnNull h) x y) p i j s = snd (isOfHLevel→isSphereFilled (isOfHLevelPath _ h x y) (funExt⁻ p)) s i j
isSnNull→isOfHLevel : {n : ℕ} → isNull (S (-1+ n)) A → isOfHLevel n A
isSnNull→isOfHLevel {n = zero} nA = fst (sec nA) ⊥.rec , λ y → fst (secCong nA _ y) (funExt ⊥.elim)
isSnNull→isOfHLevel {n = suc n} nA = isSphereFilled→isOfHLevelSuc (λ f → fst (sec nA) f , λ s i → snd (sec nA) f i s)
isOfHLevelTrunc : (n : ℕ) → isOfHLevel n (hLevelTrunc n A)
isOfHLevelTrunc zero = hub ⊥.rec , λ _ → ≡hub ⊥.rec
isOfHLevelTrunc (suc n) = isSphereFilled→isOfHLevelSuc isSphereFilledTrunc
-- isOfHLevelTrunc n = isSnNull→isOfHLevel isNull-Null
-- hLevelTrunc n is a modality
rec : {n : ℕ}
{B : Type ℓ'} →
(isOfHLevel n B) →
(g : (a : A) → B) →
(hLevelTrunc n A → B)
rec {B = B} h = Null.elim {B = λ _ → B} λ x → isOfHLevel→isSnNull h
elim : {n : ℕ}
{B : hLevelTrunc n A → Type ℓ'}
(hB : (x : hLevelTrunc n A) → isOfHLevel n (B x))
(g : (a : A) → B (∣ a ∣))
(x : hLevelTrunc n A) →
B x
elim hB = Null.elim (λ x → isOfHLevel→isSnNull (hB x))
elim2 : {n : ℕ}
{B : hLevelTrunc n A → hLevelTrunc n A → Type ℓ'}
(hB : ((x y : hLevelTrunc n A) → isOfHLevel n (B x y)))
(g : (a b : A) → B ∣ a ∣ ∣ b ∣)
(x y : hLevelTrunc n A) →
B x y
elim2 {n = n} hB g =
elim (λ _ → isOfHLevelPi n (λ _ → hB _ _))
(λ a → elim (λ _ → hB _ _) (λ b → g a b))
elim3 : {n : ℕ}
{B : (x y z : hLevelTrunc n A) → Type ℓ'}
(hB : ((x y z : hLevelTrunc n A) → isOfHLevel n (B x y z)))
(g : (a b c : A) → B (∣ a ∣) ∣ b ∣ ∣ c ∣)
(x y z : hLevelTrunc n A) →
B x y z
elim3 {n = n} hB g =
elim2 (λ _ _ → isOfHLevelPi n (hB _ _))
(λ a b → elim (λ _ → hB _ _ _) (λ c → g a b c))
HLevelTruncModality : ∀ {ℓ} (n : ℕ) → Modality ℓ
isModal (HLevelTruncModality n) = isOfHLevel n
isModalIsProp (HLevelTruncModality n) = isPropIsOfHLevel n
◯ (HLevelTruncModality n) = hLevelTrunc n
◯-isModal (HLevelTruncModality n) = isOfHLevelTrunc n
η (HLevelTruncModality n) = ∣_∣
◯-elim (HLevelTruncModality n) = elim
◯-elim-β (HLevelTruncModality n) = λ _ _ _ → refl
◯-=-isModal (HLevelTruncModality n) = isOfHLevelPath n (isOfHLevelTrunc n)
idemTrunc : (n : ℕ) → isOfHLevel n A → A ≃ (hLevelTrunc n A)
idemTrunc n hA = ∣_∣ , isModalToIsEquiv (HLevelTruncModality n) hA
-- equivalences to prop/set/groupoid truncations
propTrunc≃Trunc-1 : ∥ A ∥₋₁ ≃ ∥ A ∥ -1
propTrunc≃Trunc-1 =
isoToEquiv
(iso
(PropTrunc.elim (λ _ → isOfHLevelTrunc 1) ∣_∣)
(elim (λ _ → squash₋₁) ∣_∣₋₁)
(elim (λ _ → isOfHLevelPath 1 (isOfHLevelTrunc 1) _ _) (λ _ → refl))
(PropTrunc.elim (λ _ → isOfHLevelPath 1 squash₋₁ _ _) (λ _ → refl)))
setTrunc≃Trunc0 : ∥ A ∥₀ ≃ ∥ A ∥ 0
setTrunc≃Trunc0 =
isoToEquiv
(iso
(SetTrunc.elim (λ _ → isOfHLevelTrunc 2) ∣_∣)
(elim (λ _ → squash₀) ∣_∣₀)
(elim (λ _ → isOfHLevelPath 2 (isOfHLevelTrunc 2) _ _) (λ _ → refl))
(SetTrunc.elim (λ _ → isOfHLevelPath 2 squash₀ _ _) (λ _ → refl)))
groupoidTrunc≃Trunc1 : ∥ A ∥₁ ≃ ∥ A ∥ 1
groupoidTrunc≃Trunc1 =
isoToEquiv
(iso
(GpdTrunc.elim (λ _ → isOfHLevelTrunc 3) ∣_∣)
(elim (λ _ → squash₁) ∣_∣₁)
(elim (λ _ → isOfHLevelPath 3 (isOfHLevelTrunc 3) _ _) (λ _ → refl))
(GpdTrunc.elim (λ _ → isOfHLevelPath 3 squash₁ _ _) (λ _ → refl)))
2GroupoidTrunc≃Trunc2 : ∥ A ∥₂ ≃ ∥ A ∥ 2
2GroupoidTrunc≃Trunc2 =
isoToEquiv
(iso
(2GpdTrunc.elim (λ _ → isOfHLevelTrunc 4) ∣_∣)
(elim (λ _ → squash₂) ∣_∣₂)
(elim (λ _ → isOfHLevelPath 4 (isOfHLevelTrunc 4) _ _) (λ _ → refl))
(2GpdTrunc.elim (λ _ → isOfHLevelPath 4 squash₂ _ _) (λ _ → refl)))
---- ∥ Ω A ∥ ₙ ≡ Ω ∥ A ∥ₙ₊₁ ----
{- Proofs of Theorem 7.3.12. and Corollary 7.3.13. in the HoTT book -}
private
{- We define the fibration P to show a more general result -}
P : ∀ {ℓ} {B : Type ℓ}{n : ℕ₋₂} → ∥ B ∥ (suc₋₂ n) → ∥ B ∥ (suc₋₂ n) → Type ℓ
P x y = fst (P₁ x y)
where
P₁ : ∀ {ℓ} {B : Type ℓ} {n : ℕ₋₂} → ∥ B ∥ (suc₋₂ n) → ∥ B ∥ (suc₋₂ n) → (HLevel ℓ (2+ n))
P₁ {ℓ} {n = n} x y =
elim2 (λ _ _ → isOfHLevelHLevel (2+ n)) (λ a b → ∥ a ≡ b ∥ n , isOfHLevelTrunc (2+ n)) x y
{- We will need P to be of hLevel n + 3 -}
hLevelP : ∀{ℓ} {n : ℕ₋₂} {B : Type ℓ} (a b : ∥ B ∥ (suc₋₂ n)) → isOfHLevel (2+ (suc₋₂ n)) (P a b )
hLevelP {n = n} =
elim2
(λ x y → isProp→isOfHLevelSuc (2+ n) (isPropIsOfHLevel (2+ suc₋₂ n)) )
(λ a b → isOfHLevelSuc (2+ n) (isOfHLevelTrunc (2+ n)))
{- decode function from P x y to x ≡ y -}
decode-fun : ∀ {ℓ} {B : Type ℓ} {n : ℕ₋₂} (x y : ∥ B ∥ (suc₋₂ n)) → P x y → x ≡ y
decode-fun {B = B} {n = n} =
elim2
(λ u v → isOfHLevelPi
(2+ suc₋₂ n)
(λ _ → isOfHLevelSuc (2+ suc₋₂ n) (isOfHLevelTrunc (2+ suc₋₂ n)) u v))
decode*
where
decode* : ∀ {ℓ} {B : Type ℓ} {n : ℕ₋₂}(u v : B)
→ (P {n = n} ∣ u ∣ ∣ v ∣) → _≡_ {A = ∥ B ∥ (suc₋₂ n)} ∣ u ∣ ∣ v ∣
decode* {B = B} {n = neg2} u v =
rec
( isOfHLevelTrunc (suc zero) ∣ u ∣ ∣ v ∣
, λ _ →
isOfHLevelSuc (suc zero) (isOfHLevelTrunc (suc zero)) _ _ _ _
)
(λ p → cong (λ z → ∣ z ∣) p)
decode* {n = ℕ₋₂.-1+ n} u v =
rec (isOfHLevelTrunc (suc (suc n)) ∣ u ∣ ∣ v ∣) (λ p → cong (λ z → ∣ z ∣) p)
{- auxilliary function r used to define encode -}
r : ∀ {ℓ} {B : Type ℓ} {m : ℕ₋₂} (u : ∥ B ∥ (suc₋₂ m)) → P u u
r {m = m} = elim (λ x → hLevelP x x) (λ a → ∣ refl ∣)
{- encode function from x ≡ y to P x y -}
encode-fun : ∀ {ℓ} {B : Type ℓ} {n : ℕ₋₂} (x y : ∥ B ∥ (suc₋₂ n)) → x ≡ y → P x y
encode-fun x y p = transport (λ i → P x (p i)) (r x)
{- We need the following two lemmas on the functions behaviour for refl -}
dec-refl : ∀ {ℓ} {B : Type ℓ} {n : ℕ₋₂}
(x : ∥ B ∥ (suc₋₂ n)) → decode-fun x x (r x) ≡ refl {x = x}
dec-refl {B = B} {n = neg2} =
elim
(λ x →
isOfHLevelSuc (suc zero)
(isOfHLevelSuc (suc zero) (isOfHLevelTrunc (suc zero)) x x)
_ _)
(λ a → refl)
dec-refl {n = ℕ₋₂.-1+ n} =
elim
(λ x →
isOfHLevelSuc (suc n)
(isOfHLevelSuc (suc n)
(isOfHLevelTrunc (suc (suc n)) x x)
(decode-fun x x (r x)) refl))
(λ c → refl)
enc-refl : ∀ {ℓ} {B : Type ℓ} {n : ℕ₋₂}
(x : ∥ B ∥ (suc₋₂ n)) → encode-fun x x refl ≡ r x
enc-refl x j = transp (λ i → P x (refl {x = x} i)) j (r x)
{- decode-fun is a right-inverse -}
P-rinv : ∀ {ℓ} {B : Type ℓ} {n : ℕ₋₂} (u v : ∥ B ∥ (suc₋₂ n)) →
(x : _≡_ {A = ∥ B ∥ (suc₋₂ n)} u v) → decode-fun u v (encode-fun u v x) ≡ x
P-rinv {ℓ = ℓ} {B = B} {n = n} u v =
J (λ y p → decode-fun u y (encode-fun u y p) ≡ p)
((λ i → (decode-fun u u (enc-refl u i))) ∙ dec-refl u)
{- decode-fun is a left-inverse -}
P-linv : ∀ {ℓ} {B : Type ℓ} {n : ℕ₋₂} (u v : ∥ B ∥ (suc₋₂ n )) →
(x : P u v) → encode-fun u v (decode-fun u v x) ≡ x
P-linv {n = n} =
elim2
(λ x y → isOfHLevelPi (2+ suc₋₂ n)
(λ z → isOfHLevelSuc (2+ suc₋₂ n) (hLevelP x y) _ _))
helper
where
helper : ∀ {ℓ} {B : Type ℓ} {n : ℕ₋₂} (a b : B) (x : P {n = n} ∣ a ∣ ∣ b ∣)
→ encode-fun ∣ a ∣ ∣ b ∣ (decode-fun ∣ a ∣ ∣ b ∣ x) ≡ x
helper {n = neg2} a b =
elim
(λ x →
( sym (isOfHLevelTrunc zero .snd (encode-fun ∣ a ∣ ∣ b ∣ (decode-fun ∣ a ∣ ∣ b ∣ x)))
∙ (isOfHLevelTrunc zero .snd x)
, λ y →
isOfHLevelSuc (suc zero)
(isOfHLevelSuc zero (isOfHLevelTrunc {A = a ≡ b} zero))
_ _ _ _
))
(J
(λ y p → encode-fun ∣ a ∣ ∣ y ∣ ((decode-fun ∣ a ∣ ∣ y ∣) ∣ p ∣) ≡ ∣ p ∣)
(enc-refl ∣ a ∣))
helper {n = ℕ₋₂.-1+ n} a b =
elim
(λ x → hLevelP {n = ℕ₋₂.-1+ n} ∣ a ∣ ∣ b ∣ _ _)
(J (λ y p → encode-fun {n = ℕ₋₂.-1+ n} ∣ a ∣ ∣ y ∣ ((decode-fun ∣ a ∣ ∣ y ∣) ∣ p ∣) ≡ ∣ p ∣)
(enc-refl ∣ a ∣))
{- The final Iso established -}
IsoFinal : ∀ {ℓ} {B : Type ℓ} {n : ℕ₋₂} (x y : ∥ B ∥ (suc₋₂ n)) → Iso (x ≡ y) (P x y)
IsoFinal x y = iso (encode-fun x y ) (decode-fun x y) (P-linv x y) (P-rinv x y)
PathIdTrunc : {a b : A} (n : ℕ₋₂) → (_≡_ {A = ∥ A ∥ (suc₋₂ n)} ∣ a ∣ ∣ b ∣) ≡ (∥ a ≡ b ∥ n)
PathIdTrunc {a = a} {b = b} n = isoToPath (IsoFinal {n = n} ∣ a ∣ ∣ b ∣)
PathΩ : {a : A} (n : ℕ₋₂) → (_≡_ {A = ∥ A ∥ (suc₋₂ n)} ∣ a ∣ ∣ a ∣) ≡ (∥ a ≡ a ∥ n)
PathΩ {a = a} n = PathIdTrunc {a = a} {b = a} n
| {
"alphanum_fraction": 0.5243749017,
"avg_line_length": 37.9641791045,
"ext": "agda",
"hexsha": "94938f37604005fb67fd8a57558488162836d2d6",
"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": "cefeb3669ffdaea7b88ae0e9dd258378418819ca",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "borsiemir/cubical",
"max_forks_repo_path": "Cubical/HITs/Truncation/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "cefeb3669ffdaea7b88ae0e9dd258378418819ca",
"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": "borsiemir/cubical",
"max_issues_repo_path": "Cubical/HITs/Truncation/Properties.agda",
"max_line_length": 126,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "cefeb3669ffdaea7b88ae0e9dd258378418819ca",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "borsiemir/cubical",
"max_stars_repo_path": "Cubical/HITs/Truncation/Properties.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 5654,
"size": 12718
} |
module Numeric.Nat.Divide.Properties where
open import Prelude
open import Numeric.Nat.Properties
open import Numeric.Nat.DivMod
open import Numeric.Nat.Divide
open import Tactic.Nat
divides-add : ∀ {a b d} → d Divides a → d Divides b → d Divides (a + b)
divides-add (factor! q) (factor! q₁) = factor (q + q₁) auto
divides-mul-r : ∀ a {b d} → d Divides b → d Divides (a * b)
divides-mul-r a (factor! q) = factor (a * q) auto
divides-mul-l : ∀ {a} b {d} → d Divides a → d Divides (a * b)
divides-mul-l b (factor! q) = factor (b * q) auto
divides-mul : ∀ {a b c d} → c Divides a → d Divides b → (c * d) Divides (a * b)
divides-mul (factor! q) (factor! r) = factor (q * r) auto
mul-divides-l : (a b c : Nat) → (a * b) Divides c → a Divides c
mul-divides-l a b c (factor! q) = factor (q * b) auto
mul-divides-r : (a b c : Nat) → (a * b) Divides c → b Divides c
mul-divides-r a b c (factor! q) = factor (q * a) auto
divides-flip-mul : ∀ {a b c d} → c Divides b → d Divides a → (c * d) Divides (a * b)
divides-flip-mul {a} {b} {c} {d} c|b d|a =
transport ((c * d) Divides_) (mul-commute b a) (divides-mul c|b d|a)
divides-sub-l : ∀ {a b d} → d Divides (a + b) → d Divides a → d Divides b
divides-sub-l {b = b} {d} (factor q₁ eq) (factor! q) = factor (q₁ - q) $ by eq
divides-sub-r : ∀ {a b d} → d Divides (a + b) → d Divides b → d Divides a
divides-sub-r {a} {b} d|ab d|b rewrite add-commute a b = divides-sub-l d|ab d|b
divides-mul-cong-l : ∀ {a b} c → a Divides b → (c * a) Divides (c * b)
divides-mul-cong-l {a} {b} c (factor q eq) = factor q (by (c *_ $≡ eq))
divides-mul-cong-r : ∀ {a b} c → a Divides b → (a * c) Divides (b * c)
divides-mul-cong-r {a} {b} c (factor q eq) = factor q (by (c *_ $≡ eq))
divides-nonzero : ∀ {a b} {{_ : NonZero b}} → a Divides b → NonZero a
divides-nonzero {zero} {{nzb}} (factor! b) = transport NonZero (mul-zero-r b) nzb
divides-nonzero {suc _} _ = _
divides-refl : ∀ {a} → a Divides a
divides-refl = factor 1 auto
divides-antisym : ∀ {a b} → a Divides b → b Divides a → a ≡ b
divides-antisym (factor! q) (factor! 0) = auto
divides-antisym (factor! q) (factor 1 eq) = by eq
divides-antisym {zero} (factor! q) (factor (suc (suc q₁)) eq) = auto
divides-antisym {suc a} (factor! 0) (factor (suc (suc q₁)) eq) = by eq
divides-antisym {suc a} (factor! (suc q)) (factor (suc (suc q₁)) eq) = refute eq
divides-trans : ∀ {a b c} → a Divides b → b Divides c → a Divides c
divides-trans (factor! q) (factor! q′) = factor (q′ * q) auto
divides-zero : ∀ {a} → 0 Divides a → a ≡ 0
divides-zero (factor! q) = auto
one-divides : ∀ {a} → 1 Divides a
one-divides {a} = factor a auto
divides-one : ∀ {a} → a Divides 1 → a ≡ 1
divides-one {0} (factor k eq) = refute eq
divides-one {1} _ = refl
divides-one {suc (suc a)} (factor zero ())
divides-one {suc (suc a)} (factor (suc k) eq) = refute eq
mul=1-l : (a b : Nat) → a * b ≡ 1 → a ≡ 1
mul=1-l a b eq =
divides-one (transport (a Divides_) eq (divides-mul-l b divides-refl))
mul=1-r : (a b : Nat) → a * b ≡ 1 → b ≡ 1
mul=1-r a b eq = mul=1-l b a (by eq)
divides-less : ∀ {a b} {{_ : NonZero b}} → a Divides b → a ≤ b
divides-less {{}} (factor! 0)
divides-less {a} (factor! (suc q)) = auto
nonzero-factor : ∀ {a b} ⦃ nzb : NonZero b ⦄ (a|b : a Divides b) → NonZero (get-factor a|b)
nonzero-factor ⦃ () ⦄ (factor! zero)
nonzero-factor (factor! (suc _)) = _
cancel-mul-divides-r : ∀ a b c ⦃ _ : NonZero c ⦄ → (a * c) Divides (b * c) → a Divides b
cancel-mul-divides-r a b c (factor q qac=bc) =
factor q (mul-inj₁ (q * a) b c (by qac=bc))
cancel-mul-divides-l : ∀ a b c ⦃ _ : NonZero a ⦄ → (a * b) Divides (a * c) → b Divides c
cancel-mul-divides-l a b c rewrite mul-commute a b | mul-commute a c = cancel-mul-divides-r b c a
| {
"alphanum_fraction": 0.5940306392,
"avg_line_length": 40.2765957447,
"ext": "agda",
"hexsha": "ec7b39a7d3bea429f0c5aeab633b6ee1c30b909a",
"lang": "Agda",
"max_forks_count": 24,
"max_forks_repo_forks_event_max_datetime": "2021-04-22T06:10:41.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-03-12T18:03:45.000Z",
"max_forks_repo_head_hexsha": "da4fca7744d317b8843f2bc80a923972f65548d3",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "t-more/agda-prelude",
"max_forks_repo_path": "src/Numeric/Nat/Divide/Properties.agda",
"max_issues_count": 59,
"max_issues_repo_head_hexsha": "da4fca7744d317b8843f2bc80a923972f65548d3",
"max_issues_repo_issues_event_max_datetime": "2022-01-14T07:32:36.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-02-09T05:36:44.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "t-more/agda-prelude",
"max_issues_repo_path": "src/Numeric/Nat/Divide/Properties.agda",
"max_line_length": 97,
"max_stars_count": 111,
"max_stars_repo_head_hexsha": "da4fca7744d317b8843f2bc80a923972f65548d3",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "t-more/agda-prelude",
"max_stars_repo_path": "src/Numeric/Nat/Divide/Properties.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-12T23:29:26.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-05T11:28:15.000Z",
"num_tokens": 1529,
"size": 3786
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- The Maybe type and some operations
------------------------------------------------------------------------
-- The definitions in this file are reexported by Data.Maybe.
{-# OPTIONS --without-K --safe #-}
module Data.Maybe.Base where
open import Level
open import Data.Bool.Base using (Bool; true; false; not)
open import Data.Unit.Base using (⊤)
open import Data.These using (These; this; that; these)
open import Data.Product as Prod using (_×_; _,_)
open import Function
open import Relation.Nullary
------------------------------------------------------------------------
-- Definition
data Maybe {a} (A : Set a) : Set a where
just : (x : A) → Maybe A
nothing : Maybe A
------------------------------------------------------------------------
-- Some operations
boolToMaybe : Bool → Maybe ⊤
boolToMaybe true = just _
boolToMaybe false = nothing
is-just : ∀ {a} {A : Set a} → Maybe A → Bool
is-just (just _) = true
is-just nothing = false
is-nothing : ∀ {a} {A : Set a} → Maybe A → Bool
is-nothing = not ∘ is-just
decToMaybe : ∀ {a} {A : Set a} → Dec A → Maybe A
decToMaybe (yes x) = just x
decToMaybe (no _) = nothing
-- A dependent eliminator.
maybe : ∀ {a b} {A : Set a} {B : Maybe A → Set b} →
((x : A) → B (just x)) → B nothing → (x : Maybe A) → B x
maybe j n (just x) = j x
maybe j n nothing = n
-- A non-dependent eliminator.
maybe′ : ∀ {a b} {A : Set a} {B : Set b} → (A → B) → B → Maybe A → B
maybe′ = maybe
-- A defaulting mechanism
fromMaybe : ∀ {a} {A : Set a} → A → Maybe A → A
fromMaybe = maybe′ id
-- A safe variant of "fromJust". If the value is nothing, then the
-- return type is the unit type.
module _ {a} {A : Set a} where
From-just : Maybe A → Set a
From-just (just _) = A
From-just nothing = Lift a ⊤
from-just : (x : Maybe A) → From-just x
from-just (just x) = x
from-just nothing = _
-- Functoriality: map.
map : ∀ {a b} {A : Set a} {B : Set b} → (A → B) → Maybe A → Maybe B
map f = maybe (just ∘ f) nothing
-- Alternative: <∣>
_<∣>_ : ∀ {a} {A : Set a} → Maybe A → Maybe A → Maybe A
just x <∣> my = just x
nothing <∣> my = my
------------------------------------------------------------------------
-- Aligning and zipping
module _ {a b c} {A : Set a} {B : Set b} {C : Set c} where
alignWith : (These A B → C) → Maybe A → Maybe B → Maybe C
alignWith f (just a) (just b) = just (f (these a b))
alignWith f (just a) nothing = just (f (this a))
alignWith f nothing (just b) = just (f (that b))
alignWith f nothing nothing = nothing
zipWith : (A → B → C) → Maybe A → Maybe B → Maybe C
zipWith f (just a) (just b) = just (f a b)
zipWith _ _ _ = nothing
module _ {a b} {A : Set a} {B : Set b} where
align : Maybe A → Maybe B → Maybe (These A B)
align = alignWith id
zip : Maybe A → Maybe B → Maybe (A × B)
zip = zipWith _,_
module _ {a b} {A : Set a} {B : Set b} where
-- Injections.
thisM : A → Maybe B → These A B
thisM a = maybe′ (these a) (this a)
thatM : Maybe A → B → These A B
thatM = maybe′ these that
| {
"alphanum_fraction": 0.5338417541,
"avg_line_length": 26.4453781513,
"ext": "agda",
"hexsha": "3c5a5e541ffc4507c0d6ec6ddcbeb6c85469a948",
"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/Maybe/Base.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/Maybe/Base.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/Maybe/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 975,
"size": 3147
} |
-- Solver for Category
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Experiment.Categories.Solver.Category {o ℓ e} (𝒞 : Category o ℓ e) where
open import Level
open import Relation.Binary using (Rel)
import Categories.Morphism.Reasoning as MR
open Category 𝒞
open HomReasoning
open MR 𝒞
private
variable
A B C D E : Obj
infixr 9 _:∘_
data Expr : Rel Obj (o ⊔ ℓ) where
:id : Expr A A
_:∘_ : Expr B C → Expr A B → Expr A C
∥_∥ : A ⇒ B → Expr A B
-- Semantics
⟦_⟧ : Expr A B → A ⇒ B
⟦ :id ⟧ = id
⟦ e₁ :∘ e₂ ⟧ = ⟦ e₁ ⟧ ∘ ⟦ e₂ ⟧
⟦ ∥ f ∥ ⟧ = f
⟦_⟧N∘_ : Expr B C → A ⇒ B → A ⇒ C
⟦ :id ⟧N∘ g = g
⟦ e₁ :∘ e₂ ⟧N∘ g = ⟦ e₁ ⟧N∘ (⟦ e₂ ⟧N∘ g)
⟦ ∥ f ∥ ⟧N∘ g = f ∘ g
⟦_⟧N : Expr A B → A ⇒ B
⟦ e ⟧N = ⟦ e ⟧N∘ id
⟦e⟧N∘f≈⟦e⟧∘f : (e : Expr B C) (g : A ⇒ B) → ⟦ e ⟧N∘ g ≈ ⟦ e ⟧ ∘ g
⟦e⟧N∘f≈⟦e⟧∘f :id g = ⟺ identityˡ
⟦e⟧N∘f≈⟦e⟧∘f (e₁ :∘ e₂) g = begin
⟦ e₁ ⟧N∘ (⟦ e₂ ⟧N∘ g) ≈⟨ ⟦e⟧N∘f≈⟦e⟧∘f e₁ (⟦ e₂ ⟧N∘ g) ⟩
⟦ e₁ ⟧ ∘ (⟦ e₂ ⟧N∘ g) ≈⟨ pushʳ (⟦e⟧N∘f≈⟦e⟧∘f e₂ g) ⟩
(⟦ e₁ ⟧ ∘ ⟦ e₂ ⟧) ∘ g ∎
⟦e⟧N∘f≈⟦e⟧∘f ∥ f ∥ g = refl
⟦e⟧N≈⟦e⟧ : (e : Expr A B) → ⟦ e ⟧N ≈ ⟦ e ⟧
⟦e⟧N≈⟦e⟧ e = ⟦e⟧N∘f≈⟦e⟧∘f e id ○ identityʳ
solve : (e₁ e₂ : Expr A B) → ⟦ e₁ ⟧N ≈ ⟦ e₂ ⟧N → ⟦ e₁ ⟧ ≈ ⟦ e₂ ⟧
solve e₁ e₂ eq = begin
⟦ e₁ ⟧ ≈˘⟨ ⟦e⟧N≈⟦e⟧ e₁ ⟩
⟦ e₁ ⟧N ≈⟨ eq ⟩
⟦ e₂ ⟧N ≈⟨ ⟦e⟧N≈⟦e⟧ e₂ ⟩
⟦ e₂ ⟧ ∎
∥-∥ : ∀ {f : A ⇒ B} → Expr A B
∥-∥ {f = f} = ∥ f ∥
| {
"alphanum_fraction": 0.4543493889,
"avg_line_length": 22.0793650794,
"ext": "agda",
"hexsha": "bbc5b4639e88df0c25ba71d9e378a8c556c8784d",
"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": "37200ea91d34a6603d395d8ac81294068303f577",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "rei1024/agda-misc",
"max_forks_repo_path": "Experiment/Categories/Solver/Category.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "37200ea91d34a6603d395d8ac81294068303f577",
"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": "rei1024/agda-misc",
"max_issues_repo_path": "Experiment/Categories/Solver/Category.agda",
"max_line_length": 79,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "37200ea91d34a6603d395d8ac81294068303f577",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "rei1024/agda-misc",
"max_stars_repo_path": "Experiment/Categories/Solver/Category.agda",
"max_stars_repo_stars_event_max_datetime": "2020-04-21T00:03:43.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:49:42.000Z",
"num_tokens": 898,
"size": 1391
} |
module even where
open import Data.Nat
open import Data.Nat.Properties
open import Data.Empty
open import Data.Unit using (⊤ ; tt)
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
open import Relation.Binary.Definitions
open import nat
open import logic
even : (n : ℕ ) → Set
even zero = ⊤
even (suc zero) = ⊥
even (suc (suc n)) = even n
even? : (n : ℕ ) → Dec ( even n )
even? zero = yes tt
even? (suc zero) = no (λ ())
even? (suc (suc n)) = even? n
n+even : {n m : ℕ } → even n → even m → even ( n + m )
n+even {zero} {zero} tt tt = tt
n+even {zero} {suc m} tt em = em
n+even {suc (suc n)} {m} en em = n+even {n} {m} en em
n*even : {m n : ℕ } → even n → even ( m * n )
n*even {zero} {n} en = tt
n*even {suc m} {n} en = n+even {n} {m * n} en (n*even {m} {n} en)
even*n : {n m : ℕ } → even n → even ( n * m )
even*n {n} {m} en = subst even (*-comm m n) (n*even {m} {n} en)
record Even (i : ℕ) : Set where
field
j : ℕ
is-twice : i ≡ 2 * j
e2 : (i : ℕ) → even i → Even i
e2 zero en = record { j = 0 ; is-twice = refl }
e2 (suc (suc i)) en = record { j = suc (Even.j (e2 i en )) ; is-twice = e21 } where
e21 : suc (suc i) ≡ 2 * suc (Even.j (e2 i en))
e21 = begin
suc (suc i) ≡⟨ cong (λ k → suc (suc k)) (Even.is-twice (e2 i en)) ⟩
suc (suc (2 * Even.j (e2 i en))) ≡⟨ sym (*-distribˡ-+ 2 1 _) ⟩
2 * suc (Even.j (e2 i en)) ∎ where open ≡-Reasoning
record Odd (i : ℕ) : Set where
field
j : ℕ
is-twice : i ≡ suc (2 * j )
odd2 : (i : ℕ) → ¬ even i → even (suc i)
odd2 zero ne = ⊥-elim ( ne tt )
odd2 (suc zero) ne = tt
odd2 (suc (suc i)) ne = odd2 i ne
odd3 : (i : ℕ) → ¬ even i → Odd i
odd3 zero ne = ⊥-elim ( ne tt )
odd3 (suc zero) ne = record { j = 0 ; is-twice = refl }
odd3 (suc (suc i)) ne = record { j = Even.j (e2 (suc i) (odd2 i ne)) ; is-twice = odd31 } where
odd31 : suc (suc i) ≡ suc (2 * Even.j (e2 (suc i) (odd2 i ne)))
odd31 = begin
suc (suc i) ≡⟨ cong suc (Even.is-twice (e2 (suc i) (odd2 i ne))) ⟩
suc (2 * (Even.j (e2 (suc i) (odd2 i ne)))) ∎ where open ≡-Reasoning
odd4 : (i : ℕ) → even i → ¬ even ( suc i )
odd4 (suc (suc i)) en en1 = odd4 i en en1
| {
"alphanum_fraction": 0.5478699038,
"avg_line_length": 30.3194444444,
"ext": "agda",
"hexsha": "a1dc82bed38362aa973f43a5acc0ac4f71f44dab",
"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": "eba0538f088f3d0c0fedb19c47c081954fbc69cb",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "shinji-kono/automaton-in-agda",
"max_forks_repo_path": "src/even.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "eba0538f088f3d0c0fedb19c47c081954fbc69cb",
"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": "shinji-kono/automaton-in-agda",
"max_issues_repo_path": "src/even.agda",
"max_line_length": 96,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "eba0538f088f3d0c0fedb19c47c081954fbc69cb",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "shinji-kono/automaton-in-agda",
"max_stars_repo_path": "src/even.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 924,
"size": 2183
} |
{-# OPTIONS --without-K --termination-depth=2 #-}
open import HoTT
open import cw.CW
module cw.Sphere where
CWSphere-skel : ∀ n → Skeleton {lzero} n
CWSphere : ℕ → Type₀
CWSphere n = ⟦ CWSphere-skel n ⟧
Sphere-to-CWSphere : (n : ℕ) → Sphere n → CWSphere n
CWSphere-skel O = Bool
CWSphere-skel (S n) =
(CWSphere-skel n , Bool , cst (Sphere-to-CWSphere n))
{-
mapping:
hub true <-> north
hub false <-> south
incl _ -> north
spoke true x -> idp
spoke fales x -> merid x
! spoke true x ∙ spoke false x <- merid x
-}
private
module PosToCW n = SuspensionRec
{C = CWSphere (S n)}
(hub true) (hub false)
(λ x → (! (spoke true x)) ∙' spoke false x)
Sphere-to-CWSphere O = idf _
Sphere-to-CWSphere (S n) = PosToCW.f n
{-
Now proving the equivalence
-}
private
CWSphere-to-Sphere-incl : ∀ n → CWSphere n → Sphere (S n)
CWSphere-to-Sphere-incl _ _ = north
CWSphere-to-Sphere-hub : ∀ n → Bool → Sphere (S n)
CWSphere-to-Sphere-hub _ true = north
CWSphere-to-Sphere-hub _ false = south
CWSphere-to-Sphere-spoke : ∀ n (b : Bool) (x : Sphere n)
→ CWSphere-to-Sphere-incl n (Sphere-to-CWSphere n x)
== CWSphere-to-Sphere-hub n b
CWSphere-to-Sphere-spoke _ true _ = idp
CWSphere-to-Sphere-spoke _ false x = merid x
module PosFromCW n = AttachedRec
{attaching = cst (Sphere-to-CWSphere n)}
(CWSphere-to-Sphere-incl n)
(CWSphere-to-Sphere-hub n)
(CWSphere-to-Sphere-spoke n)
CWSphere-to-Sphere : ∀ n → CWSphere n → Sphere n
CWSphere-to-Sphere O = idf _
CWSphere-to-Sphere (S n) = PosFromCW.f n
private
from-to : ∀ n x → CWSphere-to-Sphere n (Sphere-to-CWSphere n x) == x
from-to O _ = idp
from-to (S n) = SuspensionElim.f idp idp path
where
to = Sphere-to-CWSphere (S n)
from = CWSphere-to-Sphere (S n)
module To = PosToCW n
module From = PosFromCW n
path : ∀ x → idp == idp [ (λ x → from (to x) == x) ↓ merid x ]
path x = ↓-app=idf-in $ ! $
ap (from ∘ to) (merid x) ∙ idp
=⟨ ∙-unit-r $ ap (from ∘ to) (merid x) ⟩
ap (from ∘ to) (merid x)
=⟨ ap-∘ from to (merid x) ⟩
ap from (ap to (merid x))
=⟨ To.merid-β x |in-ctx ap from ⟩
ap from (! (spoke true x) ∙' spoke false x)
=⟨ ap-∙' from (! (spoke true x)) (spoke false x) ⟩
ap from (! (spoke true x)) ∙' ap from (spoke false x)
=⟨ ap-! from (spoke true x) |in-ctx (λ p → p ∙' ap from (spoke false x)) ⟩
! (ap from (spoke true x)) ∙' ap from (spoke false x)
=⟨ From.spoke-β true x |in-ctx (λ p → ! p ∙' ap from (spoke false x)) ⟩
idp ∙' ap from (spoke false x)
=⟨ From.spoke-β false x |in-ctx (idp ∙'_) ⟩
idp ∙' merid x
∎
Sphere-to-CWSphere-is-equiv : ∀ n → is-equiv (Sphere-to-CWSphere n)
private
to-from : ∀ n x → Sphere-to-CWSphere n (CWSphere-to-Sphere n x) == x
Sphere-to-CWSphere-is-equiv n = is-eq _ (CWSphere-to-Sphere n) (to-from n) (from-to n)
to-from O _ = idp
to-from (S n) = AttachedElim.f to-from-incl to-from-hub to-from-spoke
where
to = Sphere-to-CWSphere (S n)
from = CWSphere-to-Sphere (S n)
module To = PosToCW n
module From = PosFromCW n
to-from-incl : ∀ (c : CWSphere n)
→ to (from (incl c)) == incl c
to-from-incl c =
! (spoke true (CWSphere-to-Sphere n c))
∙ ap incl (is-equiv.f-g (Sphere-to-CWSphere-is-equiv n) c)
to-from-hub : ∀ b → to (from (hub b)) == hub b
to-from-hub true = idp
to-from-hub false = idp
to-from-incl-to : ∀ (x : Sphere n)
→ to-from-incl (Sphere-to-CWSphere n x) == ! (spoke true x)
to-from-incl-to x =
! (spoke true (CWSphere-to-Sphere n (Sphere-to-CWSphere n x)))
∙ ap incl (is-equiv.f-g (Sphere-to-CWSphere-is-equiv n) (Sphere-to-CWSphere n x))
=⟨ ! $ is-equiv.adj (Sphere-to-CWSphere-is-equiv n) x
|in-ctx (λ p → ! (spoke true (CWSphere-to-Sphere n (Sphere-to-CWSphere n x))) ∙ ap incl p) ⟩
! (spoke true (CWSphere-to-Sphere n (Sphere-to-CWSphere n x)))
∙ ap incl (ap (Sphere-to-CWSphere n) (is-equiv.g-f (Sphere-to-CWSphere-is-equiv n) x))
=⟨ ! $ ap-∘ incl (Sphere-to-CWSphere n) (is-equiv.g-f (Sphere-to-CWSphere-is-equiv n) x)
|in-ctx (λ p → ! (spoke true (CWSphere-to-Sphere n (Sphere-to-CWSphere n x))) ∙ p) ⟩
! (spoke true (CWSphere-to-Sphere n (Sphere-to-CWSphere n x)))
∙ ap (incl ∘ Sphere-to-CWSphere n) (is-equiv.g-f (Sphere-to-CWSphere-is-equiv n) x)
=⟨ htpy-natural-cst=app (λ x → ! (spoke true x)) (is-equiv.g-f (Sphere-to-CWSphere-is-equiv n) x) ⟩
! (spoke true x)
∎
to-from-spoke : ∀ (b : Bool) (x : Sphere n)
→ to-from-incl (Sphere-to-CWSphere n x) == to-from-hub b
[ (λ x → to (from x) == x) ↓ spoke b x ]
to-from-spoke true x = ↓-app=idf-in $
to-from-incl (Sphere-to-CWSphere n x) ∙' spoke true x
=⟨ to-from-incl-to x |in-ctx (λ p → p ∙' spoke true x) ⟩
! (spoke true x) ∙' spoke true x
=⟨ !-inv'-l (spoke true x) ⟩
idp
=⟨ ! $ From.spoke-β true x |in-ctx (λ p → ap to p ∙ idp) ⟩
ap to (ap from (spoke true x)) ∙ idp
=⟨ ∘-ap to from (spoke true x) |in-ctx (λ p → p ∙ idp) ⟩
ap (to ∘ from) (spoke true x) ∙ idp
∎
to-from-spoke false x = ↓-app=idf-in $
to-from-incl (Sphere-to-CWSphere n x) ∙' spoke false x
=⟨ to-from-incl-to x |in-ctx (λ p → p ∙' spoke false x) ⟩
! (spoke true x) ∙' spoke false x
=⟨ ! $ To.merid-β x ⟩
ap to (merid x)
=⟨ ! $ From.spoke-β false x |in-ctx (ap to) ⟩
ap to (ap from (spoke false x))
=⟨ ∘-ap to from (spoke false x) ⟩
ap (to ∘ from) (spoke false x)
=⟨ ! $ ∙-unit-r _ ⟩
ap (to ∘ from) (spoke false x) ∙ idp
∎
Sphere-equiv-CWSphere : ∀ n → Sphere n ≃ CWSphere n
Sphere-equiv-CWSphere n = _ , Sphere-to-CWSphere-is-equiv n
CWSphere-has-dec-cells : ∀ n → has-dec-cells (CWSphere-skel n)
CWSphere-has-dec-cells 0 = Bool-has-dec-eq
CWSphere-has-dec-cells (S n) = CWSphere-has-dec-cells n , Bool-has-dec-eq
CWSphere-is-aligned : ∀ n → is-aligned (CWSphere-skel n)
CWSphere-is-aligned 0 = lift tt
CWSphere-is-aligned 1 = lift tt
CWSphere-is-aligned 2 = lift tt , (λ _ → true , spoke true true)
CWSphere-is-aligned (S (S (S n))) =
CWSphere-is-aligned (S (S n)) , (λ _ → hub true , spoke true north)
| {
"alphanum_fraction": 0.5838745446,
"avg_line_length": 35.4662921348,
"ext": "agda",
"hexsha": "998d2be404536ddc882c72d4f2edd586076eb3e1",
"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": "bc849346a17b33e2679a5b3f2b8efbe7835dc4b6",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cmknapp/HoTT-Agda",
"max_forks_repo_path": "theorems/cw/Sphere.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "bc849346a17b33e2679a5b3f2b8efbe7835dc4b6",
"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": "cmknapp/HoTT-Agda",
"max_issues_repo_path": "theorems/cw/Sphere.agda",
"max_line_length": 109,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "bc849346a17b33e2679a5b3f2b8efbe7835dc4b6",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cmknapp/HoTT-Agda",
"max_stars_repo_path": "theorems/cw/Sphere.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2369,
"size": 6313
} |
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Weakening {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped as U hiding (wk)
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.Weakening as T hiding (wk; wkEq; wkTerm; wkEqTerm)
open import Definition.LogicalRelation
open import Definition.LogicalRelation.Irrelevance
open import Tools.Embedding
open import Tools.Product
import Tools.PropositionalEquality as PE
-- Weakening of neutrals in WHNF
wkTermNe : ∀ {ρ Γ Δ k A} → ρ ∷ Δ ⊆ Γ → (⊢Δ : ⊢ Δ)
→ Γ ⊩neNf k ∷ A → Δ ⊩neNf U.wk ρ k ∷ U.wk ρ A
wkTermNe {ρ} [ρ] ⊢Δ (neNfₜ neK ⊢k k≡k) =
neNfₜ (wkNeutral ρ neK) (T.wkTerm [ρ] ⊢Δ ⊢k) (~-wk [ρ] ⊢Δ k≡k)
wkEqTermNe : ∀ {ρ Γ Δ k k′ A} → ρ ∷ Δ ⊆ Γ → (⊢Δ : ⊢ Δ)
→ Γ ⊩neNf k ≡ k′ ∷ A → Δ ⊩neNf U.wk ρ k ≡ U.wk ρ k′ ∷ U.wk ρ A
wkEqTermNe {ρ} [ρ] ⊢Δ (neNfₜ₌ neK neM k≡m) =
neNfₜ₌ (wkNeutral ρ neK) (wkNeutral ρ neM) (~-wk [ρ] ⊢Δ k≡m)
-- Weakening of reducible natural numbers
mutual
wkTermℕ : ∀ {ρ Γ Δ n} → ρ ∷ Δ ⊆ Γ → (⊢Δ : ⊢ Δ)
→ _⊩ℕ_∷ℕ Γ n → _⊩ℕ_∷ℕ Δ (U.wk ρ n)
wkTermℕ {ρ} [ρ] ⊢Δ (ℕₜ n d n≡n prop) =
ℕₜ (U.wk ρ n) (wkRed:*:Term [ρ] ⊢Δ d)
(≅ₜ-wk [ρ] ⊢Δ n≡n)
(wkNatural-prop [ρ] ⊢Δ prop)
wkNatural-prop : ∀ {ρ Γ Δ n} → ρ ∷ Δ ⊆ Γ → (⊢Δ : ⊢ Δ)
→ Natural-prop Γ n
→ Natural-prop Δ (U.wk ρ n)
wkNatural-prop ρ ⊢Δ (sucᵣ n) = sucᵣ (wkTermℕ ρ ⊢Δ n)
wkNatural-prop ρ ⊢Δ zeroᵣ = zeroᵣ
wkNatural-prop ρ ⊢Δ (ne nf) = ne (wkTermNe ρ ⊢Δ nf)
mutual
wkEqTermℕ : ∀ {ρ Γ Δ t u} → ρ ∷ Δ ⊆ Γ → (⊢Δ : ⊢ Δ)
→ _⊩ℕ_≡_∷ℕ Γ t u
→ _⊩ℕ_≡_∷ℕ Δ (U.wk ρ t) (U.wk ρ u)
wkEqTermℕ {ρ} [ρ] ⊢Δ (ℕₜ₌ k k′ d d′ t≡u prop) =
ℕₜ₌ (U.wk ρ k) (U.wk ρ k′) (wkRed:*:Term [ρ] ⊢Δ d)
(wkRed:*:Term [ρ] ⊢Δ d′) (≅ₜ-wk [ρ] ⊢Δ t≡u)
(wk[Natural]-prop [ρ] ⊢Δ prop)
wk[Natural]-prop : ∀ {ρ Γ Δ n n′} → ρ ∷ Δ ⊆ Γ → (⊢Δ : ⊢ Δ)
→ [Natural]-prop Γ n n′
→ [Natural]-prop Δ (U.wk ρ n) (U.wk ρ n′)
wk[Natural]-prop ρ ⊢Δ (sucᵣ [n≡n′]) = sucᵣ (wkEqTermℕ ρ ⊢Δ [n≡n′])
wk[Natural]-prop ρ ⊢Δ zeroᵣ = zeroᵣ
wk[Natural]-prop ρ ⊢Δ (ne x) = ne (wkEqTermNe ρ ⊢Δ x)
-- Weakening of the logical relation
wk : ∀ {ρ Γ Δ A l} → ρ ∷ Δ ⊆ Γ → ⊢ Δ → Γ ⊩⟨ l ⟩ A → Δ ⊩⟨ l ⟩ U.wk ρ A
wk ρ ⊢Δ (Uᵣ′ l′ l< ⊢Γ) = Uᵣ′ l′ l< ⊢Δ
wk ρ ⊢Δ (ℕᵣ D) = ℕᵣ (wkRed:*: ρ ⊢Δ D)
wk {ρ} [ρ] ⊢Δ (ne′ K D neK K≡K) =
ne′ (U.wk ρ K) (wkRed:*: [ρ] ⊢Δ D) (wkNeutral ρ neK) (~-wk [ρ] ⊢Δ K≡K)
wk {ρ} {Γ} {Δ} {A} {l} [ρ] ⊢Δ (Πᵣ′ F G D ⊢F ⊢G A≡A [F] [G] G-ext) =
let ⊢ρF = T.wk [ρ] ⊢Δ ⊢F
[F]′ : ∀ {ρ ρ′ E} ([ρ] : ρ ∷ E ⊆ Δ) ([ρ′] : ρ′ ∷ Δ ⊆ Γ) (⊢E : ⊢ E)
→ E ⊩⟨ l ⟩ U.wk ρ (U.wk ρ′ F)
[F]′ {ρ} {ρ′} [ρ] [ρ′] ⊢E = irrelevance′
(PE.sym (wk-comp ρ ρ′ F))
([F] ([ρ] •ₜ [ρ′]) ⊢E)
[a]′ : ∀ {ρ ρ′ E a} ([ρ] : ρ ∷ E ⊆ Δ) ([ρ′] : ρ′ ∷ Δ ⊆ Γ) (⊢E : ⊢ E)
([a] : E ⊩⟨ l ⟩ a ∷ U.wk ρ (U.wk ρ′ F) / [F]′ [ρ] [ρ′] ⊢E)
→ E ⊩⟨ l ⟩ a ∷ U.wk (ρ • ρ′) F / [F] ([ρ] •ₜ [ρ′]) ⊢E
[a]′ {ρ} {ρ′} [ρ] [ρ′] ⊢E [a] = irrelevanceTerm′ (wk-comp ρ ρ′ F)
([F]′ [ρ] [ρ′] ⊢E) ([F] ([ρ] •ₜ [ρ′]) ⊢E) [a]
[G]′ : ∀ {ρ ρ′ E a} ([ρ] : ρ ∷ E ⊆ Δ) ([ρ′] : ρ′ ∷ Δ ⊆ Γ) (⊢E : ⊢ E)
([a] : E ⊩⟨ l ⟩ a ∷ U.wk ρ (U.wk ρ′ F) / [F]′ [ρ] [ρ′] ⊢E)
→ E ⊩⟨ l ⟩ U.wk (lift (ρ • ρ′)) G [ a ]
[G]′ η η′ ⊢E [a] = [G] (η •ₜ η′) ⊢E ([a]′ η η′ ⊢E [a])
in Πᵣ′ (U.wk ρ F) (U.wk (lift ρ) G) (T.wkRed:*: [ρ] ⊢Δ D) ⊢ρF
(T.wk (lift [ρ]) (⊢Δ ∙ ⊢ρF) ⊢G)
(≅-wk [ρ] ⊢Δ A≡A)
(λ {ρ₁} [ρ₁] ⊢Δ₁ → irrelevance′ (PE.sym (wk-comp ρ₁ ρ F))
([F] ([ρ₁] •ₜ [ρ]) ⊢Δ₁))
(λ {ρ₁} [ρ₁] ⊢Δ₁ [a] → irrelevance′ (wk-comp-subst ρ₁ ρ G)
([G]′ [ρ₁] [ρ] ⊢Δ₁ [a]))
(λ {ρ₁} [ρ₁] ⊢Δ₁ [a] [b] [a≡b] →
let [a≡b]′ = irrelevanceEqTerm′ (wk-comp ρ₁ ρ F)
([F]′ [ρ₁] [ρ] ⊢Δ₁)
([F] ([ρ₁] •ₜ [ρ]) ⊢Δ₁)
[a≡b]
in irrelevanceEq″ (wk-comp-subst ρ₁ ρ G)
(wk-comp-subst ρ₁ ρ G)
([G]′ [ρ₁] [ρ] ⊢Δ₁ [a])
(irrelevance′
(wk-comp-subst ρ₁ ρ G)
([G]′ [ρ₁] [ρ] ⊢Δ₁ [a]))
(G-ext ([ρ₁] •ₜ [ρ]) ⊢Δ₁
([a]′ [ρ₁] [ρ] ⊢Δ₁ [a])
([a]′ [ρ₁] [ρ] ⊢Δ₁ [b])
[a≡b]′))
wk ρ ⊢Δ (emb′ 0<1 x) = emb′ 0<1 (wk ρ ⊢Δ x)
wkEq : ∀ {ρ Γ Δ A B l} → ([ρ] : ρ ∷ Δ ⊆ Γ) (⊢Δ : ⊢ Δ)
([A] : Γ ⊩⟨ l ⟩ A)
→ Γ ⊩⟨ l ⟩ A ≡ B / [A]
→ Δ ⊩⟨ l ⟩ U.wk ρ A ≡ U.wk ρ B / wk [ρ] ⊢Δ [A]
wkEq ρ ⊢Δ (Uᵣ′ _ _ _) (U₌ PE.refl) = (U₌ PE.refl)
wkEq ρ ⊢Δ (ℕᵣ D) (ιx (ℕ₌ A≡B)) = ιx (ℕ₌ (wkRed* ρ ⊢Δ A≡B))
wkEq {ρ} [ρ] ⊢Δ (ne′ _ _ _ _) (ιx (ne₌ M D′ neM K≡M)) =
ιx (ne₌ (U.wk ρ M) (wkRed:*: [ρ] ⊢Δ D′)
(wkNeutral ρ neM) (~-wk [ρ] ⊢Δ K≡M))
wkEq {ρ} [ρ] ⊢Δ (Πᵣ′ F G D ⊢F ⊢G A≡A [F] [G] G-ext)
(Π₌ F′ G′ D′ A≡B [F≡F′] [G≡G′]) =
Π₌ (U.wk ρ F′) (U.wk (lift ρ) G′) (T.wkRed* [ρ] ⊢Δ D′) (≅-wk [ρ] ⊢Δ A≡B)
(λ {ρ₁} [ρ₁] ⊢Δ₁ → irrelevanceEq″ (PE.sym (wk-comp ρ₁ ρ F))
(PE.sym (wk-comp ρ₁ ρ F′))
([F] ([ρ₁] •ₜ [ρ]) ⊢Δ₁)
(irrelevance′ (PE.sym (wk-comp ρ₁ ρ F))
([F] ([ρ₁] •ₜ [ρ]) ⊢Δ₁))
([F≡F′] ([ρ₁] •ₜ [ρ]) ⊢Δ₁))
(λ {ρ₁} [ρ₁] ⊢Δ₁ [a] →
let [a]′ = irrelevanceTerm′ (wk-comp ρ₁ ρ F)
(irrelevance′ (PE.sym (wk-comp ρ₁ ρ F))
([F] ([ρ₁] •ₜ [ρ]) ⊢Δ₁))
([F] ([ρ₁] •ₜ [ρ]) ⊢Δ₁) [a]
in irrelevanceEq″ (wk-comp-subst ρ₁ ρ G)
(wk-comp-subst ρ₁ ρ G′)
([G] ([ρ₁] •ₜ [ρ]) ⊢Δ₁ [a]′)
(irrelevance′ (wk-comp-subst ρ₁ ρ G)
([G] ([ρ₁] •ₜ [ρ]) ⊢Δ₁ [a]′))
([G≡G′] ([ρ₁] •ₜ [ρ]) ⊢Δ₁ [a]′))
wkEq ρ ⊢Δ (emb′ 0<1 x) (ιx A≡B) = ιx (wkEq ρ ⊢Δ x A≡B)
wkTerm : ∀ {ρ Γ Δ A t l} ([ρ] : ρ ∷ Δ ⊆ Γ) (⊢Δ : ⊢ Δ)
([A] : Γ ⊩⟨ l ⟩ A)
→ Γ ⊩⟨ l ⟩ t ∷ A / [A]
→ Δ ⊩⟨ l ⟩ U.wk ρ t ∷ U.wk ρ A / wk [ρ] ⊢Δ [A]
wkTerm {ρ} [ρ] ⊢Δ (Uᵣ′ .⁰ 0<1 ⊢Γ) (Uₜ A d typeA A≡A [t]) =
Uₜ (U.wk ρ A) (wkRed:*:Term [ρ] ⊢Δ d)
(wkType ρ typeA) (≅ₜ-wk [ρ] ⊢Δ A≡A) (wk [ρ] ⊢Δ [t])
wkTerm ρ ⊢Δ (ℕᵣ D) (ιx [t]) = ιx (wkTermℕ ρ ⊢Δ [t])
--
wkTerm {ρ} [ρ] ⊢Δ (ne′ K D neK K≡K) (ιx (neₜ k d nf)) =
ιx (neₜ (U.wk ρ k) (wkRed:*:Term [ρ] ⊢Δ d) (wkTermNe [ρ] ⊢Δ nf))
wkTerm {ρ} [ρ] ⊢Δ (Πᵣ′ F G D ⊢F ⊢G A≡A [F] [G] G-ext) (Πₜ f d funcF f≡f [f] [f]₁) =
Πₜ (U.wk ρ f) (wkRed:*:Term [ρ] ⊢Δ d) (wkFunction ρ funcF)
(≅ₜ-wk [ρ] ⊢Δ f≡f)
(λ {ρ₁} [ρ₁] ⊢Δ₁ [a] [b] [a≡b] →
let F-compEq = wk-comp ρ₁ ρ F
G-compEq = wk-comp-subst ρ₁ ρ G
[F]₁ = [F] ([ρ₁] •ₜ [ρ]) ⊢Δ₁
[F]₂ = irrelevance′ (PE.sym (wk-comp ρ₁ ρ F)) [F]₁
[a]′ = irrelevanceTerm′ F-compEq [F]₂ [F]₁ [a]
[b]′ = irrelevanceTerm′ F-compEq [F]₂ [F]₁ [b]
[G]₁ = [G] ([ρ₁] •ₜ [ρ]) ⊢Δ₁ [a]′
[G]₂ = irrelevance′ G-compEq [G]₁
[a≡b]′ = irrelevanceEqTerm′ F-compEq [F]₂ [F]₁ [a≡b]
in irrelevanceEqTerm″ (PE.cong (λ x → x ∘ _) (PE.sym (wk-comp ρ₁ ρ _)))
(PE.cong (λ x → x ∘ _) (PE.sym (wk-comp ρ₁ ρ _)))
G-compEq
[G]₁ [G]₂
([f] ([ρ₁] •ₜ [ρ]) ⊢Δ₁ [a]′ [b]′ [a≡b]′))
(λ {ρ₁} [ρ₁] ⊢Δ₁ [a] →
let [F]₁ = [F] ([ρ₁] •ₜ [ρ]) ⊢Δ₁
[F]₂ = irrelevance′ (PE.sym (wk-comp ρ₁ ρ F)) [F]₁
[a]′ = irrelevanceTerm′ (wk-comp ρ₁ ρ F) [F]₂ [F]₁ [a]
[G]₁ = [G] ([ρ₁] •ₜ [ρ]) ⊢Δ₁ [a]′
[G]₂ = irrelevance′ (wk-comp-subst ρ₁ ρ G) [G]₁
in irrelevanceTerm″ (wk-comp-subst ρ₁ ρ G)
(PE.cong (λ x → x ∘ _) (PE.sym (wk-comp ρ₁ ρ _)))
[G]₁ [G]₂ ([f]₁ ([ρ₁] •ₜ [ρ]) ⊢Δ₁ [a]′))
wkTerm ρ ⊢Δ (emb′ 0<1 x) (ιx t) = ιx (wkTerm ρ ⊢Δ x t)
wkEqTerm : ∀ {ρ Γ Δ A t u l} ([ρ] : ρ ∷ Δ ⊆ Γ) (⊢Δ : ⊢ Δ)
([A] : Γ ⊩⟨ l ⟩ A)
→ Γ ⊩⟨ l ⟩ t ≡ u ∷ A / [A]
→ Δ ⊩⟨ l ⟩ U.wk ρ t ≡ U.wk ρ u ∷ U.wk ρ A / wk [ρ] ⊢Δ [A]
wkEqTerm {ρ} [ρ] ⊢Δ (Uᵣ′ .⁰ 0<1 ⊢Γ) (Uₜ₌ A B d d′ typeA typeB A≡B [t] [u] [t≡u]) =
Uₜ₌ (U.wk ρ A) (U.wk ρ B) (wkRed:*:Term [ρ] ⊢Δ d) (wkRed:*:Term [ρ] ⊢Δ d′)
(wkType ρ typeA) (wkType ρ typeB) (≅ₜ-wk [ρ] ⊢Δ A≡B)
(wk [ρ] ⊢Δ [t]) (wk [ρ] ⊢Δ [u]) (wkEq [ρ] ⊢Δ [t] [t≡u])
wkEqTerm ρ ⊢Δ (ℕᵣ D) (ιx [t≡u]) = ιx (wkEqTermℕ ρ ⊢Δ [t≡u])
wkEqTerm {ρ} [ρ] ⊢Δ (ne′ K D neK K≡K) (ιx (neₜ₌ k m d d′ nf)) =
ιx (neₜ₌ (U.wk ρ k) (U.wk ρ m)
(wkRed:*:Term [ρ] ⊢Δ d) (wkRed:*:Term [ρ] ⊢Δ d′)
(wkEqTermNe [ρ] ⊢Δ nf))
wkEqTerm {ρ} [ρ] ⊢Δ (Πᵣ′ F G D ⊢F ⊢G A≡A [F] [G] G-ext)
(Πₜ₌ f g d d′ funcF funcG f≡g [t] [u] [f≡g]) =
let [A] = Πᵣ′ F G D ⊢F ⊢G A≡A [F] [G] G-ext
in Πₜ₌ (U.wk ρ f) (U.wk ρ g) (wkRed:*:Term [ρ] ⊢Δ d) (wkRed:*:Term [ρ] ⊢Δ d′)
(wkFunction ρ funcF) (wkFunction ρ funcG)
(≅ₜ-wk [ρ] ⊢Δ f≡g) (wkTerm [ρ] ⊢Δ [A] [t]) (wkTerm [ρ] ⊢Δ [A] [u])
(λ {ρ₁} [ρ₁] ⊢Δ₁ [a] →
let [F]₁ = [F] ([ρ₁] •ₜ [ρ]) ⊢Δ₁
[F]₂ = irrelevance′ (PE.sym (wk-comp ρ₁ ρ F)) [F]₁
[a]′ = irrelevanceTerm′ (wk-comp ρ₁ ρ F) [F]₂ [F]₁ [a]
[G]₁ = [G] ([ρ₁] •ₜ [ρ]) ⊢Δ₁ [a]′
[G]₂ = irrelevance′ (wk-comp-subst ρ₁ ρ G) [G]₁
in irrelevanceEqTerm″ (PE.cong (λ y → y ∘ _) (PE.sym (wk-comp ρ₁ ρ _)))
(PE.cong (λ y → y ∘ _) (PE.sym (wk-comp ρ₁ ρ _)))
(wk-comp-subst ρ₁ ρ G)
[G]₁ [G]₂
([f≡g] ([ρ₁] •ₜ [ρ]) ⊢Δ₁ [a]′))
wkEqTerm ρ ⊢Δ (emb′ 0<1 x) (ιx t≡u) = ιx (wkEqTerm ρ ⊢Δ x t≡u)
| {
"alphanum_fraction": 0.3793991416,
"avg_line_length": 48.7674418605,
"ext": "agda",
"hexsha": "2d592dac09dc8080fe22e257f9b9aea9efd981dc",
"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/Weakening.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/Weakening.agda",
"max_line_length": 87,
"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/Weakening.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 5359,
"size": 10485
} |
{-# OPTIONS --copatterns #-}
open import Common.Prelude
open import Common.Product
postulate
A : Set
B : A → Set
f : ∀ a → B a
bla : ∃ B
{-# NON_TERMINATING #-}
proj₁ bla = proj₁ bla
proj₂ bla = f (proj₁ bla)
T : Bool → Set
T true = Bool
T false = Bool
test : (∀ b → T b) → ∃ T
{-# NON_TERMINATING #-}
proj₁ (test f) = proj₁ (test f)
proj₂ (test f) = f (proj₁ (test f))
| {
"alphanum_fraction": 0.5968586387,
"avg_line_length": 15.9166666667,
"ext": "agda",
"hexsha": "40903f683f2042bbd822829beaf6d075688b5de7",
"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/NonTerminatingClauseInDefByCopatterns.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/NonTerminatingClauseInDefByCopatterns.agda",
"max_line_length": 35,
"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/NonTerminatingClauseInDefByCopatterns.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": 135,
"size": 382
} |
module Common.Sum where
open import Common.Level
data _⊎_ {a b} (A : Set a) (B : Set b) : Set (a ⊔ b) where
inj₁ : (x : A) → A ⊎ B
inj₂ : (y : B) → A ⊎ B
[_,_] : ∀ {a b c} {A : Set a} {B : Set b} {C : A ⊎ B → Set c} →
((x : A) → C (inj₁ x)) → ((x : B) → C (inj₂ x)) →
((x : A ⊎ B) → C x)
[ f , g ] (inj₁ x) = f x
[ f , g ] (inj₂ y) = g y
| {
"alphanum_fraction": 0.4033149171,
"avg_line_length": 24.1333333333,
"ext": "agda",
"hexsha": "44c6ed15ed0c6bf7bbb3672b61ee06cd2b5cdab2",
"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/Common/Sum.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/Common/Sum.agda",
"max_line_length": 63,
"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/Common/Sum.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": 180,
"size": 362
} |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Order
module Numbers.Modulo.Definition where
record ℤn (n : ℕ) .(pr : 0 <N n) : Set where
field
x : ℕ
.xLess : x <N n
equalityZn : {n : ℕ} .{pr : 0 <N n} → {a b : ℤn n pr} → (ℤn.x a ≡ ℤn.x b) → a ≡ b
equalityZn {a = record { x = a ; xLess = aLess }} {record { x = .a ; xLess = bLess }} refl = refl
| {
"alphanum_fraction": 0.6113537118,
"avg_line_length": 28.625,
"ext": "agda",
"hexsha": "0e36c66f7be1245dba73d51adc91f3ed56c2098e",
"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/Modulo/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/Modulo/Definition.agda",
"max_line_length": 97,
"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/Modulo/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": 172,
"size": 458
} |
{-# OPTIONS --cubical --safe #-}
module Cubical.Structures.Monoid where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Data.Sigma
open import Cubical.Foundations.SIP renaming (SNS-PathP to SNS)
open import Cubical.Structures.Pointed
open import Cubical.Structures.NAryOp
private
variable
ℓ : Level
-- Monoids
raw-monoid-structure : Type ℓ → Type ℓ
raw-monoid-structure X = X × (X → X → X)
-- If we ignore the axioms we get a "raw" monoid
raw-monoid-is-SNS : SNS {ℓ} raw-monoid-structure _
raw-monoid-is-SNS = join-SNS pointed-iso pointed-is-SNS (nAryFunIso 2) (nAryFunSNS 2)
-- Monoid axioms
monoid-axioms : (X : Type ℓ) → raw-monoid-structure X → Type ℓ
monoid-axioms X (e , _·_ ) = isSet X
× ((x y z : X) → x · (y · z) ≡ (x · y) · z)
× ((x : X) → x · e ≡ x)
× ((x : X) → e · x ≡ x)
monoid-structure : Type ℓ → Type ℓ
monoid-structure = add-to-structure raw-monoid-structure monoid-axioms
Monoid : Type (ℓ-suc ℓ)
Monoid {ℓ} = TypeWithStr ℓ monoid-structure
-- Monoid extractors
⟨_⟩ : Monoid {ℓ} → Type ℓ
⟨ G , _ ⟩ = G
monoid-id : (M : Monoid {ℓ}) → ⟨ M ⟩
monoid-id (_ , (e , _) , _) = e
monoid-operation : (M : Monoid {ℓ}) → ⟨ M ⟩ → ⟨ M ⟩ → ⟨ M ⟩
monoid-operation (_ , (_ , f) , _) = f
-- Monoid syntax with explicit monoid
module monoid-syntax where
id : (M : Monoid {ℓ}) → ⟨ M ⟩
id = monoid-id
monoid-operation-syntax : (M : Monoid {ℓ}) → ⟨ M ⟩ → ⟨ M ⟩ → ⟨ M ⟩
monoid-operation-syntax = monoid-operation
infixr 18 monoid-operation-syntax
syntax monoid-operation-syntax M x y = x ·⟨ M ⟩ y
open monoid-syntax
-- More Monoid extractors
monoid-is-set : (M : Monoid {ℓ}) → isSet (⟨ M ⟩)
monoid-is-set (_ , _ , P , _) = P
monoid-assoc : (M : Monoid {ℓ})
→ (x y z : ⟨ M ⟩) → x ·⟨ M ⟩ (y ·⟨ M ⟩ z) ≡ (x ·⟨ M ⟩ y) ·⟨ M ⟩ z
monoid-assoc (_ , _ , _ , P , _) = P
monoid-rid : (M : Monoid {ℓ})
→ (x : ⟨ M ⟩) → x ·⟨ M ⟩ (id M) ≡ x
monoid-rid (_ , _ , _ , _ , P , _) = P
monoid-lid : (M : Monoid {ℓ})
→ (x : ⟨ M ⟩) → (id M) ·⟨ M ⟩ x ≡ x
monoid-lid (_ , _ , _ , _ , _ , P) = P
-- Monoid equivalence
monoid-iso : StrIso monoid-structure ℓ
monoid-iso = add-to-iso (join-iso pointed-iso (nAryFunIso 2)) monoid-axioms
-- We have to show that the monoid axioms are indeed propositions
monoid-axioms-are-Props : (X : Type ℓ) (s : raw-monoid-structure X) → isProp (monoid-axioms X s)
monoid-axioms-are-Props X (e , _·_) s = β s
where
α = s .fst
β = isProp× isPropIsSet
(isProp× (isPropΠ3 (λ x y z → α (x · (y · z)) ((x · y) · z)))
(isProp× (isPropΠ (λ x → α (x · e) x)) (isPropΠ (λ x → α (e · x) x))))
monoid-is-SNS : SNS {ℓ} monoid-structure monoid-iso
monoid-is-SNS = add-axioms-SNS _ monoid-axioms-are-Props raw-monoid-is-SNS
MonoidPath : (M N : Monoid {ℓ}) → (M ≃[ monoid-iso ] N) ≃ (M ≡ N)
MonoidPath = SIP monoid-is-SNS
-- Added for its use in groups
-- If there exists a inverse of an element it is unique
inv-lemma : (M : Monoid {ℓ})
→ (x y z : ⟨ M ⟩)
→ y ·⟨ M ⟩ x ≡ id M
→ x ·⟨ M ⟩ z ≡ id M
→ y ≡ z
inv-lemma M x y z left-inverse right-inverse =
y ≡⟨ sym (monoid-rid M y) ⟩
y ·⟨ M ⟩ id M ≡⟨ cong (λ - → y ·⟨ M ⟩ -) (sym right-inverse) ⟩
y ·⟨ M ⟩ (x ·⟨ M ⟩ z) ≡⟨ monoid-assoc M y x z ⟩
(y ·⟨ M ⟩ x) ·⟨ M ⟩ z ≡⟨ cong (λ - → - ·⟨ M ⟩ z) left-inverse ⟩
id M ·⟨ M ⟩ z ≡⟨ monoid-lid M z ⟩
z ∎
-- Monoid ·syntax
module monoid-·syntax (M : Monoid {ℓ}) where
infixr 18 _·_
_·_ : ⟨ M ⟩ → ⟨ M ⟩ → ⟨ M ⟩
_·_ = monoid-operation M
₁ : ⟨ M ⟩
₁ = monoid-id M
| {
"alphanum_fraction": 0.5595687332,
"avg_line_length": 29.2125984252,
"ext": "agda",
"hexsha": "788318e4b334a0b0590e1a5cf7baabb8c198ec4c",
"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": "c67854d2e11aafa5677e25a09087e176fafd3e43",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cmester0/cubical",
"max_forks_repo_path": "Cubical/Structures/Monoid.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c67854d2e11aafa5677e25a09087e176fafd3e43",
"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": "cmester0/cubical",
"max_issues_repo_path": "Cubical/Structures/Monoid.agda",
"max_line_length": 96,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "c67854d2e11aafa5677e25a09087e176fafd3e43",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cmester0/cubical",
"max_stars_repo_path": "Cubical/Structures/Monoid.agda",
"max_stars_repo_stars_event_max_datetime": "2020-03-23T23:52:11.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-03-23T23:52:11.000Z",
"num_tokens": 1493,
"size": 3710
} |
-- TODO
-- Common syntax.
module BasicT.Syntax.Common where
open import Common.Context public
-- Types, or propositions.
infixl 9 _∧_
infixr 7 _▻_
data Ty : Set where
α_ : Atom → Ty
_▻_ : Ty → Ty → Ty
_∧_ : Ty → Ty → Ty
⊤ : Ty
BOOL : Ty
NAT : Ty
-- Additional useful types.
infix 7 _▻◅_
_▻◅_ : Ty → Ty → Ty
A ▻◅ B = (A ▻ B) ∧ (B ▻ A)
infixr 7 _▻⋯▻_
_▻⋯▻_ : Cx Ty → Ty → Ty
∅ ▻⋯▻ B = B
(Ξ , A) ▻⋯▻ B = Ξ ▻⋯▻ (A ▻ B)
infixr 7 _▻⋯▻⋆_
_▻⋯▻⋆_ : Cx Ty → Cx Ty → Ty
Γ ▻⋯▻⋆ ∅ = ⊤
Γ ▻⋯▻⋆ (Ξ , A) = (Γ ▻⋯▻⋆ Ξ) ∧ (Γ ▻⋯▻ A)
| {
"alphanum_fraction": 0.4719710669,
"avg_line_length": 14.9459459459,
"ext": "agda",
"hexsha": "63c83b726b9649b8379988c48bdb7c1e888ba18c",
"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": "BasicT/Syntax/Common.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": "BasicT/Syntax/Common.agda",
"max_line_length": 39,
"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": "BasicT/Syntax/Common.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": 334,
"size": 553
} |
{-# OPTIONS --safe #-}
module Cubical.Data.Bool.Properties where
open import Cubical.Core.Everything
open import Cubical.Functions.Involution
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Transport
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.Pointed
open import Cubical.Data.Sum
open import Cubical.Data.Bool.Base
open import Cubical.Data.Empty as Empty
open import Cubical.Data.Sigma
open import Cubical.HITs.PropositionalTruncation hiding (rec)
open import Cubical.Relation.Nullary
open import Cubical.Relation.Nullary.DecidableEq
private
variable
ℓ : Level
A : Type ℓ
notnot : ∀ x → not (not x) ≡ x
notnot true = refl
notnot false = refl
notIso : Iso Bool Bool
Iso.fun notIso = not
Iso.inv notIso = not
Iso.rightInv notIso = notnot
Iso.leftInv notIso = notnot
notIsEquiv : isEquiv not
notIsEquiv = involIsEquiv {f = not} notnot
notEquiv : Bool ≃ Bool
notEquiv = involEquiv {f = not} notnot
notEq : Bool ≡ Bool
notEq = involPath {f = not} notnot
private
-- This computes to false as expected
nfalse : Bool
nfalse = transp (λ i → notEq i) i0 true
-- Sanity check
nfalsepath : nfalse ≡ false
nfalsepath = refl
K-Bool
: (P : {b : Bool} → b ≡ b → Type ℓ)
→ (∀{b} → P {b} refl)
→ ∀{b} → (q : b ≡ b) → P q
K-Bool P Pr {false} = J (λ{ false q → P q ; true _ → Lift ⊥ }) Pr
K-Bool P Pr {true} = J (λ{ true q → P q ; false _ → Lift ⊥ }) Pr
isSetBool : isSet Bool
isSetBool a b = J (λ _ p → ∀ q → p ≡ q) (K-Bool (refl ≡_) refl)
true≢false : ¬ true ≡ false
true≢false p = subst (λ b → if b then Bool else ⊥) p true
false≢true : ¬ false ≡ true
false≢true p = subst (λ b → if b then ⊥ else Bool) p true
¬true→false : (x : Bool) → ¬ x ≡ true → x ≡ false
¬true→false false _ = refl
¬true→false true p = Empty.rec (p refl)
¬false→true : (x : Bool) → ¬ x ≡ false → x ≡ true
¬false→true false p = Empty.rec (p refl)
¬false→true true _ = refl
not≢const : ∀ x → ¬ not x ≡ x
not≢const false = true≢false
not≢const true = false≢true
zeroˡ : ∀ x → true or x ≡ true
zeroˡ false = refl
zeroˡ true = refl
zeroʳ : ∀ x → x or true ≡ true
zeroʳ false = refl
zeroʳ true = refl
or-identityˡ : ∀ x → false or x ≡ x
or-identityˡ false = refl
or-identityˡ true = refl
or-identityʳ : ∀ x → x or false ≡ x
or-identityʳ false = refl
or-identityʳ true = refl
or-comm : ∀ x y → x or y ≡ y or x
or-comm false y =
false or y ≡⟨ or-identityˡ y ⟩
y ≡⟨ sym (or-identityʳ y) ⟩
y or false ∎
or-comm true y =
true or y ≡⟨ zeroˡ y ⟩
true ≡⟨ sym (zeroʳ y) ⟩
y or true ∎
or-assoc : ∀ x y z → x or (y or z) ≡ (x or y) or z
or-assoc false y z =
false or (y or z) ≡⟨ or-identityˡ _ ⟩
y or z ≡[ i ]⟨ or-identityˡ y (~ i) or z ⟩
((false or y) or z) ∎
or-assoc true y z =
true or (y or z) ≡⟨ zeroˡ _ ⟩
true ≡⟨ sym (zeroˡ _) ⟩
true or z ≡[ i ]⟨ zeroˡ y (~ i) or z ⟩
(true or y) or z ∎
or-idem : ∀ x → x or x ≡ x
or-idem false = refl
or-idem true = refl
⊕-identityʳ : ∀ x → x ⊕ false ≡ x
⊕-identityʳ false = refl
⊕-identityʳ true = refl
⊕-comm : ∀ x y → x ⊕ y ≡ y ⊕ x
⊕-comm false false = refl
⊕-comm false true = refl
⊕-comm true false = refl
⊕-comm true true = refl
⊕-assoc : ∀ x y z → x ⊕ (y ⊕ z) ≡ (x ⊕ y) ⊕ z
⊕-assoc false y z = refl
⊕-assoc true false z = refl
⊕-assoc true true z = notnot z
not-⊕ˡ : ∀ x y → not (x ⊕ y) ≡ not x ⊕ y
not-⊕ˡ false y = refl
not-⊕ˡ true y = notnot y
⊕-invol : ∀ x y → x ⊕ (x ⊕ y) ≡ y
⊕-invol false x = refl
⊕-invol true x = notnot x
isEquiv-⊕ : ∀ x → isEquiv (x ⊕_)
isEquiv-⊕ x = involIsEquiv (⊕-invol x)
⊕-Path : ∀ x → Bool ≡ Bool
⊕-Path x = involPath {f = x ⊕_} (⊕-invol x)
⊕-Path-refl : ⊕-Path false ≡ refl
⊕-Path-refl = isInjectiveTransport refl
¬transportNot : ∀(P : Bool ≡ Bool) b → ¬ (transport P (not b) ≡ transport P b)
¬transportNot P b eq = not≢const b sub
where
sub : not b ≡ b
sub = subst {A = Bool → Bool} (λ f → f (not b) ≡ f b)
(λ i c → transport⁻Transport P c i) (cong (transport⁻ P) eq)
module BoolReflection where
data Table (A : Type₀) (P : Bool ≡ A) : Type₀ where
inspect : (b c : A)
→ transport P false ≡ b
→ transport P true ≡ c
→ Table A P
table : ∀ P → Table Bool P
table = J Table (inspect false true refl refl)
reflLemma : (P : Bool ≡ Bool)
→ transport P false ≡ false
→ transport P true ≡ true
→ transport P ≡ transport (⊕-Path false)
reflLemma P ff tt i false = ff i
reflLemma P ff tt i true = tt i
notLemma : (P : Bool ≡ Bool)
→ transport P false ≡ true
→ transport P true ≡ false
→ transport P ≡ transport (⊕-Path true)
notLemma P ft tf i false = ft i
notLemma P ft tf i true = tf i
categorize : ∀ P → transport P ≡ transport (⊕-Path (transport P false))
categorize P with table P
categorize P | inspect false true p q
= subst (λ b → transport P ≡ transport (⊕-Path b)) (sym p) (reflLemma P p q)
categorize P | inspect true false p q
= subst (λ b → transport P ≡ transport (⊕-Path b)) (sym p) (notLemma P p q)
categorize P | inspect false false p q
= Empty.rec (¬transportNot P false (q ∙ sym p))
categorize P | inspect true true p q
= Empty.rec (¬transportNot P false (q ∙ sym p))
⊕-complete : ∀ P → P ≡ ⊕-Path (transport P false)
⊕-complete P = isInjectiveTransport (categorize P)
⊕-comp : ∀ p q → ⊕-Path p ∙ ⊕-Path q ≡ ⊕-Path (q ⊕ p)
⊕-comp p q = isInjectiveTransport (λ i x → ⊕-assoc q p x i)
open Iso
reflectIso : Iso Bool (Bool ≡ Bool)
reflectIso .fun = ⊕-Path
reflectIso .inv P = transport P false
reflectIso .leftInv = ⊕-identityʳ
reflectIso .rightInv P = sym (⊕-complete P)
reflectEquiv : Bool ≃ (Bool ≡ Bool)
reflectEquiv = isoToEquiv reflectIso
IsoBool→∙ : ∀ {ℓ} {A : Pointed ℓ} → Iso ((Bool , true) →∙ A) (typ A)
Iso.fun IsoBool→∙ f = fst f false
fst (Iso.inv IsoBool→∙ a) false = a
fst (Iso.inv (IsoBool→∙ {A = A}) a) true = pt A
snd (Iso.inv IsoBool→∙ a) = refl
Iso.rightInv IsoBool→∙ a = refl
Iso.leftInv IsoBool→∙ (f , p) =
ΣPathP ((funExt (λ { false → refl ; true → sym p}))
, λ i j → p (~ i ∨ j))
-- import here to avoid conflicts
open import Cubical.Data.Unit
-- relation to hProp
BoolProp≃BoolProp* : {a : Bool} → Bool→Type a ≃ Bool→Type* {ℓ} a
BoolProp≃BoolProp* {a = true} = Unit≃Unit*
BoolProp≃BoolProp* {a = false} = uninhabEquiv Empty.rec Empty.rec*
Bool→TypeInj : (a b : Bool) → Bool→Type a ≃ Bool→Type b → a ≡ b
Bool→TypeInj true true _ = refl
Bool→TypeInj true false p = Empty.rec (p .fst tt)
Bool→TypeInj false true p = Empty.rec (invEq p tt)
Bool→TypeInj false false _ = refl
Bool→TypeInj* : (a b : Bool) → Bool→Type* {ℓ} a ≃ Bool→Type* {ℓ} b → a ≡ b
Bool→TypeInj* true true _ = refl
Bool→TypeInj* true false p = Empty.rec* (p .fst tt*)
Bool→TypeInj* false true p = Empty.rec* (invEq p tt*)
Bool→TypeInj* false false _ = refl
isPropBool→Type : {a : Bool} → isProp (Bool→Type a)
isPropBool→Type {a = true} = isPropUnit
isPropBool→Type {a = false} = isProp⊥
isPropBool→Type* : {a : Bool} → isProp (Bool→Type* {ℓ} a)
isPropBool→Type* {a = true} = isPropUnit*
isPropBool→Type* {a = false} = isProp⊥*
DecBool→Type : {a : Bool} → Dec (Bool→Type a)
DecBool→Type {a = true} = yes tt
DecBool→Type {a = false} = no (λ x → x)
DecBool→Type* : {a : Bool} → Dec (Bool→Type* {ℓ} a)
DecBool→Type* {a = true} = yes tt*
DecBool→Type* {a = false} = no (λ (lift x) → x)
Dec→DecBool : {P : Type ℓ} → (dec : Dec P) → P → Bool→Type (Dec→Bool dec)
Dec→DecBool (yes p) _ = tt
Dec→DecBool (no ¬p) q = Empty.rec (¬p q)
DecBool→Dec : {P : Type ℓ} → (dec : Dec P) → Bool→Type (Dec→Bool dec) → P
DecBool→Dec (yes p) _ = p
Dec≃DecBool : {P : Type ℓ} → (h : isProp P)(dec : Dec P) → P ≃ Bool→Type (Dec→Bool dec)
Dec≃DecBool h dec = propBiimpl→Equiv h isPropBool→Type (Dec→DecBool dec) (DecBool→Dec dec)
Bool≡BoolDec : {a : Bool} → a ≡ Dec→Bool (DecBool→Type {a = a})
Bool≡BoolDec {a = true} = refl
Bool≡BoolDec {a = false} = refl
Dec→DecBool* : {P : Type ℓ} → (dec : Dec P) → P → Bool→Type* {ℓ} (Dec→Bool dec)
Dec→DecBool* (yes p) _ = tt*
Dec→DecBool* (no ¬p) q = Empty.rec (¬p q)
DecBool→Dec* : {P : Type ℓ} → (dec : Dec P) → Bool→Type* {ℓ} (Dec→Bool dec) → P
DecBool→Dec* (yes p) _ = p
Dec≃DecBool* : {P : Type ℓ} → (h : isProp P)(dec : Dec P) → P ≃ Bool→Type* {ℓ} (Dec→Bool dec)
Dec≃DecBool* h dec = propBiimpl→Equiv h isPropBool→Type* (Dec→DecBool* dec) (DecBool→Dec* dec)
Bool≡BoolDec* : {a : Bool} → a ≡ Dec→Bool (DecBool→Type* {ℓ} {a = a})
Bool≡BoolDec* {a = true} = refl
Bool≡BoolDec* {a = false} = refl
Bool→Type× : (a b : Bool) → Bool→Type (a and b) → Bool→Type a × Bool→Type b
Bool→Type× true true _ = tt , tt
Bool→Type× true false p = Empty.rec p
Bool→Type× false true p = Empty.rec p
Bool→Type× false false p = Empty.rec p
Bool→Type×' : (a b : Bool) → Bool→Type a × Bool→Type b → Bool→Type (a and b)
Bool→Type×' true true _ = tt
Bool→Type×' true false (_ , p) = Empty.rec p
Bool→Type×' false true (p , _) = Empty.rec p
Bool→Type×' false false (p , _) = Empty.rec p
Bool→Type×≃ : (a b : Bool) → Bool→Type a × Bool→Type b ≃ Bool→Type (a and b)
Bool→Type×≃ a b =
propBiimpl→Equiv (isProp× isPropBool→Type isPropBool→Type) isPropBool→Type
(Bool→Type×' a b) (Bool→Type× a b)
Bool→Type⊎ : (a b : Bool) → Bool→Type (a or b) → Bool→Type a ⊎ Bool→Type b
Bool→Type⊎ true true _ = inl tt
Bool→Type⊎ true false _ = inl tt
Bool→Type⊎ false true _ = inr tt
Bool→Type⊎ false false p = Empty.rec p
Bool→Type⊎' : (a b : Bool) → Bool→Type a ⊎ Bool→Type b → Bool→Type (a or b)
Bool→Type⊎' true true _ = tt
Bool→Type⊎' true false _ = tt
Bool→Type⊎' false true _ = tt
Bool→Type⊎' false false (inl p) = Empty.rec p
Bool→Type⊎' false false (inr p) = Empty.rec p
PropBoolP→P : (dec : Dec A) → Bool→Type (Dec→Bool dec) → A
PropBoolP→P (yes p) _ = p
P→PropBoolP : (dec : Dec A) → A → Bool→Type (Dec→Bool dec)
P→PropBoolP (yes p) _ = tt
P→PropBoolP (no ¬p) = ¬p
Bool≡ : Bool → Bool → Bool
Bool≡ true true = true
Bool≡ true false = false
Bool≡ false true = false
Bool≡ false false = true
Bool≡≃ : (a b : Bool) → (a ≡ b) ≃ Bool→Type (Bool≡ a b)
Bool≡≃ true true = isContr→≃Unit (inhProp→isContr refl (isSetBool _ _))
Bool≡≃ true false = uninhabEquiv true≢false Empty.rec
Bool≡≃ false true = uninhabEquiv false≢true Empty.rec
Bool≡≃ false false = isContr→≃Unit (inhProp→isContr refl (isSetBool _ _))
open Iso
-- Bool is equivalent to bi-point type
Iso-⊤⊎⊤-Bool : Iso (Unit ⊎ Unit) Bool
Iso-⊤⊎⊤-Bool .fun (inl tt) = true
Iso-⊤⊎⊤-Bool .fun (inr tt) = false
Iso-⊤⊎⊤-Bool .inv true = inl tt
Iso-⊤⊎⊤-Bool .inv false = inr tt
Iso-⊤⊎⊤-Bool .leftInv (inl tt) = refl
Iso-⊤⊎⊤-Bool .leftInv (inr tt) = refl
Iso-⊤⊎⊤-Bool .rightInv true = refl
Iso-⊤⊎⊤-Bool .rightInv false = refl
| {
"alphanum_fraction": 0.6232244973,
"avg_line_length": 30.5408450704,
"ext": "agda",
"hexsha": "46e47801e5ef6493120bffc2f09dece244a8e59f",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "howsiyu/cubical",
"max_forks_repo_path": "Cubical/Data/Bool/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "howsiyu/cubical",
"max_issues_repo_path": "Cubical/Data/Bool/Properties.agda",
"max_line_length": 94,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "howsiyu/cubical",
"max_stars_repo_path": "Cubical/Data/Bool/Properties.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 4326,
"size": 10842
} |
module Adjoint where
import Category
import Functor
open Category
open Functor using (Functor)
module Adj where
open Functor.Projections using (Map; map)
data _⊢_ {ℂ ⅅ : Cat}(F : Functor ℂ ⅅ)(G : Functor ⅅ ℂ) : Set1 where
adjunction :
(_* : {X : Obj ℂ}{Y : Obj ⅅ} -> Map F X ─→ Y -> X ─→ Map G Y)
(_# : {X : Obj ℂ}{Y : Obj ⅅ} -> X ─→ Map G Y -> Map F X ─→ Y)
(inv₁ : {X : Obj ℂ}{Y : Obj ⅅ}(g : X ─→ Map G Y) -> g # * == g)
(inv₂ : {X : Obj ℂ}{Y : Obj ⅅ}(f : Map F X ─→ Y) -> f * # == f)
(nat₁ : {X₁ X₂ : Obj ℂ}{Y₁ Y₂ : Obj ⅅ}
(f : Y₁ ─→ Y₂)(g : X₂ ─→ X₁)(h : Map F X₁ ─→ Y₁) ->
(f ∘ h ∘ map F g) * == map G f ∘ (h *) ∘ g
)
(nat₂ : {X₁ X₂ : Obj ℂ}{Y₁ Y₂ : Obj ⅅ}
(f : Y₁ ─→ Y₂)(g : X₂ ─→ X₁)(h : X₁ ─→ Map G Y₁) ->
(map G f ∘ h ∘ g) # == f ∘ (h #) ∘ map F g
)
-> F ⊢ G
open Adj public
| {
"alphanum_fraction": 0.4401805869,
"avg_line_length": 27.6875,
"ext": "agda",
"hexsha": "e04b61d135edd98d941c446f2d74ded99f4e0e95",
"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/cat/Adjoint.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/cat/Adjoint.agda",
"max_line_length": 69,
"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/cat/Adjoint.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": 412,
"size": 886
} |
{-
This is mostly for convenience, when working with ideals
(which are defined for general rings) in a commutative ring.
-}
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommRing.Ideal where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Powerset
open import Cubical.Algebra.CommRing.Base
open import Cubical.Algebra.Ring.Ideal renaming (IdealsIn to IdealsInRing)
open import Cubical.Algebra.RingSolver.ReflectionSolving
private
variable
ℓ : Level
IdealsIn : (R : CommRing ℓ) → Type _
IdealsIn R = IdealsInRing (CommRing→Ring R)
module _ (Ring@(R , str) : CommRing ℓ) where
open CommRingStr str
makeIdeal : (I : R → hProp ℓ)
→ (+-closed : {x y : R} → x ∈ I → y ∈ I → (x + y) ∈ I)
→ (0r-closed : 0r ∈ I)
→ (·-closedLeft : {x : R} → (r : R) → x ∈ I → r · x ∈ I)
→ IdealsIn (R , str)
makeIdeal I +-closed 0r-closed ·-closedLeft = I ,
(record
{ +-closed = +-closed
; -closed = λ x∈I → subst (_∈ I) (useSolver _)
(·-closedLeft (- 1r) x∈I)
; 0r-closed = 0r-closed
; ·-closedLeft = ·-closedLeft
; ·-closedRight = λ r x∈I →
subst (_∈ I)
(·-comm r _)
(·-closedLeft r x∈I)
})
where useSolver : (x : R) → - 1r · x ≡ - x
useSolver = solve Ring
| {
"alphanum_fraction": 0.5572413793,
"avg_line_length": 32.9545454545,
"ext": "agda",
"hexsha": "2e932e928d414fc25378f4c75103cc8b80f9907d",
"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": "f2d74ae8e2e176963029a35bd886364480948214",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "kl-i/cubical-0.3",
"max_forks_repo_path": "Cubical/Algebra/CommRing/Ideal.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "f2d74ae8e2e176963029a35bd886364480948214",
"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": "kl-i/cubical-0.3",
"max_issues_repo_path": "Cubical/Algebra/CommRing/Ideal.agda",
"max_line_length": 74,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "f2d74ae8e2e176963029a35bd886364480948214",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "kl-i/cubical-0.3",
"max_stars_repo_path": "Cubical/Algebra/CommRing/Ideal.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 453,
"size": 1450
} |
-- Jesper, 2018-11-29: Instances with explicit arguments will never be
-- used, so declaring them should give a warning.
postulate
X : Set
instance _ : Set → X -- this should give a warning
it : {{_ : X}} → X
it {{x}} = x
-- OTOH, this is fine as the instance can be used inside the module
module _ (A : Set) where
postulate instance instX : X
test : X
test = it
-- Andreas, 2020-01-29, issue #4360:
-- Such warnings should also be given for data and record constructors.
record R (A : Set) : Set where
instance constructor r
field
a : A
data D (A : Set) : Set where
instance c : A → D A
| {
"alphanum_fraction": 0.6601626016,
"avg_line_length": 21.9642857143,
"ext": "agda",
"hexsha": "bd2ad40ac54cc462692cba7aacf129a40ab319ba",
"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": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "shlevy/agda",
"max_forks_repo_path": "test/Succeed/WarningInstanceWithExplicitArg.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/WarningInstanceWithExplicitArg.agda",
"max_line_length": 71,
"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/WarningInstanceWithExplicitArg.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": 189,
"size": 615
} |
{-# OPTIONS --without-K --safe #-}
module Categories.Functor where
open import Level
open import Function renaming (id to id→; _∘_ to _●_) using ()
open import Categories.Category
open import Categories.Functor.Core public
private
variable
o ℓ e o′ ℓ′ e′ o″ ℓ″ e″ : Level
Endofunctor : Category o ℓ e → Set _
Endofunctor C = Functor C C
id : ∀ {C : Category o ℓ e} → Functor C C
id {C = C} = record
{ F₀ = id→
; F₁ = id→
; identity = Category.Equiv.refl C
; homomorphism = Category.Equiv.refl C
; F-resp-≈ = id→
}
infixr 9 _∘F_
-- note that this definition could be shortened by inlining the definitions for
-- identity′ and homomorphism′, but the definitions below are simpler to understand.
_∘F_ : ∀ {C : Category o ℓ e} {D : Category o′ ℓ′ e′} {E : Category o″ ℓ″ e″}
→ Functor D E → Functor C D → Functor C E
_∘F_ {C = C} {D = D} {E = E} F G = record
{ F₀ = F.₀ ● G.₀
; F₁ = F.₁ ● G.₁
; identity = identity′
; homomorphism = homomorphism′
; F-resp-≈ = F.F-resp-≈ ● G.F-resp-≈
}
where
module C = Category C using (id)
module D = Category D using (id)
module E = Category E using (id; module HomReasoning)
module F = Functor F
module G = Functor G
identity′ : ∀ {A} → E [ F.₁ (G.₁ (C.id {A})) ≈ E.id ]
identity′ = begin
F.₁ (G.₁ C.id) ≈⟨ F.F-resp-≈ G.identity ⟩
F.₁ D.id ≈⟨ F.identity ⟩
E.id ∎
where open E.HomReasoning
homomorphism′ : ∀ {X Y Z} {f : C [ X , Y ]} {g : C [ Y , Z ]}
→ E [ F.₁ (G.₁ (C [ g ∘ f ])) ≈ E [ F.₁ (G.₁ g) ∘ F.₁ (G.₁ f) ] ]
homomorphism′ {f = f} {g = g} = begin
F.₁ (G.₁ (C [ g ∘ f ])) ≈⟨ F.F-resp-≈ G.homomorphism ⟩
F.₁ (D [ G.₁ g ∘ G.₁ f ]) ≈⟨ F.homomorphism ⟩
E [ F.₁ (G.₁ g) ∘ F.₁ (G.₁ f) ] ∎
where open E.HomReasoning
| {
"alphanum_fraction": 0.5521978022,
"avg_line_length": 30.3333333333,
"ext": "agda",
"hexsha": "9848b37353792ff07c1033bcbfea5bb728ce5426",
"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/Functor.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/Functor.agda",
"max_line_length": 84,
"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/Functor.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": 724,
"size": 1820
} |
module Type.Properties.Inhabited{ℓ} where
import Lvl
open import Type
-- An inhabited type, which essentially means non-empty (there exists objects with this type), and this object is pointed out/specified/chosen.
-- This means that there exists objects with such an type, and such an object is extractable constructively (like a witness).
-- Also called: Pointed type.
record ◊ (T : Type{ℓ}) : Type{ℓ} where
constructor intro
field
⦃ existence ⦄ : T
open ◊ ⦃ ... ⦄ renaming (existence to [◊]-existence) public
| {
"alphanum_fraction": 0.7281368821,
"avg_line_length": 37.5714285714,
"ext": "agda",
"hexsha": "e4a63e264a33e050d9ee36b73c420bbfa398b5cd",
"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": "Type/Properties/Inhabited.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": "Type/Properties/Inhabited.agda",
"max_line_length": 143,
"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": "Type/Properties/Inhabited.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": 143,
"size": 526
} |
{-
ℚ is a Commutative Ring
-}
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommRing.Instances.QuoQ where
open import Cubical.Foundations.Prelude
open import Cubical.Algebra.CommRing
open import Cubical.HITs.Rationals.QuoQ
renaming (ℚ to ℚType ; _+_ to _+ℚ_; _·_ to _·ℚ_; -_ to -ℚ_)
open CommRingStr
ℚCommRing : CommRing ℓ-zero
ℚCommRing .fst = ℚType
ℚCommRing .snd .0r = 0
ℚCommRing .snd .1r = 1
ℚCommRing .snd ._+_ = _+ℚ_
ℚCommRing .snd ._·_ = _·ℚ_
ℚCommRing .snd .-_ = -ℚ_
ℚCommRing .snd .isCommRing = isCommRingℚ
where
abstract
isCommRingℚ : IsCommRing 0 1 _+ℚ_ _·ℚ_ -ℚ_
isCommRingℚ = makeIsCommRing
isSetℚ +-assoc +-identityʳ
+-inverseʳ +-comm ·-assoc
·-identityʳ (λ x y z → sym (·-distribˡ x y z)) ·-comm
| {
"alphanum_fraction": 0.6866666667,
"avg_line_length": 22.7272727273,
"ext": "agda",
"hexsha": "ac9b1a86ced624aed4d58148384973c137296d31",
"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": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "thomas-lamiaux/cubical",
"max_forks_repo_path": "Cubical/Algebra/CommRing/Instances/QuoQ.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"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": "thomas-lamiaux/cubical",
"max_issues_repo_path": "Cubical/Algebra/CommRing/Instances/QuoQ.agda",
"max_line_length": 61,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "thomas-lamiaux/cubical",
"max_stars_repo_path": "Cubical/Algebra/CommRing/Instances/QuoQ.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 309,
"size": 750
} |
{-# OPTIONS --prop --rewriting #-}
open import Calf.CostMonoid
open import Data.Nat using (ℕ)
module Examples.Sorting.Comparable
(costMonoid : CostMonoid) (fromℕ : ℕ → CostMonoid.ℂ costMonoid) where
open CostMonoid costMonoid using (ℂ)
open import Calf costMonoid
open import Calf.Types.Bool
open import Calf.Types.Bounded costMonoid
open import Relation.Nullary
open import Relation.Binary
open import Relation.Binary.PropositionalEquality as Eq using (_≡_; refl; module ≡-Reasoning)
open import Data.Product using (_×_; _,_; proj₁; proj₂; ∃)
open import Function
record Comparable : Set₁ where
field
A : tp pos
_≤_ : val A → val A → Set
_≤ᵇ_ : val A → val A → cmp (F bool)
≤ᵇ-reflects-≤ : ∀ {x y b} → ◯ ((x ≤ᵇ y) ≡ ret b → Reflects (x ≤ y) b)
≤-refl : Reflexive _≤_
≤-trans : Transitive _≤_
≤-total : Total _≤_
≤-antisym : Antisymmetric _≡_ _≤_
h-cost : (x y : val A) → IsBounded bool (x ≤ᵇ y) (fromℕ 1)
NatComparable : Comparable
NatComparable = record
{ A = nat
; _≤_ = _≤_
; _≤ᵇ_ = λ x y → step (F bool) (fromℕ 1) (ret (x ≤ᵇ y))
; ≤ᵇ-reflects-≤ = reflects
; ≤-refl = ≤-refl
; ≤-trans = ≤-trans
; ≤-total = ≤-total
; ≤-antisym = ≤-antisym
; h-cost = λ _ _ →
bound/relax
(λ u → CostMonoid.≤-reflexive costMonoid (CostMonoid.+-identityʳ costMonoid (fromℕ 1)))
(bound/step (fromℕ 1) (CostMonoid.zero costMonoid) bound/ret)
}
where
open import Calf.Types.Nat
open import Data.Nat
open import Data.Nat.Properties
ret-injective : ∀ {𝕊 v₁ v₂} → ret {U (meta 𝕊)} v₁ ≡ ret {U (meta 𝕊)} v₂ → v₁ ≡ v₂
ret-injective {𝕊} = Eq.cong (λ e → bind {U (meta 𝕊)} (meta 𝕊) e id)
reflects : ∀ {m n b} → ◯ (step (F bool) (fromℕ 1) (ret (m ≤ᵇ n)) ≡ ret {bool} b → Reflects (m ≤ n) b)
reflects {m} {n} {b} u h with ret-injective (Eq.subst (_≡ ret b) (step/ext (F bool) (ret (m ≤ᵇ n)) (fromℕ 1) u) h)
... | refl = ≤ᵇ-reflects-≤ m n
| {
"alphanum_fraction": 0.6179659267,
"avg_line_length": 31.7540983607,
"ext": "agda",
"hexsha": "395aa45da6e443c6d6a7400031f40cf1c078fbd9",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2022-01-29T08:12:01.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-10-06T10:28:24.000Z",
"max_forks_repo_head_hexsha": "e51606f9ca18d8b4cf9a63c2d6caa2efc5516146",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "jonsterling/agda-calf",
"max_forks_repo_path": "src/Examples/Sorting/Comparable.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e51606f9ca18d8b4cf9a63c2d6caa2efc5516146",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Apache-2.0"
],
"max_issues_repo_name": "jonsterling/agda-calf",
"max_issues_repo_path": "src/Examples/Sorting/Comparable.agda",
"max_line_length": 118,
"max_stars_count": 29,
"max_stars_repo_head_hexsha": "e51606f9ca18d8b4cf9a63c2d6caa2efc5516146",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "jonsterling/agda-calf",
"max_stars_repo_path": "src/Examples/Sorting/Comparable.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-22T20:35:11.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-07-14T03:18:28.000Z",
"num_tokens": 770,
"size": 1937
} |
{- Name: Bowornmet (Ben) Hudson and Theodore (Ted) Kim
-- COMP360 Final Project: Group Theory in Agda --
In this project, we define some fundamental ideas of group theory and
prove a few basic theorems about the topic using Agda. For example, we
define what a group is, and give several elementary examples of groups.
We utilize the notion of propositional equality in Agda to prove our
theorems using equation chains.
-}
open import Preliminaries
module finalproject where
-- addition of nats
plusNat : Nat → Nat → Nat
plusNat Z m = m
plusNat (S n) m = S (plusNat n m)
-- integers
data Int : Set where
_-_ : (n : Nat) → (m : Nat) → Int
-- negation
-_ : Int → Int
- (n - m) = m - n
-- addition of ints
plusInt : Int → Int → Int
plusInt (n1 - m1) (n2 - m2) = plusNat n1 n2 - plusNat m1 m2
-- operation
Op : Set → Set
Op el = el → el → el
-- record of Group
{- Definition: a Group is a set G with a binary operation, *, with three properties:
1.) G has an identity element, e ∈ G, such that ∀ x ∈ G, e*x = x = x*e.
2.) ∀ x ∈ G, ∃ x' ∈ G such that x*x' = e = x'*x, where e is the identity element of G.
3.) G is associative. That is, ∀ x y z ∈ G, (x*y)*z = x*(y*z).
-}
record Group : Set1 where
field
el : Set
_*_ : Op el
e : el
inv : el → el
assoc : ∀ x y z → ((x * y) * z) == (x * (y * z))
ident-l : ∀ x → (e * x) == x
ident-r : ∀ x → (x * e) == x
inv-l : ∀ x → ((inv x) * x) == e
inv-r : ∀ x → (x * (inv x)) == e
-- first example, Bools with "multiplication" operation. Comparable to Z mod 2
-- with addition
-- multiplication of bools
multB : Bool → Bool → Bool
multB True True = True
multB True False = False
multB False True = False
multB False False = True
-- associativity of bools
assocB : ∀ (x y z : Bool) → multB (multB x y) z == multB x (multB y z)
assocB True True True = Refl
assocB True True False = Refl
assocB True False True = Refl
assocB True False False = Refl
assocB False True True = Refl
assocB False True False = Refl
assocB False False True = Refl
assocB False False False = Refl
-- proof of identity
multTruel : ∀ (x : Bool) → (multB True x == x)
multTruel True = Refl
multTruel False = Refl
multTruer : ∀ (x : Bool) → (multB x True == x)
multTruer True = Refl
multTruer False = Refl
-- inverses of bools
invB : Bool → Bool
invB True = True
invB False = False
-- proof of inverses with identity
invBMultl : ∀ (x : Bool) → (multB (invB x) x == True)
invBMultl True = Refl
invBMultl False = Refl
invBMultr : ∀ (x : Bool) → (multB x (invB x) == True)
invBMultr True = Refl
invBMultr False = Refl
-- proof that the Booleans are a group on multiplication
Bool*-isgroup : Group
Bool*-isgroup = record {
el = Bool;
_*_ = multB;
e = True;
inv = invB;
assoc = assocB;
ident-l = multTruel;
ident-r = multTruer;
inv-l = invBMultl;
inv-r = invBMultr }
-- second example of a group, ints with the addition operation
-- congruence
congruenceNatInt : ∀ (a b c d : Nat) → a == c → b == d → a - b == c - d
congruenceNatInt .c .d c d Refl Refl = Refl
congruenceNat : ∀ (x y : Nat) → x == y → (S x) == (S y)
congruenceNat .y y Refl = Refl
congruenceNat' : ∀ (n m : Nat) → n == m → S n == S m
congruenceNat' .m m Refl = Refl
-- lemma
addZNat : ∀ (x : Nat) → plusNat x Z == x
addZNat Z = Refl
addZNat (S x) = congruenceNat (plusNat x Z) x (addZNat x)
-- proof of associativity
assocNat+ : (x y z : Nat) → plusNat (plusNat x y) z == plusNat x (plusNat y z)
assocNat+ Z y z = Refl
assocNat+ (S x) y z = congruenceNat (plusNat (plusNat x y) z) (plusNat x (plusNat y z)) (assocNat+ x y z)
assocInt+ : ∀ (a b c : Int) → plusInt (plusInt a b) c == plusInt a (plusInt b c)
assocInt+ (n1 - m1) (n2 - m2) (n3 - m3) = congruenceNatInt (plusNat (plusNat n1 n2) n3)
(plusNat (plusNat m1 m2) m3) (plusNat n1 (plusNat n2 n3))
(plusNat m1 (plusNat m2 m3)) (assocNat+ n1 n2 n3) (assocNat+ m1 m2 m3)
-- proof of identity
addIntZl : ∀ (n : Int) → (plusInt (Z - Z) n == n)
addIntZl (n - m) = Refl
addIntZr : ∀ (n : Int) → (plusInt n (Z - Z) == n)
addIntZr (n - m) = congruenceNatInt (plusNat n 0) (plusNat m 0) n m (addZNat n) (addZNat m)
-- proof of inverses
-- issue with quotient type: impossible to prove that (S n) - (S n) = 0 - 0 without equality constructor
-- had problems in including the equality constructor, only thing we could not work out
invIntl : ∀ (n : Int) → plusInt (- n) n == (Z - Z)
invIntl (n - m) = {!!}
invIntr : ∀ (n : Int) → plusInt n (- n) == (Z - Z)
invIntr (n - m) = {!!}
-- proof that the integers on addition are a group
Int+-isgroup : Group
Int+-isgroup = record {
el = Int;
_*_ = plusInt;
e = Z - Z;
inv = -_;
assoc = assocInt+;
ident-l = addIntZl;
ident-r = addIntZr;
inv-l = invIntl;
inv-r = invIntr }
{- Definition: an group is called abelian if it is commutative.
That is, ∀ x y ∈ G, x*y = y*x. Our record of an abelian group
requires a group and a proof that the group operation
is commutative.
-}
record AbelianGroup (G : Group) : Set where
open Group G
field
comm : ∀ (x y : el) → x * y == y * x
-- proof of commutativity for multiplication on bools
commB : ∀ (x y : Bool) → multB x y == multB y x
commB True True = Refl
commB True False = Refl
commB False True = Refl
commB False False = Refl
Bool*-isAbelian : AbelianGroup Bool*-isgroup
Bool*-isAbelian = record {
comm = commB }
-- some theorems
module Theorems (G : Group) where
open Group G
congruenceOP : {a b c : el} → a == b → a * c == b * c
congruenceOP Refl = Refl
congruenceOP' : {a b c : el} → b == c → a * b == a * c
congruenceOP' Refl = Refl
sym : {a b : el} → a == b → b == a
sym Refl = Refl
-- extremely simple theorem
babytheorem : (a b : el) → ((a * e) * b) == (a * b)
babytheorem a b = congruenceOP (ident-r a)
-- theorem 1: Let G be a group, and let a and b ∈ G. Then (a * b)^-1 = b^-1 * a^-1.
theorem1 : ∀ (a b : el) → inv (a * b) == (inv b * inv a)
theorem1 a b = inv (a * b) =⟨ sym (ident-r (inv (a * b))) ⟩
(inv (a * b) * e) =⟨ sym (congruenceOP' (inv-r a)) ⟩
(inv (a * b) * (a * inv a)) =⟨ congruenceOP' (congruenceOP (sym (ident-r a))) ⟩
(inv (a * b) * ((a * e) * inv a)) =⟨ congruenceOP' (congruenceOP (congruenceOP' (sym (inv-r b)))) ⟩
(inv (a * b) * ((a * (b * inv b)) * inv a)) =⟨ congruenceOP' (congruenceOP (sym (assoc a b (inv b)))) ⟩
(inv (a * b) * (((a * b) * inv b) * inv a)) =⟨ congruenceOP' (assoc (a * b) (inv b) (inv a)) ⟩
(inv (a * b) * ((a * b) * (inv b * inv a))) =⟨ sym (assoc (inv (a * b)) (a * b) (inv b * inv a)) ⟩
((inv (a * b) * (a * b)) * (inv b * inv a)) =⟨ congruenceOP (inv-l (a * b)) ⟩
(e * (inv b * inv a)) =⟨ ident-l (inv b * inv a) ⟩
(inv b * inv a) ∎
-- theorem 2: Let G be a group, and let a, b, and c ∈ G. If a * c = b * c, then a = b.
theorem2 : ∀ (a b c : el) → (a * c) == (b * c) → a == b
theorem2 a b c p = a =⟨ sym (ident-r a) ⟩
a * e =⟨ congruenceOP' (sym (inv-r c)) ⟩
(a * (c * inv c)) =⟨ sym (assoc a c (inv c)) ⟩
(a * c) * inv c =⟨ congruenceOP p ⟩
(b * c) * inv c =⟨ assoc b c (inv c) ⟩
(b * (c * inv c)) =⟨ congruenceOP' (inv-r c) ⟩
(b * e) =⟨ ident-r b ⟩
b ∎
-- theorem 3: Let G be a group, and let g ∈ G. If g * g = g, then g = e.
theorem3 : ∀ (g : el) → (g * g) == g → g == e
theorem3 g p = g =⟨ sym (ident-r g) ⟩
(g * e) =⟨ congruenceOP' (sym (inv-r g)) ⟩
(g * (g * inv g)) =⟨ sym (assoc g g (inv g)) ⟩
(g * g) * inv g =⟨ congruenceOP p ⟩
g * inv g =⟨ inv-r g ⟩
e ∎
-- lemma 1: for all x ∈ G, if x * x = e, x^-1 = x. That is, x is its own inverse.
lemma1 : ∀ (x : el) → (p : x * x == e) → inv x == x
lemma1 x p = (inv x) =⟨ sym (ident-r (inv x)) ⟩
(inv x * e) =⟨ congruenceOP' (sym p) ⟩
inv x * (x * x) =⟨ sym (assoc (inv x) x x) ⟩
(inv x * x) * x =⟨ congruenceOP (inv-l x) ⟩
(e * x) =⟨ ident-l x ⟩
x ∎
-- theorem 4: let G be a group. If ∀ x ∈ G, x * x = e, then G is abelian.
theorem4 : (p : ∀ x → (x * x) == e) → AbelianGroup G
theorem4 p = record {
comm = λ a b → a * b =⟨ congruenceOP (sym (ident-r a)) ⟩
(a * e) * b =⟨ congruenceOP (congruenceOP' (sym (inv-r a))) ⟩
(a * (a * inv a)) * b =⟨ congruenceOP (sym (assoc a a (inv a))) ⟩
((a * a) * inv a) * b =⟨ congruenceOP (congruenceOP (p a)) ⟩
(e * inv a) * b =⟨ congruenceOP (ident-l (inv a)) ⟩
inv a * b =⟨ congruenceOP' (sym (ident-r b)) ⟩
inv a * (b * e) =⟨ congruenceOP' (congruenceOP' (sym (inv-r b))) ⟩
inv a * (b * (b * inv b)) =⟨ congruenceOP' (sym (assoc b b (inv b))) ⟩
inv a * ((b * b) * inv b) =⟨ congruenceOP' (congruenceOP (p b)) ⟩
inv a * (e * inv b) =⟨ congruenceOP' (ident-l (inv b)) ⟩
(inv a * inv b) =⟨ sym (theorem1 b a) ⟩
(inv (b * a)) =⟨ lemma1 (b * a) (p (b * a)) ⟩
(b * a) ∎ }
-- theorem 5: Let G be a group, and a, b, and c ∈ G. If (a * b) * c = e, then (b * c) * a = e as well.
theorem5 : ∀ (a b c : el) → ((a * b) * c) == e → ((b * c) * a) == e
theorem5 a b c p = ((b * c) * a) =⟨ sym (ident-l ((b * c) * a)) ⟩
e * ((b * c) * a) =⟨ congruenceOP (sym (inv-l a)) ⟩
(inv a * a) * ((b * c) * a) =⟨ assoc (inv a) a ((b * c) * a) ⟩
inv a * (a * ((b * c) * a)) =⟨ sym (congruenceOP' (assoc a (b * c) a)) ⟩
inv a * ((a * (b * c)) * a) =⟨ congruenceOP' (congruenceOP (sym (assoc a b c))) ⟩
inv a * (((a * b) * c) * a) =⟨ congruenceOP' (congruenceOP p) ⟩
inv a * (e * a) =⟨ congruenceOP' (ident-l a) ⟩
(inv a * a) =⟨ inv-l a ⟩
e ∎
{- Definition: a homomorphism is a function f from a group (G , *) to another group (H , ∘)
such that (∀ a,b ∈ G), f(a*b) = f(a)∘f(b). Our definition of a homomorphism also includes a
proof that homomorphisms preserve identity elements between groups. That is, f(e_G) = e_H,
where e_G and e_H are the identity elements in G and H, respectively.
-}
-- record of homomorphisms
record Homomorphism (G : Group) (H : Group) : Set where
open Group renaming (_*_ to *)
field
f : el G → el H
preserve-id : f (e G) == e H
preserve-op : ∀ (a b : el G) → (f (* G a b)) == * H (f a) (f b)
-- third example of a group, Z mod 2 under addition.
-- Z mod 2
data Zmod2 : Set where
Zero : Zmod2
One : Zmod2
-- addition mod 2
plusmod2 : Zmod2 → Zmod2 → Zmod2
plusmod2 Zero Zero = Zero
plusmod2 Zero One = One
plusmod2 One Zero = One
plusmod2 One One = Zero
-- identity of Z mod 2
idenZmod2-l : (x : Zmod2) → plusmod2 Zero x == x
idenZmod2-l Zero = Refl
idenZmod2-l One = Refl
idenZmod2-r : (x : Zmod2) → plusmod2 x Zero == x
idenZmod2-r Zero = Refl
idenZmod2-r One = Refl
-- inverses of Z mod 2 (the inverse of anything in Z mod 2 is itself)
invZmod2 : Zmod2 → Zmod2
invZmod2 x = x
-- left and right inverses of Z mod 2
invZmod2-lr : (x : Zmod2) → plusmod2 x x == Zero
invZmod2-lr Zero = Refl
invZmod2-lr One = Refl
-- associativity of addition in Z mod 2
assocZmod2 : (x y z : Zmod2) → plusmod2 (plusmod2 x y) z == plusmod2 x (plusmod2 y z)
assocZmod2 Zero Zero Zero = Refl
assocZmod2 Zero Zero One = Refl
assocZmod2 Zero One Zero = Refl
assocZmod2 Zero One One = Refl
assocZmod2 One Zero Zero = Refl
assocZmod2 One Zero One = Refl
assocZmod2 One One Zero = Refl
assocZmod2 One One One = Refl
-- commutativity of addition in Z mod 2
commZmod2 : (x y : Zmod2) → plusmod2 x y == plusmod2 y x
commZmod2 Zero Zero = Refl
commZmod2 Zero One = Refl
commZmod2 One Zero = Refl
commZmod2 One One = Refl
-- Zmod2 is a group on addition.
Zmod2+-isgroup : Group
Zmod2+-isgroup = record {
el = Zmod2;
_*_ = plusmod2;
e = Zero;
inv = invZmod2;
assoc = assocZmod2;
ident-l = idenZmod2-l;
ident-r = idenZmod2-r;
inv-l = λ x → invZmod2-lr x;
inv-r = λ x → invZmod2-lr x }
-- proof that Z mod 2 on addition is an abelian group.
Zmod2+-isAbelian : AbelianGroup (Zmod2+-isgroup)
Zmod2+-isAbelian = record {
comm = commZmod2 }
-- example of a homomorphism: mapBool-to-Zmod2 is a homomorphism from Bools on multiplication to Zmod2 with addition.
-- map from Bools to the elements of Zmod2.
mapBool-to-Zmod2 : Bool → Zmod2
mapBool-to-Zmod2 True = Zero
mapBool-to-Zmod2 False = One
-- proof that the map from Bools to Zmod2 preserves composition.
mapBool-to-Zmod2-preserve-op : (a b : Bool) → mapBool-to-Zmod2 (multB a b) == plusmod2 (mapBool-to-Zmod2 a) (mapBool-to-Zmod2 b)
mapBool-to-Zmod2-preserve-op True True = Refl
mapBool-to-Zmod2-preserve-op True False = Refl
mapBool-to-Zmod2-preserve-op False True = Refl
mapBool-to-Zmod2-preserve-op False False = Refl
homomorphism-example : Homomorphism (Bool*-isgroup) (Zmod2+-isgroup)
homomorphism-example = record {
f = mapBool-to-Zmod2;
preserve-id = Refl;
preserve-op = mapBool-to-Zmod2-preserve-op }
-- record of isomorphisms.
{- Definition: a homomorphism between two groups is called an isomorphism
if it is bijective (both one-to-one and onto). The isomorphism record
requires a homomorphism along with proofs that it is both one-to-one
(injective) and onto (surjective).
-}
record Isomorphism (G : Group) (H : Group) : Set where
open Group
open Homomorphism
field
homomorphism : Homomorphism G H
injective : ∀ (a b : el G) → f homomorphism a == f homomorphism b → a == b
surjective : ∀ (b : el H) → Σ (λ g → f homomorphism g == b)
-- example of an isomorphism
-- proof that this map from Bools to Zmod2 is injective (that is, ∀ a b : Bool, f(a) = f(b) implies a = b).
mapB-Zmod2-inj : (a b : Bool) → mapBool-to-Zmod2 a == mapBool-to-Zmod2 b → a == b
mapB-Zmod2-inj True True p = Refl
mapB-Zmod2-inj True False ()
mapB-Zmod2-inj False True ()
mapB-Zmod2-inj False False p = Refl
-- proof that this map from Bools to Zmod2 is surjective (that is, ∀ b : Zmod2, ∃ a ∈ Bool such that f(a) = b).
mapB-Zmod2-sur : (n : Zmod2) → Σ (λ bool → mapBool-to-Zmod2 bool == n)
mapB-Zmod2-sur Zero = True , Refl
mapB-Zmod2-sur One = False , Refl
-- the homomorphism between Bools on multiplication to Zmod2 with addition is isomorphic
isomorphism-example : Isomorphism Bool*-isgroup Zmod2+-isgroup
isomorphism-example = record {
homomorphism = homomorphism-example;
injective = mapB-Zmod2-inj;
surjective = mapB-Zmod2-sur }
| {
"alphanum_fraction": 0.4983571931,
"avg_line_length": 41.6723716381,
"ext": "agda",
"hexsha": "54b184bb6cc1ee372f89b936a8698a69d67072f4",
"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": "2404a6ef2688f879bda89860bb22f77664ad813e",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "benhuds/Agda",
"max_forks_repo_path": "ug/finalproject.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "2404a6ef2688f879bda89860bb22f77664ad813e",
"max_issues_repo_issues_event_max_datetime": "2020-05-12T00:32:45.000Z",
"max_issues_repo_issues_event_min_datetime": "2020-03-23T08:39:04.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "benhuds/Agda",
"max_issues_repo_path": "ug/finalproject.agda",
"max_line_length": 133,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "2404a6ef2688f879bda89860bb22f77664ad813e",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "benhuds/Agda",
"max_stars_repo_path": "ug/finalproject.agda",
"max_stars_repo_stars_event_max_datetime": "2019-08-08T12:27:18.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-04-26T20:22:22.000Z",
"num_tokens": 5672,
"size": 17044
} |
module PiQ.Eval where
open import Data.Empty
open import Data.Unit hiding (_≟_)
open import Data.Sum
open import Data.Product
open import Data.Maybe
open import Data.Nat hiding (_≟_)
open import Data.List as L hiding (_∷_)
open import Relation.Binary.Core
open import Relation.Binary
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
open import Function using (_∘_)
open import PiQ.Syntax
open import PiQ.Opsem
open import PiQ.AuxLemmas
open import PiQ.NoRepeat
open import PiQ.Invariants
infix 100 _⃗
infix 100 _⃖
-- Stuck states must be either of the form ⟨ c ∣ v ∣ ☐ ⟩◁), ［ c ∣ v ∣ ☐ ］▷ or ⊠
Stuck : ∀ {st} → is-stuck st
→ (Σ[ A ∈ 𝕌 ] Σ[ B ∈ 𝕌 ] Σ[ c ∈ A ↔ B ] Σ[ v ∈ ⟦ A ⟧ ] st ≡ ⟨ c ∣ v ∣ ☐ ⟩◁)
⊎ (Σ[ A ∈ 𝕌 ] Σ[ B ∈ 𝕌 ] Σ[ c ∈ A ↔ B ] Σ[ v ∈ ⟦ B ⟧ ] st ≡ ［ c ∣ v ∣ ☐ ］▷)
⊎ st ≡ ⊠
Stuck {⟨ unite₊l ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁))
Stuck {⟨ uniti₊l ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁))
Stuck {⟨ swap₊ ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁))
Stuck {⟨ assocl₊ ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁))
Stuck {⟨ assocr₊ ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁))
Stuck {⟨ unite⋆l ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁))
Stuck {⟨ uniti⋆l ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁))
Stuck {⟨ swap⋆ ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁))
Stuck {⟨ assocl⋆ ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁))
Stuck {⟨ assocr⋆ ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁))
Stuck {⟨ dist ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁))
Stuck {⟨ factor ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁))
Stuck {⟨ id↔ ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₂))
Stuck {⟨ c₁ ⨾ c₂ ∣ v ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₃))
Stuck {⟨ c₁ ⊕ c₂ ∣ inj₁ x ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₄))
Stuck {⟨ c₁ ⊕ c₂ ∣ inj₂ y ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₅))
Stuck {⟨ c₁ ⊗ c₂ ∣ (x , y) ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗₆))
Stuck {⟨ ε₊ ∣ inj₁ x ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦ε₊₁))
Stuck {⟨ ε₊ ∣ inj₂ (- x) ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦ε₊₂))
Stuck {⟨ ηₓ _ ∣ tt ∣ κ ⟩▷} stuck = ⊥-elim (stuck (_ , ↦⃗ηₓ))
Stuck {⟨ εₓ v ∣ (v' , ↻) ∣ κ ⟩▷} stuck with v ≟ v'
... | yes p = ⊥-elim (stuck (_ , ↦⃗εₓ₁ {eq = p}))
... | no p = ⊥-elim (stuck (_ , ↦⃗εₓ₂ {neq = p}))
Stuck {［ c ∣ v ∣ ☐ ］▷} stuck = inj₂ (inj₁ (_ , _ , c , v , refl))
Stuck {［ c₁ ∣ v ∣ ☐⨾ c₂ • κ ］▷} stuck = ⊥-elim (stuck (_ , ↦⃗₇))
Stuck {［ c ∣ v ∣ c₁ ⨾☐• κ ］▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁₀))
Stuck {［ c ∣ v ∣ ☐⊕ c₂ • κ ］▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁₁))
Stuck {［ c ∣ v ∣ c₁ ⊕☐• κ ］▷} stuck = ⊥-elim (stuck (_ , ↦⃗₁₂))
Stuck {［ c ∣ v ∣ ☐⊗[ c₂ , x ]• κ ］▷} stuck = ⊥-elim (stuck (_ , ↦⃗₈))
Stuck {［ c ∣ v ∣ [ c₁ , x ]⊗☐• κ ］▷} stuck = ⊥-elim (stuck (_ , ↦⃗₉))
Stuck {⟨ c ∣ v ∣ ☐ ⟩◁} stuck = inj₁ (_ , _ , c , v , refl)
Stuck {⟨ c₁ ∣ v ∣ ☐⨾ c₂ • κ ⟩◁} stuck = ⊥-elim (stuck (_ , ↦⃖₃))
Stuck {⟨ c₂ ∣ v ∣ c₁ ⨾☐• κ ⟩◁} stuck = ⊥-elim (stuck (_ , ↦⃖₇))
Stuck {⟨ c₁ ∣ v ∣ ☐⊕ c₂ • κ ⟩◁} stuck = ⊥-elim (stuck (_ , ↦⃖₄))
Stuck {⟨ c₂ ∣ v ∣ c₁ ⊕☐• κ ⟩◁} stuck = ⊥-elim (stuck (_ , ↦⃖₅))
Stuck {⟨ c₁ ∣ x ∣ ☐⊗[ c₂ , y ]• κ ⟩◁} stuck = ⊥-elim (stuck (_ , ↦⃖₆))
Stuck {⟨ c₂ ∣ y ∣ [ c₁ , x ]⊗☐• κ ⟩◁} stuck = ⊥-elim (stuck (_ , ↦⃖₈))
Stuck {［ unite₊l ∣ v ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ inj₂ v ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ uniti₊l ∣ inj₂ y ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ y ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ swap₊ ∣ inj₁ x ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ inj₂ x ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ swap₊ ∣ inj₂ y ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ inj₁ y ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ assocl₊ ∣ inj₁ (inj₁ x) ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ inj₁ x ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ assocl₊ ∣ inj₁ (inj₂ y) ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ inj₂ (inj₁ y) ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ assocl₊ ∣ inj₂ y ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ inj₂ (inj₂ y) ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ assocr₊ ∣ inj₁ x ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ inj₁ (inj₁ x) ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ assocr₊ ∣ inj₂ (inj₁ x) ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ inj₁ (inj₂ x) ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ assocr₊ ∣ inj₂ (inj₂ y) ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ (inj₂ y) ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ unite⋆l ∣ v ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ (tt , v) ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ uniti⋆l ∣ (tt , v) ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ v ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ swap⋆ ∣ (x , y) ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ (y , x) ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ assocl⋆ ∣ (x , y) , z ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ x , (y , z) ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ assocr⋆ ∣ x , (y , z) ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ (x , y) , z ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ dist ∣ inj₁ (x , z) ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ inj₁ x , z ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ dist ∣ inj₂ (y , z) ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ inj₂ y , z ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ factor ∣ inj₁ x , z ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ inj₁ (x , z) ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ factor ∣ inj₂ y , z ∣ κ ］◁} stuck = ⊥-elim (stuck (⟨ _ ∣ inj₂ (y , z) ∣ _ ⟩◁ , ↦⃖₁))
Stuck {［ id↔ ∣ v ∣ κ ］◁} stuck = ⊥-elim (stuck (_ , ↦⃖₂))
Stuck {［ c₁ ⨾ c₂ ∣ v ∣ κ ］◁} stuck = ⊥-elim (stuck (_ , ↦⃖₁₀))
Stuck {［ c₁ ⊕ c₂ ∣ inj₁ x ∣ κ ］◁} stuck = ⊥-elim (stuck (_ , ↦⃖₁₁))
Stuck {［ c₁ ⊕ c₂ ∣ inj₂ y ∣ κ ］◁} stuck = ⊥-elim (stuck (_ , ↦⃖₁₂))
Stuck {［ c₁ ⊗ c₂ ∣ (x , y) ∣ κ ］◁} stuck = ⊥-elim (stuck (_ , ↦⃖₉))
Stuck {［ η₊ ∣ inj₁ x ∣ κ ］◁} stuck = ⊥-elim (stuck (_ , ↦η₊₁))
Stuck {［ η₊ ∣ inj₂ (- x) ∣ κ ］◁} stuck = ⊥-elim (stuck (_ , ↦η₊₂))
Stuck {［ ηₓ v ∣ (v' , ↻) ∣ κ ］◁} stuck with v ≟ v'
... | yes p = ⊥-elim (stuck (_ , ↦⃖ηₓ₁ {eq = p}))
... | no p = ⊥-elim (stuck (_ , ↦⃖ηₓ₂ {neq = p}))
Stuck {［ εₓ _ ∣ tt ∣ κ ］◁} stuck = ⊥-elim (stuck (_ , ↦⃖εₓ))
Stuck {⊠} stuck = inj₂ (inj₂ refl)
-- Find next step of given the state
step : (st : State) → ∃[ st' ] (st ↦ st') ⊎ is-stuck st
step ⟨ unite₊l ∣ v ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₁)
step ⟨ uniti₊l ∣ v ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₁)
step ⟨ swap₊ ∣ v ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₁)
step ⟨ assocl₊ ∣ v ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₁)
step ⟨ assocr₊ ∣ v ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₁)
step ⟨ unite⋆l ∣ v ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₁)
step ⟨ uniti⋆l ∣ v ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₁)
step ⟨ swap⋆ ∣ v ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₁)
step ⟨ assocl⋆ ∣ v ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₁)
step ⟨ assocr⋆ ∣ v ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₁)
step ⟨ dist ∣ v ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₁)
step ⟨ factor ∣ v ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₁)
step ⟨ id↔ ∣ v ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₂)
step ⟨ c₁ ⨾ c₂ ∣ v ∣ κ ⟩▷ = inj₁ (⟨ c₁ ∣ v ∣ ☐⨾ c₂ • κ ⟩▷ , ↦⃗₃)
step ⟨ c₁ ⊕ c₂ ∣ inj₁ x ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₄)
step ⟨ c₁ ⊕ c₂ ∣ inj₂ y ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₅)
step ⟨ c₁ ⊗ c₂ ∣ (x , y) ∣ κ ⟩▷ = inj₁ (_ , ↦⃗₆)
step ⟨ ε₊ ∣ inj₁ x ∣ κ ⟩▷ = inj₁ (_ , ↦ε₊₁)
step ⟨ ε₊ ∣ inj₂ (- x) ∣ κ ⟩▷ = inj₁ (_ , ↦ε₊₂)
step ⟨ ηₓ _ ∣ tt ∣ κ ⟩▷ = inj₁ (_ , ↦⃗ηₓ)
step ⟨ εₓ v ∣ v' , ↻ ∣ κ ⟩▷ with v ≟ v'
... | yes p = inj₁ (_ , (↦⃗εₓ₁ {eq = p}))
... | no p = inj₁ (_ , (↦⃗εₓ₂ {neq = p}))
step ［ c ∣ v ∣ ☐ ］▷ = inj₂ (λ ())
step ［ c₁ ∣ v ∣ ☐⨾ c₂ • κ ］▷ = inj₁ (_ , ↦⃗₇)
step ［ c₂ ∣ v ∣ c₁ ⨾☐• κ ］▷ = inj₁ (_ , ↦⃗₁₀)
step ［ c₁ ∣ v ∣ ☐⊕ c₂ • κ ］▷ = inj₁ (_ , ↦⃗₁₁)
step ［ c₂ ∣ v ∣ c₁ ⊕☐• κ ］▷ = inj₁ (_ , ↦⃗₁₂)
step ［ c₁ ∣ v ∣ ☐⊗[ c₂ , x ]• κ ］▷ = inj₁ (_ , ↦⃗₈)
step ［ c₂ ∣ v ∣ [ c₁ , x ]⊗☐• κ ］▷ = inj₁ (_ , ↦⃗₉)
step ⟨ c ∣ v ∣ ☐ ⟩◁ = inj₂ (λ ())
step ⟨ c₁ ∣ v ∣ ☐⨾ c₂ • κ ⟩◁ = inj₁ (_ , ↦⃖₃)
step ⟨ c₂ ∣ v ∣ c₁ ⨾☐• κ ⟩◁ = inj₁ (_ , ↦⃖₇)
step ⟨ c₁ ∣ v ∣ ☐⊕ c₂ • κ ⟩◁ = inj₁ (_ , ↦⃖₄)
step ⟨ c₂ ∣ v ∣ c₁ ⊕☐• κ ⟩◁ = inj₁ (_ , ↦⃖₅)
step ⟨ c₁ ∣ v ∣ ☐⊗[ c₂ , x ]• κ ⟩◁ = inj₁ (_ , ↦⃖₆)
step ⟨ c₂ ∣ v ∣ [ c₁ , x ]⊗☐• κ ⟩◁ = inj₁ (_ , ↦⃖₈)
step ［ unite₊l ∣ v ∣ κ ］◁ = inj₁ (⟨ _ ∣ inj₂ v ∣ _ ⟩◁ , ↦⃖₁)
step ［ uniti₊l ∣ inj₂ v ∣ κ ］◁ = inj₁ (⟨ _ ∣ v ∣ _ ⟩◁ , ↦⃖₁)
step ［ swap₊ ∣ inj₁ x ∣ κ ］◁ = inj₁ (⟨ _ ∣ inj₂ x ∣ _ ⟩◁ , ↦⃖₁)
step ［ swap₊ ∣ inj₂ y ∣ κ ］◁ = inj₁ (⟨ _ ∣ inj₁ y ∣ _ ⟩◁ , ↦⃖₁)
step ［ assocl₊ ∣ inj₁ (inj₁ x) ∣ κ ］◁ = inj₁ (⟨ _ ∣ inj₁ x ∣ _ ⟩◁ , ↦⃖₁)
step ［ assocl₊ ∣ inj₁ (inj₂ y) ∣ κ ］◁ = inj₁ (⟨ _ ∣ inj₂ (inj₁ y) ∣ _ ⟩◁ , ↦⃖₁)
step ［ assocl₊ ∣ inj₂ z ∣ κ ］◁ = inj₁ (⟨ _ ∣ inj₂ (inj₂ z) ∣ _ ⟩◁ , ↦⃖₁)
step ［ assocr₊ ∣ inj₁ x ∣ κ ］◁ = inj₁ (⟨ _ ∣ inj₁ (inj₁ x) ∣ _ ⟩◁ , ↦⃖₁)
step ［ assocr₊ ∣ inj₂ (inj₁ y) ∣ κ ］◁ = inj₁ (⟨ _ ∣ inj₁ (inj₂ y) ∣ _ ⟩◁ , ↦⃖₁)
step ［ assocr₊ ∣ inj₂ (inj₂ z) ∣ κ ］◁ = inj₁ (⟨ _ ∣ inj₂ z ∣ _ ⟩◁ , ↦⃖₁)
step ［ unite⋆l ∣ v ∣ κ ］◁ = inj₁ (⟨ _ ∣ tt , v ∣ _ ⟩◁ , ↦⃖₁)
step ［ uniti⋆l ∣ (tt , v) ∣ κ ］◁ = inj₁ (⟨ _ ∣ v ∣ _ ⟩◁ , ↦⃖₁)
step ［ swap⋆ ∣ (x , y) ∣ κ ］◁ = inj₁ (⟨ _ ∣ (y , x) ∣ _ ⟩◁ , ↦⃖₁)
step ［ assocl⋆ ∣ (x , y) , z ∣ κ ］◁ = inj₁ (⟨ _ ∣ x , (y , z) ∣ _ ⟩◁ , ↦⃖₁)
step ［ assocr⋆ ∣ x , (y , z) ∣ κ ］◁ = inj₁ (⟨ _ ∣ (x , y) , z ∣ _ ⟩◁ , ↦⃖₁)
step ［ dist ∣ inj₁ (x , z) ∣ κ ］◁ = inj₁ (⟨ _ ∣ inj₁ x , z ∣ _ ⟩◁ , ↦⃖₁)
step ［ dist ∣ inj₂ (y , z) ∣ κ ］◁ = inj₁ (⟨ _ ∣ inj₂ y , z ∣ _ ⟩◁ , ↦⃖₁)
step ［ factor ∣ inj₁ x , z ∣ κ ］◁ = inj₁ (⟨ _ ∣ inj₁ (x , z) ∣ _ ⟩◁ , ↦⃖₁)
step ［ factor ∣ inj₂ y , z ∣ κ ］◁ = inj₁ (⟨ _ ∣ inj₂ (y , z) ∣ _ ⟩◁ , ↦⃖₁)
step ［ id↔ ∣ v ∣ κ ］◁ = inj₁ (_ , ↦⃖₂)
step ［ c₁ ⨾ c₂ ∣ v ∣ κ ］◁ = inj₁ (_ , ↦⃖₁₀)
step ［ c₁ ⊕ c₂ ∣ inj₁ x ∣ κ ］◁ = inj₁ (_ , ↦⃖₁₁)
step ［ c₁ ⊕ c₂ ∣ inj₂ y ∣ κ ］◁ = inj₁ (_ , ↦⃖₁₂)
step ［ c₁ ⊗ c₂ ∣ (x , y) ∣ κ ］◁ = inj₁ (_ , ↦⃖₉)
step ［ η₊ ∣ inj₁ x ∣ κ ］◁ = inj₁ (_ , ↦η₊₁)
step ［ η₊ ∣ inj₂ (- x) ∣ κ ］◁ = inj₁ (_ , ↦η₊₂)
step ［ ηₓ v ∣ (v' , ↻) ∣ κ ］◁ with v ≟ v'
... | yes p = inj₁ (_ , (↦⃖ηₓ₁ {eq = p}))
... | no p = inj₁ (_ , (↦⃖ηₓ₂ {neq = p}))
step ［ εₓ _ ∣ tt ∣ κ ］◁ = inj₁ (_ , ↦⃖εₓ)
step ⊠ = inj₂ (λ ())
-- Values tagged with direction
data Val (A B : 𝕌) : Set where
_⃗ : ⟦ A ⟧ → Val A B
_⃖ : ⟦ B ⟧ → Val A B
-- Termination is guaranteed by PiQ.NoRepeat and the finiteness of states
{-# TERMINATING #-}
run : (st₀ : State) → (init : is-initial st₀)
→ let (A , B , c) = getℂ st₀ (st-is-initial⇒st≢⊠ st₀ init)
in (Σ[ v ∈ ⟦ A ⟧ ] st₀ ↦* ⟨ c ∣ v ∣ ☐ ⟩◁)
⊎ (Σ[ v ∈ ⟦ B ⟧ ] st₀ ↦* ［ c ∣ v ∣ ☐ ］▷)
⊎ st₀ ↦* ⊠
run st₀ init = run' st₀ ◾
where
run' : (st : State) → st₀ ↦* st → let (A , B , c) = getℂ st₀ (st-is-initial⇒st≢⊠ st₀ init)
in (Σ[ v ∈ ⟦ A ⟧ ] st₀ ↦* ⟨ c ∣ v ∣ ☐ ⟩◁)
⊎ (Σ[ v ∈ ⟦ B ⟧ ] st₀ ↦* ［ c ∣ v ∣ ☐ ］▷)
⊎ st₀ ↦* ⊠
run' st rs with step st
... | inj₁ (st' , r) = run' st' (rs ++↦ (r ∷ ◾))
... | inj₂ stuck with Stuck stuck
... | inj₁ (A , B , c , v , refl) with ℂInvariant* rs (st-is-initial⇒st≢⊠ st₀ init) (λ ())
... | refl = inj₁ (v , rs)
run' st rs | inj₂ stuck | inj₂ (inj₁ (A , B , c , v , refl)) with ℂInvariant* rs (st-is-initial⇒st≢⊠ st₀ init) (λ ())
... | refl = inj₂ (inj₁ (v , rs))
run' st rs | inj₂ stuck | inj₂ (inj₂ refl) = inj₂ (inj₂ rs)
-- Forward evaluator of PiQ
eval : ∀ {A B} → (A ↔ B) → Val A B → Maybe (Val B A)
eval c (v ⃗) = [ just ∘ _⃖ ∘ proj₁ , [ just ∘ _⃗ ∘ proj₁ , (λ _ → nothing) ]′ ]′ (run ⟨ c ∣ v ∣ ☐ ⟩▷ (λ ()))
eval c (v ⃖) = [ just ∘ _⃖ ∘ proj₁ , [ just ∘ _⃗ ∘ proj₁ , (λ _ → nothing) ]′ ]′ (run ［ c ∣ v ∣ ☐ ］◁ (λ ()))
-- Backward evaluator of PiQ
evalᵣₑᵥ : ∀ {A B} → (A ↔ B) → Val B A → Maybe (Val A B)
evalᵣₑᵥ c (v ⃖) = [ just ∘ _⃗ ∘ proj₁ , [ just ∘ _⃖ ∘ proj₁ , (λ _ → nothing) ]′ ]′ (run ⟨ c ∣ v ∣ ☐ ⟩▷ (λ ()))
evalᵣₑᵥ c (v ⃗) = [ just ∘ _⃗ ∘ proj₁ , [ just ∘ _⃖ ∘ proj₁ , (λ _ → nothing) ]′ ]′ (run ［ c ∣ v ∣ ☐ ］◁ (λ ()))
-- Evaluator which generate execution traces
convert↦ : ∀ {st st'} → st ↦* st' → List State
convert↦ (◾ {st}) = st L.∷ []
convert↦ (_∷_ {st} r rs) = st L.∷ convert↦ rs
evalₜᵣ : ∀ {A B} → (A ↔ B) → ⟦ A ⟧ → List State
evalₜᵣ c v with (run ⟨ c ∣ v ∣ ☐ ⟩▷ (λ ()))
... | inj₁ (_ , rs) = convert↦ rs
... | inj₂ (inj₁ (_ , rs)) = convert↦ rs
... | inj₂ (inj₂ rs) = convert↦ rs
-- Faster evaluator which does not carry the reduction trace.
-- Returns the result and the number of steps it takes
{-# TERMINATING #-}
eval' : ∀ {A B} → (A ↔ B) → ⟦ A ⟧ → Maybe (Σ[ t ∈ 𝕌 ] ⟦ t ⟧) × ℕ
eval' c v = run' ⟨ c ∣ v ∣ ☐ ⟩▷ 0
where
getV : State → Maybe (Σ[ t ∈ 𝕌 ] ⟦ t ⟧)
getV ⟨ _ ∣ v ∣ _ ⟩▷ = just (_ , v)
getV ［ _ ∣ v ∣ _ ］▷ = just (_ , v)
getV ⟨ _ ∣ v ∣ _ ⟩◁ = just (_ , v)
getV ［ _ ∣ v ∣ _ ］◁ = just (_ , v)
getV ⊠ = nothing
run' : State → ℕ → Maybe (Σ[ t ∈ 𝕌 ] ⟦ t ⟧) × ℕ
run' st n with step st
... | inj₁ (st' , _) = run' st' (suc n)
... | inj₂ stuck = getV st , n
| {
"alphanum_fraction": 0.4107463152,
"avg_line_length": 55.0343347639,
"ext": "agda",
"hexsha": "d6d031ff60137e2b3af1a2932b04f79abee8c486",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-04T06:54:45.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-04T06:54:45.000Z",
"max_forks_repo_head_hexsha": "fb380f2e67dcb4a94f353dbaec91624fcb5b8933",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "DreamLinuxer/popl21-artifact",
"max_forks_repo_path": "PiQ/Eval.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "fb380f2e67dcb4a94f353dbaec91624fcb5b8933",
"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": "DreamLinuxer/popl21-artifact",
"max_issues_repo_path": "PiQ/Eval.agda",
"max_line_length": 121,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "fb380f2e67dcb4a94f353dbaec91624fcb5b8933",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "DreamLinuxer/popl21-artifact",
"max_stars_repo_path": "PiQ/Eval.agda",
"max_stars_repo_stars_event_max_datetime": "2020-10-10T21:41:32.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-10-07T12:07:53.000Z",
"num_tokens": 7354,
"size": 12823
} |
import Lvl
open import Structure.Operator.Vector
open import Structure.Setoid
open import Type
module Structure.Operator.Vector.LinearCombination.Proofs
{ℓᵥ ℓₛ ℓᵥₑ ℓₛₑ}
{V : Type{ℓᵥ}} ⦃ equiv-V : Equiv{ℓᵥₑ}(V) ⦄
{S : Type{ℓₛ}} ⦃ equiv-S : Equiv{ℓₛₑ}(S) ⦄
{_+ᵥ_ : V → V → V}
{_⋅ₛᵥ_ : S → V → V}
{_+ₛ_ _⋅ₛ_ : S → S → S}
⦃ vectorSpace : VectorSpace(_+ᵥ_)(_⋅ₛᵥ_)(_+ₛ_)(_⋅ₛ_) ⦄
where
open VectorSpace(vectorSpace)
import Lvl
open import Function.Equals
open import Logic.Predicate
open import Numeral.CoordinateVector as Vec using () renaming (Vector to Vec)
open import Numeral.Finite
open import Numeral.Natural
open import Structure.Function.Multi
import Structure.Function.Names as Names
open import Structure.Operator.Proofs.Util
open import Structure.Operator.Properties
open import Structure.Operator
open import Structure.Operator.Vector.LinearCombination ⦃ vectorSpace = vectorSpace ⦄
open import Structure.Operator.Vector.Proofs
open import Structure.Relator.Properties
open import Syntax.Function
open import Syntax.Number
open import Syntax.Transitivity
open import Type
private variable ℓ ℓ₁ ℓ₂ ℓₗ : Lvl.Level
private variable n n₁ n₂ : ℕ
private variable i j k : 𝕟(n)
private variable vf vf₁ vf₂ : Vec(n)(V)
private variable sf sf₁ sf₂ : Vec(n)(S)
instance
linearCombination-binaryOperator : BinaryOperator(linearCombination{n})
linearCombination-binaryOperator = intro p where
p : Names.Congruence₂(linearCombination{n})
p {𝟎} {vf₁} {vf₂} (intro vfeq) {sf₁} {sf₂} (intro sfeq) = reflexivity(_≡_)
p {𝐒(𝟎)} {vf₁} {vf₂} (intro vfeq) {sf₁} {sf₂} (intro sfeq) = congruence₂(_⋅ₛᵥ_) sfeq vfeq
p {𝐒(𝐒(n))} {vf₁} {vf₂} (intro vfeq) {sf₁} {sf₂} (intro sfeq) =
(sf₁(𝟎) ⋅ₛᵥ vf₁(𝟎)) +ᵥ linearCombination(Vec.tail vf₁) (Vec.tail sf₁) 🝖[ _≡_ ]-[ congruence₂(_+ᵥ_) (congruence₂(_⋅ₛᵥ_) sfeq vfeq) (p {𝐒(n)} (intro vfeq) (intro sfeq)) ]
(sf₂(𝟎) ⋅ₛᵥ vf₂(𝟎)) +ᵥ linearCombination(Vec.tail vf₂) (Vec.tail sf₂) 🝖-end
instance
linearCombination-scalar-preserves-[+] : Preserving₂(linearCombination vf) (Vec.map₂(_+ₛ_)) (_+ᵥ_)
linearCombination-scalar-preserves-[+] {vf = vf} = intro(p{vf = vf}) where
p : ∀{n}{vf : Vec(n)(V)} → Names.Preserving₂(linearCombination vf) (Vec.map₂(_+ₛ_)) (_+ᵥ_)
p {𝟎}{vf} {sf₁} {sf₂} =
𝟎ᵥ 🝖[ _≡_ ]-[ identityₗ(_+ᵥ_)(𝟎ᵥ) ]-sym
𝟎ᵥ +ᵥ 𝟎ᵥ 🝖-end
p {𝐒(𝟎)}{vf} {sf₁} {sf₂} =
(Vec.map₂(_+ₛ_) sf₁ sf₂ 𝟎) ⋅ₛᵥ vf(𝟎) 🝖[ _≡_ ]-[]
(sf₁(𝟎) +ₛ sf₂(𝟎)) ⋅ₛᵥ vf(𝟎) 🝖[ _≡_ ]-[ [⋅ₛᵥ][+ₛ][+ᵥ]-distributivityᵣ ]
(sf₁(𝟎) ⋅ₛᵥ vf(𝟎)) +ᵥ (sf₂(𝟎) ⋅ₛᵥ vf(𝟎)) 🝖-end
p {𝐒(𝐒(n))}{vf} {sf₁} {sf₂} =
((Vec.map₂(_+ₛ_) sf₁ sf₂ 𝟎) ⋅ₛᵥ vf(𝟎)) +ᵥ (linearCombination {𝐒(n)} (Vec.tail vf) (Vec.tail(Vec.map₂(_+ₛ_) sf₁ sf₂))) 🝖[ _≡_ ]-[]
((sf₁(𝟎) +ₛ sf₂(𝟎)) ⋅ₛᵥ vf(𝟎)) +ᵥ (linearCombination {𝐒(n)} (Vec.tail vf) (Vec.tail(Vec.map₂(_+ₛ_) sf₁ sf₂))) 🝖[ _≡_ ]-[ congruence₂(_+ᵥ_) [⋅ₛᵥ][+ₛ][+ᵥ]-distributivityᵣ (p {𝐒(n)}{Vec.tail vf} {Vec.tail sf₁} {Vec.tail sf₂}) ]
((sf₁(𝟎) ⋅ₛᵥ vf(𝟎)) +ᵥ (sf₂(𝟎) ⋅ₛᵥ vf(𝟎))) +ᵥ ((linearCombination {𝐒(n)} (Vec.tail vf) (Vec.tail sf₁)) +ᵥ (linearCombination {𝐒(n)} (Vec.tail vf) (Vec.tail sf₂))) 🝖[ _≡_ ]-[ One.associate-commute4 (commutativity(_+ᵥ_)) ]
(((sf₁(𝟎) ⋅ₛᵥ vf(𝟎)) +ᵥ (linearCombination {𝐒(n)} (Vec.tail vf) (Vec.tail sf₁))) +ᵥ ((sf₂(𝟎) ⋅ₛᵥ vf(𝟎)) +ᵥ (linearCombination {𝐒(n)} (Vec.tail vf) (Vec.tail sf₂)))) 🝖-end
instance
linearCombination-scalar-preserves-[⋅] : ∀{s} → Preserving₁(linearCombination vf) (Vec.map(s ⋅ₛ_)) (s ⋅ₛᵥ_)
linearCombination-scalar-preserves-[⋅] {vf = vf} {s = s} = intro(p{vf = vf}) where
p : ∀{n}{vf : Vec(n)(V)} → Names.Preserving₁(linearCombination vf) (Vec.map(s ⋅ₛ_)) (s ⋅ₛᵥ_)
p {𝟎} {vf} {sf} =
𝟎ᵥ 🝖[ _≡_ ]-[ [⋅ₛᵥ]-absorberᵣ ]-sym
s ⋅ₛᵥ 𝟎ᵥ 🝖-end
p {𝐒(𝟎)} {vf} {sf} =
(s ⋅ₛ sf(𝟎)) ⋅ₛᵥ vf(𝟎) 🝖[ _≡_ ]-[ [⋅ₛ][⋅ₛᵥ]-compatibility ]
s ⋅ₛᵥ (sf(𝟎) ⋅ₛᵥ vf(𝟎)) 🝖-end
p {𝐒(𝐒(n))} {vf} {sf} =
linearCombination vf (Vec.map (s ⋅ₛ_) sf) 🝖[ _≡_ ]-[]
((s ⋅ₛ sf(𝟎)) ⋅ₛᵥ vf(𝟎)) +ᵥ (linearCombination (Vec.tail vf) (Vec.map (s ⋅ₛ_) (Vec.tail sf))) 🝖[ _≡_ ]-[ congruence₂(_+ᵥ_) ⦃ [+ᵥ]-binary-operator ⦄ [⋅ₛ][⋅ₛᵥ]-compatibility (p {𝐒(n)} {Vec.tail vf} {Vec.tail sf}) ]
(s ⋅ₛᵥ (sf(𝟎) ⋅ₛᵥ vf(𝟎))) +ᵥ (s ⋅ₛᵥ (linearCombination (Vec.tail vf) (Vec.tail sf))) 🝖[ _≡_ ]-[ distributivityₗ(_⋅ₛᵥ_)(_+ᵥ_) ]-sym
s ⋅ₛᵥ ((sf(𝟎) ⋅ₛᵥ vf(𝟎)) +ᵥ (linearCombination (Vec.tail vf) (Vec.tail sf))) 🝖[ _≡_ ]-[]
s ⋅ₛᵥ (linearCombination vf sf) 🝖-end
-- linearCombination-of-unit : linearCombination vf (Vec.fill 𝟏ₛ) ≡ (foldᵣ(_+_) 𝟎ᵥ vf)
postulate linearCombination-of-indexProject : (linearCombination vf (Vec.indexProject i 𝟏ₛ 𝟎ₛ) ≡ vf(i))
| {
"alphanum_fraction": 0.591828479,
"avg_line_length": 55.5505617978,
"ext": "agda",
"hexsha": "2316d1a470eeedbd50933749858b01472d803920",
"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/Vector/LinearCombination/Proofs.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/Vector/LinearCombination/Proofs.agda",
"max_line_length": 285,
"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/Vector/LinearCombination/Proofs.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": 2386,
"size": 4944
} |
{-# OPTIONS --without-K #-}
module hott.equivalence.properties where
open import sum
open import equality.core
open import equality.calculus
open import function.core
open import function.isomorphism
open import function.extensionality
open import hott.equivalence.core
open import hott.equivalence.alternative
open import hott.univalence
open import hott.level
sym≈ : ∀ {i j}{X : Set i}{Y : Set j}
→ X ≈ Y → Y ≈ X
sym≈ = ≅'⇒≈ ∘ sym≅' ∘ ≈⇒≅'
-- being a weak equivalence is propositional
we-h1 : ∀ {i j}{X : Set i}{Y : Set j}
→ (f : X → Y)
→ h 1 (weak-equiv f)
we-h1 f = Π-level λ _ → contr-h1 _
apply≈-inj : ∀ {i j}{X : Set i}{Y : Set j}
→ injective (apply≈ {X = X}{Y = Y})
apply≈-inj {x = (f , w)}{.f , w'} refl =
unapΣ (refl , h1⇒prop (we-h1 f) w w')
abstract
univ-sym≈ : ∀ {i}{X Y : Set i}
→ (w : X ≈ Y)
→ sym (≈⇒≡ w)
≡ ≈⇒≡ (sym≈ w)
univ-sym≈ {i}{X}{Y} w = inverse-unique p q lem-inv
where
p : X ≡ Y
p = ≈⇒≡ w
q : Y ≡ X
q = ≈⇒≡ (sym≈ w)
p-β : coerce p ≡ apply≈ w
p-β = uni-coherence w
q-β : coerce q ≡ invert≈ w
q-β = uni-coherence (sym≈ w)
lem : coerce (p · q) ≡ coerce refl
lem = coerce-hom p q
· (ap (λ h → coerce q ∘ h) p-β
· ap (λ h → h ∘ apply≈ w) q-β
· funext (_≅_.iso₁ (≈⇒≅ w)))
lem-inv : p · q ≡ refl
lem-inv = iso⇒inj uni-iso (apply≈-inj lem)
| {
"alphanum_fraction": 0.5239085239,
"avg_line_length": 24.8793103448,
"ext": "agda",
"hexsha": "34fe70707e94df1032e8c55c7d467ac21d3fc0f8",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2019-02-26T06:17:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-04-11T17:19:12.000Z",
"max_forks_repo_head_hexsha": "beebe176981953ab48f37de5eb74557cfc5402f4",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "HoTT/M-types",
"max_forks_repo_path": "hott/equivalence/properties.agda",
"max_issues_count": 4,
"max_issues_repo_head_hexsha": "bbbc3bfb2f80ad08c8e608cccfa14b83ea3d258c",
"max_issues_repo_issues_event_max_datetime": "2016-10-26T11:57:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-02-02T14:32:16.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "pcapriotti/agda-base",
"max_issues_repo_path": "src/hott/equivalence/properties.agda",
"max_line_length": 52,
"max_stars_count": 27,
"max_stars_repo_head_hexsha": "beebe176981953ab48f37de5eb74557cfc5402f4",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "HoTT/M-types",
"max_stars_repo_path": "hott/equivalence/properties.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-09T07:26:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-04-14T15:47:03.000Z",
"num_tokens": 574,
"size": 1443
} |
module FFI.Data.HaskellInt where
open import Agda.Builtin.Int using (Int)
{-# FOREIGN GHC import qualified Data.Int #-}
postulate HaskellInt : Set
{-# COMPILE GHC HaskellInt = type Data.Int.Int #-}
postulate
intToHaskellInt : Int → HaskellInt
haskellIntToInt : HaskellInt → Int
{-# COMPILE GHC intToHaskellInt = fromIntegral #-}
{-# COMPILE GHC haskellIntToInt = fromIntegral #-}
| {
"alphanum_fraction": 0.7396907216,
"avg_line_length": 25.8666666667,
"ext": "agda",
"hexsha": "9ab0868e26bdf8f8fd1d8dce6021539d79603225",
"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": "362428f8b4b6f5c9d43f4daf55bcf7873f536c3f",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "XanderYZZ/luau",
"max_forks_repo_path": "prototyping/FFI/Data/HaskellInt.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "362428f8b4b6f5c9d43f4daf55bcf7873f536c3f",
"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": "XanderYZZ/luau",
"max_issues_repo_path": "prototyping/FFI/Data/HaskellInt.agda",
"max_line_length": 50,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "72d8d443431875607fd457a13fe36ea62804d327",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "TheGreatSageEqualToHeaven/luau",
"max_stars_repo_path": "prototyping/FFI/Data/HaskellInt.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-11T21:30:17.000Z",
"max_stars_repo_stars_event_min_datetime": "2022-02-11T21:30:17.000Z",
"num_tokens": 100,
"size": 388
} |
{-# OPTIONS -v tc.unquote:30 #-}
open import Common.Prelude
open import Common.Reflection
data Box : Bool → Set where
box : (b : Bool) → Box b
works : (b : Bool) → Box b → Bool
works b (box .b) = unquote (give (var 0 []))
works₂ : (b : Bool) → Box b → Bool
unquoteDef works₂ = defineFun works₂ (clause
( arg (argInfo visible relevant) (var "b")
∷ arg (argInfo visible relevant) (con (quote box)
(arg (argInfo visible relevant) dot ∷ []))
∷ [])
(var 0 []) ∷ [])
works₃ : (b : Bool) → Box b → (x y : Bool) → Bool
unquoteDef works₃ = defineFun works₃ (clause
( arg (argInfo visible relevant) (var "b")
∷ arg (argInfo visible relevant) (con (quote box)
(arg (argInfo visible relevant) dot ∷ []))
∷ arg (argInfo visible relevant) (var "x")
∷ arg (argInfo visible relevant) (var "y")
∷ [])
(var 2 []) ∷ [])
| {
"alphanum_fraction": 0.6073546856,
"avg_line_length": 30.1071428571,
"ext": "agda",
"hexsha": "d67ca040fd0abbfa59d94f248063911122862569",
"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/Issue1344.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/Issue1344.agda",
"max_line_length": 51,
"max_stars_count": 3,
"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/Issue1344.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": 280,
"size": 843
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- The Maybe type
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Maybe where
open import Data.Unit using (⊤)
open import Data.Empty using (⊥)
open import Data.Bool.Base using (T)
open import Data.Maybe.Relation.Unary.All
open import Data.Maybe.Relation.Unary.Any
------------------------------------------------------------------------
-- The base type and some operations
open import Data.Maybe.Base public
------------------------------------------------------------------------
-- Using Any and All to define Is-just and Is-nothing
Is-just : ∀ {a} {A : Set a} → Maybe A → Set a
Is-just = Any (λ _ → ⊤)
Is-nothing : ∀ {a} {A : Set a} → Maybe A → Set a
Is-nothing = All (λ _ → ⊥)
to-witness : ∀ {p} {P : Set p} {m : Maybe P} → Is-just m → P
to-witness (just {x = p} _) = p
to-witness-T : ∀ {p} {P : Set p} (m : Maybe P) → T (is-just m) → P
to-witness-T (just p) _ = p
to-witness-T nothing ()
| {
"alphanum_fraction": 0.4616805171,
"avg_line_length": 29.2702702703,
"ext": "agda",
"hexsha": "7df273af8073330a3dd14329a8589bc6918d1749",
"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/Maybe.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/Maybe.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/Maybe.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 273,
"size": 1083
} |
module OldBasicILP.Syntax.Projection where
open import Common.UntypedContext public
import OldBasicILP.UntypedSyntax.ClosedHilbertSequential as CHS
import OldBasicILP.UntypedSyntax.ClosedHilbert as CH
-- Projection of types and derivations to a form parametrised by a closed, untyped representation of syntax.
module ClosedHilbertSequential where
open import OldBasicILP.Syntax.ClosedHilbertSequential
mutual
⌊_⌋ᵀ : Ty → CHS.Ty
⌊ α P ⌋ᵀ = CHS.α P
⌊ A ▻ B ⌋ᵀ = ⌊ A ⌋ᵀ CHS.▻ ⌊ B ⌋ᵀ
⌊ p ⦂ A ⌋ᵀ = ⌊ p ⌋ᴾ CHS.⦂ ⌊ A ⌋ᵀ
⌊ A ∧ B ⌋ᵀ = ⌊ A ⌋ᵀ CHS.∧ ⌊ B ⌋ᵀ
⌊ ⊤ ⌋ᵀ = CHS.⊤
-- FIXME: WHat is going on here?
postulate
⌊_⌋ᴾ : ∀ {Ξ A} → Proof Ξ A → CHS.Proof
⌊_⌋ᵀ⋆ : Cx Ty → Cx CHS.Ty
⌊ ∅ ⌋ᵀ⋆ = ∅
⌊ Γ , A ⌋ᵀ⋆ = ⌊ Γ ⌋ᵀ⋆ , ⌊ A ⌋ᵀ
⌊_⌋∈ : ∀ {Ξ A} → A ∈ Ξ → ⌊ A ⌋ᵀ ∈ ⌊ Ξ ⌋ᵀ⋆
⌊ top ⌋∈ = top
⌊ pop i ⌋∈ = pop ⌊ i ⌋∈
⌊_⌋ᴰ : ∀ {Ξ} → ⊢ᴰ Ξ → CHS.⊢ᴰ ⌊ Ξ ⌋ᵀ⋆
⌊ nil ⌋ᴰ = CHS.nil
⌊ mp i j d ⌋ᴰ = CHS.mp ⌊ i ⌋∈ ⌊ j ⌋∈ ⌊ d ⌋ᴰ
⌊ ci d ⌋ᴰ = CHS.ci ⌊ d ⌋ᴰ
⌊ ck d ⌋ᴰ = CHS.ck ⌊ d ⌋ᴰ
⌊ cs d ⌋ᴰ = CHS.cs ⌊ d ⌋ᴰ
⌊ nec `d d ⌋ᴰ = {!CHS.nec ⌊ `d ⌋ᴰ ⌊ d ⌋ᴰ!}
⌊ cdist d ⌋ᴰ = {!CHS.cdist ⌊ d ⌋ᴰ!}
⌊ cup d ⌋ᴰ = {!CHS.cup ⌊ d ⌋ᴰ!}
⌊ cdown d ⌋ᴰ = CHS.cdown ⌊ d ⌋ᴰ
⌊ cpair d ⌋ᴰ = CHS.cpair ⌊ d ⌋ᴰ
⌊ cfst d ⌋ᴰ = CHS.cfst ⌊ d ⌋ᴰ
⌊ csnd d ⌋ᴰ = CHS.csnd ⌊ d ⌋ᴰ
⌊ unit d ⌋ᴰ = CHS.unit ⌊ d ⌋ᴰ
⌊_⌋ : ∀ {A} → ⊢ A → CHS.⊢ ⌊ A ⌋ᵀ
⌊ Ξ , d ⌋ = ⌊ Ξ ⌋ᵀ⋆ , ⌊ d ⌋ᴰ
-- Projection of types and derivations to a form parametrised by a closed, untyped representation of syntax.
module ClosedHilbert where
open import OldBasicILP.Syntax.ClosedHilbert
mutual
⌊_⌋ᵀ : Ty → CH.Ty
⌊ α P ⌋ᵀ = CH.α P
⌊ A ▻ B ⌋ᵀ = ⌊ A ⌋ᵀ CH.▻ ⌊ B ⌋ᵀ
⌊ p ⦂ A ⌋ᵀ = ⌊ p ⌋ᴾ CH.⦂ ⌊ A ⌋ᵀ
⌊ A ∧ B ⌋ᵀ = ⌊ A ⌋ᵀ CH.∧ ⌊ B ⌋ᵀ
⌊ ⊤ ⌋ᵀ = CH.⊤
⌊_⌋ᴾ : ∀ {A} → Proof A → CH.Proof
⌊ [ d ] ⌋ᴾ = CH.[ CH.ᴿ⌊ ⌊ d ⌋ ⌋ ]
⌊_⌋ : ∀ {A} → ⊢ A → CH.⊢ ⌊ A ⌋ᵀ
⌊ app d₁ d₂ ⌋ = CH.app ⌊ d₁ ⌋ ⌊ d₂ ⌋
⌊ ci ⌋ = CH.ci
⌊ ck ⌋ = CH.ck
⌊ cs ⌋ = CH.cs
⌊ box d ⌋ = CH.box ⌊ d ⌋
⌊ cdist ⌋ = CH.cdist
⌊ cup ⌋ = CH.cup
⌊ cdown ⌋ = CH.cdown
⌊ cpair ⌋ = CH.cpair
⌊ cfst ⌋ = CH.cfst
⌊ csnd ⌋ = CH.csnd
⌊ unit ⌋ = CH.unit
| {
"alphanum_fraction": 0.4589455488,
"avg_line_length": 28.2195121951,
"ext": "agda",
"hexsha": "ae9a7ae9501ded3f173265cd21cbb1aecc8a49a2",
"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": "OldBasicILP/Syntax/Projection.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": "OldBasicILP/Syntax/Projection.agda",
"max_line_length": 108,
"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": "OldBasicILP/Syntax/Projection.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": 1537,
"size": 2314
} |
-- Andreas, 2016-07-19 revisiting issue #418
module Issue418private where
open import Common.Equality
abstract
A : Set₁
A = Set
private
works : A ≡ A
works = refl
test : A ≡ _
test = refl
-- Since test is private, abstract definitions are transparent in its type.
-- The meta should be solved (by A or Set).
| {
"alphanum_fraction": 0.6706231454,
"avg_line_length": 16.0476190476,
"ext": "agda",
"hexsha": "1acfcf0137a9cd61f7ff9dcadcd0a354818b0141",
"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/Issue418private.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/Issue418private.agda",
"max_line_length": 75,
"max_stars_count": 3,
"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/Issue418private.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": 95,
"size": 337
} |
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.NType2
open import lib.PathFunctor
open import lib.PathGroupoid
open import lib.types.Bool
open import lib.types.IteratedSuspension
open import lib.types.LoopSpace
open import lib.types.Nat
open import lib.types.Paths
open import lib.types.Pi
open import lib.types.Pointed
open import lib.types.Sigma
open import lib.types.Suspension
open import lib.types.TLevel
open import lib.types.Unit
open import nicolai.pseudotruncations.Preliminary-definitions
open import nicolai.pseudotruncations.Liblemmas
open import nicolai.pseudotruncations.SeqColim
open import nicolai.pseudotruncations.wconstSequence
module nicolai.pseudotruncations.PseudoTruncs-wconst-seq where
open import nicolai.pseudotruncations.pointed-O-Sphere
open import nicolai.pseudotruncations.LoopsAndSpheres
open import nicolai.pseudotruncations.PseudoTruncs
{- The special sequence that we consider -}
module PtruncsSeq {i} (X : Type i) where
A : ℕ → Type i
A O = X
A (S n) = Pseudo n -1-trunc (A n)
f : (n : ℕ) → A n → A (S n)
f n x = point n -1 x
C : Sequence {i}
C = (A , f)
{- A main result: If we have an inhabitant of X, then the sequence is weakly constant.
This is Lemma 6.2 ! -}
module PtruncSeqWC {i} (X : Type i) (x₀ : X) where
open PtruncsSeq {i} X
fs : (n : ℕ) → A n
fs O = x₀
fs (S n) = f n (fs n)
P : (n : ℕ) → (x : A n) → Type i
P n x = f n x == fs (S n)
{- This is the easy 'Case j ≡ -2' -}
f₀-x₀ : (y : X) → P O y
f₀-x₀ y = (spoke O -1 r (lift false)) ∙ ! (spoke O -1 r (lift true)) where
r : Sphere {i} O → X
r (lift true) = x₀
r (lift false) = y
{- Now, the general case is done by induction on n
(note that this variable is called 'j' in the paper).
Hence, what is 'j' in the paper is now 'S n'.
Unfortunately, we have to do everything in one "big"
step with many "where" clauses due to the mutual dependencies. -}
fₙ-x₀ : (n : ℕ) → (y : A n) → P n y
fₙ-x₀ O y = f₀-x₀ y
fₙ-x₀ (S n) = Pseudotrunc-ind n Point Hub Spoke where
-- just for convenience - saves brackets
norₙ' : Sphere' {i} n
norₙ' = nor' n
fⁿx₀ = fs n
Point : (w : A n) → P (S n) (point n -1 w)
Point w = ap (point (S n) -1) (fₙ-x₀ n w)
Hub : (r : Sphere' n → A n) → point S n -1 _ == _
Hub r = ap (point (S n) -1) (! (spoke n -1 r norₙ') ∙ fₙ-x₀ n (r norₙ'))
{- The definition of [Spoke] is the hard part.
First, we do the easy things that we have to do... -}
Spoke : (r : _) → (x : Sphere' n) → _
Spoke r = λ x → from-transp (P (S n))
(spoke n -1 r x)
(
transport (P (S n)) (spoke n -1 r x) (Point (r x))
=⟨ trans-ap₁ (f (S n)) (fs (S (S n))) (spoke n -1 r x) (Point (r x)) ⟩
! (ap (point (S n) -1) (spoke n -1 r x)) ∙ Point (r x)
=⟨ ! (ap (point (S n) -1) (spoke n -1 r x)) ∙ₗ ! (∙-unit-r (Point (r x))) ⟩
! (ap (point (S n) -1) (spoke n -1 r x)) ∙ Point (r x) ∙ idp
{- Now comes the hard step which requires A LOT of work in the where clause
below: we can compose with something which, for a complicated reason, is idp! -}
=⟨ ! (ap (point (S n) -1) (spoke n -1 r x)) ∙ₗ (Point (r x) ∙ₗ ! (k-const x)) ⟩
! (ap (point (S n) -1) (spoke n -1 r x)) ∙ Point (r x) ∙ k x
{- From here, it's easy; we just have to re-associate paths and cancel inverses.
This could be done with standard library lemmas, but it's easier to just use
an 'ad-hoc' lemma. -}
=⟨ multi-cancelling (ap (point S n -1) (spoke n -1 r x)) (Point (r x)) (Hub r) ⟩
Hub r
∎
)
where
{- Now, the actual work follows! -}
{- First, we define the interesting loop.
In the paper, it is called [kₓ].
Here, it is just [k x]. -}
k : (x : Sphere' {i} n)
→ Ω (Pseudo S n -1-trunc (A (S n)) ,
f (S n) (f n fⁿx₀))
k x = ! (Point (r x)) ∙ ap (point (S n) -1) (spoke n -1 r x) ∙ (Hub r)
{- We want to show that [k] factors as [ap pₙ ∘ h].
First, we define h. -}
h : Sphere' {i} n
→ Ω (Pseudo n -1-trunc (A n) ,
f n fⁿx₀)
h x = ! (fₙ-x₀ n (r x))
∙ (spoke n -1 r x)
∙ (! (spoke n -1 r norₙ') ∙ fₙ-x₀ n (r norₙ'))
{- The statement that k == ap pₙ ∘ h: -}
k-p-h : k == ap (point S n -1) ∘ h
k-p-h = λ= (λ (x : Sphere' {i} n)
→ k x
=⟨ idp ⟩
! (Point (r x))
∙ (ap (point (S n) -1) (spoke n -1 r x) ∙ (Hub r))
=⟨ !-ap (point S n -1) (fₙ-x₀ n (r x))
∙ᵣ ( ap (point S n -1) (spoke n -1 r x)
∙ Hub r) ⟩
ap (point (S n) -1) (! (fₙ-x₀ n (r x)))
∙ ap (point (S n) -1) (spoke n -1 r x)
∙ (Hub r)
=⟨ ! (ap (point (S n) -1) (! (fₙ-x₀ n (r x)))
∙ₗ ap-∙ point S n -1
(spoke n -1 r x)
_ ) ⟩
ap (point (S n) -1) (! (fₙ-x₀ n (r x)))
∙ ap (point (S n) -1)
( spoke n -1 r x
∙ (! (spoke n -1 r norₙ')
∙ fₙ-x₀ n (r norₙ')))
=⟨ ! (ap-∙ point S n -1 (! (fₙ-x₀ n (r x))) _) ⟩
ap (point S n -1) (h x)
∎)
{- [h] can be made into a a pointed map, written [ĥ] -}
ĥ : (⊙Sphere' {i} n)
→̇ ⊙Ω (A (S n) ,
f n fⁿx₀)
ĥ = h ,
(! (fₙ-x₀ n (r _))
∙ (spoke n -1 r _)
∙ ! (spoke n -1 r norₙ')
∙ fₙ-x₀ n (r norₙ')
=⟨ (! (fₙ-x₀ n (r _)))
∙ₗ (! (∙-assoc (spoke n -1 r _)
(! (spoke n -1 r norₙ'))
(fₙ-x₀ n (r norₙ')))) ⟩
! (fₙ-x₀ n (r _))
∙ ((spoke n -1 r _) ∙ (! (spoke n -1 r norₙ')))
∙ fₙ-x₀ n (r norₙ')
=⟨ ! (fₙ-x₀ n (r _))
∙ₗ !-inv-r (spoke n -1 r _)
∙ᵣ fₙ-x₀ n (r norₙ') ⟩
! (fₙ-x₀ n (r _))
∙ idp
∙ fₙ-x₀ n (r norₙ')
=⟨ !-inv-l (fₙ-x₀ n (r _)) ⟩
idp
∎ )
{- A pointed version of the first constructor. -}
pointsₙ : (A (S n) , f n fⁿx₀) →̇ A (S (S n)) , f (S n) (f n fⁿx₀)
pointsₙ = point S n -1 , idp
open null
open hom-adjoint
points-Φ⁻¹-null : isNull∙ (pointsₙ ⊙∘ Φ⁻¹ _ _ ĥ)
points-Φ⁻¹-null = <– (isNull-equiv (pointsₙ ⊙∘ Φ⁻¹ _ _ ĥ))
-- translate from isNull∙'
(null-lequiv (pointsₙ ⊙∘ Φ⁻¹ _ _ ĥ)
-- translate from isNulld; this,
-- we have done already!
(cmp-nll'.from-sphere-null'∙ n (Φ⁻¹ _ _ ĥ)))
ap-points-ĥ-null : isNull∙ (⊙ap (point S n -1 , idp) ⊙∘ ĥ)
ap-points-ĥ-null = –> (combine-isnull-nat' ĥ (point S n -1 , idp)) points-Φ⁻¹-null
{- ... consequently, h is always refl [in the library "idp"]: -}
points-h-const : (x : Sphere' n) → ap (point S n -1) (h x) == idp
points-h-const x = null-lequiv-easy _ ap-points-ĥ-null x
{- ... and so is k: -}
k-const : (x : Sphere' n) → k x == idp
k-const x = app= k-p-h x ∙ points-h-const x
{- Main result: each function in the sequence is propositional! -}
wconst-f : wconst-chain C
wconst-f n w₁ w₂ = fₙ-x₀ n w₁ ∙ ! (fₙ-x₀ n w₂)
{- Another important result:
if we want to show a proposition, we can assume A₀ instead of Aω
But this should follow from the general induction principle, so... TODO
-}
module PtruncSeqResult' {i} (X : Type i) where
open PtruncsSeq {i} X -- this defines the chain C of pseudo-truncations
SC = SeqCo C
reduction-lemma : (P : Type i) → (is-prop P) → (A O → P) → (SC → P)
reduction-lemma P ip ff = SeqCo-rec {C = C} {B = P} Ins Glue where
Ins : (n : ℕ) → A n → P
Ins O = ff
Ins (S n) = Pseudotrunc-rec {P = P} n Point-1 Hub-1 Spoke-1 where
Point-1 : _ → P
Point-1 x = Ins n x
Hub-1 : (Sphere' n → A n) → P
Hub-1 r = Ins n (r (nor' n))
Spoke-1 : (r : Sphere' n → A n) (x : Sphere' n) → Point-1 (r x) == Hub-1 r
Spoke-1 r x = prop-has-all-paths {A = P} ip _ _
Glue : (n : ℕ) (a : A n) → Ins n a == Ins (S n) (f n a)
Glue n a = prop-has-all-paths ip _ _
{- Corollary of the main result: The colimit of the considered sequence is propositional! -}
module PtruncSeqResult {i} (X : Type i) where
open PtruncsSeq {i} X -- this defines the chain C of pseudo-truncations
colim-is-prp : is-prop (SeqCo C)
colim-is-prp =
inhab-to-contr-is-prop
(PtruncSeqResult'.reduction-lemma X (is-contr (SeqCo C)) has-level-is-prop
(λ x₀ → ins O x₀ , prop-has-all-paths (wconst-prop C (PtruncSeqWC.wconst-f X x₀))
(ins O x₀)))
open PtruncSeqResult' X
{- If we have the propositional truncation in the theory: -}
open import lib.types.Truncation
colim-is-trunc : (Trunc ⟨-1⟩ X) ≃ SeqCo C
colim-is-trunc = equiv (Trunc-rec (colim-is-prp) (ins 0))
(reduction-lemma (Trunc ⟨-1⟩ X) Trunc-level [_])
(λ _ → prop-has-all-paths colim-is-prp _ _)
(λ _ → prop-has-all-paths Trunc-level _ _)
| {
"alphanum_fraction": 0.4685148515,
"avg_line_length": 35.5633802817,
"ext": "agda",
"hexsha": "36232f1e491af8039961a7842f379ba6ba73baf2",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nicolaikraus/HoTT-Agda",
"max_forks_repo_path": "nicolai/pseudotruncations/PseudoTruncs-wconst-seq.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nicolaikraus/HoTT-Agda",
"max_issues_repo_path": "nicolai/pseudotruncations/PseudoTruncs-wconst-seq.agda",
"max_line_length": 94,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nicolaikraus/HoTT-Agda",
"max_stars_repo_path": "nicolai/pseudotruncations/PseudoTruncs-wconst-seq.agda",
"max_stars_repo_stars_event_max_datetime": "2021-06-30T00:17:55.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-06-30T00:17:55.000Z",
"num_tokens": 3478,
"size": 10100
} |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Category.Monoidal
open import Categories.Category.Monoidal.Closed
module Categories.Category.Monoidal.Closed.IsClosed.Pentagon
{o ℓ e} {C : Category o ℓ e} {M : Monoidal C} (Cl : Closed M) where
open import Data.Product using (Σ; _,_)
open import Function using (_$_) renaming (_∘_ to _∙_)
open import Function.Equality as Π using (Π)
open import Categories.Category.Product
open import Categories.Category.Monoidal.Properties M
open import Categories.Morphism C
open import Categories.Morphism.Properties C
open import Categories.Morphism.Reasoning C
open import Categories.Functor renaming (id to idF)
open import Categories.Functor.Bifunctor
open import Categories.Functor.Bifunctor.Properties
open import Categories.NaturalTransformation hiding (id)
open import Categories.NaturalTransformation.Dinatural hiding (_∘ʳ_)
open import Categories.NaturalTransformation.NaturalIsomorphism as NI hiding (refl)
import Categories.Category.Closed as Cls
open Closed Cl
private
module C = Category C
open Category C
open Commutation
module ℱ = Functor
module ⊗ = Functor ⊗
α⇒ = associator.from
α⇐ = associator.to
λ⇒ = unitorˡ.from
λ⇐ = unitorˡ.to
ρ⇒ = unitorʳ.from
ρ⇐ = unitorʳ.to
open HomReasoning
open Π.Π
open adjoint renaming (unit to η; counit to ε; Ladjunct to 𝕃; Ladjunct-comm′ to 𝕃-comm′;
Ladjunct-resp-≈ to 𝕃-resp-≈)
open import Categories.Category.Monoidal.Closed.IsClosed.Identity Cl
open import Categories.Category.Monoidal.Closed.IsClosed.L Cl
-- some intermediate steps as lemmas
private
-- ⊗.F₀ (⊗.F₀ ([-,-].F₀ (u , v) , [-,-].F₀ (x , u)) , x) ⇒ v
inner : {x : Obj} (v u : Obj) → ((Functor.F₀ [ u ,-] v) ⊗₀ (Functor.F₀ [ x ,-] u) ) ⊗₀ x ⇒ v
inner {x} v u = ε.η v ∘ id ⊗₁ ε.η {x} u ∘ α⇒
VU-UY⇒VY-VU : {U V X Y : Obj} → inner {X} V U ∘ (id ⊗₁ 𝕃 (inner U Y) ∘ α⇒) ⊗₁ id ≈
inner V Y ∘ (𝕃 (inner V U) ⊗₁ id) ⊗₁ id
VU-UY⇒VY-VU {U} {V} {X} {Y} = begin
inner V U ∘ (id ⊗₁ 𝕃 (inner U Y) ∘ α⇒) ⊗₁ id ≈⟨ pushʳ $ ℱ.homomorphism (-⊗ X) ⟩
(inner V U ∘ (id ⊗₁ 𝕃 (inner U Y)) ⊗₁ id) ∘ α⇒ ⊗₁ id ≈⟨ pull-last assoc-commute-from ⟩∘⟨refl ⟩
(ε.η V ∘ id ⊗₁ ε.η U ∘ id ⊗₁ 𝕃 (inner U Y) ⊗₁ id ∘ α⇒) ∘ α⇒ ⊗₁ id ≈⟨ (∘-resp-≈ʳ $ pullˡ $ ⟺ (ℱ.homomorphism ([ U , V ]₀ ⊗-))) ⟩∘⟨refl ⟩
(ε.η V ∘ id ⊗₁ (ε.η U ∘ 𝕃 (inner U Y) ⊗₁ id) ∘ α⇒) ∘ α⇒ ⊗₁ id ≈⟨ ∘-resp-≈ˡ (⟺ assoc) ○ assoc ⟩
(ε.η V ∘ id ⊗₁ (ε.η U ∘ 𝕃 (inner U Y) ⊗₁ id)) ∘ (α⇒ ∘ α⇒ ⊗₁ id) ≈⟨ ∘-resp-≈ˡ $ ∘-resp-≈ʳ $ ℱ.F-resp-≈ ([ U , V ]₀ ⊗-) (RLadjunct≈id ○ ⟺ assoc) ⟩
(ε.η V ∘ id ⊗₁ ((ε.η U ∘ id ⊗₁ ε.η Y) ∘ α⇒)) ∘ (α⇒ ∘ α⇒ ⊗₁ id) ≈⟨ ∘-resp-≈ˡ $ ∘-resp-≈ʳ $ ℱ.homomorphism ([ U , V ]₀ ⊗-) ⟩
(ε.η V ∘ id ⊗₁ (ε.η U ∘ id ⊗₁ ε.η Y) ∘ id ⊗₁ α⇒) ∘ (α⇒ ∘ α⇒ ⊗₁ id) ≈⟨ pull-last refl ⟩
ε.η V ∘ id ⊗₁ (ε.η U ∘ id ⊗₁ ε.η Y) ∘ (id ⊗₁ α⇒ ∘ α⇒ ∘ α⇒ ⊗₁ id) ≈⟨ refl⟩∘⟨ ∘-resp-≈ (ℱ.homomorphism ([ U , V ]₀ ⊗-)) pentagon ⟩
ε.η V ∘ (id ⊗₁ ε.η U ∘ id ⊗₁ (id ⊗₁ ε.η Y)) ∘ (α⇒ ∘ α⇒) ≈⟨ ⟺ assoc ○ ⟺ assoc ⟩
((ε.η V ∘ id ⊗₁ ε.η U ∘ id ⊗₁ (id ⊗₁ ε.η Y)) ∘ α⇒) ∘ α⇒ ≈⟨ pull-last (⟺ assoc-commute-from) ⟩∘⟨refl ⟩
(ε.η V ∘ id ⊗₁ ε.η U ∘ α⇒ ∘ (id ⊗₁ id) ⊗₁ ε.η Y) ∘ α⇒ ≈⟨ assoc ○ ∘-resp-≈ʳ (∘-resp-≈ˡ (⟺ assoc)) ○ ⟺ (center refl) ⟩
(ε.η V ∘ id ⊗₁ ε.η U ∘ α⇒) ∘ (id ⊗₁ id) ⊗₁ ε.η Y ∘ α⇒ ≈⟨ ∘-resp-≈ʳ $ ∘-resp-≈ˡ $ ⊗.F-resp-≈ (⊗.identity , refl) ⟩
(ε.η V ∘ id ⊗₁ ε.η U ∘ α⇒) ∘ id ⊗₁ ε.η Y ∘ α⇒ ≈˘⟨ center⁻¹ RLadjunct≈id refl ⟩
ε.η V ∘ (𝕃 (ε.η V ∘ id ⊗₁ ε.η U ∘ α⇒) ⊗₁ id ∘ id ⊗₁ ε.η Y) ∘ α⇒ ≈⟨ ∘-resp-≈ʳ $ pushˡ (⟺ [ ⊗ ]-commute) ⟩
ε.η V ∘ id ⊗₁ ε.η Y ∘ 𝕃 (inner V U) ⊗₁ id ∘ α⇒ ≈˘⟨ refl⟩∘⟨ refl⟩∘⟨ ⊗.F-resp-≈ (refl , ⊗.identity) ⟩∘⟨refl ⟩
ε.η V ∘ id ⊗₁ ε.η Y ∘ 𝕃 (inner V U) ⊗₁ (id ⊗₁ id) ∘ α⇒ ≈˘⟨ pull-last assoc-commute-from ⟩
(inner V Y) ∘ (𝕃 (inner V U) ⊗₁ id) ⊗₁ id ∎
expand-[-,-] : {U V X Y : Obj} →
(ε.η [ X , V ]₀ ∘ id ⊗₁ ε.η [ X , U ]₀ ∘ α⇒) ∘ (L X U V ⊗₁ L X Y U) ⊗₁ id ≈
𝕃 (ε.η V ∘ id ⊗₁ ε.η Y ∘ α⇒) ∘ 𝕃 (ε.η V ∘ id ⊗₁ ε.η U ∘ α⇒) ⊗₁ id
expand-[-,-] {U} {V} {X} {Y} = begin
(inner XV XU) ∘ (L X U V ⊗₁ L X Y U) ⊗₁ id ≈⟨ pull-last assoc-commute-from ⟩
ε.η XV ∘ id ⊗₁ ε.η XU ∘ L X U V ⊗₁ L X Y U ⊗₁ id ∘ α⇒ ≈⟨ refl⟩∘⟨ pullˡ (⟺ ⊗.homomorphism ○ ⊗.F-resp-≈ (identityˡ , refl)) ⟩
ε.η XV ∘ L X U V ⊗₁ (ε.η XU ∘ L X Y U ⊗₁ id) ∘ α⇒ ≈⟨ refl⟩∘⟨ [ ⊗ ]-decompose₁ ⟩∘⟨refl ⟩
ε.η XV ∘ (L X U V ⊗₁ id ∘ id ⊗₁ (ε.η XU ∘ L X Y U ⊗₁ id)) ∘ α⇒ ≈⟨ center⁻¹ RLadjunct≈id (∘-resp-≈ˡ (ℱ.F-resp-≈ ([ U , V ]₀ ⊗-) RLadjunct≈id)) ⟩
𝕃 (inner V U) ∘ (id ⊗₁ 𝕃 (inner U Y) ∘ α⇒) ≈˘⟨ 𝕃-comm′ ⟩
𝕃 (inner V U ∘ (id ⊗₁ 𝕃 (inner U Y) ∘ α⇒) ⊗₁ id) ≈⟨ 𝕃-resp-≈ VU-UY⇒VY-VU ⟩
𝕃 (inner V Y ∘ (𝕃 (inner V U) ⊗₁ id) ⊗₁ id) ≈⟨ 𝕃-comm′ ⟩
𝕃 (inner V Y) ∘ 𝕃 (inner V U) ⊗₁ id ∎
where
XV = [ X , V ]₀
XU = [ X , U ]₀
UV = [ U , V ]₀
pentagon′ : {U V X Y : Obj} →
[ [ U , V ]₀ ⇒ [ [ Y , U ]₀ , [ [ X , Y ]₀ , [ X , V ]₀ ]₀ ]₀ ]⟨
L X U V ⇒⟨ [ [ X , U ]₀ , [ X , V ]₀ ]₀ ⟩
L [ X , Y ]₀ [ X , U ]₀ [ X , V ]₀ ⇒⟨ [ [ [ X , Y ]₀ , [ X , U ]₀ ]₀ , [ [ X , Y ]₀ , [ X , V ]₀ ]₀ ]₀ ⟩
[ L X Y U , id ]₁
≈ L Y U V ⇒⟨ [ [ Y , U ]₀ , [ Y , V ]₀ ]₀ ⟩
[ id , L X Y V ]₁
⟩
pentagon′ {U} {V} {X} {Y} = begin
[ L X Y U , id ]₁ ∘ L [ X , Y ]₀ XU XV ∘ L X U V ≈˘⟨ refl ⟩∘⟨ 𝕃-comm′ ⟩
[ L X Y U , id ]₁ ∘ 𝕃 (𝕃 (ε.η XV ∘ id ⊗₁ ε.η XU ∘ α⇒) ∘ L X U V ⊗₁ id) ≈˘⟨ pushˡ [ [-,-] ]-commute ⟩
([ id , 𝕃 (inner XV XU) ∘ L X U V ⊗₁ id ]₁ ∘ [ L X Y U , id ]₁) ∘ η.η UV ≈˘⟨ pushʳ (mate.commute₁ (L X Y U)) ⟩
[ id , 𝕃 (inner XV XU) ∘ L X U V ⊗₁ id ]₁ ∘ [ id , id ⊗₁ L X Y U ]₁ ∘ η.η UV ≈˘⟨ pushˡ (ℱ.homomorphism [ [ Y , U ]₀ ,-]) ⟩
𝕃 ((𝕃 (inner XV XU) ∘ L X U V ⊗₁ id) ∘ id ⊗₁ L X Y U) ≈˘⟨ 𝕃-resp-≈ $ pushʳ [ ⊗ ]-decompose₁ ⟩
𝕃 (𝕃 (inner XV XU) ∘ L X U V ⊗₁ L X Y U) ≈˘⟨ 𝕃-resp-≈ $ 𝕃-comm′ ⟩
𝕃 (𝕃 $ (inner XV XU) ∘ (L X U V ⊗₁ L X Y U) ⊗₁ id) ≈⟨ 𝕃-resp-≈ $ 𝕃-resp-≈ $ expand-[-,-] ⟩
𝕃 (𝕃 $ 𝕃 (inner V Y) ∘ 𝕃 (inner V U) ⊗₁ id) ≈⟨ 𝕃-resp-≈ 𝕃-comm′ ⟩
𝕃 (L X Y V ∘ 𝕃 (inner V U)) ≈⟨ pushˡ (ℱ.homomorphism [ [ Y , U ]₀ ,-]) ⟩
[ id , L X Y V ]₁ ∘ L Y U V ∎
where
XV = [ X , V ]₀
XU = [ X , U ]₀
UV = [ U , V ]₀
| {
"alphanum_fraction": 0.4545320993,
"avg_line_length": 57.686440678,
"ext": "agda",
"hexsha": "9eaebd1d958f04a7827b08491b1b70a314dcd0dc",
"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": "6ebc1349ee79669c5c496dcadd551d5bbefd1972",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Taneb/agda-categories",
"max_forks_repo_path": "Categories/Category/Monoidal/Closed/IsClosed/Pentagon.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "6ebc1349ee79669c5c496dcadd551d5bbefd1972",
"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": "Taneb/agda-categories",
"max_issues_repo_path": "Categories/Category/Monoidal/Closed/IsClosed/Pentagon.agda",
"max_line_length": 152,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "6ebc1349ee79669c5c496dcadd551d5bbefd1972",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Taneb/agda-categories",
"max_stars_repo_path": "Categories/Category/Monoidal/Closed/IsClosed/Pentagon.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 3424,
"size": 6807
} |
-- Andreas, 2019-06-17, LAIM 2019, issue #3855
-- Only allow erased definitions (such as projections of erased fields)
-- in erased context.
open import Common.IO
open import Common.Unit
open import Common.String
open import Common.Bool
record Erased (A : Set) : Set where
constructor erase
field
@0 gone : A
noWorld : Bool → Erased String
noWorld true = erase "Hello world!"
noWorld false = erase "Hallo, Welt!"
-- Illegal definition, should raise a type error.
unerase : ∀{A : Set} → Erased A → A
unerase = Erased.gone
main = putStrLn (unerase (noWorld false))
-- WAS: type checker let it through, compiler produces ill-formed Haskell
| {
"alphanum_fraction": 0.7243491577,
"avg_line_length": 24.1851851852,
"ext": "agda",
"hexsha": "909d87d52f84bd3143d15557b54139d0a160660d",
"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/Issue3855.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/Issue3855.agda",
"max_line_length": 73,
"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/Issue3855.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": 175,
"size": 653
} |
module Structure.Relator.Apartness.Proofs where
open import Data
open import Data.Either as Either
open import Data.Tuple as Tuple
open import Functional
open import Logic.Classical
open import Logic.Propositional
open import Logic.Propositional.Theorems
import Lvl
open import Structure.Relator.Apartness
open import Structure.Relator.Equivalence
open import Structure.Relator.Properties
open import Syntax.Implication
open import Type
private variable ℓ ℓ₁ ℓ₂ ℓ₃ ℓₗ ℓₗ₁ ℓₗ₂ ℓₗ₃ ℓₗ₄ ℓₑ ℓₑ₁ ℓₑ₂ ℓₑ₃ ℓₑ₄ : Lvl.Level
private variable T A B : Type{ℓ}
private variable _▫_ : T → T → Type{ℓ}
module _ {_▫_ : T → T → Type{ℓ}} where
instance
-- The negation of an apartness relation is an equivalence relation.
-- This is a reason for using an apartness relation in constructive real mathematics. Both the apartness properties and the equivalence properties are sought after and by starting with an apartness relation, one gets both.
apartness-equivalenceᵣ : ⦃ apart : Apartness(_▫_) ⦄ → Equivalence((¬_) ∘₂ (_▫_))
Reflexivity.proof (Equivalence.reflexivity apartness-equivalenceᵣ) = irreflexivity(_▫_)
Symmetry.proof (Equivalence.symmetry apartness-equivalenceᵣ) = contrapositiveᵣ(symmetry(_▫_))
Transitivity.proof (Equivalence.transitivity apartness-equivalenceᵣ) nxy nyz = [∨]-elim nxy nyz ∘ cotransitivity(_▫_)
module _ ⦃ classical : Classical₂(_▫_) ⦄ where
equivalence-apartnessᵣ : ⦃ equi : Equivalence(_▫_) ⦄ → Apartness((¬_) ∘₂ (_▫_))
Irreflexivity.proof (Apartness.irreflexivity equivalence-apartnessᵣ) = [¬¬]-intro (reflexivity(_▫_))
Symmetry.proof (Apartness.symmetry equivalence-apartnessᵣ) = contrapositiveᵣ(symmetry(_▫_))
CoTransitivity.proof (Apartness.cotransitivity equivalence-apartnessᵣ) {x}{y}{z} nxz with excluded-middle(x ▫ y) | excluded-middle(y ▫ z)
... | Left xy | Left yz with () ← nxz(transitivity(_▫_) xy yz)
... | Left xy | Right nyz = [∨]-introᵣ nyz
... | Right nxy | Left yz = [∨]-introₗ nxy
... | Right nxy | Right nyz = [∨]-introₗ nxy
equivalence-apartnessₗ : ⦃ apart : Apartness((¬_) ∘₂ (_▫_)) ⦄ → Equivalence(_▫_)
Reflexivity.proof (Equivalence.reflexivity equivalence-apartnessₗ) = [¬¬]-elim(irreflexivity((¬_) ∘₂ (_▫_)))
Symmetry.proof (Equivalence.symmetry equivalence-apartnessₗ) = contrapositiveₗ(symmetry((¬_) ∘₂ (_▫_)))
Transitivity.proof (Equivalence.transitivity equivalence-apartnessₗ) {x}{y}{z} xy yz with excluded-middle(x ▫ z)
... | Left xz = xz
... | Right nxz with cotransitivity((¬_) ∘₂ (_▫_)) nxz
... | Left nxy with () ← nxy xy
... | Right nyz with () ← nyz yz
apartness-equivalenceₗ : ⦃ equi : Equivalence((¬_) ∘₂ (_▫_)) ⦄ → Apartness(_▫_)
Irreflexivity.proof (Apartness.irreflexivity apartness-equivalenceₗ) = reflexivity((¬_) ∘₂ (_▫_))
Symmetry.proof (Apartness.symmetry apartness-equivalenceₗ) = contrapositiveₗ(symmetry((¬_) ∘₂ (_▫_)))
CoTransitivity.proof (Apartness.cotransitivity apartness-equivalenceₗ) {x}{y}{z} =
(x ▫ z) ⇒-[ [¬¬]-intro ]
¬¬(x ▫ z) ⇒-[ contrapositiveᵣ(uncurry(transitivity((¬_) ∘₂ (_▫_)))) ]
¬(¬(x ▫ y) ∧ ¬(y ▫ z)) ⇒-[ [¬]-preserves-[∧][∨]ᵣ ]
¬¬(x ▫ y) ∨ ¬¬(y ▫ z) ⇒-[ Either.map [¬¬]-elim [¬¬]-elim ]
(x ▫ y) ∨ (y ▫ z) ⇒-end
| {
"alphanum_fraction": 0.6709774436,
"avg_line_length": 57.3275862069,
"ext": "agda",
"hexsha": "aec653fb4d9fb3a16987ff7ff841dc1c95c1d135",
"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/Relator/Apartness/Proofs.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/Relator/Apartness/Proofs.agda",
"max_line_length": 226,
"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/Relator/Apartness/Proofs.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": 1178,
"size": 3325
} |
import Lvl
open import Logic
open import Type
module Data.List.Relation.Pairwise {ℓ₁ ℓ₂} {T : Type{ℓ₁}} where
open import Data.List
import Data.List.Functions as List
open import Data.List.Relation.Quantification
open import Functional
open import Logic.Propositional
-- Whether a list's elements pairwise satisfy a binary relation with their adjacent elements in the list.
-- Example:
-- AdjacentlyPairwise(_▫_) [a,b,c,d,e]
-- ↔ (∧){
-- • (a ▫ b)
-- • (b ▫ c)
-- • (c ▫ d)
-- • (d ▫ e)
-- }
-- Note: Equivalent to OrderedPairwise(_▫_) when (_▫_) is transitive.
data AdjacentlyPairwise(_▫_ : T → T → Stmt{ℓ₂}) : List(T) → Stmt{ℓ₁ Lvl.⊔ ℓ₂} where
instance
empty : AdjacentlyPairwise(_▫_)(∅)
single : ∀{a} → AdjacentlyPairwise(_▫_)(List.singleton(a))
step : ∀{a b}{l} → ⦃ _ : (a ▫ b) ⦄ → ⦃ _ : AdjacentlyPairwise(_▫_)(b ⊰ l) ⦄ → AdjacentlyPairwise(_▫_)(a ⊰ b ⊰ l)
-- Whether a list's elements pairwise satisfy a binary relation with all the successive elements in the list.
-- Example:
-- OrderedPairwise(_▫_) [a,b,c,d,e]
-- ↔ (∧){
-- • (a ▫ b)
-- • (a ▫ c)
-- • (a ▫ d)
-- • (a ▫ e)
-- • (b ▫ c)
-- • (b ▫ d)
-- • (b ▫ e)
-- • (c ▫ d)
-- • (c ▫ e)
-- • (d ▫ e)
-- }
-- Note: Equivalent to Pairwise(_▫_) when (_▫_) is symmetric.
data OrderedPairwise(_▫_ : T → T → Stmt{ℓ₂}) : List(T) → Stmt{ℓ₁ Lvl.⊔ ℓ₂} where
empty : OrderedPairwise(_▫_)(∅)
step : ∀{a}{l} → AllElements(a ▫_)(l) → OrderedPairwise(_▫_)(l) → OrderedPairwise(_▫_)(a ⊰ l)
-- TODO: Is this correct? Using (_∧_)?
Pairwise : (T → T → Stmt{ℓ₂}) → List(T) → Stmt
Pairwise(_▫_) = OrderedPairwise(x ↦ y ↦ (y ▫ x) ∧ (x ▫ y))
| {
"alphanum_fraction": 0.5735468565,
"avg_line_length": 32.4230769231,
"ext": "agda",
"hexsha": "7d9cffb4e3c663ae8061bec849d4351792101a6a",
"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/List/Relation/Pairwise.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/List/Relation/Pairwise.agda",
"max_line_length": 118,
"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/List/Relation/Pairwise.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": 656,
"size": 1686
} |
open import Agda.Builtin.Nat
-- split on m
-- WAS: m = zero or m = suc m
-- WANT: m = suc m because 2nd clause already covers m = zero
f : Nat -> Nat -> Nat
f m zero = {!!}
f zero zero = zero
f _ _ = zero
-- However for g, we still get m = zero or m = suc m
-- because the other splits are orthogonal / catchalls
g : Nat -> Nat -> Nat
g m zero = {!!}
g zero n = zero
g _ _ = zero
| {
"alphanum_fraction": 0.6103896104,
"avg_line_length": 19.25,
"ext": "agda",
"hexsha": "6b66b9159e45344b239c9f2d58457e114175aa6e",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/interaction/Issue3829-2.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/interaction/Issue3829-2.agda",
"max_line_length": 61,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/interaction/Issue3829-2.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": 124,
"size": 385
} |
module _ where
open import Common.Prelude hiding (_>>=_)
open import Common.Reflection
pattern `Nat = def (quote Nat) []
unquoteDecl f =
declareDef (vArg f) `Nat
| {
"alphanum_fraction": 0.7142857143,
"avg_line_length": 15.2727272727,
"ext": "agda",
"hexsha": "7f8668917dfe3c0fbb5ab68d004927502736d072",
"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/UnquoteDeclNotDefined.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/UnquoteDeclNotDefined.agda",
"max_line_length": 41,
"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/UnquoteDeclNotDefined.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": 46,
"size": 168
} |
module _ where
postulate D : Set
module A where
infixr 5 _∷_
postulate
_∷_ : Set₁ → D → D
module B where
infix 5 _∷_
postulate
_∷_ : Set₁ → Set₁ → D
open A
open B
foo : D
foo = Set ∷ Set
| {
"alphanum_fraction": 0.5943396226,
"avg_line_length": 8.8333333333,
"ext": "agda",
"hexsha": "337293df44551674c489a75b61a3b5109e14f8e8",
"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": "aac88412199dd4cbcb041aab499d8a6b7e3f4a2e",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "hborum/agda",
"max_forks_repo_path": "test/Fail/Issue1194m.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "aac88412199dd4cbcb041aab499d8a6b7e3f4a2e",
"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": "hborum/agda",
"max_issues_repo_path": "test/Fail/Issue1194m.agda",
"max_line_length": 25,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "aac88412199dd4cbcb041aab499d8a6b7e3f4a2e",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "hborum/agda",
"max_stars_repo_path": "test/Fail/Issue1194m.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": 87,
"size": 212
} |
module Cats.Category.Setoids where
open import Cats.Util.SetoidMorphism public using
(_⇒_ ; _≈_ ; ≈-intro ; ≈-elim ; ≈-elim′ ; equiv ; _∘_ ; id ; ∘-resp ; assoc ; id-l
; id-r)
open import Level using (_⊔_ ; suc)
open import Relation.Binary using (Setoid)
open import Cats.Category.Base
open import Cats.Category.Sets using (Sets)
open import Cats.Util.Conv
instance
HasArrow-⇒ : ∀ {l l≈} {A B : Setoid l l≈}
→ HasArrow (A ⇒ B) (suc l) l l
HasArrow-⇒ {l} = record { Cat = Sets l ; _⃗ = _⇒_.arr }
Setoids : ∀ l l≈ → Category (suc (l ⊔ l≈)) (l ⊔ l≈) (l ⊔ l≈)
Setoids l l≈ = record
{ Obj = Setoid l l≈
; _⇒_ = λ A B → A ⇒ B
; _≈_ = _≈_
; id = id
; _∘_ = _∘_
; equiv = equiv
; ∘-resp = λ {A} {B} {C} {f} {g} {h} {i} → ∘-resp {f = f} {g} {h} {i}
; id-r = λ {A} {B} {f} → id-r {f = f}
; id-l = λ {A} {B} {f} → id-l {f = f}
; assoc = λ {A} {B} {C} {D} {f} {g} {h} → assoc {f = f} {g} {h}
}
| {
"alphanum_fraction": 0.5058201058,
"avg_line_length": 27.7941176471,
"ext": "agda",
"hexsha": "54044f1762c4c279e3b38cd1c27c902f83ce8ddc",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "a3b69911c4c6ec380ddf6a0f4510d3a755734b86",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "alessio-b-zak/cats",
"max_forks_repo_path": "Cats/Category/Setoids.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "a3b69911c4c6ec380ddf6a0f4510d3a755734b86",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "alessio-b-zak/cats",
"max_issues_repo_path": "Cats/Category/Setoids.agda",
"max_line_length": 84,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "a3b69911c4c6ec380ddf6a0f4510d3a755734b86",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "alessio-b-zak/cats",
"max_stars_repo_path": "Cats/Category/Setoids.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 430,
"size": 945
} |
{-# OPTIONS --sized-types #-}
module Ex where
open import Size
open import Data.Empty
open import Data.Unit
open import Data.Nat
open import Data.Product
open import Data.Sum
open import Data.Fin
open import Function
open import Relation.Binary.PropositionalEquality
open import Relation.Nullary
• : Set
• = ⊤
-- | Container for defining signatures
record Cont : Set₁ where
constructor cont
field
Pos : Set
Sh : Pos → Set
open Cont
-- | Extension of a container
⟪_⟫ : Cont → Set → Set
⟪ cont P S ⟫ X = Σ P (λ p → S p → X)
-- | Finite and infinite trees over a signature
record T∞ {i : Size} (C : Cont) : Set where
coinductive
field
out : ∀ {j : Size< i} → • ⊎ ⟪ C ⟫ (T∞ {j} C)
open T∞
------
-- Example due to Fu Peng
-----
-- In the following, we give two interpretations to the logic program
-- ⇒ P(c)
-- P(x), P(f(f x)) ⇒ P(f x).
-- The first is an inductive interpretation, the second is coinductive.
-- In both cases we are able to prove that there is a tree x : Tree sig₁,
-- such that P x holds.
-- | Signature has two symbols, a nullary and a unary symbol.
sig₁ : Cont
sig₁ = cont (⊤ ⊎ ⊤) S
where
S : ⊤ ⊎ ⊤ → Set
S (inj₁ tt) = Fin 0
S (inj₂ tt) = Fin 1
-- | Symbol names
c' f' : Pos sig₁
c' = inj₁ tt
f' = inj₂ tt
-- | Symbol constructor for c
c : T∞ sig₁
out c = inj₂ (c' , (λ ()))
-- | Constructor for symbol f
f : T∞ sig₁ → T∞ sig₁
out (f x) = inj₂ (f' , (λ _ → x))
-- | c and f a distinct constructors
c≢f : (x : T∞ sig₁) → c ≡ f x → ⊥
c≢f x p = lem x (cong (λ t → out t {∞}) p)
where
lem : (y : T∞ sig₁) → out c ≡ out (f y) → ⊥
lem y ()
-- | Inductive interpretation of LP
data P-ind : T∞ sig₁ → Set where
c-P : P-ind c
f-P : (x : T∞ sig₁) → P-ind x → P-ind (f (f x)) → P-ind (f x)
-- | P c holds immediately.
p-ind₀ : ∃ λ x → P-ind x
p-ind₀ = (c , c-P)
unprvbl-lem : (x : T∞ sig₁) → P-ind (f x) → ⊥
unprvbl-lem x q = m x (f x) q refl
where
m : (x y : T∞ sig₁) → P-ind y → y ≡ f x → ⊥
m x .c c-P p = (c≢f x p)
m x .(f x₁) (f-P x₁ p q₁) e = m (f x₁) (f (f x₁)) q₁ refl
-- | We can show that there is no tree x, s.t. P-ind (f x) holds.
unprvbl : ¬ (∃ λ x → P-ind (f x))
unprvbl (x , q) = unprvbl-lem x q
-------
-- Coinductive interpretation of LP
F : (T∞ sig₁ → Set) → T∞ sig₁ → Set
F G x = m (out x)
where
m : ⊤ ⊎ ⟪ sig₁ ⟫ (T∞ sig₁) → Set
m (inj₁ tt) = ⊥ -- case for •
m (inj₂ (inj₁ tt , _)) = ⊤ -- case for c, k₀
m (inj₂ (inj₂ tt , α)) = -- case for f x, k₁
let x = α zero
in G x × G (f (f x))
record P-coind' (x : T∞ sig₁) : Set where
coinductive
field
p-out' : F P-coind' x
open P-coind'
record P-coind {i : Size} (x : T∞ sig₁) : Set where
coinductive
field
p-out : ∀ {j : Size< i} → F (P-coind {j}) x
open P-coind
-- | Trivial proof
k₀ : P-coind c
p-out k₀ = tt
-- | Non-trivial proof
p-coind : ∃ λ x → P-coind (f x)
p-coind = (_ , k _ k₀)
where
k : ∀{i} → (x : T∞ sig₁) → P-coind {i} x → P-coind {i} (f x)
p-out (k x q) = (q , k (f x) (k x q))
-------------------------------------------
------- From example
-------------------------------------------
-- | The signature has two symbols: S of arity 1 and cons of arity 2.
sig₂ : Cont
sig₂ = cont (⊤ ⊎ ⊤) ar₂
where
ar₂ : ⊤ ⊎ ⊤ → Set
ar₂ (inj₁ tt) = Fin 1
ar₂ (inj₂ tt) = Fin 2
-- | Easier to read symbol names
S' cons' : Pos sig₂
S' = inj₁ tt
cons' = inj₂ tt
-- | Tree constructors for S
S : ∀{i} → T∞ {i} sig₂ → T∞ {i} sig₂
out (S x) = inj₂ (S' , (λ _ → x))
-- | Tree constructors for cons
cons : T∞ sig₂ → T∞ sig₂ → T∞ sig₂
out (cons x y) = inj₂ (cons' , α)
where
α : Sh sig₂ cons' → T∞ sig₂
α zero = x
α (suc _) = y
-- | Coinductive conlusion for the rule
-- from(S x, y) ⇒ from(x, cons (x, y)).
-- Note that we need to encode this as
-- from(S x, y) ∧ x ≡ x' ⇒ from(x, cons (x', y)).
From-Enc : (T∞ sig₂ → T∞ sig₂ → Set) → T∞ sig₂ → T∞ sig₂ → Set
From-Enc G x y with (out y)
... | inj₁ tt = ⊥ -- no clause for from(x, •)
... | inj₂ (inj₁ tt , _) = ⊥ -- neither for from(x, S y)
... | inj₂ (inj₂ tt , α) = -- from(S x, y) ∧ x ≡ x' ⇒ from(x, cons (x', y))
let x' = α zero
y = α (suc zero)
in x ≡ x' × G (S x) y
-- | Define From as coinductive relation.
record From (x y : T∞ sig₂) : Set where
coinductive
field
out-From : From-Enc From x y
open From
----- Below, we construct for each x : T∞ sig₂ a term tₓ that is related to x
----- via From, and prove that this is indeed the case.
-- | t x = cons x (cons (s x) ...
t : T∞ sig₂ → T∞ sig₂
out (t x) = inj₂ (cons' , α)
where
α : Sh sig₂ cons' → T∞ sig₂
α zero = x
α (suc _) = t (S x)
-- | Prove that x and tₓ are related via From.
lem : (x : T∞ sig₂) → From x (t x)
out-From (lem x) = (refl , lem (S x))
-- | From is inhabitated if T∞ sig₂ is.
thm : (x : T∞ sig₂) → ∃ λ y → From x y
thm x = , (lem x)
----------------------------------------
-- Different approach to show that From is inhabited:
-- The separate definition of T∞ and From makes it impossible, or at least
-- extremly difficult, to construct y and From x y at the same time.
-- The predicate ∃-From x thus simultaneously defines a special existential
-- quantifier for T∞ sig₂ that ensures that the given witness y fulfills
-- From x y.
-- Note that elements of ∃-From contain a lot of junk, as we always just use
-- the root of a tree. This make the first projection rather complicated, see
-- p₁. I guess, this could be made more economical.
∃-From-Enc : ∀{i} → (T∞ {i} sig₂ → Set) → T∞ {i} sig₂ → Set
∃-From-Enc {i} G x = Σ (⟪ sig₂ ⟫ (T∞ sig₂)) m
where
m : ⟪ sig₂ ⟫ (T∞ {i} sig₂) → Set
m (inj₁ tt , _) = ⊥
m (inj₂ tt , α) =
let x' = α zero
y = α (suc zero)
in x ≡ x' × G (S x)
record ∃-From {i : Size} (x : T∞ {i} sig₂) : Set where
coinductive
field
out-∃-From : {j : Size< i} → ∃-From-Enc (∃-From {j}) x
open ∃-From
postulate
T∞-ext : ∀{C} → (x y : T∞ C) → out x ≡ out y → x ≡ y
-- | Project out the witness.
p₁ : ∀ {i x} → ∃-From {i} x → T∞ {i} sig₂
out (p₁ u) {j} with out-∃-From u
... | (inj₁ tt , _) , ()
... | (inj₂ tt , α) , q , u' = inj₂ (cons' , α')
where
t' = p₁ u'
α' : Fin 2 → T∞ {j} sig₂
α' zero = α zero
α' (suc _) = t'
p₂ : ∀ {x} → (u : ∃-From x) → From x (p₁ u)
out-From (p₂ {x} u) = {!!}
where
m : (v : ∃-From-Enc ∃-From x) → v ≡ out-∃-From u → From-Enc From x (p₁ u)
m v p with v
... | ((inj₁ tt , _) , ())
... | ((inj₂ tt , α) , q , u') = {!!} -- subst (From-Enc From x) s m'
where
v' : From (S x) (p₁ u')
v' = p₂ u'
α' : Fin 2 → T∞ sig₂
α' zero = α zero
α' (suc _) = p₁ u'
s : ∀ {α q u'} → ((inj₂ tt , α) , q , u') ≡ out-∃-From u →
record { out = inj₂ (cons' , α') } ≡ p₁ u
s p with out-∃-From u
s p | r = {!!}
{-
s p with out-∃-From u
s p | (inj₁ tt , _) , ()
s p | ((inj₂ tt , α₁) , q₁ , u'₁) = ?
-- T∞-ext (record { out = inj₂ (cons' , α') }) (p₁ u) {!!}
-}
m' : From-Enc From x (record { out = inj₂ (cons' , α') })
m' = (q , v')
thm₂ : ∀{i} → (x : T∞ {i} sig₂) → ∃-From {i} x
out-∃-From (thm₂ {i} x) {j} = ((cons' , α) , refl , u)
where
u = thm₂ {j} (S x)
α : Sh sig₂ cons' → T∞ {j} sig₂
α zero = x
α (suc _) = p₁ u
---------------------
-- Some other tries
--------------------
{-
F : (ℕ → Set) → ℕ → Set
F G 0 = ⊤
F G (suc n) = G n
record NatLp (n : ℕ) : Set where
coinductive
field
out : F NatLp n
open NatLp
lem : (n : ℕ) → NatLp n
out (lem zero) = tt
out (lem (suc n)) = lem n
record bad (A : Set) (a : A) : Set where
coinductive
field
bad-out : bad A a
open bad
bad-lem : (n : ℕ) → bad ℕ n
bad-out (bad-lem n) = bad-lem n
-}
| {
"alphanum_fraction": 0.5136907057,
"avg_line_length": 25.0935483871,
"ext": "agda",
"hexsha": "0029eed8d60a21ff085bf8a6a61a57fe30ba083a",
"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": "8fc7a6cd878f37f9595124ee8dea62258da28aa4",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "hbasold/Sandbox",
"max_forks_repo_path": "LP2/Ex.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "8fc7a6cd878f37f9595124ee8dea62258da28aa4",
"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": "hbasold/Sandbox",
"max_issues_repo_path": "LP2/Ex.agda",
"max_line_length": 77,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "8fc7a6cd878f37f9595124ee8dea62258da28aa4",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "hbasold/Sandbox",
"max_stars_repo_path": "LP2/Ex.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 3147,
"size": 7779
} |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Setoids.Subset
open import Setoids.Setoids
open import Setoids.Orders.Partial.Definition
open import Setoids.Orders.Total.Definition
open import Sets.EquivalenceRelations
open import Rings.Orders.Total.Definition
open import Rings.Orders.Partial.Definition
open import Rings.Definition
open import Fields.Fields
open import Groups.Definition
open import Functions.Definition
module Fields.Orders.LeastUpperBounds.Examples {a b c : _} {A : Set a} {S : Setoid {a} {b} A} {_<_ : Rel {_} {c} A} {_+_ _*_ : A → A → A} {R : Ring S _+_ _*_} {pOrder : SetoidPartialOrder S _<_} {pOrderedRing : PartiallyOrderedRing R pOrder} (orderedRing : TotallyOrderedRing pOrderedRing) (F : Field R) (isNontrivial : Setoid._∼_ S (Ring.0R R) (Ring.1R R) → False) where
open PartiallyOrderedRing pOrderedRing
open Setoid S
open Equivalence eq
open SetoidTotalOrder (TotallyOrderedRing.total orderedRing)
open Field F
open Ring R
open SetoidPartialOrder pOrder
open Group additiveGroup
open import Rings.Orders.Partial.Lemmas pOrderedRing
open import Rings.Orders.Total.Lemmas orderedRing
open import Fields.Orders.LeastUpperBounds.Definition pOrder
charNot2 : Setoid._∼_ S (Ring.1R R + Ring.1R R) (Ring.0R R) → False
charNot2 = orderedImpliesCharNot2 nontrivial
openIntervalPred : (a : A) → (b : A) → a < b → A → Set _
openIntervalPred a b a<b x = (a < x) && (x < b)
openInterval : (a : A) → (b : A) → (a<b : a < b) → subset S (openIntervalPred a b a<b)
openInterval a b a<b x=y (a<x ,, x<b) = SetoidPartialOrder.<WellDefined pOrder reflexive x=y a<x ,, SetoidPartialOrder.<WellDefined pOrder x=y reflexive x<b
1/2 : A
1/2 with allInvertible (1R + 1R) charNot2
... | n , _ = n
1/2Is1/2 : 1/2 * (1R + 1R) ∼ 1R
1/2Is1/2 with allInvertible (1R + 1R) charNot2
... | n , pr = pr
1/2Is1/2' : (1/2 + 1/2) ∼ 1R
1/2Is1/2' = transitive (+WellDefined (symmetric identIsIdent) (symmetric identIsIdent)) (transitive (transitive (symmetric *DistributesOver+') *Commutative) 1/2Is1/2)
halfHalves : (a : A) → ((a + a) * 1/2) ∼ a
halfHalves a = transitive *DistributesOver+' (transitive (transitive (transitive (symmetric *DistributesOver+) (*WellDefined reflexive 1/2Is1/2')) *Commutative) identIsIdent)
0<1/2 : 0R < 1/2
0<1/2 = halvePositive 1/2 (<WellDefined reflexive (symmetric (transitive (symmetric (transitive *DistributesOver+ (+WellDefined (transitive *Commutative identIsIdent) (transitive *Commutative identIsIdent)))) 1/2Is1/2)) (0<1 nontrivial))
min<mean : (a b : A) → a < b → a < ((a + b) * 1/2)
min<mean a b a<b = <WellDefined (transitive *DistributesOver+' (transitive (+WellDefined *Commutative *Commutative) (transitive (symmetric *DistributesOver+') (transitive (*WellDefined 1/2Is1/2' reflexive) identIsIdent)))) reflexive a+a<a+b
where
a+a<a+b : ((a + a) * 1/2) < ((a + b) * 1/2)
a+a<a+b = ringCanMultiplyByPositive 0<1/2 (<WellDefined reflexive groupIsAbelian (orderRespectsAddition a<b a))
mean<max : (a b : A) → a < b → ((a + b) * 1/2) < b
mean<max a b a<b = <WellDefined reflexive (halfHalves b) a+b<b+b
where
a+b<b+b : ((a + b) * 1/2) < ((b + b) * 1/2)
a+b<b+b = ringCanMultiplyByPositive 0<1/2 (orderRespectsAddition a<b b)
example1 : (a b : A) (a<b : a < b) → LeastUpperBound (openInterval a b a<b) b
LeastUpperBound.upperBound (example1 a b a<b) y (a<y ,, y<b) = inl y<b
LeastUpperBound.leastUpperBound (example1 a b a<b) y isUpperBound with totality b y
LeastUpperBound.leastUpperBound (example1 a b a<b) y isUpperBound | inl (inl x) = inl x
LeastUpperBound.leastUpperBound (example1 a b a<b) y isUpperBound | inl (inr y<b) = exFalso false
where
betterBound : A
betterBound = (y + b) * 1/2
p1 : ((y + b) * 1/2) < ((b + b) * 1/2)
p1 = ringCanMultiplyByPositive 0<1/2 (orderRespectsAddition y<b b)
p2 : betterBound < b
p2 = <WellDefined reflexive (transitive (*WellDefined (transitive (symmetric (+WellDefined identIsIdent identIsIdent)) (transitive (+WellDefined *Commutative *Commutative) (symmetric *DistributesOver+))) reflexive) (transitive (symmetric *Associative) (transitive (transitive (*WellDefined reflexive (transitive *Commutative 1/2Is1/2)) *Commutative) identIsIdent))) p1
a<y : a < y
a<y with isUpperBound ((a + b) * 1/2) (min<mean a b a<b ,, mean<max a b a<b)
a<y | inl a+b/2<y = <Transitive (min<mean a b a<b) a+b/2<y
a<y | inr a+b/2=y = <WellDefined reflexive a+b/2=y (min<mean a b a<b)
p3 : ((a + a) * 1/2) < ((y + b) * 1/2)
p3 = ringCanMultiplyByPositive 0<1/2 (ringAddInequalities a<y a<b)
a<betterBound : a < betterBound
a<betterBound = <WellDefined (halfHalves a) reflexive p3
bad : (betterBound < y) || (betterBound ∼ y)
bad = isUpperBound betterBound (a<betterBound ,, p2)
false : False
false with bad
false | inl mean<y with min<mean y b y<b
... | y<mean = irreflexive (<Transitive y<mean mean<y)
false | inr x = irreflexive (<WellDefined (symmetric x) reflexive (min<mean y b y<b))
LeastUpperBound.leastUpperBound (example1 a b a<b) y isUpperBound | inr x = inr x
| {
"alphanum_fraction": 0.6946190102,
"avg_line_length": 53.0416666667,
"ext": "agda",
"hexsha": "0e964b33bff4b8be15787e52b65d585fa5176b03",
"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": "Fields/Orders/LeastUpperBounds/Examples.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": "Fields/Orders/LeastUpperBounds/Examples.agda",
"max_line_length": 372,
"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": "Fields/Orders/LeastUpperBounds/Examples.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": 1805,
"size": 5092
} |
-- Andreas, 2020-04-15, issue #4586
-- Better error message when `let` contains an absurd pattern.
test : Set₁
test = let f ()
in Set
-- WAS:
-- Not a valid let-declaration
-- when scope checking let f () in Set
-- EXPECTED:
-- Missing right hand side in let binding
-- when scope checking let f () in Set
| {
"alphanum_fraction": 0.665615142,
"avg_line_length": 21.1333333333,
"ext": "agda",
"hexsha": "c2cd15854233bb433a0c063ae7512f7894886258",
"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": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "shlevy/agda",
"max_forks_repo_path": "test/Fail/Issue4586LetBindingAbsurd.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/Issue4586LetBindingAbsurd.agda",
"max_line_length": 62,
"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/Issue4586LetBindingAbsurd.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": 88,
"size": 317
} |
-- Andreas, 2014-05-02
-- As of now, we have no negative integer literals, and these parse as identifiers.
module _ where
open import Common.Prelude
n : Nat
n = -1
-- Should give error "not in scope: -1"
| {
"alphanum_fraction": 0.7019230769,
"avg_line_length": 17.3333333333,
"ext": "agda",
"hexsha": "355b2cfa72272aaf4a031b46bdf1d6732fb85ef2",
"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/NegativeIntegerLiteral.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/NegativeIntegerLiteral.agda",
"max_line_length": 83,
"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/NegativeIntegerLiteral.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": 60,
"size": 208
} |
module UnSizedIO.ConsoleObject where
open import UnSizedIO.Console
open import UnSizedIO.Object
open import UnSizedIO.IOObject
-- A console object is an IO object for the IO interface of console
ConsoleObject : (iface : Interface) → Set
ConsoleObject iface = IOObject ConsoleInterface iface
| {
"alphanum_fraction": 0.8080808081,
"avg_line_length": 22.8461538462,
"ext": "agda",
"hexsha": "e91282f9e620d8c508cf7978cd89404f98671630",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:41:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-09-01T15:02:37.000Z",
"max_forks_repo_head_hexsha": "7cc45e0148a4a508d20ed67e791544c30fecd795",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "agda/ooAgda",
"max_forks_repo_path": "src/UnSizedIO/ConsoleObject.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7cc45e0148a4a508d20ed67e791544c30fecd795",
"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": "agda/ooAgda",
"max_issues_repo_path": "src/UnSizedIO/ConsoleObject.agda",
"max_line_length": 68,
"max_stars_count": 23,
"max_stars_repo_head_hexsha": "7cc45e0148a4a508d20ed67e791544c30fecd795",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "agda/ooAgda",
"max_stars_repo_path": "src/UnSizedIO/ConsoleObject.agda",
"max_stars_repo_stars_event_max_datetime": "2020-10-12T23:15:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-06-19T12:57:55.000Z",
"num_tokens": 71,
"size": 297
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Propertiers of any for containers
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Container.Morphism.Properties where
open import Level using (_⊔_; suc)
open import Function as F using (_$_)
open import Data.Product using (∃; proj₁; proj₂; _,_)
open import Relation.Binary using (Setoid)
open import Relation.Binary.PropositionalEquality as P using (_≡_; _≗_)
open import Data.Container.Core
open import Data.Container.Morphism
open import Data.Container.Relation.Binary.Equality.Setoid
-- Identity
module _ {s p} (C : Container s p) where
id-correct : ∀ {x} {X : Set x} → ⟪ id C ⟫ {X = X} ≗ F.id
id-correct x = P.refl
-- Composition.
module _ {s₁ s₂ s₃ p₁ p₂ p₃}
{C₁ : Container s₁ p₁} {C₂ : Container s₂ p₂} {C₃ : Container s₃ p₃}
where
∘-correct : (f : C₂ ⇒ C₃) (g : C₁ ⇒ C₂) → ∀ {x} {X : Set x} →
⟪ f ∘ g ⟫ {X = X} ≗ (⟪ f ⟫ F.∘ ⟪ g ⟫)
∘-correct f g xs = P.refl
module _ {s₁ s₂ p₁ p₂} {C₁ : Container s₁ p₁} {C₂ : Container s₂ p₂} where
-- Naturality.
Natural : ∀ x e → (∀ {X : Set x} → ⟦ C₁ ⟧ X → ⟦ C₂ ⟧ X) →
Set (s₁ ⊔ s₂ ⊔ p₁ ⊔ p₂ ⊔ suc (x ⊔ e))
Natural x e m =
∀ {X : Set x} (Y : Setoid x e) → let module Y = Setoid Y in
(f : X → Y.Carrier) (xs : ⟦ C₁ ⟧ X) →
Eq Y C₂ (m $ map f xs) (map f $ m xs)
-- Container morphisms are natural.
natural : ∀ (m : C₁ ⇒ C₂) x e → Natural x e ⟪ m ⟫
natural m x e Y f xs = refl Y C₂
module _ {s₁ s₂ p₁ p₂} (C₁ : Container s₁ p₁) (C₂ : Container s₂ p₂) where
-- Natural transformations.
NT : ∀ x e → Set (s₁ ⊔ s₂ ⊔ p₁ ⊔ p₂ ⊔ suc (x ⊔ e))
NT x e = ∃ λ (m : ∀ {X : Set x} → ⟦ C₁ ⟧ X → ⟦ C₂ ⟧ X) → Natural x e m
module _ {s₁ s₂ p₁ p₂} {C₁ : Container s₁ p₁} {C₂ : Container s₂ p₂} where
-- All natural functions of the right type are container morphisms.
complete : ∀ {e} → (nt : NT C₁ C₂ p₁ e) →
∃ λ m → (X : Setoid p₁ e) → let module X = Setoid X in
∀ xs → Eq X C₂ (proj₁ nt xs) (⟪ m ⟫ xs)
complete (nt , nat) =
(m , λ X xs → nat X (proj₂ xs) (proj₁ xs , F.id)) where
m : C₁ ⇒ C₂
m .shape = λ s → proj₁ (nt (s , F.id))
m .position = proj₂ (nt (_ , F.id))
| {
"alphanum_fraction": 0.5313445741,
"avg_line_length": 31.2567567568,
"ext": "agda",
"hexsha": "513651e434de95fb65f49e491d53b00fa3f0557f",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-04T06:54:45.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-04T06:54:45.000Z",
"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/Container/Morphism/Properties.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/Container/Morphism/Properties.agda",
"max_line_length": 77,
"max_stars_count": 5,
"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/Container/Morphism/Properties.agda",
"max_stars_repo_stars_event_max_datetime": "2020-10-10T21:41:32.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-10-07T12:07:53.000Z",
"num_tokens": 852,
"size": 2313
} |
module Issue488 where
open import Data.Product using (∃-syntax; -,_; _×_; _,_)
open import Relation.Nullary using (¬_)
open import Relation.Binary.PropositionalEquality using (_≡_; refl; sym; trans)
module CounterExample where
data Term : Set where
A B C D : Term
data _—→_ : (M N : Term) → Set where
B—→C : B —→ C
C—→B : C —→ B
B—→A : B —→ A
C—→D : C —→ D
infix 2 _—↠_
infix 1 begin_
infixr 2 _—→⟨_⟩_
infix 3 _∎
data _—↠_ : Term → Term → Set where
_∎ : ∀ M
---------
→ M —↠ M
_—→⟨_⟩_ : ∀ L {M N}
→ L —→ M
→ M —↠ N
---------
→ L —↠ N
begin_ : ∀ {M N}
→ M —↠ N
------
→ M —↠ N
begin M—↠N = M—↠N
diamond : ∀ {L M N}
→ ((L —→ M) × (L —→ N))
-----------------------------
→ ∃[ P ] ((M —↠ P) × (N —↠ P))
diamond (B—→A , B—→A) = -, ((A ∎) , (A ∎))
diamond (C—→B , C—→B) = -, ((B ∎) , (B ∎))
diamond (B—→C , B—→C) = -, ((C ∎) , (C ∎))
diamond (C—→D , C—→D) = -, ((D ∎) , (D ∎))
diamond (B—→C , B—→A) = -, ((begin C —→⟨ C—→B ⟩ B —→⟨ B—→A ⟩ A ∎) , (A ∎))
diamond (C—→B , C—→D) = -, ((begin B —→⟨ B—→C ⟩ C —→⟨ C—→D ⟩ D ∎) , (D ∎))
diamond (B—→A , B—→C) = -, ((A ∎) , (begin C —→⟨ C—→B ⟩ B —→⟨ B—→A ⟩ A ∎))
diamond (C—→D , C—→B) = -, ((D ∎) , (begin B —→⟨ B—→C ⟩ C —→⟨ C—→D ⟩ D ∎))
A—↠A : ∀ {P} → A —↠ P → P ≡ A
A—↠A (.A ∎) = refl
D—↠D : ∀ {P} → D —↠ P → P ≡ D
D—↠D (.D ∎) = refl
¬confluence : ¬ (∀ {L M N}
→ ((L —↠ M) × (L —↠ N))
-----------------------------
→ ∃[ P ] ((M —↠ P) × (N —↠ P)))
¬confluence confluence
with confluence ( (begin B —→⟨ B—→A ⟩ A ∎)
, (begin B —→⟨ B—→C ⟩ C —→⟨ C—→D ⟩ D ∎) )
... | (P , (A—↠P , D—↠P))
with trans (sym (A—↠A A—↠P)) (D—↠D D—↠P)
... | ()
module DeterministicImpliesDiamondPropertyAndConfluence where
infix 2 _—↠_
infix 1 begin_
infixr 2 _—→⟨_⟩_
infix 3 _∎
postulate
Term : Set
_—→_ : Term → Term → Set
postulate
deterministic : ∀ {L M N}
→ L —→ M
→ L —→ N
------
→ M ≡ N
data _—↠_ : Term → Term → Set where
_∎ : ∀ M
---------
→ M —↠ M
_—→⟨_⟩_ : ∀ L {M N}
→ L —→ M
→ M —↠ N
-------
→ L —↠ N
begin_ : ∀ {M N}
→ M —↠ N
------
→ M —↠ N
begin M—↠N = M—↠N
diamond : ∀ {L M N}
→ ((L —→ M) × (L —→ N))
--------------------
→ ∃[ P ] ((M —↠ P) × (N —↠ P))
diamond (L—→M , L—→N)
rewrite deterministic L—→M L—→N = -, ((_ ∎) , (_ ∎))
confluence : ∀ {L M N}
→ (L —↠ M)
→ (L —↠ N)
--------------------
→ ∃[ P ] ((M —↠ P) × (N —↠ P))
confluence {L} {.L} { N} (.L ∎) L—↠N = -, (L—↠N , (N ∎))
confluence {L} { M} {.L} L—↠M (.L ∎) = -, ((M ∎) , L—↠M)
confluence {L} { M} { N} (.L —→⟨ L—→M′ ⟩ M′—↠M) (.L —→⟨ L—→N′ ⟩ N′—↠N)
rewrite deterministic L—→M′ L—→N′ = confluence M′—↠M N′—↠N
| {
"alphanum_fraction": 0.3556252177,
"avg_line_length": 23.7272727273,
"ext": "agda",
"hexsha": "bf46778aa0e8e4dd9c1b174f48b806bb9cce52b1",
"lang": "Agda",
"max_forks_count": 304,
"max_forks_repo_forks_event_max_datetime": "2022-03-28T11:35:02.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-07-16T18:24:59.000Z",
"max_forks_repo_head_hexsha": "5468837f55cbea38d5c5a163e1ea5d48edb92bcc",
"max_forks_repo_licenses": [
"CC-BY-4.0"
],
"max_forks_repo_name": "andorp/plfa.github.io",
"max_forks_repo_path": "extra/Issue488.agda",
"max_issues_count": 323,
"max_issues_repo_head_hexsha": "5468837f55cbea38d5c5a163e1ea5d48edb92bcc",
"max_issues_repo_issues_event_max_datetime": "2022-03-30T07:42:57.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-07-05T22:34:34.000Z",
"max_issues_repo_licenses": [
"CC-BY-4.0"
],
"max_issues_repo_name": "andorp/plfa.github.io",
"max_issues_repo_path": "extra/Issue488.agda",
"max_line_length": 79,
"max_stars_count": 1003,
"max_stars_repo_head_hexsha": "5468837f55cbea38d5c5a163e1ea5d48edb92bcc",
"max_stars_repo_licenses": [
"CC-BY-4.0"
],
"max_stars_repo_name": "andorp/plfa.github.io",
"max_stars_repo_path": "extra/Issue488.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-27T07:03:28.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-07-05T18:15:14.000Z",
"num_tokens": 1395,
"size": 2871
} |
module SizedPolyIO.Console where
open import Level using () renaming (zero to lzero)
open import Size
open import NativePolyIO
open import SizedPolyIO.Base
data ConsoleCommand : Set where
putStrLn : String → ConsoleCommand
getLine : ConsoleCommand
ConsoleResponse : ConsoleCommand → Set
ConsoleResponse (putStrLn s) = Unit
ConsoleResponse getLine = String
consoleI : IOInterface lzero lzero
Command consoleI = ConsoleCommand
Response consoleI = ConsoleResponse
IOConsole : Size → Set → Set
IOConsole i = IO consoleI i
IOConsole+ : Size → Set → Set
IOConsole+ i = IO+ consoleI i
translateIOConsoleLocal : (c : ConsoleCommand) → NativeIO (ConsoleResponse c)
translateIOConsoleLocal (putStrLn s) = nativePutStrLn s
translateIOConsoleLocal getLine = nativeGetLine
translateIOConsole : {A : Set} → IOConsole ∞ A → NativeIO A
translateIOConsole = translateIO translateIOConsoleLocal
main : NativeIO (Unit {lzero})
main = nativePutStrLn "Console"
| {
"alphanum_fraction": 0.7760577915,
"avg_line_length": 26.9166666667,
"ext": "agda",
"hexsha": "08f5d4d4a9f94afaf61e39ceca8a1c561650c640",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:41:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-09-01T15:02:37.000Z",
"max_forks_repo_head_hexsha": "7cc45e0148a4a508d20ed67e791544c30fecd795",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "agda/ooAgda",
"max_forks_repo_path": "src/SizedPolyIO/Console.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7cc45e0148a4a508d20ed67e791544c30fecd795",
"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": "agda/ooAgda",
"max_issues_repo_path": "src/SizedPolyIO/Console.agda",
"max_line_length": 77,
"max_stars_count": 23,
"max_stars_repo_head_hexsha": "7cc45e0148a4a508d20ed67e791544c30fecd795",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "agda/ooAgda",
"max_stars_repo_path": "src/SizedPolyIO/Console.agda",
"max_stars_repo_stars_event_max_datetime": "2020-10-12T23:15:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-06-19T12:57:55.000Z",
"num_tokens": 247,
"size": 969
} |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Lists.Lists
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Decidable.Sets
open import Numbers.Naturals.Definition
open import Numbers.Naturals.Semiring
module Computability.LambdaCalculus.Definition where
open import UnorderedSet.Definition (ℕDecideEquality)
data Term : Set where
var : (v : ℕ) → Term
lam : (x : ℕ) → Term → Term
apply : Term → Term → Term
| {
"alphanum_fraction": 0.7489626556,
"avg_line_length": 26.7777777778,
"ext": "agda",
"hexsha": "6a490ecd00337ddeb41027758bb0d2bdcadc2d66",
"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": "Computability/LambdaCalculus/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": "Computability/LambdaCalculus/Definition.agda",
"max_line_length": 58,
"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": "Computability/LambdaCalculus/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": 135,
"size": 482
} |
module StateSizedIO.Base where
open import Size
open import SizedIO.Base
open import Data.Product
record IOInterfaceˢ : Set₁ where
field
IOStateˢ : Set
Commandˢ : IOStateˢ → Set
Responseˢ : (s : IOStateˢ) → (m : Commandˢ s) → Set
IOnextˢ : (s : IOStateˢ) → (m : Commandˢ s) → (Responseˢ s m) → IOStateˢ
open IOInterfaceˢ public
record Interfaceˢ : Set₁ where
field
Stateˢ : Set
Methodˢ : Stateˢ → Set
Resultˢ : (s : Stateˢ) → (m : Methodˢ s) → Set
nextˢ : (s : Stateˢ) → (m : Methodˢ s) → (Resultˢ s m) → Stateˢ
open Interfaceˢ public
module _ (ioi : IOInterface) (let C = Command ioi) (let R = Response ioi)
(oi : Interfaceˢ) (let S = Stateˢ oi) (let M = Methodˢ oi) (let Rt = Resultˢ oi)
(let n = nextˢ oi)
where
record IOObjectˢ (i : Size) (s : Stateˢ) : Set where
coinductive
field
method : ∀{j : Size< i} (m : M s) → IO ioi ∞ ( Σ[ r ∈ Rt s m ] IOObjectˢ j (n s m r))
open IOObjectˢ public
module _ (I : IOInterfaceˢ )
(let S = IOStateˢ I) (let C = Commandˢ I)
(let R = Responseˢ I) (let n = nextˢ I)
where
mutual
record IOˢ (i : Size) (A : S → Set) (s : S) : Set where
coinductive
constructor delay
field
forceˢ : {j : Size< i} → IOˢ' j A s
data IOˢ' (i : Size) (A : S → Set) (s : S) : Set where
doˢ' : (c : C s) (f : (r : R s c) → IOˢ i A (n s c r)) → IOˢ' i A s
returnˢ' : (a : A s) → IOˢ' i A s
data IOˢ+ (i : Size) (A : S → Set) (s : S) : Set where
do' : (c : C s) (f : (r : R s c) → IOˢ i A (n s c r)) → IOˢ+ i A s
open IOˢ public
module _ {I : IOInterfaceˢ }
(let S = Stateˢ I) (let C = Commandˢ I)
(let R = Responseˢ I) (let n = nextˢ I)
where
returnˢ : ∀{i}{A : S → Set} (s : S) (a : A s) → IOˢ I i A s
forceˢ (returnˢ s a) = returnˢ' a
doˢ : ∀{i}{A : S → Set} (s : S) (c : C s)
(f : (r : R s c) → IOˢ I i A (n s c r))
→ IOˢ I i A s
forceˢ (doˢ s c f) = doˢ' c f
| {
"alphanum_fraction": 0.5148467433,
"avg_line_length": 28.602739726,
"ext": "agda",
"hexsha": "d4539c72173d8d5c04e5f36e8826c9d907fca41e",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:41:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-09-01T15:02:37.000Z",
"max_forks_repo_head_hexsha": "7cc45e0148a4a508d20ed67e791544c30fecd795",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "agda/ooAgda",
"max_forks_repo_path": "src/StateSizedIO/Base.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7cc45e0148a4a508d20ed67e791544c30fecd795",
"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": "agda/ooAgda",
"max_issues_repo_path": "src/StateSizedIO/Base.agda",
"max_line_length": 99,
"max_stars_count": 23,
"max_stars_repo_head_hexsha": "7cc45e0148a4a508d20ed67e791544c30fecd795",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "agda/ooAgda",
"max_stars_repo_path": "src/StateSizedIO/Base.agda",
"max_stars_repo_stars_event_max_datetime": "2020-10-12T23:15:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-06-19T12:57:55.000Z",
"num_tokens": 864,
"size": 2088
} |
open import Categories
open import Functors
import RMonads
module RMonads.RKleisli
{a b c d}
{C : Cat {a}{b}}
{D : Cat {c}{d}}
{J : Fun C D}
(M : RMonads.RMonad J) where
open import Library
open RMonads.RMonad M
open Cat
open Fun
Kl : Cat
Kl = record{
Obj = Obj C;
Hom = λ X Y → Hom D (OMap J X) (T Y);
iden = η;
comp = λ f g → comp D (bind f) g;
idl = λ{X}{Y}{f} →
proof
comp D (bind η) f
≅⟨ cong (λ g → comp D g f) law1 ⟩
comp D (iden D) f
≅⟨ idl D ⟩
f
∎;
idr = law2;
ass = λ{_ _ _ _ f g h} →
proof
comp D (bind (comp D (bind f) g)) h
≅⟨ cong (λ f → comp D f h) law3 ⟩
comp D (comp D (bind f) (bind g)) h
≅⟨ ass D ⟩
comp D (bind f) (comp D (bind g) h)
∎}
| {
"alphanum_fraction": 0.5092105263,
"avg_line_length": 19,
"ext": "agda",
"hexsha": "d565af1194cbcad1d68f23b64f04005b0fb7146c",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-11-04T21:33:13.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-11-04T21:33:13.000Z",
"max_forks_repo_head_hexsha": "74707d3538bf494f4bd30263d2f5515a84733865",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "jmchapman/Relative-Monads",
"max_forks_repo_path": "RMonads/RKleisli.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "74707d3538bf494f4bd30263d2f5515a84733865",
"max_issues_repo_issues_event_max_datetime": "2019-05-29T09:50:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-13T13:12:33.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "jmchapman/Relative-Monads",
"max_issues_repo_path": "RMonads/RKleisli.agda",
"max_line_length": 40,
"max_stars_count": 21,
"max_stars_repo_head_hexsha": "74707d3538bf494f4bd30263d2f5515a84733865",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "jmchapman/Relative-Monads",
"max_stars_repo_path": "RMonads/RKleisli.agda",
"max_stars_repo_stars_event_max_datetime": "2021-02-13T18:02:18.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-07-30T01:25:12.000Z",
"num_tokens": 337,
"size": 760
} |
----------------------------------------------------------------------
-- --
-- Author : Jan Stolarek <[email protected]> --
-- License : Public Domain --
-- --
-- This module contains Agda implementation of code presented in --
-- "Why Dependent Types Matter" by Thorsten Altenkirch, Conor --
-- McBride and James McKinna. Original code in the paper was --
-- written in Epigram but with its official web page offline --
-- Epigram seems to be dead. Original paper elides details of some --
-- proofs. I supplied the missing parts so that this module is --
-- complete and self-contained. I avoided using the standard --
-- library to show how the proofs are constructed from --
-- scratch. This means I have to reinvent some of basic things like --
-- natural numbers, lists or vector. Some of the code below is not --
-- mine, in which case I refer to the original source. If you're --
-- reading "Why Dependent Types Matter" I encourage you to try and --
-- implement all the code by yourself. I assure you that this will --
-- be very rewarding. --
-- --
-- This code was written and tested in Agda 2.3.2.1. YMMV --
-- --
----------------------------------------------------------------------
module WhyDependentTypesMatter where
-- Reinventing the wheel: we will need a type of pairs to implement
-- deal function that splits list into a pair of lists. Sg is in fact
-- type of dependent pairs. This code is taken from Conor McBride:
-- https://github.com/pigworker/MetaprogAgda/blob/master/Basics.agda
record Sg (S : Set)(T : S → Set) : Set where
constructor _,_
field
fst : S
snd : T fst
open Sg public
_×_ : Set → Set → Set
S × T = Sg S λ _ → T
infixr 4 _,_ _×_
-- Section 1 : Introduction
-- ~~~~~~~~~~~~~~~~~~~~~~~~
-- Standard implementation of merge sort with no dependent types. This
-- implements code shown in the paper in Figure 1.
data Nat : Set where
zero : Nat
suc : Nat → Nat
data Order : Set where
le ge : Order
data List (X : Set) : Set where
nil : List X
_::_ : X → List X → List X
order : Nat → Nat → Order
order zero y = le
order (suc x) zero = ge
order (suc x) (suc y) = order x y
-- deal splits a list into a pair of lists. If the input list has even length
-- then the output lists have the same length. If input has odd length then
-- first output list is longer by one.
deal : {X : Set} → List X → List X × List X
deal nil = nil , nil
deal (x :: nil) = x :: nil , nil
deal (y :: (z :: xs)) with deal xs
deal (y :: (z :: xs)) | ys , zs = y :: ys , z :: zs
-- We have a small problem with merge and sort functions - Agda's termination
-- checker complains about merge and sort. The problem is that it doesn't see
-- that parameteres to merge are actually getting smaller in the recursive
-- calls. This results from the usage of "with" pattern, which is desugared to
-- an auxiliary function (say, "go"). Here's an explanation from Andreas Abel:
--
-- the termination checker refutes this call pattern.
--
-- merge (x :: xs) (y :: ys)
-- --> go x xs y ys ...
-- --> merge xs (y :: ys)
--
-- The termination checker sees that in merge-->go, the arguments all become
-- smaller, but in go--->merge, one argument becomes bigger. Since it has
-- simplistic, it cannot remember where y and ys came from and that taken
-- together, they are actually the same as we started out.
--
-- See Andreas' full explanation on Agda mailing list here:
-- https://lists.chalmers.se/pipermail/agda/2013/005948.html
--
-- I could rewrite the code to avoid this problem, but I'm leaving it as-is
-- because IMO it teaches something important about Agda's termination checker.
merge : List Nat → List Nat → List Nat
merge nil ys = ys
merge xs nil = xs
merge (x :: xs) (y :: ys) with order x y
merge (x :: xs) (y :: ys) | le = x :: merge xs (y :: ys)
merge (x :: xs) (y :: ys) | ge = y :: merge (x :: xs) ys
-- After I posted the original code I realized that it is not obvious that this
-- function is total. We know that (deal xs) is smaller than xs, but I think
-- that this isn't obvious.
sort : List Nat → List Nat
sort xs with deal xs
sort xs | ys , nil = ys
sort xs | ys , zs = merge (sort ys) (sort zs)
-- Section 3.1 : Totality is Good for more than the Soul
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Here we reinvent another wheel - refl
data _≡_ {S : Set} (s : S) : S → Set where
refl : s ≡ s
infixl 1 _≡_
-- Section 3.2 : Defusing General Recursion
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Merge sort with explicit structure of recursion.
data Parity : Set where
p0 p1 : Parity
data DealT (X : Set) : Set where
empT : DealT X
leafT : X → DealT X
nodeT : Parity → DealT X → DealT X → DealT X
insertT : {X : Set} → X → DealT X → DealT X
insertT x empT = leafT x
insertT x (leafT y) = nodeT p0 (leafT y) (leafT x)
insertT x (nodeT p0 l r) = nodeT p1 (insertT x l) r
insertT x (nodeT p1 l r) = nodeT p0 l (insertT x r)
dealT : {X : Set} → List X → DealT X
dealT nil = empT
dealT (x :: xs) = insertT x (dealT xs)
mergeT : DealT Nat → List Nat
mergeT empT = nil
mergeT (leafT x) = x :: nil
mergeT (nodeT p l r) = merge (mergeT l) (mergeT r)
-- In the paper this function is called sort. Here and in other places I rename
-- functions to avoid name clashes.
sortT : List Nat → List Nat
sortT xs = mergeT (dealT xs)
-- Section 4 : Maintaining Invariants by Static Indexing
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Note that I'm using (suc n) instead of (1 + n). Why?
-- becuase I'm not using Agda's BUILTIN pragmas, so I'd
-- have to write (suc zero) instead of 1. This doesn't
-- change much in the proofs we'll be doing.
data Vec (X : Set) : Nat → Set where
vnil : Vec X zero
vcons : {n : Nat} → X → Vec X n → Vec X (suc n)
vtail : {X : Set} {n : Nat} → Vec X (suc n) → Vec X n
vtail (vcons x xs) = xs
-- @ is a reserved sign in Agda, so I'm using vapp to denote
-- vectorized application.
vapp : {A B : Set} {n : Nat} → Vec (A → B) n → Vec A n → Vec B n
vapp vnil vnil = vnil
vapp (vcons f fs) (vcons s ss) = vcons (f s) (vapp fs ss)
_+_ : Nat → Nat → Nat
zero + n = n
suc m + n = suc (m + n)
infixl 4 _+_
_++_ : {X : Set} {n m : Nat} → Vec X n → Vec X m → Vec X (n + m)
vnil ++ ys = ys
vcons x xs ++ ys = vcons x (xs ++ ys)
vec : {X : Set} {n : Nat} → X → Vec X n
vec {X} {zero} x = vnil
vec {X} {suc n} x = vcons x (vec x)
xpose : {X : Set} {n m : Nat} → Vec (Vec X n) m → Vec (Vec X m) n
xpose vnil = vec vnil
xpose (vcons xj xi'j) = vapp (vapp (vec vcons) xj) (xpose xi'j)
-- Section 4.1 : Static Indexing and Proofs
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- This section is the one that is missing some of the proofs.
vrevacc : {X : Set} {n m : Nat} → Vec X n → Vec X m → Vec X (n + m)
vrevacc vnil ys = ys
vrevacc (vcons x xs) ys = {!!} -- vrevacc xs (vcons x ys)
-- We can't fill in the correct code, because Agda doesn't know that m + (1 + n)
-- eqauls 1 + (m + n). We will have to prove it.
-- To conduct a proof we will need three properties:
-- a) symmetry: if a equals b then b equals a
sym : {A : Set} → {a b : A} → a ≡ b → b ≡ a
sym refl = refl
-- b) congruence: if a equals b, then (f a) equals (f b)
cong : {A B : Set} (f : A → B) → ∀ {x y} → x ≡ y → f x ≡ f y
cong f refl = refl
-- c) substitution: if we have a proposition that is true for a
-- and a equals b, then proposition is also true for b
subst : {A : Set}(P : A → Set) → {a b : A} → a ≡ b → P a → P b
subst prp refl p = p
-- These three properties were taken from Thorsten Altenkirch's course
-- on Computer Aided Formal Reasoning: http://www.cs.nott.ac.uk/~txa/g53cfr/
-- If you don't know how they work and why do we need them now is a good moment
-- to stop reading "Why Dependent Types Matter" and go through lectures 1-9
-- of Thorsten's course.
plusSuc : (m n : Nat) → suc (m + n) ≡ m + (suc n)
plusSuc zero n = refl
plusSuc (suc m) n = cong suc (plusSuc m n)
vrevacc2 : {X : Set} {n m : Nat} → Vec X n → Vec X m → Vec X (n + m)
vrevacc2 vnil ys = ys
vrevacc2 {X} {suc n} {m} (vcons x xs) ys =
subst (Vec X) (sym (plusSuc n m)) (vrevacc2 xs (vcons x ys))
-- Last line corresponds to
--
-- {[plusSuc m' n⟩} vrevacc2 xs (vcons x ys)
--
-- in the paper. Call to vrevacc2 produces Vec with index n + (suc m). The
-- problem is we need index suc (n + m). We need to prove their equality. we
-- already proved with plusSuc that suc (n + m) equals n + (suc m). Since now
-- we're proving something opposite we make use of symmetry: we apply sym to
-- plusSuc. Having a proof is not enough - we must apply it to convert from the
-- result produced by vrevacc2 to the result expected by the typechecker. To do
-- this we use subst function. Our proposition is (Vec X). Look at the type
-- signature of subst - the proposition is something that will take an element
-- of Set (in this case Nat) and produce an element of Set. Vec X will return an
-- element of Set (ie a type) when we pass it an index of type Nat. subst
-- replaces (substitutes) index n + (suc m) produced by vrevacc2 with
-- suc (n + m).
plusZero : (n : Nat) → n + zero ≡ n
plusZero zero = refl
plusZero (suc n) = cong suc (plusZero n)
vrev : {X : Set} {n : Nat} → Vec X n → Vec X n
vrev {X} {n} xs = subst (Vec X) (plusZero n) (vrevacc2 xs vnil)
-- Section 4.2 : Sized Merge-Sort
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- note that mergeS is a renamed merge from the paper
mergeS : {n m : Nat} → Vec Nat n → Vec Nat m → Vec Nat (n + m)
mergeS {zero } {_ } vnil ys = ys
mergeS {suc n} {zero } (vcons x xs) vnil =
subst (Vec Nat) (sym (plusZero (suc n))) (vcons x xs)
mergeS {suc n} {suc m} (vcons x xs) (vcons y ys) with order x y
mergeS {suc n} {suc m} (vcons x xs) (vcons y ys) | le =
vcons x (mergeS xs (vcons y ys))
mergeS {suc n} {suc m} (vcons x xs) (vcons y ys) | ge =
subst (Vec Nat) (plusSuc (suc n) m) (vcons y (mergeS (vcons x xs) ys))
p2n : Parity → Nat
p2n p0 = zero
p2n p1 = suc zero
-- Data types and functions below have S (mnemonic for Sized) appended to their
-- name to avoid name clash.
data DealTS (X : Set) : Nat → Set where
empT : DealTS X zero
leafT : X → DealTS X (suc zero)
nodeT : {n : Nat} → (p : Parity) → DealTS X (p2n p + n) → DealTS X n
→ DealTS X ((p2n p + n) + n)
mergeTS : {n : Nat} → DealTS Nat n → Vec Nat n
mergeTS empT = vnil
mergeTS (leafT x) = vcons x vnil
mergeTS (nodeT p l r) = mergeS (mergeTS l) (mergeTS r)
insertTS : {n : Nat} {X : Set} → X → DealTS X n → DealTS X (suc n)
insertTS x empT = leafT x
insertTS x (leafT y ) = nodeT p0 (leafT y) (leafT x)
insertTS x (nodeT p0 l r) = nodeT p1 (insertTS x l) r
insertTS {.(p2n p1 + n + n)} {X} x (nodeT {n} p1 l r) =
subst (DealTS X) (sym (cong suc (plusSuc n n))) (nodeT p0 l (insertTS x r))
-- | | |
-- | | +---- suc (n + n) ≡ n + suc n
-- | +-------------- suc (suc (n + n)) ≡ suc (n + suc n))
-- +------------------- suc (n + suc n)) ≡ suc (suc (n + n))
--
-- It took me a while to figure out this proof (though in retrospect it is
-- simple). The expected size of the resulting vector is:
--
-- suc (suc (n + n))
--
-- First suc comes from the type signature of insertTS, second suc comes from
-- p2n p1 (which is suc zero), and n + n comes from nodeT definition. The actual
-- size produced by recursive call to nodeT is:
--
-- suc (n + suc n))
--
-- Outer suc comes from type signature, n is size of l, suc n is size of new r
-- (ie. r with x inserted into it).
dealTS : {X : Set} {n : Nat} → Vec X n → DealTS X n
dealTS vnil = empT
dealTS (vcons x xs) = insertTS x (dealTS xs)
sortTS : {n : Nat} → Vec Nat n → Vec Nat n
sortTS xs = mergeTS (dealTS xs)
-- Section 5.1 : Evidence of Ordering
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
data _≤_ : Nat → Nat → Set where
le0 : {y : Nat} → zero ≤ y
leS : {x : Nat} {y : Nat} → x ≤ y → suc x ≤ suc y
data OrderD : Nat → Nat → Set where
le : {x : Nat} {y : Nat} → x ≤ y → OrderD x y
ge : {x : Nat} {y : Nat} → y ≤ x → OrderD x y
orderD : (x : Nat) → (y : Nat) → OrderD x y
orderD zero y = le le0
orderD (suc x) zero = ge le0
orderD (suc x) (suc y) with orderD x y
orderD (suc x) (suc y) | le xley = le (leS xley)
orderD (suc x) (suc y) | ge ylex = ge (leS ylex)
leRefl : {x : Nat} → x ≤ x
leRefl {zero} = le0
leRefl {suc x} = leS leRefl
leTrans : {x y z : Nat} → x ≤ y → y ≤ z → x ≤ z
leTrans le0 yz = le0
leTrans (leS xy) (leS yz) = leS (leTrans xy yz)
leASym : {x y : Nat} → x ≤ y → y ≤ x → x ≡ x
leASym le0 le0 = refl
leASym (leS xy) (leS yx) = refl
-- Second equation for leASym is surprisingly simple. I admit I don't fully
-- understand why I could simply use refl here, without doing inductive proof.
-- Section 5.2 : Locally Sorted Lists
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- LNat = Nat lifted with infinity
data LNat : Set where
zero : LNat
suc : LNat → LNat
inf : LNat
lift : Nat → LNat
lift zero = zero
lift (suc x) = suc (lift x)
-- In the paper ≤ is used for comparisons on lifted Nats. I'm using ≤' to avoid
-- name clash.
data _≤'_ : LNat → LNat → Set where
le0 : {y : LNat} → zero ≤' y
leS : {x : LNat} {y : LNat} → x ≤' y → suc x ≤' suc y
leI : {x : LNat} → x ≤' inf
data CList : LNat → Set where
cnil : CList inf
ccons : {y : LNat} → (x : Nat) → (lift x) ≤' y → CList y → CList (lift x)
-- |
-- +---------------------------+
-- +--> Paper compares lifted and unlifted Nat using ≤.
-- This seems incorrect or at least unprecise.
-- The problem with CList is that we can't create it if we don't know the least
-- element. That's why the paper says sort is bound by min.
clist : CList zero
clist = ccons zero le0 (
ccons (suc (suc zero)) (leS (leS le0)) (
ccons (suc (suc zero)) leI cnil))
data OList : Nat → Set where
onil : {b : Nat} → OList b
ocons : {b : Nat} → (x : Nat) → b ≤ x → OList x → OList b
-- With OList we can just create the list by saying it is bound by zero.
olist : OList zero
olist = ocons (suc zero) le0 onil
olist2 : OList zero
olist2 = ocons (suc zero) le0 (ocons (suc (suc zero)) (leS le0) onil)
-- mergeO (ie. merge for open-bounds lists) has the same problem that we've seen
-- earlier with merge and sort - termination checker complains because we use
-- "with" pattern.
mergeO : {b : Nat} → OList b → OList b → OList b
mergeO onil ys = ys
mergeO (ocons x blex xs) onil = ocons x blex xs
mergeO (ocons x blex xs) (ocons y bley ys) with orderD x y
mergeO (ocons x blex xs) (ocons y bley ys) | le xley =
ocons x blex (mergeO xs (ocons y xley ys))
mergeO (ocons x blex xs) (ocons y bley ys) | ge ylex =
ocons y bley (mergeO (ocons x ylex xs) ys)
-- The important thing here is that both lists passed to mergeO must share their
-- lower bound. That's why we have to replace old evidence of ordering (bley in
-- the first case) with the new one (xley).
mergeTO : DealT Nat → OList zero
mergeTO empT = onil
mergeTO (leafT x) = ocons x le0 onil
mergeTO (nodeT p l r) = mergeO (mergeTO l) (mergeTO r)
sortO : List Nat → OList zero
sortO xs = mergeTO (dealT xs)
| {
"alphanum_fraction": 0.5861260691,
"avg_line_length": 38.0361445783,
"ext": "agda",
"hexsha": "b3575cd034c9ba5f5be3f04aaf79f2c5eb2c920e",
"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": "dc333ed142584cf52cc885644eed34b356967d8b",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "andrejtokarcik/agda-semantics",
"max_forks_repo_path": "tests/beyond/WhyDependentTypesMatter.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "dc333ed142584cf52cc885644eed34b356967d8b",
"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": "andrejtokarcik/agda-semantics",
"max_issues_repo_path": "tests/beyond/WhyDependentTypesMatter.agda",
"max_line_length": 80,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "dc333ed142584cf52cc885644eed34b356967d8b",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "andrejtokarcik/agda-semantics",
"max_stars_repo_path": "tests/beyond/WhyDependentTypesMatter.agda",
"max_stars_repo_stars_event_max_datetime": "2018-12-06T17:24:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-08-10T15:33:56.000Z",
"num_tokens": 5044,
"size": 15785
} |
-- Andreas, 2019-04-10, issue #3687, name mayhem when printing module contents (C-c C-o)
-- {-# OPTIONS -v interaction.contents.record:20 #-}
record Cat : Set₁ where
field
Obj : Set
Hom : (A B : Obj) → Set
Eq : ∀{A B} (f g : Hom A B) → Set
id : (A : Obj) → Hom A A
comp : ∀{A B C} (f : Hom B C) (g : Hom A B) → Hom A C
record Functor (C1 C2 : Cat) : Set where
record FunEq {C D : Cat} (F G : Functor C D) : Set₁ where
field
eqMap : ∀{c d} (f g : Cat.Hom C c d) (eq : Cat.Eq C f g) → Set
test : ∀ C D (F G : Functor C D) → FunEq F G
FunEq.eqMap (test C D F G) f g f=g = {!D!} -- C-c C-o
-- In the output, the names are completely garbled:
-- Names
-- Obj : Set
-- Hom : f=g → f=g → Set
-- Eq : {A B : g} → f=g A B → f=g A B → Set
-- id : (A : f) → g A A
-- comp : {A B : d} {C = C₁ : d} → f B C₁ → f A B → f A C₁
-- test/interaction$ make AGDA_BIN=agda-2.5.1.1 Issue3687.cmp
| {
"alphanum_fraction": 0.5234541578,
"avg_line_length": 29.3125,
"ext": "agda",
"hexsha": "dcc08f82babe35d7db4bc271bba9f98cfc41a31d",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/interaction/Issue3687.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/interaction/Issue3687.agda",
"max_line_length": 88,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/interaction/Issue3687.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": 384,
"size": 938
} |
Subsets and Splits