Datasets:

typeof
/

algebraic-stack

Dataset card Data Studio Files Files and versions Community

Split (3)

train · 3.4M rows

Search is not available for this dataset

text string	meta dict
module _ where open import Common.Prelude renaming (_+_ to _+N_) open import Common.Integer diff : Nat → Nat → Integer diff a zero = pos a diff zero (suc b) = negsuc b diff (suc a) (suc b) = diff a b _+_ : Integer → Integer → Integer pos a + pos b = pos (a +N b) pos a + negsuc b = diff a (suc b) negsuc a + pos b = diff b (suc a) negsuc a + negsuc b = negsuc (suc a +N b) printInt : Integer → IO Unit printInt n = putStrLn (intToString n) main : IO Unit main = printInt (pos 42 + pos 58) ,, printInt (pos 42 + negsuc 141) ,, printInt (pos 42 + negsuc 31) ,, printInt (negsuc 42 + pos 143) ,, printInt (negsuc 42 + pos 33) ,, printInt (negsuc 42 + negsuc 56)	{ "alphanum_fraction": 0.595890411, "avg_line_length": 26.0714285714, "ext": "agda", "hexsha": "0ba399540897dcbde387e3ca1b1d243171286248", "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/BuiltinInt.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/BuiltinInt.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/BuiltinInt.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": 270, "size": 730 }
{-# OPTIONS --without-K --rewriting #-} open import HoTT renaming (pt to pt⊙) open import cw.CW module cw.FinCW where record AttachedFinSkeleton n (Skel : Type₀) (Real : Skel → Skeleton n) : Type₀ where constructor attached-fin-skeleton field skel : Skel numCells : ℕ attaching : Attaching ⟦ Real skel ⟧ (Fin numCells) (Sphere n) FinSkeleton : ℕ → Type₀ FinSkeleton-realize : {n : ℕ} → FinSkeleton n → Skeleton n FinSkeleton O = ℕ FinSkeleton (S n) = AttachedFinSkeleton n (FinSkeleton n) FinSkeleton-realize FinSkeleton-realize {n = O} n = Fin n , Fin-is-set FinSkeleton-realize {n = S n} (attached-fin-skeleton _ s α) = attached-skeleton _ (Fin s , Fin-is-set) α ⦉_⦊ = FinSkeleton-realize -- Pointedness -- this function is needed for pointedness fcw-head : ∀ {n : ℕ} → FinSkeleton n → Type₀ fcw-head = cw-head ∘ FinSkeleton-realize fcw-head-has-dec-eq : ∀ {n : ℕ} (fin-skel : FinSkeleton n) → has-dec-eq (fcw-head fin-skel) fcw-head-has-dec-eq {n = 0} _ = Fin-has-dec-eq fcw-head-has-dec-eq {n = S n} (attached-fin-skeleton skel _ _) = fcw-head-has-dec-eq skel -- this function is needed for pointedness fcw-incl^ : ∀ {n : ℕ} (skel : FinSkeleton n) → fcw-head skel → ⟦ ⦉ skel ⦊ ⟧ fcw-incl^ fin-skel = incl^ (FinSkeleton-realize fin-skel) -- disjointly pointed skeletons record ⊙FinSkeleton (n : ℕ) : Type₁ where constructor ⊙fin-skeleton field skel : FinSkeleton n pt : fcw-head skel ⊙FinSkeleton-realize : {n : ℕ} → ⊙FinSkeleton n → ⊙Skeleton {i = lzero} n ⊙FinSkeleton-realize (⊙fin-skeleton skel pt) = ⊙skeleton (FinSkeleton-realize skel) pt (fcw-head-has-dec-eq skel pt) ⊙⦉_⦊ : {n : ℕ} → ⊙FinSkeleton n → ⊙Skeleton {i = lzero} n ⊙⦉_⦊ = ⊙FinSkeleton-realize -- Take a prefix of a skeleton fcw-init : ∀ {n} → FinSkeleton (S n) → FinSkeleton n fcw-init (attached-fin-skeleton skel _ _) = skel ⊙fcw-init : ∀ {n} → ⊙FinSkeleton (S n) → ⊙FinSkeleton n ⊙fcw-init (⊙fin-skeleton skel pt) = ⊙fin-skeleton (fcw-init skel) pt -- Extra conditions on CW complexes -- 1. decidable equalities FinSkeleton-has-cells-with-dec-eq : ∀ {n} (fin-skel : FinSkeleton n) → has-cells-with-dec-eq (FinSkeleton-realize fin-skel) FinSkeleton-has-cells-with-dec-eq {n = O} fin-skel = Fin-has-dec-eq FinSkeleton-has-cells-with-dec-eq {n = S n} fin-skel = FinSkeleton-has-cells-with-dec-eq (fcw-init fin-skel) , Fin-has-dec-eq ⊙FinSkeleton-has-cells-with-dec-eq : ∀ {n} (⊙fin-skel : ⊙FinSkeleton n) → ⊙has-cells-with-dec-eq (⊙FinSkeleton-realize ⊙fin-skel) ⊙FinSkeleton-has-cells-with-dec-eq ⊙fin-skel = FinSkeleton-has-cells-with-dec-eq _ -- 2. choice FinSkeleton-has-cells-with-choice : ∀ t {n} (fin-skel : FinSkeleton n) j → has-cells-with-choice t (FinSkeleton-realize fin-skel) j FinSkeleton-has-cells-with-choice t {n = O} fin-skel j = Fin-has-choice t j FinSkeleton-has-cells-with-choice t {n = S n} fin-skel j = FinSkeleton-has-cells-with-choice t (fcw-init fin-skel) j , Fin-has-choice t j ⊙FinSkeleton-has-cells-with-choice : ∀ t {n} (fin-skel : ⊙FinSkeleton n) j → ⊙has-cells-with-choice t (⊙FinSkeleton-realize fin-skel) j ⊙FinSkeleton-has-cells-with-choice t fin-skel j = FinSkeleton-has-cells-with-choice t _ j	{ "alphanum_fraction": 0.6897637795, "avg_line_length": 34.8901098901, "ext": "agda", "hexsha": "7152828740176501526475aee5bdabeed489c298", "lang": "Agda", "max_forks_count": 50, "max_forks_repo_forks_event_max_datetime": "2022-02-14T03:03:25.000Z", "max_forks_repo_forks_event_min_datetime": "2015-01-10T01:48:08.000Z", "max_forks_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "timjb/HoTT-Agda", "max_forks_repo_path": "theorems/cw/FinCW.agda", "max_issues_count": 31, "max_issues_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e", "max_issues_repo_issues_event_max_datetime": "2021-10-03T19:15:25.000Z", "max_issues_repo_issues_event_min_datetime": "2015-03-05T20:09:00.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "timjb/HoTT-Agda", "max_issues_repo_path": "theorems/cw/FinCW.agda", "max_line_length": 89, "max_stars_count": 294, "max_stars_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "timjb/HoTT-Agda", "max_stars_repo_path": "theorems/cw/FinCW.agda", "max_stars_repo_stars_event_max_datetime": "2022-03-20T13:54:45.000Z", "max_stars_repo_stars_event_min_datetime": "2015-01-09T16:23:23.000Z", "num_tokens": 1135, "size": 3175 }
-- binary search trees (not balanced) open import bool open import bool-thms2 open import eq open import maybe open import product open import product-thms open import bool-relations using (transitive ; total) module bst (A : Set) (_≤A_ : A → A → 𝔹) (≤A-trans : transitive _≤A_) (≤A-total : total _≤A_) where open import bool-relations _≤A_ hiding (transitive ; total) open import minmax _≤A_ ≤A-trans ≤A-total data bst : A → A → Set where bst-leaf : ∀ {l u : A} → l ≤A u ≡ tt → bst l u bst-node : ∀ {l l' u' u : A}(d : A) → bst l' d → bst d u' → l ≤A l' ≡ tt → u' ≤A u ≡ tt → bst l u -- find a node which is isomorphic (_=A_) to d and return it; or else return nothing bst-search : ∀{l u : A}(d : A) → bst l u → maybe (Σ A (λ d' → d iso𝔹 d' ≡ tt)) bst-search d (bst-leaf _) = nothing bst-search d (bst-node d' L R _ _) with keep (d ≤A d') bst-search d (bst-node d' L R _ _) \| tt , p1 with keep (d' ≤A d) bst-search d (bst-node d' L R _ _) \| tt , p1 \| tt , p2 = just (d' , iso𝔹-intro p1 p2) bst-search d (bst-node d' L R _ _) \| tt , p1 \| ff , p2 = bst-search d L bst-search d (bst-node d' L R _ _) \| ff , p1 = bst-search d R bst-dec-lb : ∀ {l l' u' : A} → bst l' u' → l ≤A l' ≡ tt → bst l u' bst-dec-lb (bst-leaf p) q = bst-leaf (≤A-trans q p) bst-dec-lb (bst-node d L R p1 p2) q = bst-node d L R (≤A-trans q p1) p2 bst-inc-ub : ∀ {l' u' u : A} → bst l' u' → u' ≤A u ≡ tt → bst l' u bst-inc-ub (bst-leaf p) q = bst-leaf (≤A-trans p q) bst-inc-ub (bst-node d L R p1 p2) q = bst-node d L R p1 (≤A-trans p2 q) bst-insert : ∀{l u : A}(d : A) → bst l u → bst (min d l) (max d u) bst-insert d (bst-leaf p) = bst-node d (bst-leaf ≤A-refl) (bst-leaf ≤A-refl) min-≤1 max-≤1 bst-insert d (bst-node d' L R p1 p2) with keep (d ≤A d') bst-insert d (bst-node d' L R p1 p2) \| tt , p with bst-insert d L bst-insert d (bst-node d' L R p1 p2) \| tt , p \| L' rewrite p = bst-node d' L' (bst-inc-ub R (≤A-trans p2 max-≤2)) (min2-mono p1) ≤A-refl bst-insert d (bst-node d' L R p1 p2) \| ff , p with bst-insert d R bst-insert d (bst-node d' L R p1 p2) \| ff , p \| R' rewrite p = bst-node d' (bst-dec-lb L p1) R' min-≤2 (max2-mono p2)	{ "alphanum_fraction": 0.5747387551, "avg_line_length": 41.5283018868, "ext": "agda", "hexsha": "b3f8197f02d5ed9e2d4fd35b142177b0967b074e", "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": "2ad96390a9be5c238e73709a21533c7354cedd0c", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "logicshan/IAL", "max_forks_repo_path": "bst.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "2ad96390a9be5c238e73709a21533c7354cedd0c", "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": "logicshan/IAL", "max_issues_repo_path": "bst.agda", "max_line_length": 90, "max_stars_count": null, "max_stars_repo_head_hexsha": "2ad96390a9be5c238e73709a21533c7354cedd0c", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "logicshan/IAL", "max_stars_repo_path": "bst.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 891, "size": 2201 }
{- https://github.com/mietek/hilbert-gentzen An Agda formalisation of IPC, IS4, ICML, and ILP. Work in progress. Made by Miëtek Bak. Published under the MIT X11 license. -} module Everything where import Common import Common.Context import Common.ContextPair import Common.Predicate import Common.PredicateBasedContext import Common.Semantics import Common.UntypedContext -- Basic intuitionistic propositional calculus, without ∨ or ⊥. -- Common syntax. import BasicIPC.Syntax.Common -- Hilbert-style formalisation of closed syntax. import BasicIPC.Syntax.ClosedHilbertSequential -- Sequences of terms. import BasicIPC.Syntax.ClosedHilbert -- Nested terms. -- Hilbert-style formalisation of syntax. import BasicIPC.Syntax.HilbertSequential -- Sequences of terms. import BasicIPC.Syntax.Hilbert -- Nested terms. -- Gentzen-style formalisation of syntax. import BasicIPC.Syntax.Gentzen -- Simple terms. import BasicIPC.Syntax.GentzenNormalForm -- Normal forms and neutrals. import BasicIPC.Syntax.GentzenSpinalNormalForm -- Normal forms, neutrals, and spines. -- Translation between different formalisations of syntax. import BasicIPC.Syntax.Translation -- Basic Tarski-style semantics, for soundness only. import BasicIPC.Semantics.BasicTarski -- Tarski-style semantics with glueing for α and ▻, after Coquand-Dybjer. import BasicIPC.Semantics.TarskiGluedClosedImplicit -- Implicit closed syntax. import BasicIPC.Semantics.TarskiGluedClosedHilbert -- Hilbert-style closed syntax. -- Tarski-style semantics with contexts as concrete worlds, and glueing for α and ▻. import BasicIPC.Semantics.TarskiConcreteGluedImplicit -- Implicit syntax. import BasicIPC.Semantics.TarskiConcreteGluedHilbert -- Hilbert-style syntax. import BasicIPC.Semantics.TarskiConcreteGluedGentzen -- Gentzen-style syntax. -- Kripke-style semantics with contexts as concrete worlds, and glueing for α and ▻. import BasicIPC.Semantics.KripkeConcreteGluedImplicit -- Implicit syntax. import BasicIPC.Semantics.KripkeConcreteGluedHilbert -- Hilbert-style syntax. import BasicIPC.Semantics.KripkeConcreteGluedGentzen -- Gentzen-style syntax. -- Kripke-style semantics with contexts as concrete worlds. import BasicIPC.Semantics.KripkeConcrete -- Kripke-style semantics with abstract worlds. import BasicIPC.Semantics.KripkeMcKinseyTarski -- McKinsey-Tarski embedding. import BasicIPC.Semantics.KripkeGodel -- Gödel embedding. -- Available metatheory for basic IPC. -- -- ┌─────┬─────┬─────┬─────┬─────┐ -- │ CH │ H │ G │ Gⁿᶠ │ Gˢⁿᶠ│ -- ┌─────┼─────┼─────┼─────┼─────┼─────┤ -- │ BT │ e₀ │ e │ e │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TGCI│ e₀q₀│ eq₀ │ eq₀ │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TGCH│ e₀q₀│ eq₀ │ │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TCGI│ │ eq │ eq │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TCGH│ │ eq │ eq │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TCGG│ │ eq │ eq │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ KCGI│ │ eq │ eq │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ KCGH│ │ eq │ eq │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ KCGG│ │ eq │ eq │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ KC │ │ eq │ eq │ eq │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ KMT │ │ eq │ eq │ eq │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ KG │ │ eq │ eq │ eq │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ HS │ │ │ │ │ n │ -- └─────┴─────┴─────┴─────┴─────┴─────┘ -- -- e₀ : Soundness only, for closed terms only. -- e₀q₀ : Soundness and completeness, for closed terms only. -- e : Soundness only. -- eq₀ : Soundness, for all terms; completeness, for closed terms only. -- eq : Soundness and completeness, or normalisation by evaluation. -- n : Normalisation by other means. import BasicIPC.Metatheory.ClosedHilbert-BasicTarski import BasicIPC.Metatheory.ClosedHilbert-TarskiGluedClosedImplicit import BasicIPC.Metatheory.ClosedHilbert-TarskiGluedClosedHilbert import BasicIPC.Metatheory.Hilbert-BasicTarski import BasicIPC.Metatheory.Hilbert-TarskiGluedClosedImplicit import BasicIPC.Metatheory.Hilbert-TarskiGluedClosedHilbert import BasicIPC.Metatheory.Hilbert-TarskiConcreteGluedImplicit import BasicIPC.Metatheory.Hilbert-TarskiConcreteGluedHilbert import BasicIPC.Metatheory.Hilbert-TarskiConcreteGluedGentzen import BasicIPC.Metatheory.Hilbert-KripkeConcreteGluedImplicit import BasicIPC.Metatheory.Hilbert-KripkeConcreteGluedHilbert import BasicIPC.Metatheory.Hilbert-KripkeConcreteGluedGentzen import BasicIPC.Metatheory.Hilbert-KripkeConcrete import BasicIPC.Metatheory.Hilbert-KripkeMcKinseyTarski import BasicIPC.Metatheory.Hilbert-KripkeGodel import BasicIPC.Metatheory.Gentzen-BasicTarski import BasicIPC.Metatheory.Gentzen-TarskiGluedClosedImplicit import BasicIPC.Metatheory.Gentzen-TarskiConcreteGluedImplicit import BasicIPC.Metatheory.Gentzen-TarskiConcreteGluedHilbert import BasicIPC.Metatheory.Gentzen-TarskiConcreteGluedGentzen import BasicIPC.Metatheory.Gentzen-KripkeConcreteGluedImplicit import BasicIPC.Metatheory.Gentzen-KripkeConcreteGluedHilbert import BasicIPC.Metatheory.Gentzen-KripkeConcreteGluedGentzen import BasicIPC.Metatheory.Gentzen-KripkeConcrete import BasicIPC.Metatheory.Gentzen-KripkeMcKinseyTarski import BasicIPC.Metatheory.Gentzen-KripkeGodel import BasicIPC.Metatheory.GentzenNormalForm-KripkeConcrete import BasicIPC.Metatheory.GentzenNormalForm-KripkeMcKinseyTarski import BasicIPC.Metatheory.GentzenNormalForm-KripkeGodel import BasicIPC.Metatheory.GentzenSpinalNormalForm-HereditarySubstitution -- TODO -- Common syntax. import BasicT.Syntax.Common -- Gentzen-style formalisation of syntax. import BasicT.Syntax.Gentzen import BasicT.Syntax.GentzenNormalForm -- Basic Tarski-style semantics, for soundness only. import BasicT.Semantics.BasicTarski -- Available metatheory. import BasicT.Metatheory.Gentzen-BasicTarski import BasicT.Metatheory.GentzenNormalForm-Unknown -- Intuitionistic propositional calculus. -- Common syntax. import IPC.Syntax.Common -- Hilbert-style formalisation of closed syntax. import IPC.Syntax.ClosedHilbertSequential -- Sequences of terms. import IPC.Syntax.ClosedHilbert -- Nested terms. -- Hilbert-style formalisation of syntax. import IPC.Syntax.HilbertSequential -- Sequences of terms. import IPC.Syntax.Hilbert -- Nested terms. -- Gentzen-style formalisation of syntax. import IPC.Syntax.Gentzen -- Simple terms. import IPC.Syntax.GentzenNormalForm -- Normal forms and neutrals. import IPC.Syntax.GentzenSpinalNormalForm -- Normal forms, neutrals, and spines. -- Translation between different formalisations of syntax. import IPC.Syntax.Translation -- Basic Tarski-style semantics, for soundness only. import IPC.Semantics.BasicTarski -- Kripke-style semantics with exploding abstract worlds. import IPC.Semantics.KripkeExploding -- Available metatheory for IPC. -- -- ┌─────┬─────┬─────┬─────┬─────┐ -- │ CH │ H │ G │ Gⁿᶠ │ Gˢⁿᶠ│ -- ┌─────┼─────┼─────┼─────┼─────┼─────┤ -- │ BT │ e₀ │ e │ e │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ KE │ │ │ eq │ eq │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ HS │ │ │ │ │ n │ -- └─────┴─────┴─────┴─────┴─────┴─────┘ -- -- e₀ : Soundness only, for closed terms only. -- e₀q₀ : Soundness and completeness, for closed terms only. -- e : Soundness only. -- eq₀ : Soundness, for all terms; completeness, for closed terms only. -- eq : Soundness and completeness, or normalisation by evaluation. -- n : Normalisation by other means. import IPC.Metatheory.ClosedHilbert-BasicTarski import IPC.Metatheory.Hilbert-BasicTarski import IPC.Metatheory.Gentzen-BasicTarski import IPC.Metatheory.Gentzen-KripkeExploding import IPC.Metatheory.GentzenNormalForm-KripkeExploding import IPC.Metatheory.GentzenSpinalNormalForm-HereditarySubstitution -- Basic intuitionistic modal logic S4, without ∨, ⊥, or ◇. -- Common syntax. import BasicIS4.Syntax.Common -- Hilbert-style formalisation of closed syntax. import BasicIS4.Syntax.ClosedHilbertSequential -- Sequences of terms. import BasicIS4.Syntax.ClosedHilbert -- Nested terms. -- Hilbert-style formalisation of syntax. import BasicIS4.Syntax.HilbertSequential -- Sequences of terms. import BasicIS4.Syntax.Hilbert -- Nested terms. -- Gentzen-style formalisation of syntax, after Bierman-de Paiva. import BasicIS4.Syntax.Gentzen -- Hilbert-style formalisation of syntax with context pairs. import BasicIS4.Syntax.DyadicHilbertSequential -- Sequences of terms. import BasicIS4.Syntax.DyadicHilbert -- Nested terms. -- Gentzen-style formalisation of syntax with context pairs, after Pfenning-Davies. import BasicIS4.Syntax.DyadicGentzen -- Simple terms. import BasicIS4.Syntax.DyadicGentzenNormalForm -- Normal forms and neutrals. import BasicIS4.Syntax.DyadicGentzenSpinalNormalForm -- Normal forms, neutrals, and spines. -- Gentzen-style formalisation of labelled syntax, after Basin-Matthews-Viganò. import BasicIS4.Syntax.LabelledGentzen -- Translation between different formalisations of syntax. import BasicIS4.Syntax.Translation -- Basic Kripke-style semantics with abstract worlds, for soundness only. import BasicIS4.Semantics.BasicKripkeOno -- Ono-style conditions. import BasicIS4.Semantics.BasicKripkeBozicDosen -- Božić-Došen-style conditions. import BasicIS4.Semantics.BasicKripkeEwald -- Ewald-style conditions. import BasicIS4.Semantics.BasicKripkeAlechina -- Alechina-style conditions. -- Tarski-style semantics with glueing for α, ▻, and □, after Gabbay-Nanevski. import BasicIS4.Semantics.TarskiClosedOvergluedImplicit -- Implicit closed syntax. import BasicIS4.Semantics.TarskiClosedOvergluedHilbert -- Hilbert-style closed syntax. -- Tarski-style semantics with contexts as concrete worlds, and glueing for α, ▻, and □. import BasicIS4.Semantics.TarskiOvergluedImplicit -- Implicit syntax. import BasicIS4.Semantics.TarskiOvergluedHilbert -- Hilbert-style syntax. import BasicIS4.Semantics.TarskiOvergluedGentzen -- Gentzen-style syntax. -- Tarski-style semantics with contexts as concrete worlds, and glueing for □ only. import BasicIS4.Semantics.TarskiGluedImplicit -- Implicit syntax. import BasicIS4.Semantics.TarskiGluedHilbert -- Hilbert-style syntax. import BasicIS4.Semantics.TarskiGluedGentzen -- Gentzen-style syntax. -- Tarski-style semantics with context pairs as concrete worlds, and glueing for α, ▻, and □. import BasicIS4.Semantics.TarskiOvergluedDyadicImplicit -- Implicit syntax. import BasicIS4.Semantics.TarskiOvergluedDyadicHilbert -- Hilbert-style syntax. import BasicIS4.Semantics.TarskiOvergluedDyadicGentzen -- Gentzen-style syntax. -- Tarski-style semantics with context pairs as concrete worlds, and glueing for □ only. import BasicIS4.Semantics.TarskiGluedDyadicImplicit -- Implicit syntax. -- TODO import BasicIS4.Semantics.TarskiGluedDyadicHilbert -- Hilbert-style syntax. import BasicIS4.Semantics.TarskiGluedDyadicGentzen -- Gentzen-style syntax. -- Canonical model equipment for Kripke-style semantics with contexts as concrete worlds. import BasicIS4.Equipment.KripkeCanonical import BasicIS4.Equipment.KripkeNonCanonical -- Canonical model equipment for Kripke-style semantics with context pairs as concrete worlds. import BasicIS4.Equipment.KripkeDyadicCanonical import BasicIS4.Equipment.KripkeDyadicNonCanonical -- Available metatheory for basic IS4. -- -- ┌─────┬─────┬─────┬─────┬─────┐ -- │ CH │ H │ G │ DH │ DG │ -- ┌─────┼─────┼─────┼─────┼─────┼─────┤ -- │ BKO │ │ e │ e │ e │ e │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ BKBD│ │ e │ e │ e │ e │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ BKE │ │ e │ e │ e │ e │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ BKA&│ │ e │ e │ e │ e │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TCOI│ e₀q₀│ eq₀ │ eq₀ │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TCOH│ e₀q₀│ eq₀ │ │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TOI │ │ eq │ eq │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TOH │ │ eq │ │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TOG │ │ eq │ eq │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TGI │ │ eq │ WIP │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TGH │ │ eq │ │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TGG │ │ │ WIP │ │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TODI│ │ │ │ eq │ eq │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TODH│ │ │ │ eq │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TODG│ │ │ │ eq │ eq │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TGDI│ │ │ │ WIP │ WIP │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TGDH│ │ │ │ WIP │ │ -- ├─────┼─────┼─────┼─────┼─────┼─────┤ -- │ TGDG│ │ │ │ │ WIP │ -- └─────┴─────┴─────┴─────┴─────┴─────┘ -- -- e₀ : Soundness only, for closed terms only. -- e₀q₀ : Soundness and completeness, for closed terms only. -- e : Soundness only. -- eq₀ : Soundness, for all terms; completeness, for closed terms only. -- eq : Soundness and completeness, or normalisation by evaluation. -- WIP : Work in progress. import BasicIS4.Metatheory.ClosedHilbert-TarskiClosedOvergluedImplicit import BasicIS4.Metatheory.ClosedHilbert-TarskiClosedOvergluedHilbert import BasicIS4.Metatheory.Hilbert-BasicKripkeOno import BasicIS4.Metatheory.Hilbert-BasicKripkeBozicDosen import BasicIS4.Metatheory.Hilbert-BasicKripkeEwald import BasicIS4.Metatheory.Hilbert-BasicKripkeAlechina import BasicIS4.Metatheory.Hilbert-TarskiClosedOvergluedImplicit import BasicIS4.Metatheory.Hilbert-TarskiClosedOvergluedHilbert import BasicIS4.Metatheory.Hilbert-TarskiOvergluedImplicit import BasicIS4.Metatheory.Hilbert-TarskiOvergluedHilbert import BasicIS4.Metatheory.Hilbert-TarskiOvergluedGentzen import BasicIS4.Metatheory.Hilbert-TarskiGluedImplicit import BasicIS4.Metatheory.Hilbert-TarskiGluedHilbert import BasicIS4.Metatheory.Gentzen-BasicKripkeOno import BasicIS4.Metatheory.Gentzen-BasicKripkeBozicDosen import BasicIS4.Metatheory.Gentzen-BasicKripkeEwald import BasicIS4.Metatheory.Gentzen-BasicKripkeAlechina import BasicIS4.Metatheory.Gentzen-TarskiClosedOvergluedImplicit import BasicIS4.Metatheory.Gentzen-TarskiOvergluedImplicit import BasicIS4.Metatheory.Gentzen-TarskiOvergluedGentzen import BasicIS4.Metatheory.Gentzen-TarskiGluedImplicit -- FIXME import BasicIS4.Metatheory.Gentzen-TarskiGluedGentzen -- FIXME import BasicIS4.Metatheory.DyadicHilbert-BasicKripkeOno import BasicIS4.Metatheory.DyadicHilbert-BasicKripkeBozicDosen import BasicIS4.Metatheory.DyadicHilbert-BasicKripkeEwald import BasicIS4.Metatheory.DyadicHilbert-BasicKripkeAlechina import BasicIS4.Metatheory.DyadicHilbert-TarskiOvergluedDyadicImplicit import BasicIS4.Metatheory.DyadicHilbert-TarskiOvergluedDyadicHilbert import BasicIS4.Metatheory.DyadicHilbert-TarskiOvergluedDyadicGentzen import BasicIS4.Metatheory.DyadicHilbert-TarskiGluedDyadicImplicit -- FIXME import BasicIS4.Metatheory.DyadicHilbert-TarskiGluedDyadicHilbert import BasicIS4.Metatheory.DyadicGentzen-BasicKripkeOno import BasicIS4.Metatheory.DyadicGentzen-BasicKripkeBozicDosen import BasicIS4.Metatheory.DyadicGentzen-BasicKripkeEwald import BasicIS4.Metatheory.DyadicGentzen-BasicKripkeAlechina import BasicIS4.Metatheory.DyadicGentzen-TarskiOvergluedDyadicImplicit import BasicIS4.Metatheory.DyadicGentzen-TarskiOvergluedDyadicGentzen import BasicIS4.Metatheory.DyadicGentzen-TarskiGluedDyadicImplicit -- FIXME import BasicIS4.Metatheory.DyadicGentzen-TarskiGluedDyadicGentzen -- FIXME import BasicIS4.Metatheory.DyadicGentzenSpinalNormalForm-HereditarySubstitution -- Basic intuitionistic contextual modal logic, without ∨ or ⊥. -- Common syntax. import BasicICML.Syntax.Common -- Gentzen-style formalisation of syntax with context pairs, after Nanevski-Pfenning-Pientka. import BasicICML.Syntax.DyadicGentzen import BasicICML.Syntax.DyadicGentzenNormalForm import BasicICML.Syntax.DyadicGentzenSpinalNormalForm -- Available metatheory for basic ICML. import BasicICML.Metatheory.DyadicGentzenSpinalNormalForm-HereditarySubstitution -- Basic intuitionistic logic of proofs, without ∨, ⊥, or +. -- Common syntax. import BasicILP.Syntax.Common -- Gentzen-style formalisation of syntax with context pairs. import BasicILP.Syntax.DyadicGentzen import BasicILP.Syntax.DyadicGentzenNormalForm -- (To be rewritten.) -- Common syntax, with types parametrised by a closed, untyped representation of syntax. import OldBasicILP.UntypedSyntax.Common -- Hilbert-style formalisation of closed syntax. import OldBasicILP.UntypedSyntax.ClosedHilbertSequential -- Sequences of terms. import OldBasicILP.UntypedSyntax.ClosedHilbert -- Nested terms. -- Translation between different formalisations of syntax. import OldBasicILP.UntypedSyntax.Translation -- FIXME -- Common syntax, with types parametrised by closed syntax. import OldBasicILP.Syntax.Common -- Hilbert-style formalisation of closed syntax. import OldBasicILP.Syntax.ClosedHilbertSequential -- Sequences of terms. import OldBasicILP.Syntax.ClosedHilbert -- Nested terms. -- Translation between different formalisations of syntax. import OldBasicILP.Syntax.Translation -- FIXME -- import OldBasicILP.Syntax.Projection -- FIXME -- (To be rewritten.) import OlderBasicILP.Indirect import OlderBasicILP.Indirect.Hilbert.Sequential import OlderBasicILP.Indirect.Hilbert.Nested import OlderBasicILP.Indirect.Gentzen -- import OlderBasicILP.Indirect.Translation import OlderBasicILP.Direct.Hilbert.Nested import OlderBasicILP.Direct.Gentzen -- import OlderBasicILP.Direct.Translation	{ "alphanum_fraction": 0.6896925663, "avg_line_length": 39.0741525424, "ext": "agda", "hexsha": "53517d1bc506796910aa1f00a084e6caae34564f", "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": "Everything.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": "Everything.agda", "max_line_length": 94, "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": "Everything.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": 5965, "size": 18443 }
module IPL where data _∧_ (P : Set) (Q : Set) : Set where ∧-intro : P → Q → (P ∧ Q) proof₁ : {P Q : Set} → (P ∧ Q) → P proof₁ (∧-intro p q) = p proof₂ : {P Q : Set} → (P ∧ Q) → Q proof₂ (∧-intro p q) = q _⇔_ : (P : Set) → (Q : Set) → Set a ⇔ b = (a → b) ∧ (b → a) ∧-comm′ : (P Q : Set) → (P ∧ Q) → (Q ∧ P) ∧-comm′ _ _ (∧-intro p q) = ∧-intro q p ∧-comm : (P Q : Set) → (P ∧ Q) ⇔ (Q ∧ P) ∧-comm P Q = ∧-intro (∧-comm′ P Q) (∧-comm′ Q P) ∧-comm1′ : {P Q : Set} → (P ∧ Q) → (Q ∧ P) ∧-comm1′ (∧-intro p q) = ∧-intro q p data _∨_ (P Q : Set) : Set where ∨-intro₁ : P → P ∨ Q ∨-intro₂ : Q → P ∨ Q ∨-elim : {A B C : Set} → (A → C) → (B → C) → (A ∨ B) → C ∨-elim ac bc (∨-intro₁ a) = ac a ∨-elim ac bc (∨-intro₂ b) = bc b ∨-comm′ : {A B : Set} → (A ∨ B) → (B ∨ A) ∨-comm′ (∨-intro₁ a) = ∨-intro₂ a ∨-comm′ (∨-intro₂ b) = ∨-intro₁ b ∨-comm : {A B : Set} → (A ∨ B) ⇔ (B ∨ A) ∨-comm = ∧-intro ∨-comm′ ∨-comm′ data ⊥ : Set where ¬ : Set → Set ¬ A = A → ⊥	{ "alphanum_fraction": 0.4219712526, "avg_line_length": 18.3773584906, "ext": "agda", "hexsha": "6fbdc19033d4ca5c3209752661d0580d0b004364", "lang": "Agda", "max_forks_count": 2, "max_forks_repo_forks_event_max_datetime": "2017-06-03T06:32:26.000Z", "max_forks_repo_forks_event_min_datetime": "2015-12-02T02:10:26.000Z", "max_forks_repo_head_hexsha": "a6fc111e02dc631f56302bb059d855446792bebc", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "shouya/thinking-dumps", "max_forks_repo_path": "learyouanagda/IPL.agda", "max_issues_count": 1, "max_issues_repo_head_hexsha": "a6fc111e02dc631f56302bb059d855446792bebc", "max_issues_repo_issues_event_max_datetime": "2015-08-04T22:05:11.000Z", "max_issues_repo_issues_event_min_datetime": "2015-06-14T06:07:33.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "shouya/thinking-dumps", "max_issues_repo_path": "learyouanagda/IPL.agda", "max_line_length": 56, "max_stars_count": 24, "max_stars_repo_head_hexsha": "a6fc111e02dc631f56302bb059d855446792bebc", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "shouya/thinking-dumps", "max_stars_repo_path": "learyouanagda/IPL.agda", "max_stars_repo_stars_event_max_datetime": "2022-01-09T01:02:15.000Z", "max_stars_repo_stars_event_min_datetime": "2015-02-14T17:18:34.000Z", "num_tokens": 516, "size": 974 }
------------------------------------------------------------------------ -- The Agda standard library -- -- Conversion of ≤ to <, along with a number of properties ------------------------------------------------------------------------ -- Possible TODO: Prove that a conversion ≤ → < → ≤ returns a -- relation equivalent to the original one (and similarly for -- < → ≤ → <). open import Relation.Binary module Relation.Binary.NonStrictToStrict {a ℓ₁ ℓ₂} {A : Set a} (_≈_ : Rel A ℓ₁) (_≤_ : Rel A ℓ₂) where open import Relation.Nullary open import Relation.Binary.Consequences open import Function open import Data.Product open import Data.Sum ------------------------------------------------------------------------ -- Conversion -- _≤_ can be turned into _<_ as follows: _<_ : Rel A _ x < y = (x ≤ y) × ¬ (x ≈ y) ------------------------------------------------------------------------ -- The converted relations have certain properties -- (if the original relations have certain other properties) irrefl : Irreflexive _≈_ _<_ irrefl x≈y x<y = proj₂ x<y x≈y trans : IsPartialOrder _≈_ _≤_ → Transitive _<_ trans po = λ x<y y<z → ( PO.trans (proj₁ x<y) (proj₁ y<z) , λ x≈z → proj₂ x<y $ lemma (proj₁ x<y) (proj₁ y<z) x≈z ) where module PO = IsPartialOrder po lemma : ∀ {x y z} → x ≤ y → y ≤ z → x ≈ z → x ≈ y lemma x≤y y≤z x≈z = PO.antisym x≤y $ PO.trans y≤z (PO.reflexive $ PO.Eq.sym x≈z) antisym⟶asym : Antisymmetric _≈_ _≤_ → Asymmetric _<_ antisym⟶asym antisym (x≤y , ¬x≈y) (y≤x , ¬y≈x) = ¬x≈y (antisym x≤y y≤x) <-resp-≈ : IsEquivalence _≈_ → _≤_ Respects₂ _≈_ → _<_ Respects₂ _≈_ <-resp-≈ eq ≤-resp-≈ = (λ {x y' y} y'≈y x<y' → ( proj₁ ≤-resp-≈ y'≈y (proj₁ x<y') , λ x≈y → proj₂ x<y' (Eq.trans x≈y (Eq.sym y'≈y)) ) ) , (λ {y x' x} x'≈x x'<y → ( proj₂ ≤-resp-≈ x'≈x (proj₁ x'<y) , λ x≈y → proj₂ x'<y (Eq.trans x'≈x x≈y) )) where module Eq = IsEquivalence eq trichotomous : Symmetric _≈_ → Decidable _≈_ → Antisymmetric _≈_ _≤_ → Total _≤_ → Trichotomous _≈_ _<_ trichotomous ≈-sym ≈-dec antisym total x y with ≈-dec x y ... \| yes x≈y = tri≈ (irrefl x≈y) x≈y (irrefl (≈-sym x≈y)) ... \| no x≉y with total x y ... \| inj₁ x≤y = tri< (x≤y , x≉y) x≉y (x≉y ∘ antisym x≤y ∘ proj₁) ... \| inj₂ x≥y = tri> (x≉y ∘ flip antisym x≥y ∘ proj₁) x≉y (x≥y , x≉y ∘ ≈-sym) decidable : Decidable _≈_ → Decidable _≤_ → Decidable _<_ decidable ≈-dec ≤-dec x y with ≈-dec x y \| ≤-dec x y ... \| yes x≈y \| _ = no (flip proj₂ x≈y) ... \| no x≉y \| yes x≤y = yes (x≤y , x≉y) ... \| no x≉y \| no x≰y = no (x≰y ∘ proj₁) isPartialOrder⟶isStrictPartialOrder : IsPartialOrder _≈_ _≤_ → IsStrictPartialOrder _≈_ _<_ isPartialOrder⟶isStrictPartialOrder po = record { isEquivalence = PO.isEquivalence ; irrefl = irrefl ; trans = trans po ; <-resp-≈ = <-resp-≈ PO.isEquivalence PO.≤-resp-≈ } where module PO = IsPartialOrder po isTotalOrder⟶isStrictTotalOrder : Decidable _≈_ → IsTotalOrder _≈_ _≤_ → IsStrictTotalOrder _≈_ _<_ isTotalOrder⟶isStrictTotalOrder dec-≈ tot = record { isEquivalence = TO.isEquivalence ; trans = trans TO.isPartialOrder ; compare = trichotomous TO.Eq.sym dec-≈ TO.antisym TO.total ; <-resp-≈ = <-resp-≈ TO.isEquivalence TO.≤-resp-≈ } where module TO = IsTotalOrder tot isDecTotalOrder⟶isStrictTotalOrder : IsDecTotalOrder _≈_ _≤_ → IsStrictTotalOrder _≈_ _<_ isDecTotalOrder⟶isStrictTotalOrder dtot = isTotalOrder⟶isStrictTotalOrder DTO._≟_ DTO.isTotalOrder where module DTO = IsDecTotalOrder dtot	{ "alphanum_fraction": 0.5625342841, "avg_line_length": 33.7592592593, "ext": "agda", "hexsha": "73e2eed20a132478a4d0490a1e70c2f0108c7e4b", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "9d4c43b1609d3f085636376fdca73093481ab882", "max_forks_repo_licenses": [ "Apache-2.0" ], "max_forks_repo_name": "qwe2/try-agda", "max_forks_repo_path": "agda-stdlib-0.9/src/Relation/Binary/NonStrictToStrict.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "9d4c43b1609d3f085636376fdca73093481ab882", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "Apache-2.0" ], "max_issues_repo_name": "qwe2/try-agda", "max_issues_repo_path": "agda-stdlib-0.9/src/Relation/Binary/NonStrictToStrict.agda", "max_line_length": 72, "max_stars_count": 1, "max_stars_repo_head_hexsha": "9d4c43b1609d3f085636376fdca73093481ab882", "max_stars_repo_licenses": [ "Apache-2.0" ], "max_stars_repo_name": "qwe2/try-agda", "max_stars_repo_path": "agda-stdlib-0.9/src/Relation/Binary/NonStrictToStrict.agda", "max_stars_repo_stars_event_max_datetime": "2016-10-20T15:52:05.000Z", "max_stars_repo_stars_event_min_datetime": "2016-10-20T15:52:05.000Z", "num_tokens": 1384, "size": 3646 }
-- This module is used to illustrate how to import a non-parameterised module. module examples.syntax.ModuleA where data Nat : Set where zero : Nat suc : Nat -> Nat plus : Nat -> Nat -> Nat eval : Nat -> Nat eval zero = zero eval (suc x) = suc (eval x) eval (plus zero y) = eval y eval (plus (suc x) y) = suc (eval (plus x y)) eval (plus (plus x y) z) = eval (plus x (plus y z))	{ "alphanum_fraction": 0.5787037037, "avg_line_length": 25.4117647059, "ext": "agda", "hexsha": "4a77449488fbd7dcde1b9f52534f28351388fc07", "lang": "Agda", "max_forks_count": 1, "max_forks_repo_forks_event_max_datetime": "2022-03-12T11:35:18.000Z", "max_forks_repo_forks_event_min_datetime": "2022-03-12T11:35:18.000Z", "max_forks_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "masondesu/agda", "max_forks_repo_path": "examples/outdated-and-incorrect/syntax/ModuleA.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "masondesu/agda", "max_issues_repo_path": "examples/outdated-and-incorrect/syntax/ModuleA.agda", "max_line_length": 78, "max_stars_count": 1, "max_stars_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "asr/agda-kanso", "max_stars_repo_path": "examples/outdated-and-incorrect/syntax/ModuleA.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": 138, "size": 432 }
-- Andreas, 2012-09-24 Ensure that size successor is monotone {-# OPTIONS --sized-types #-} module SizeSucMonotone where open import Common.Size data Bool : Set where true false : Bool -- T should be monotone in its second arg T : Bool → Size → Set T true i = Size< i T false i = Size< (↑ i) test : {x : Bool}{i : Size}{j : Size< i} → T x j → T x i test h = h	{ "alphanum_fraction": 0.6467391304, "avg_line_length": 20.4444444444, "ext": "agda", "hexsha": "50929eca1d6b85e2437e0e55941884f581f6690c", "lang": "Agda", "max_forks_count": 1, "max_forks_repo_forks_event_max_datetime": "2022-03-12T11:35:18.000Z", "max_forks_repo_forks_event_min_datetime": "2022-03-12T11:35:18.000Z", "max_forks_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "masondesu/agda", "max_forks_repo_path": "test/succeed/SizeSucMonotone.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/SizeSucMonotone.agda", "max_line_length": 61, "max_stars_count": 1, "max_stars_repo_head_hexsha": "477c8c37f948e6038b773409358fd8f38395f827", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "larrytheliquid/agda", "max_stars_repo_path": "test/succeed/SizeSucMonotone.agda", "max_stars_repo_stars_event_max_datetime": "2018-10-10T17:08:44.000Z", "max_stars_repo_stars_event_min_datetime": "2018-10-10T17:08:44.000Z", "num_tokens": 119, "size": 368 }
module Data.String.Exts where open import Data.Bool hiding (_<?_) open import Data.Char hiding (_<?_) open import Data.String hiding (_<?_) open import Data.Maybe open import Data.Nat open import Relation.Nullary.Decidable {-# FOREIGN GHC import Data.Text #-} postulate strHead : String -> Maybe Char strNull : String -> Bool strTake : ℕ -> String -> String strDrop : ℕ -> String -> String stripPrefix : String -> String -> Maybe String strLength : String -> ℕ {-# COMPILE GHC strHead = (fmap fst) . uncons #-} {-# COMPILE GHC strNull = Data.Text.null #-} {-# COMPILE GHC strTake = Data.Text.take . fromIntegral #-} {-# COMPILE GHC strDrop = Data.Text.drop . fromIntegral #-} {-# COMPILE GHC stripPrefix = stripPrefix #-} {-# COMPILE GHC strLength = toInteger . Data.Text.length #-} shortenString : ℕ -> String -> String shortenString l s = if ⌊ length s <? l ⌋ then s else strTake l s ++ "..."	{ "alphanum_fraction": 0.6772082879, "avg_line_length": 27.7878787879, "ext": "agda", "hexsha": "99ac2b5fa49d0fa4689c0093a90ecd79c39b0fe8", "lang": "Agda", "max_forks_count": 2, "max_forks_repo_forks_event_max_datetime": "2021-10-20T10:46:20.000Z", "max_forks_repo_forks_event_min_datetime": "2019-06-27T23:12:48.000Z", "max_forks_repo_head_hexsha": "62fa6f36e4555360d94041113749bbb6d291691c", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "WhatisRT/meta-cedille", "max_forks_repo_path": "stdlib-exts/Data/String/Exts.agda", "max_issues_count": 10, "max_issues_repo_head_hexsha": "62fa6f36e4555360d94041113749bbb6d291691c", "max_issues_repo_issues_event_max_datetime": "2020-04-25T15:29:17.000Z", "max_issues_repo_issues_event_min_datetime": "2019-06-13T17:44:43.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "WhatisRT/meta-cedille", "max_issues_repo_path": "stdlib-exts/Data/String/Exts.agda", "max_line_length": 73, "max_stars_count": 35, "max_stars_repo_head_hexsha": "62fa6f36e4555360d94041113749bbb6d291691c", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "WhatisRT/meta-cedille", "max_stars_repo_path": "stdlib-exts/Data/String/Exts.agda", "max_stars_repo_stars_event_max_datetime": "2021-10-12T22:59:10.000Z", "max_stars_repo_stars_event_min_datetime": "2019-06-13T07:44:50.000Z", "num_tokens": 239, "size": 917 }
{-# OPTIONS --without-K --rewriting #-} open import HoTT import homotopy.RelativelyConstantToSetExtendsViaSurjection as SurjExt module homotopy.vankampen.Code {i j k l} (span : Span {i} {j} {k}) {D : Type l} (h : D → Span.C span) (h-is-surj : is-surj h) where open Span span open import homotopy.vankampen.CodeAP span h h-is-surj open import homotopy.vankampen.CodeBP span h h-is-surj pcAA-to-pcBA : ∀ d₀ {a} → precodeAA (f (h d₀)) a → precodeBA (g (h d₀)) a pcAB-to-pcBB : ∀ d₀ {b} → precodeAB (f (h d₀)) b → precodeBB (g (h d₀)) b pcAA-to-pcBA d₀ (pc-a pA) = pc-bba d₀ (pc-b idp₀) pA pcAA-to-pcBA d₀ (pc-aba d pc pA) = pc-bba d (pcAB-to-pcBB d₀ pc) pA pcAB-to-pcBB d₀ (pc-aab d pc pB) = pc-bab d (pcAA-to-pcBA d₀ pc) pB abstract pcAA-to-pcBA-rel : ∀ d₀ {a} {pcAA₁ pcAA₂ : precodeAA (f (h d₀)) a} → precodeAA-rel pcAA₁ pcAA₂ → precodeBA-rel (pcAA-to-pcBA d₀ pcAA₁) (pcAA-to-pcBA d₀ pcAA₂) pcAB-to-pcBB-rel : ∀ d₀ {a} {pcAB₁ pcAB₂ : precodeAB (f (h d₀)) a} → precodeAB-rel pcAB₁ pcAB₂ → precodeBB-rel (pcAB-to-pcBB d₀ pcAB₁) (pcAB-to-pcBB d₀ pcAB₂) pcAA-to-pcBA-rel d₀ (pcAAr-idp₀-idp₀ pcAA) = pcBAr-idp₀-idp₀ (pcAA-to-pcBA d₀ pcAA) pcAA-to-pcBA-rel d₀ (pcAAr-cong r pA) = pcBAr-cong (pcAB-to-pcBB-rel d₀ r) pA pcAB-to-pcBB-rel d₀ (pcABr-idp₀-idp₀ pcAB) = pcBBr-idp₀-idp₀ (pcAB-to-pcBB d₀ pcAB) pcAB-to-pcBB-rel d₀ (pcABr-switch pcAB pC) = pcBBr-switch (pcAB-to-pcBB d₀ pcAB) pC pcAB-to-pcBB-rel d₀ (pcABr-cong r pB) = pcBBr-cong (pcAA-to-pcBA-rel d₀ r) pB cAA-to-cBA : ∀ d₀ {a} → codeAA (f (h d₀)) a → codeBA (g (h d₀)) a cAA-to-cBA d₀ = SetQuot-rec SetQuot-level (q[_] ∘ pcAA-to-pcBA d₀) (quot-rel ∘ pcAA-to-pcBA-rel d₀) cAB-to-cBB : ∀ d₀ {b} → codeAB (f (h d₀)) b → codeBB (g (h d₀)) b cAB-to-cBB d₀ = SetQuot-rec SetQuot-level (q[_] ∘ pcAB-to-pcBB d₀) (quot-rel ∘ pcAB-to-pcBB-rel d₀) -- BX to AX pcBA-to-pcAA : ∀ d₀ {a} → precodeBA (g (h d₀)) a → precodeAA (f (h d₀)) a pcBB-to-pcAB : ∀ d₀ {b} → precodeBB (g (h d₀)) b → precodeAB (f (h d₀)) b pcBA-to-pcAA d₀ (pc-bba d pc pA) = pc-aba d (pcBB-to-pcAB d₀ pc) pA pcBB-to-pcAB d₀ (pc-b pB) = pc-aab d₀ (pc-a idp₀) pB pcBB-to-pcAB d₀ (pc-bab d pc pB) = pc-aab d (pcBA-to-pcAA d₀ pc) pB abstract pcBA-to-pcAA-rel : ∀ d₀ {a} {pcBA₁ pcBA₂ : precodeBA (g (h d₀)) a} → precodeBA-rel pcBA₁ pcBA₂ → precodeAA-rel (pcBA-to-pcAA d₀ pcBA₁) (pcBA-to-pcAA d₀ pcBA₂) pcBB-to-pcAB-rel : ∀ d₀ {a} {pcBB₁ pcBB₂ : precodeBB (g (h d₀)) a} → precodeBB-rel pcBB₁ pcBB₂ → precodeAB-rel (pcBB-to-pcAB d₀ pcBB₁) (pcBB-to-pcAB d₀ pcBB₂) pcBA-to-pcAA-rel d₀ (pcBAr-idp₀-idp₀ pcBA) = pcAAr-idp₀-idp₀ (pcBA-to-pcAA d₀ pcBA) pcBA-to-pcAA-rel d₀ (pcBAr-cong r pA) = pcAAr-cong (pcBB-to-pcAB-rel d₀ r) pA pcBB-to-pcAB-rel d₀ (pcBBr-idp₀-idp₀ pcBB) = pcABr-idp₀-idp₀ (pcBB-to-pcAB d₀ pcBB) pcBB-to-pcAB-rel d₀ (pcBBr-switch pcBB pC) = pcABr-switch (pcBB-to-pcAB d₀ pcBB) pC pcBB-to-pcAB-rel d₀ (pcBBr-cong r pB) = pcABr-cong (pcBA-to-pcAA-rel d₀ r) pB cBA-to-cAA : ∀ d₀ {a} → codeBA (g (h d₀)) a → codeAA (f (h d₀)) a cBA-to-cAA d₀ = SetQuot-rec SetQuot-level (q[_] ∘ pcBA-to-pcAA d₀) (quot-rel ∘ pcBA-to-pcAA-rel d₀) cBB-to-cAB : ∀ d₀ {b} → codeBB (g (h d₀)) b → codeAB (f (h d₀)) b cBB-to-cAB d₀ = SetQuot-rec SetQuot-level (q[_] ∘ pcBB-to-pcAB d₀) (quot-rel ∘ pcBB-to-pcAB-rel d₀) -- roundtrips abstract pcBA-to-pcAA-to-pcBA : ∀ d₀ {a} (pcBA : precodeBA _ a) → q[ pcAA-to-pcBA d₀ (pcBA-to-pcAA d₀ pcBA) ] == q[ pcBA ] :> codeBA _ a pcBB-to-pcAB-to-pcBB : ∀ d₀ {b} (pcBB : precodeBB _ b) → q[ pcAB-to-pcBB d₀ (pcBB-to-pcAB d₀ pcBB) ] == q[ pcBB ] :> codeBB _ b pcBA-to-pcAA-to-pcBA d₀ (pc-bba d pc pA) = pcBB-to-pcAB-to-pcBB d₀ pc \|in-ctx λ c → c-bba d c pA pcBB-to-pcAB-to-pcBB d₀ (pc-b pB) = pcBB-idp₀-idp₀-head pB pcBB-to-pcAB-to-pcBB d₀ (pc-bab d pc pB) = pcBA-to-pcAA-to-pcBA d₀ pc \|in-ctx λ c → c-bab d c pB pcAA-to-pcBA-to-pcAA : ∀ d₀ {a} (pcAA : precodeAA _ a) → q[ pcBA-to-pcAA d₀ (pcAA-to-pcBA d₀ pcAA) ] == q[ pcAA ] :> codeAA _ a pcAB-to-pcBB-to-pcAB : ∀ d₀ {b} (pcAB : precodeAB _ b) → q[ pcBB-to-pcAB d₀ (pcAB-to-pcBB d₀ pcAB) ] == q[ pcAB ] :> codeAB _ b pcAA-to-pcBA-to-pcAA d₀ (pc-aba d pc pA) = pcAB-to-pcBB-to-pcAB d₀ pc \|in-ctx λ c → c-aba d c pA pcAA-to-pcBA-to-pcAA d₀ (pc-a pA) = pcAA-idp₀-idp₀-head pA pcAB-to-pcBB-to-pcAB d₀ (pc-aab d pc pB) = pcAA-to-pcBA-to-pcAA d₀ pc \|in-ctx λ c → c-aab d c pB private pcAA-lemma : ∀ d₁ d₂ {a₁} (p : h d₂ == h d₁) (pcAA : precodeAA _ a₁) → q[ pcBA-prepend d₁ [ ap g p ] (pcAA-to-pcBA d₁ pcAA) ] == q[ pcAA-to-pcBA d₂ (pcAA-prepend d₁ [ ap f p ] pcAA) ] pcAB-lemma : ∀ d₁ d₂ {b₁} (p : h d₂ == h d₁) (pcAB : precodeAB _ b₁) → q[ pcBB-prepend d₁ [ ap g p ] (pcAB-to-pcBB d₁ pcAB) ] == q[ pcAB-to-pcBB d₂ (pcAB-prepend d₁ [ ap f p ] pcAB) ] pcAA-lemma d₁ d₂ p (pc-a pA) = ap (λ c → c-bba d₁ c pA) $ ! $ q[ ⟧b idp₀ bb⟦ _ ⟧a [ ap f p ] ba⟦ _ ⟧b idp₀ ] =⟨ quot-rel (pcBBr-switch (⟧b idp₀) [ p ]) ⟩ q[ ⟧b idp₀ bb⟦ _ ⟧a idp₀ ba⟦ _ ⟧b [ ap g p ] ] =⟨ pcBB-idp₀-idp₀-head [ ap g p ] ⟩ q[ ⟧b [ ap g p ] ] =⟨ ! (quot-rel (pcBBr-idp₀-idp₀ (pc-b [ ap g p ]))) ⟩ q[ ⟧b [ ap g p ] bb⟦ _ ⟧a idp₀ ba⟦ _ ⟧b idp₀ ] =∎ pcAA-lemma d₁ d₂ p (pc-aba d pc pA) = pcAB-lemma d₁ d₂ p pc \|in-ctx (λ c → c-bba d c pA) pcAB-lemma d₁ d₂ p (pc-aab d pc pB) = pcAA-lemma d₁ d₂ p pc \|in-ctx (λ c → c-bab d c pB) module CodeAAEquivCodeBA (a₁ : A) where eqv-on-image : (d₀ : D) → codeAA (f (h d₀)) a₁ ≃ codeBA (g (h d₀)) a₁ eqv-on-image d₀ = equiv to from to-from from-to where to : codeAA (f (h d₀)) a₁ → codeBA (g (h d₀)) a₁ to = cAA-to-cBA d₀ from : codeBA (g (h d₀)) a₁ → codeAA (f (h d₀)) a₁ from = cBA-to-cAA d₀ abstract to-from : ∀ cBA → to (from cBA) == cBA to-from = SetQuot-elim (λ _ → =-preserves-set SetQuot-is-set) (pcBA-to-pcAA-to-pcBA d₀) (λ _ → prop-has-all-paths-↓ (SetQuot-is-set _ _)) from-to : ∀ cAA → from (to cAA) == cAA from-to = SetQuot-elim (λ _ → =-preserves-set SetQuot-is-set) (pcAA-to-pcBA-to-pcAA d₀) (λ _ → prop-has-all-paths-↓ (SetQuot-is-set _ _)) abstract eqv-is-const : ∀ d₁ d₂ (p : h d₁ == h d₂) → eqv-on-image d₁ == eqv-on-image d₂ [ (λ c → codeAA (f c) a₁ ≃ codeBA (g c) a₁) ↓ p ] eqv-is-const d₁ d₂ p = ↓-Subtype-in (λ d → is-equiv-prop) $ ↓-→-from-transp $ λ= $ SetQuot-elim (λ _ → =-preserves-set SetQuot-is-set) (λ pcAA → transport (λ c → codeBA (g c) a₁) p q[ pcAA-to-pcBA d₁ pcAA ] =⟨ ap-∘ (λ b → codeBA b a₁) g p \|in-ctx (λ p → coe p q[ pcAA-to-pcBA d₁ pcAA ]) ⟩ transport (λ b → codeBA b a₁) (ap g p) q[ pcAA-to-pcBA d₁ pcAA ] =⟨ transp-cBA-l d₁ (ap g p) (pcAA-to-pcBA d₁ pcAA) ⟩ q[ pcBA-prepend d₁ [ ! $ ap g p ] (pcAA-to-pcBA d₁ pcAA) ] =⟨ !-ap g p \|in-ctx (λ p → q[ pcBA-prepend d₁ [ p ] (pcAA-to-pcBA d₁ pcAA) ]) ⟩ q[ pcBA-prepend d₁ [ ap g (! p) ] (pcAA-to-pcBA d₁ pcAA) ] =⟨ pcAA-lemma d₁ d₂ (! p) pcAA ⟩ q[ pcAA-to-pcBA d₂ (pcAA-prepend d₁ [ ap f (! p) ] pcAA) ] =⟨ ap-! f p \|in-ctx (λ p → q[ pcAA-to-pcBA d₂ (pcAA-prepend d₁ [ p ] pcAA) ]) ⟩ q[ pcAA-to-pcBA d₂ (pcAA-prepend d₁ [ ! $ ap f p ] pcAA) ] =⟨ ! $ transp-cAA-l d₁ (ap f p) pcAA \|in-ctx cAA-to-cBA d₂ ⟩ cAA-to-cBA d₂ (transport (λ a → codeAA a a₁) (ap f p) q[ pcAA ]) =⟨ ∘-ap (λ c → codeAA c a₁) f p \|in-ctx (λ p → coe p q[ pcAA ]) \|in-ctx cAA-to-cBA d₂ ⟩ cAA-to-cBA d₂ (transport (λ c → codeAA (f c) a₁) p q[ pcAA ]) =∎) (λ _ → prop-has-all-paths-↓ (SetQuot-is-set _ _)) module SE = SurjExt (λ c → ≃-is-set SetQuot-is-set SetQuot-is-set) h h-is-surj eqv-on-image eqv-is-const abstract eqv : ∀ c → codeAA (f c) a₁ ≃ codeBA (g c) a₁ eqv = SE.ext eqv-β : ∀ d → eqv (h d) == eqv-on-image d eqv-β = SE.β module CodeABEquivCodeBB (b₁ : B) where eqv-on-image : (d₀ : D) → codeAB (f (h d₀)) b₁ ≃ codeBB (g (h d₀)) b₁ eqv-on-image d₀ = equiv to from to-from from-to where to : codeAB (f (h d₀)) b₁ → codeBB (g (h d₀)) b₁ to = cAB-to-cBB d₀ from : codeBB (g (h d₀)) b₁ → codeAB (f (h d₀)) b₁ from = cBB-to-cAB d₀ abstract to-from : ∀ cBB → to (from cBB) == cBB to-from = SetQuot-elim (λ _ → =-preserves-set SetQuot-is-set) (pcBB-to-pcAB-to-pcBB d₀) (λ _ → prop-has-all-paths-↓ (SetQuot-is-set _ _)) from-to : ∀ cAB → from (to cAB) == cAB from-to = SetQuot-elim (λ _ → =-preserves-set SetQuot-is-set) (pcAB-to-pcBB-to-pcAB d₀) (λ _ → prop-has-all-paths-↓ (SetQuot-is-set _ _)) abstract eqv-is-const : ∀ d₁ d₂ (p : h d₁ == h d₂) → eqv-on-image d₁ == eqv-on-image d₂ [ (λ c → codeAB (f c) b₁ ≃ codeBB (g c) b₁) ↓ p ] eqv-is-const d₁ d₂ p = ↓-Subtype-in (λ d → is-equiv-prop) $ ↓-→-from-transp $ λ= $ SetQuot-elim (λ _ → =-preserves-set SetQuot-is-set) (λ pcAB → transport (λ c → codeBB (g c) b₁) p q[ pcAB-to-pcBB d₁ pcAB ] =⟨ ap-∘ (λ b → codeBB b b₁) g p \|in-ctx (λ p → coe p q[ pcAB-to-pcBB d₁ pcAB ]) ⟩ transport (λ b → codeBB b b₁) (ap g p) q[ pcAB-to-pcBB d₁ pcAB ] =⟨ transp-cBB-l d₁ (ap g p) (pcAB-to-pcBB d₁ pcAB) ⟩ q[ pcBB-prepend d₁ [ ! $ ap g p ] (pcAB-to-pcBB d₁ pcAB) ] =⟨ !-ap g p \|in-ctx (λ p → q[ pcBB-prepend d₁ [ p ] (pcAB-to-pcBB d₁ pcAB) ]) ⟩ q[ pcBB-prepend d₁ [ ap g (! p) ] (pcAB-to-pcBB d₁ pcAB) ] =⟨ pcAB-lemma d₁ d₂ (! p) pcAB ⟩ q[ pcAB-to-pcBB d₂ (pcAB-prepend d₁ [ ap f (! p) ] pcAB) ] =⟨ ap-! f p \|in-ctx (λ p → q[ pcAB-to-pcBB d₂ (pcAB-prepend d₁ [ p ] pcAB) ]) ⟩ q[ pcAB-to-pcBB d₂ (pcAB-prepend d₁ [ ! $ ap f p ] pcAB) ] =⟨ ! $ transp-cAB-l d₁ (ap f p) pcAB \|in-ctx cAB-to-cBB d₂ ⟩ cAB-to-cBB d₂ (transport (λ a → codeAB a b₁) (ap f p) q[ pcAB ]) =⟨ ∘-ap (λ c → codeAB c b₁) f p \|in-ctx (λ p → coe p q[ pcAB ]) \|in-ctx cAB-to-cBB d₂ ⟩ cAB-to-cBB d₂ (transport (λ c → codeAB (f c) b₁) p q[ pcAB ]) =∎) (λ _ → prop-has-all-paths-↓ (SetQuot-is-set _ _)) module SE = SurjExt (λ c → ≃-is-set SetQuot-is-set SetQuot-is-set) h h-is-surj eqv-on-image eqv-is-const abstract eqv : ∀ c → codeAB (f c) b₁ ≃ codeBB (g c) b₁ eqv = SE.ext eqv-β : ∀ d → eqv (h d) == eqv-on-image d eqv-β = SE.β module EqvPAIdEqvPB where abstract path-on-image : ∀ d₀ d₁ → CodeAAEquivCodeBA.eqv (f (h d₁)) (h d₀) == CodeABEquivCodeBB.eqv (g (h d₁)) (h d₀) [ (λ p → codeAP (f (h d₀)) p ≃ codeBP (g (h d₀)) p) ↓ glue (h d₁) ] path-on-image d₀ d₁ = CodeAAEquivCodeBA.eqv-β (f (h d₁)) d₀ ∙ᵈ lemma ∙'ᵈ ! (CodeABEquivCodeBB.eqv-β (g (h d₁)) d₀) where lemma : CodeAAEquivCodeBA.eqv-on-image (f (h d₁)) d₀ == CodeABEquivCodeBB.eqv-on-image (g (h d₁)) d₀ [ (λ p → codeAP (f (h d₀)) p ≃ codeBP (g (h d₀)) p) ↓ glue (h d₁) ] lemma = ↓-Subtype-in (λ d → is-equiv-prop) $ ↓-→-from-transp $ λ= $ SetQuot-elim (λ _ → =-preserves-set SetQuot-is-set) (λ pcAA → transport (λ p → codeBP (g (h d₀)) p) (glue (h d₁)) q[ pcAA-to-pcBA d₀ pcAA ] =⟨ transp-cBP-glue d₁ (pcAA-to-pcBA d₀ pcAA) ⟩ q[ pcAA-to-pcBA d₀ pcAA ba⟦ d₁ ⟧b idp₀ ] =⟨ ! $ transp-cAP-glue d₁ pcAA \|in-ctx cAB-to-cBB d₀ ⟩ cAB-to-cBB d₀ (transport (λ p → codeAP (f (h d₀)) p) (glue (h d₁)) q[ pcAA ]) =∎) (λ _ → prop-has-all-paths-↓ $ SetQuot-is-set _ _) abstract path : ∀ c₀ c₁ → CodeAAEquivCodeBA.eqv (f c₁) c₀ == CodeABEquivCodeBB.eqv (g c₁) c₀ [ (λ p → codeAP (f c₀) p ≃ codeBP (g c₀) p) ↓ glue c₁ ] path = SurjExt.ext (λ c₀ → Π-is-set λ c₁ → ↓-preserves-level $ ≃-is-set SetQuot-is-set SetQuot-is-set) h h-is-surj (λ d₀ → SurjExt.ext (λ c₁ → ↓-preserves-level $ ≃-is-set SetQuot-is-set SetQuot-is-set) h h-is-surj (λ d₁ → path-on-image d₀ d₁) (λ _ _ _ → prop-has-all-paths-↓ $ ↓-level $ ≃-is-set SetQuot-is-set SetQuot-is-set)) (λ _ _ _ → prop-has-all-paths-↓ $ Π-is-prop λ _ → ↓-level $ ≃-is-set SetQuot-is-set SetQuot-is-set) cAP-equiv-cBP : ∀ c₀ p₁ → codeAP (f c₀) p₁ ≃ codeBP (g c₀) p₁ cAP-equiv-cBP c₀ = Pushout-elim {P = λ p₁ → codeAP (f c₀) p₁ ≃ codeBP (g c₀) p₁} (λ a₁ → CodeAAEquivCodeBA.eqv a₁ c₀) (λ b₁ → CodeABEquivCodeBB.eqv b₁ c₀) (λ c₁ → EqvPAIdEqvPB.path c₀ c₁) module Code = PushoutRec {D = Pushout span → Type (lmax (lmax (lmax i j) k) l)} codeAP codeBP (λ c₀ → λ= $ ua ∘ cAP-equiv-cBP c₀) code : Pushout span → Pushout span → Type (lmax (lmax (lmax i j) k) l) code = Code.f abstract code-level : ∀ {p₀ p₁} → is-set (code p₀ p₁) code-level {p₀} {p₁} = Pushout-elim {P = λ p₀ → ∀ p₁ → is-set (code p₀ p₁)} (λ a₀ p₁ → codeAP-level {a₀} {p₁}) (λ b₀ p₁ → codeBP-level {b₀} {p₁}) (λ c₀ → prop-has-all-paths-↓ $ Π-is-prop λ p₁ → is-set-is-prop) p₀ p₁ code-is-set = code-level abstract transp-cPA-glue : ∀ d₀ {a₁} (pcAA : precodeAA (f (h d₀)) a₁) → transport (λ p₀ → code p₀ (left a₁)) (glue (h d₀)) q[ pcAA ] == q[ pcAA-to-pcBA d₀ pcAA ] transp-cPA-glue d₀ {a₁} pcAA = transport (λ p₀ → code p₀ (left a₁)) (glue (h d₀)) q[ pcAA ] =⟨ ap (λ e → coe e q[ pcAA ]) ( ap-∘ (_$ left a₁) code (glue (h d₀)) ∙ ap (ap (_$ left a₁)) (Code.glue-β (h d₀)) ∙ app=-β (ua ∘ cAP-equiv-cBP (h d₀)) (left a₁) ∙ ap ua (CodeAAEquivCodeBA.eqv-β a₁ d₀)) ⟩ coe (ua (CodeAAEquivCodeBA.eqv-on-image a₁ d₀)) q[ pcAA ] =⟨ coe-β (CodeAAEquivCodeBA.eqv-on-image a₁ d₀) q[ pcAA ] ⟩ q[ pcAA-to-pcBA d₀ pcAA ] =∎ transp-cPB-glue : ∀ d₀ {b₁} (pcAB : precodeAB (f (h d₀)) b₁) → transport (λ p₀ → code p₀ (right b₁)) (glue (h d₀)) q[ pcAB ] == q[ pcAB-to-pcBB d₀ pcAB ] transp-cPB-glue d₀ {b₁} pcAB = transport (λ p₀ → code p₀ (right b₁)) (glue (h d₀)) q[ pcAB ] =⟨ ap (λ e → coe e q[ pcAB ]) ( ap-∘ (_$ right b₁) code (glue (h d₀)) ∙ ap (ap (_$ right b₁)) (Code.glue-β (h d₀)) ∙ app=-β (ua ∘ cAP-equiv-cBP (h d₀)) (right b₁) ∙ ap ua (CodeABEquivCodeBB.eqv-β b₁ d₀)) ⟩ coe (ua (CodeABEquivCodeBB.eqv-on-image b₁ d₀)) q[ pcAB ] =⟨ coe-β (CodeABEquivCodeBB.eqv-on-image b₁ d₀) q[ pcAB ] ⟩ q[ pcAB-to-pcBB d₀ pcAB ] =∎ -- code to path abstract pcAA-to-pcBA-to-path : ∀ d₀ {a₁} (pcAA : precodeAA _ a₁) → pcBA-to-path (pcAA-to-pcBA d₀ pcAA) == !₀ [ glue (h d₀) ] ∙₀' pcAA-to-path pcAA pcAB-to-pcBB-to-path : ∀ d₀ {b₁} (pcAB : precodeAB _ b₁) → pcBB-to-path (pcAB-to-pcBB d₀ pcAB) == !₀ [ glue (h d₀) ] ∙₀' pcAB-to-path pcAB pcAA-to-pcBA-to-path d₀ (pc-a pA) = ∙₀'-unit-l (!₀ [ glue (h d₀) ] ∙₀' ap₀ left pA) pcAA-to-pcBA-to-path d₀ (pc-aba d pc pA) = ap (λ p → p ∙₀' !₀ [ glue (h d) ] ∙₀' ap₀ left pA) (pcAB-to-pcBB-to-path d₀ pc) ∙ ∙₀'-assoc (!₀ [ glue (h d₀) ]) (pcAB-to-path pc) (!₀ [ glue (h d) ] ∙₀' ap₀ left pA) pcAB-to-pcBB-to-path d₀ (pc-aab d pc pB) = ap (λ p → p ∙₀' [ glue (h d) ] ∙₀' ap₀ right pB) (pcAA-to-pcBA-to-path d₀ pc) ∙ ∙₀'-assoc (!₀ [ glue (h d₀) ]) (pcAA-to-path pc) ([ glue (h d) ] ∙₀' ap₀ right pB) abstract decodeAA-is-decodeBA : ∀ {a₁} c₀ → decodeAA {f c₀} {a₁} == decodeBA {g c₀} {a₁} [ (λ p₀ → code p₀ (left a₁) → p₀ =₀ left a₁) ↓ glue c₀ ] decodeAA-is-decodeBA {a₁ = a₁} = SurjExt.ext (λ _ → ↓-preserves-level $ Π-is-set λ _ → Trunc-level) h h-is-surj (λ d₀ → ↓-→-from-transp $ λ= $ SetQuot-elim {P = λ cAA → transport (_=₀ left a₁) (glue (h d₀)) (decodeAA cAA) == decodeBA (transport (λ p₀ → code p₀ (left a₁)) (glue (h d₀)) cAA)} (λ _ → =-preserves-set Trunc-level) (λ pcAA → transport (_=₀ left a₁) (glue (h d₀)) (pcAA-to-path pcAA) =⟨ transp₀-idf=₀cst [ glue (h d₀) ] (pcAA-to-path pcAA) ⟩ !₀ [ glue (h d₀) ] ∙₀ pcAA-to-path pcAA =⟨ ∙₀=∙₀' [ ! (glue (h d₀)) ] (pcAA-to-path pcAA) ⟩ !₀ [ glue (h d₀) ] ∙₀' pcAA-to-path pcAA =⟨ ! $ pcAA-to-pcBA-to-path d₀ pcAA ⟩ pcBA-to-path (pcAA-to-pcBA d₀ pcAA) =⟨ ! $ ap (λ e → decodeBA (–> e q[ pcAA ])) (CodeAAEquivCodeBA.eqv-β a₁ d₀) ⟩ decodeBA (–> (CodeAAEquivCodeBA.eqv a₁ (h d₀)) q[ pcAA ]) =⟨ ! $ ap decodeBA (coe-β (CodeAAEquivCodeBA.eqv a₁ (h d₀)) q[ pcAA ]) ⟩ decodeBA (coe (ua (CodeAAEquivCodeBA.eqv a₁ (h d₀))) q[ pcAA ]) =⟨ ! $ ap (λ p → decodeBA (coe p q[ pcAA ])) (app=-β (ua ∘ cAP-equiv-cBP (h d₀)) (left a₁)) ⟩ decodeBA (coe (app= (λ= λ p₁ → ua (cAP-equiv-cBP (h d₀) p₁)) (left a₁)) q[ pcAA ]) =⟨ ! $ ap (λ p → decodeBA (coe (app= p (left a₁)) q[ pcAA ])) (Code.glue-β (h d₀)) ⟩ decodeBA (coe (app= (ap code (glue (h d₀))) (left a₁)) q[ pcAA ]) =⟨ ap (λ p → decodeBA (coe p q[ pcAA ])) (∘-ap (λ f₁ → f₁ (left a₁)) code (glue (h d₀))) ⟩ decodeBA (transport (λ p₀ → code p₀ (left a₁)) (glue (h d₀)) q[ pcAA ]) =∎) (λ _ → prop-has-all-paths-↓ $ Trunc-level {n = 0} _ _)) (λ _ _ _ → prop-has-all-paths-↓ $ ↓-level $ Π-is-set λ _ → Trunc-level) abstract decodeAB-is-decodeBB : ∀ {b₁} c₀ → decodeAB {f c₀} {b₁} == decodeBB {g c₀} {b₁} [ (λ p₀ → code p₀ (right b₁) → p₀ =₀ right b₁) ↓ glue c₀ ] decodeAB-is-decodeBB {b₁ = b₁} = SurjExt.ext (λ _ → ↓-preserves-level $ Π-is-set λ _ → Trunc-level) h h-is-surj (λ d₀ → ↓-→-from-transp $ λ= $ SetQuot-elim {P = λ cAB → transport (_=₀ right b₁) (glue (h d₀)) (decodeAB cAB) == decodeBB (transport (λ p₀ → code p₀ (right b₁)) (glue (h d₀)) cAB)} (λ _ → =-preserves-set Trunc-level) (λ pcAB → transport (_=₀ right b₁) (glue (h d₀)) (pcAB-to-path pcAB) =⟨ transp₀-idf=₀cst [ glue (h d₀) ] (pcAB-to-path pcAB) ⟩ !₀ [ glue (h d₀) ] ∙₀ pcAB-to-path pcAB =⟨ ∙₀=∙₀' [ ! (glue (h d₀)) ] (pcAB-to-path pcAB) ⟩ !₀ [ glue (h d₀) ] ∙₀' pcAB-to-path pcAB =⟨ ! $ pcAB-to-pcBB-to-path d₀ pcAB ⟩ pcBB-to-path (pcAB-to-pcBB d₀ pcAB) =⟨ ! $ ap (λ e → decodeBB (–> e q[ pcAB ])) (CodeABEquivCodeBB.eqv-β b₁ d₀) ⟩ decodeBB (–> (CodeABEquivCodeBB.eqv b₁ (h d₀)) q[ pcAB ]) =⟨ ! $ ap decodeBB (coe-β (CodeABEquivCodeBB.eqv b₁ (h d₀)) q[ pcAB ]) ⟩ decodeBB (coe (ua (CodeABEquivCodeBB.eqv b₁ (h d₀))) q[ pcAB ]) =⟨ ! $ ap (λ p → decodeBB (coe p q[ pcAB ])) (app=-β (ua ∘ cAP-equiv-cBP (h d₀)) (right b₁)) ⟩ decodeBB (coe (app= (λ= λ p₁ → ua (cAP-equiv-cBP (h d₀) p₁)) (right b₁)) q[ pcAB ]) =⟨ ! $ ap (λ p → decodeBB (coe (app= p (right b₁)) q[ pcAB ])) (Code.glue-β (h d₀)) ⟩ decodeBB (coe (app= (ap code (glue (h d₀))) (right b₁)) q[ pcAB ]) =⟨ ap (λ p → decodeBB (coe p q[ pcAB ])) (∘-ap (λ f₁ → f₁ (right b₁)) code (glue (h d₀))) ⟩ decodeBB (transport (λ p₀ → code p₀ (right b₁)) (glue (h d₀)) q[ pcAB ]) =∎) (λ _ → prop-has-all-paths-↓ $ Trunc-level {n = 0} _ _)) (λ _ _ _ → prop-has-all-paths-↓ $ ↓-level $ Π-is-set λ _ → Trunc-level) abstract decodeAP-is-decodeBP : ∀ c₀ p₁ → decodeAP {f c₀} {p₁} == decodeBP {g c₀} {p₁} [ (λ p₀ → code p₀ p₁ → p₀ =₀ p₁) ↓ glue c₀ ] decodeAP-is-decodeBP c₀ = Pushout-elim {P = λ p₁ → decodeAP {f c₀} {p₁} == decodeBP {g c₀} {p₁} [ (λ p₀ → code p₀ p₁ → p₀ =₀ p₁) ↓ glue c₀ ]} (λ a₁ → decodeAA-is-decodeBA {a₁ = a₁} c₀) (λ b₁ → decodeAB-is-decodeBB {b₁ = b₁} c₀) (λ _ → prop-has-all-paths-↓ $ ↓-level $ Π-is-set λ _ → Trunc-level) decode : ∀ {p₀ p₁} → code p₀ p₁ → p₀ =₀ p₁ decode {p₀} {p₁} = Pushout-elim {P = λ p₀ → code p₀ p₁ → p₀ =₀ p₁} (λ a₀ → decodeAP {a₀} {p₁}) (λ b₀ → decodeBP {b₀} {p₁}) (λ c₀ → decodeAP-is-decodeBP c₀ p₁) p₀	{ "alphanum_fraction": 0.5274369626, "avg_line_length": 49.7644230769, "ext": "agda", "hexsha": "bc6734a499ec29d85e08ff59ac292f7268528578", "lang": "Agda", "max_forks_count": 1, "max_forks_repo_forks_event_max_datetime": "2018-12-26T21:31:57.000Z", "max_forks_repo_forks_event_min_datetime": "2018-12-26T21:31:57.000Z", "max_forks_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "mikeshulman/HoTT-Agda", "max_forks_repo_path": "theorems/homotopy/vankampen/Code.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "mikeshulman/HoTT-Agda", "max_issues_repo_path": "theorems/homotopy/vankampen/Code.agda", "max_line_length": 107, "max_stars_count": null, "max_stars_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "mikeshulman/HoTT-Agda", "max_stars_repo_path": "theorems/homotopy/vankampen/Code.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 8952, "size": 20702 }
{-# OPTIONS --cubical --no-import-sorts --safe #-} open import Cubical.Core.Everything open import Cubical.Relation.Binary.Raw module Cubical.Relation.Binary.Reasoning.Preorder {c ℓ} {A : Type c} (P : Preorder A ℓ) where open Preorder P ------------------------------------------------------------------------ -- Publicly re-export the contents of the base module open import Cubical.Relation.Binary.Reasoning.Base.Single _∼_ isPreorder public	{ "alphanum_fraction": 0.6391982183, "avg_line_length": 32.0714285714, "ext": "agda", "hexsha": "e9a699340bc25b259149e9f191737c5c073e49ae", "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/Relation/Binary/Reasoning/Preorder.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/Relation/Binary/Reasoning/Preorder.agda", "max_line_length": 93, "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/Relation/Binary/Reasoning/Preorder.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 105, "size": 449 }
------------------------------------------------------------------------ -- The Agda standard library -- -- This module is DEPRECATED. Please use the -- Relation.Binary.Construct.Closure.Reflexive module directly. ------------------------------------------------------------------------ {-# OPTIONS --without-K --safe #-} module Data.ReflexiveClosure where open import Relation.Binary.Construct.Closure.Reflexive public {-# WARNING_ON_IMPORT "Data.ReflexiveClosure was deprecated in v0.16. Use Relation.Binary.Construct.Closure.Reflexive instead." #-}	{ "alphanum_fraction": 0.5737410072, "avg_line_length": 30.8888888889, "ext": "agda", "hexsha": "43bf72b8c3f5908bfe99310c706247a93594289d", "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": "agda-stdlib/src/Data/ReflexiveClosure.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": "agda-stdlib/src/Data/ReflexiveClosure.agda", "max_line_length": 72, "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": "agda-stdlib/src/Data/ReflexiveClosure.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": 99, "size": 556 }
{-# OPTIONS --cubical --safe #-} module Cubical.Data.Prod.Properties where open import Cubical.Core.Everything open import Cubical.Data.Prod.Base open import Cubical.Data.Sigma open import Cubical.Foundations.Prelude open import Cubical.Foundations.Equiv open import Cubical.Foundations.HLevels open import Cubical.Foundations.Isomorphism open import Cubical.Foundations.Univalence private variable ℓ ℓ' : Level A : Type ℓ B : Type ℓ' -- Swapping is an equivalence swap : A × B → B × A swap (x , y) = (y , x) swap-invol : (xy : A × B) → swap (swap xy) ≡ xy swap-invol (_ , _) = refl isEquivSwap : (A : Type ℓ) (B : Type ℓ') → isEquiv (λ (xy : A × B) → swap xy) isEquivSwap A B = isoToIsEquiv (iso swap swap swap-invol swap-invol) swapEquiv : (A : Type ℓ) (B : Type ℓ') → A × B ≃ B × A swapEquiv A B = (swap , isEquivSwap A B) swapEq : (A : Type ℓ) (B : Type ℓ') → A × B ≡ B × A swapEq A B = ua (swapEquiv A B) private open import Cubical.Data.Nat -- As × is defined as a datatype this computes as expected -- (i.e. "C-c C-n test1" reduces to (2 , 1)). If × is implemented -- using Sigma this would be "transp (λ i → swapEq ℕ ℕ i) i0 (1 , 2)" test : ℕ × ℕ test = transp (λ i → swapEq ℕ ℕ i) i0 (1 , 2) testrefl : test ≡ (2 , 1) testrefl = refl -- equivalence between the sigma-based definition and the inductive one A×B≃A×ΣB : A × B ≃ A ×Σ B A×B≃A×ΣB = isoToEquiv (iso (λ { (a , b) → (a , b)}) (λ { (a , b) → (a , b)}) (λ _ → refl) (λ { (a , b) → refl })) A×B≡A×ΣB : A × B ≡ A ×Σ B A×B≡A×ΣB = ua A×B≃A×ΣB swapΣEquiv : (A : Type ℓ) (B : Type ℓ') → A ×Σ B ≃ B ×Σ A swapΣEquiv A B = compEquiv (compEquiv (invEquiv A×B≃A×ΣB) (swapEquiv A B)) A×B≃A×ΣB -- truncation for products isOfHLevelProd : (n : ℕ) → isOfHLevel n A → isOfHLevel n B → isOfHLevel n (A × B) isOfHLevelProd {A = A} {B = B} n h1 h2 = let h : isOfHLevel n (A ×Σ B) h = isOfHLevelΣ n h1 (λ _ → h2) in transport (λ i → isOfHLevel n (A×B≡A×ΣB {A = A} {B = B} (~ i))) h ×-≃ : ∀ {ℓ₁ ℓ₂ ℓ₃ ℓ₄} {A : Type ℓ₁} {B : Type ℓ₂} {C : Type ℓ₃} {D : Type ℓ₄} → A ≃ C → B ≃ D → A × B ≃ C × D ×-≃ {A = A} {B = B} {C = C} {D = D} f g = isoToEquiv (iso φ ψ η ε) where φ : A × B → C × D φ (a , b) = equivFun f a , equivFun g b ψ : C × D → A × B ψ (c , d) = equivFun (invEquiv f) c , equivFun (invEquiv g) d η : section φ ψ η (c , d) i = retEq f c i , retEq g d i ε : retract φ ψ ε (a , b) i = secEq f a i , secEq g b i	{ "alphanum_fraction": 0.5636077196, "avg_line_length": 29.523255814, "ext": "agda", "hexsha": "2113997fefcd048c8de5076e6473db414d916367", "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/Data/Prod/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/Data/Prod/Properties.agda", "max_line_length": 83, "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/Data/Prod/Properties.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 1070, "size": 2539 }
{-# OPTIONS --cubical #-} open import Agda.Primitive.Cubical open import Agda.Builtin.Cubical.Path data S1 : Set where base : S1 loop : base ≡ base postulate weird : S1 → I bad : (x : S1) → I bad base = {!!} bad (loop x) = {!!}	{ "alphanum_fraction": 0.6074380165, "avg_line_length": 15.125, "ext": "agda", "hexsha": "043d9ec7d5f7c24bf6dc6294e8315bcc95a6da23", "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/Issue3314.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/Issue3314.agda", "max_line_length": 37, "max_stars_count": 1989, "max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "cruhland/agda", "max_stars_repo_path": "test/Fail/Issue3314.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": 85, "size": 242 }
module Structure.Categorical.Multi where open import Data open import Data.Boolean open import Data.Tuple using (_⨯_ ; _,_) open import Data.Tuple.Raiseᵣ import Data.Tuple.Raiseᵣ.Functions as Raise open import Data.Tuple.RaiseTypeᵣ import Data.Tuple.RaiseTypeᵣ.Functions as RaiseType open import Function.Multi open import Function.Multi.Functions open import Functional using (_→ᶠ_) import Functional.Dependent as Fn open import Lang.Instance import Lvl open import Logic open import Logic.Predicate open import Logic.Propositional open import Numeral.Natural open import Numeral.Natural.Oper.Comparisons open import Structure.Setoid import Structure.Categorical.Names as Names import Structure.Operator.Names as Names import Structure.Relator.Names as Names open import Structure.Relator.Properties open import Syntax.Function open import Type open import Type.Properties.Singleton private variable ℓ ℓₒ ℓₘ ℓₘ₁ ℓₘ₂ ℓₑ ℓₑ₁ ℓₑ₂ : Lvl.Level private variable Obj Obj₁ Obj₂ : Type{ℓₒ} module Morphism where module _ (_⟶_ : Obj → Obj → Stmt{ℓₘ}) ⦃ morphism-equiv : ∀{x y} → Equiv{ℓₑ}(x ⟶ y) ⦄ where {- -- Examples: -- MorphismChain(3) T x y z -- = compose(1) ((x ⟶ y) ,_) (MorphismChain(2) T y) z -- = (x ⟶ y) , (MorphismChain(2) T y z) -- = (x ⟶ y) , (y ⟶ z) , T(z) -- -- MorphismChain(4) T x y z w -- = compose(2) ((x ⟶ y) ,_) (MorphismChain(3) T y) z w -- = (x ⟶ y) , (MorphismChain(3) T y z w) -- = (x ⟶ y) , (y ⟶ z) , (z ⟶ w) , T(w) MorphismChain : (n : ℕ) → (Obj → Type{ℓₘ}) → (RaiseType.repeat (𝐒(n)) Obj) ⇉ Types(Raise.repeat (𝐒(n)) ℓₘ) MorphismChain 0 T x = T(x) MorphismChain 1 T x y = (x ⟶ y) , T(y) MorphismChain (𝐒(𝐒(n))) T x y = compose(𝐒(n)) ((x ⟶ y) ,_) (MorphismChain(𝐒(n)) T y) -- Examples: -- MorphismMapping(2) x y -- = MorphismChain(2)(x ⟶_) x y -- = (x ⟶ y) → (x ⟶ y) -- -- MorphismMapping(3) x y z -- = MorphismChain(3)(x ⟶_) x y z -- = (x ⟶ y) → (y ⟶ z) → (x ⟶ z) -- -- MorphismMapping(4) x y z w -- = MorphismChain(4)(x ⟶_) x y z w -- = (x ⟶ y) → (y ⟶ z) → (z ⟶ w) → (x ⟶ w) MorphismMapping : (n : ℕ) → (RaiseType.repeat n Obj) ⇉ Type{ℓₘ} MorphismMapping(0) = Unit MorphismMapping(1) = {!!} MorphismMapping(𝐒(𝐒 n)) = {!!} --MorphismMapping(𝐒 n) = curry(n) {!Fs ↦ (uncurry(n) (MorphismChain(n)) Fs ⇉ (? → ?))!} {- MorphismMapping(1) x = ? -- MorphismChain(1)(x ⟶_) x MorphismMapping(𝐒(𝐒(n))) x = compose(𝐒(n)) (RaiseType.reduceᵣ{𝐒(n)}{\ℓ₁ ℓ₂ → ℓ₁ Lvl.⊔ ℓ₂} _→ᶠ_) (MorphismChain(𝐒(𝐒(n))) (x ⟶_) x) -- MorphismChain(𝐒(𝐒(n)))(x ⟶_) x-} -} MorphismFlippedChain : (n : ℕ) → (RaiseType.repeat (𝐒(n)) Obj) ⇉ Type{ℓₘ} MorphismFlippedChain 𝟎 x = x ⟶ x MorphismFlippedChain (𝐒(n)) x = Out(𝐒(n)) (x ⟶_) x where Out : (n : ℕ) → (Obj → Type{ℓₘ}) → (RaiseType.repeat (𝐒(n)) Obj) ⇉ Type{ℓₘ} Out 0 T x = T(x) Out 1 T x y = (x ⟶ y) → T(y) Out (𝐒(𝐒(n))) T x y = Out(𝐒(n)) (z ↦ ((x ⟶ y) → T(z))) y module _ (_⟶₁_ : Obj₁ → Obj₁ → Stmt{ℓₘ₁}) ⦃ morphism-equiv₁ : ∀{x y} → Equiv{ℓₑ₁}(x ⟶₁ y) ⦄ (_⟶₂_ : Obj₂ → Obj₂ → Stmt{ℓₘ₂}) ⦃ morphism-equiv₂ : ∀{x y} → Equiv{ℓₑ₂}(x ⟶₂ y) ⦄ where private open module Equiv₂{x}{y} = Equiv(morphism-equiv₂{x}{y}) using () renaming (_≡_ to _≡₂_) module _ {F : Obj₁ → Obj₂} where -- Definition of the relation between a function and an operation that says: -- The function preserves the operation. -- Often used when defining homomorphisms. -- Examples: -- Preserving(0) (map)(G₁)(G₂) -- = ∀{x} → (map ∘₀ G₁ ≡ G₂ on₀ map) -- = ∀{x} → (map(G₁) ≡ G₂(f)) -- Preserving(1) (map)(G₁)(G₂) -- = ∀{x y}{f : x ⟶ y} → ((map ∘₁ G₁)(f) ≡ (G₂ on₁ map)(f)) -- = ∀{x y}{f : x ⟶ y} → (map(G₁(f)) ≡ G₂(map(f))) -- Preserving(2) (map)(G₁)(G₂) -- = ∀{x y z}{f₁ : y ⟶ z}{f₂ : x ⟶ y} → ((map ∘₂ G₁)(f₁)(f₂) ≡ (G₂ on₂ map)(f₁)(f₂)) -- = ∀{x y z}{f₁ : y ⟶ z}{f₂ : x ⟶ y} → (map(G₁ f₁ f₂) ≡ G₂ (map(f₁)) (map(f₂))) -- Preserving(3) (map)(G₁)(G₂) -- = ∀{f₁ f₂ f₃} → ((map ∘₃ G₁)(f₁)(f₂)(f₃) ≡ (G₂ on₃ map)(f₁)(f₂)(f₃)) -- = ∀{f₁ f₂ f₃} → (map(G₁ f₁ f₂ f₃) ≡ G₂ (map(f₁)) (map(f₂)) (map(f₃))) Preserving : (n : ℕ) → (map : ∀{x y} → (x ⟶₁ y) → (F(x) ⟶₂ F(y))) → (quantifier₊(𝐒(n))(∀ₗ) (MorphismFlippedChain(_⟶₁_)(n))) → (quantifier₊(𝐒(n))(∀ₗ) (MorphismFlippedChain(_⟶₂_)(n))) → (RaiseType.repeat (𝐒(n)) Obj₁) ⇉ Stmt{if(n ≤? 0) then (ℓₑ₂) else (ℓₘ₁ Lvl.⊔ ℓₑ₂)} Preserving 0 map G₁ G₂ x = (map{x}(G₁) ≡ G₂) Preserving 1 map G₁ G₂ x y = ∀{f : x ⟶₁ y} → map (G₁(f)) ≡ G₂(map f) Preserving (𝐒(𝐒(n))) map G₁ G₂ x y = {!Preserving(𝐒(n)) map ? ? y!} -- ∀{f} → (G₁(f)) (G₂(map f)) --Preserving 2 map G₁ G₂ x y z = ∀{f₁ : y ⟶₁ z}{f₂ : x ⟶₁ y} → (map(G₁(f₁)(f₂)) ≡ G₂(map f₁)(map f₂)) -- Preserving (𝐒(𝐒(𝐒(n)))) map G₁ G₂ x y z = {!∀{f} → Preserving(𝐒(𝐒(n))) map !} --test (P ↦ (∀{f} → P f)) (f ↦ Preserving (𝐒(𝐒(n))) map {!G₁!} {!G₂!} y z) where -- test : ((P : {!!}) → TYPE ({!!} Lvl.⊔ {!!})) → ((f : {!!} ⟶₁ {!!}) → RaiseType.repeat (𝐒 n) Obj₁ ⇉ Type) → (RaiseType.repeat (𝐒 n) Obj₁ ⇉ Type) -- compose(𝐒(n)) (P ↦ (∀{f} → P f)) ({!f ↦ Preserving (𝐒(𝐒(n))) map {!G₁!} {!G₂!} {!!} {!!}!}) -- compose(𝐒(n)) {!!} {!!} -- ∀{f : x ⟶₁ y} → -- Preserving(𝐒(𝐒(n))) map (\{a b} → {!G₁{a}{x}{b}!}) \{a b} → {!G₂{a}{F x}{b}!} {- -- Preserving 3 map G₁ G₂ a x y z -- = ∀{f : a ⟶₁ x} → Preserving 2 map (G₁(f)) (G₂(map f)) x y z -- = ∀{f : a ⟶₁ x}{f₁ : x ⟶₁ y}{f₂ : y ⟶₁ z} → (map(G₁(f)(f₁)(f₂)) ≡ G₂(map f)(map f₁)(map f₂)) -- ∀{x y}{f : x ⟶₁ y} → Preserving(𝐒(𝐒(n))) (map) (G₁(f)) (G₂(map(f))) {- Preserving(𝟎) (f)(g₁)(g₂) = (f(g₁) ≡ g₂) Preserving(𝐒(𝟎)) (f)(g₁)(g₂) = (∀{x} → f(g₁(x)) ≡ g₂(f(x))) Preserving(𝐒(𝐒(n))) (f)(g₁)(g₂) = (∀{x} → Preserving(𝐒(n)) (f) (g₁(x)) (g₂(f(x)))) -- ∀{x y z : Objₗ}{f : y ⟶ z}{g : x ⟶ y} → (map(f ∘ g) ≡ map(f) ∘ map(g)) -} -}	{ "alphanum_fraction": 0.5083816892, "avg_line_length": 43.3846153846, "ext": "agda", "hexsha": "a61593de71245bcfe6dc15a4bf2d398e8980224f", "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/Categorical/Multi.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/Categorical/Multi.agda", "max_line_length": 271, "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/Categorical/Multi.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": 2800, "size": 6204 }
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9. Copyright (c) 2021, Oracle and/or its affiliates. Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl -} import LibraBFT.Impl.Consensus.LedgerRecoveryData as LedgerRecoveryData open import LibraBFT.Impl.OBM.Logging.Logging open import LibraBFT.ImplShared.Consensus.Types open import Optics.All open import Util.Prelude ------------------------------------------------------------------------------ open import Data.String using (String) module LibraBFT.Impl.Consensus.RecoveryData where findBlocksToPrune : HashValue → List Block → List QuorumCert → (List HashValue × List Block × List QuorumCert) new : Maybe Vote → LedgerRecoveryData → List Block → RootMetadata → List QuorumCert → Maybe TimeoutCertificate → Either ErrLog RecoveryData new lastVote storageLedger blocks0 rootMetadata quorumCerts0 highestTimeoutCertificate = do (root@(RootInfo∙new rb _ _) , blocks1 , quorumCerts1) ← withErrCtx' (here' []) (LedgerRecoveryData.findRoot blocks0 quorumCerts0 storageLedger) let (blocksToPrune , blocks , quorumCerts) = findBlocksToPrune (rb ^∙ bId) blocks1 quorumCerts1 epoch = rb ^∙ bEpoch pure $ mkRecoveryData (case lastVote of λ where (just v) → if-dec v ^∙ vEpoch ≟ epoch then just v else nothing nothing → nothing) root rootMetadata blocks quorumCerts (just blocksToPrune) (case highestTimeoutCertificate of λ where (just tc) → if-dec tc ^∙ tcEpoch ≟ epoch then just tc else nothing nothing → nothing) where here' : List String → List String here' t = "RecoveryData" ∷ "new" ∷ t -- TODO (the "TODO" is in the Haskell code) findBlocksToPrune _rootId blocks quorumCerts = ([] , blocks , quorumCerts)	{ "alphanum_fraction": 0.6781429317, "avg_line_length": 36.8653846154, "ext": "agda", "hexsha": "b5df892b9dfea36e82dbfd93e38cc0b96d669db3", "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": "a4674fc473f2457fd3fe5123af48253cfb2404ef", "max_forks_repo_licenses": [ "UPL-1.0" ], "max_forks_repo_name": "LaudateCorpus1/bft-consensus-agda", "max_forks_repo_path": "src/LibraBFT/Impl/Consensus/RecoveryData.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "a4674fc473f2457fd3fe5123af48253cfb2404ef", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "UPL-1.0" ], "max_issues_repo_name": "LaudateCorpus1/bft-consensus-agda", "max_issues_repo_path": "src/LibraBFT/Impl/Consensus/RecoveryData.agda", "max_line_length": 111, "max_stars_count": null, "max_stars_repo_head_hexsha": "a4674fc473f2457fd3fe5123af48253cfb2404ef", "max_stars_repo_licenses": [ "UPL-1.0" ], "max_stars_repo_name": "LaudateCorpus1/bft-consensus-agda", "max_stars_repo_path": "src/LibraBFT/Impl/Consensus/RecoveryData.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 524, "size": 1917 }
{-# OPTIONS --without-K #-} module Circle where open import Agda.Prim open import Data.Product open import Function renaming (_∘_ to _○_) infixr 8 _∘_ -- path composition infix 4 _≡_ -- propositional equality infix 4 _∼_ -- homotopy between two functions infix 4 _≃_ -- type of equivalences infix 2 _∎ -- equational reasoning infixr 2 _≡⟨_⟩_ -- equational reasoning ------------------------------------------------------------------------------ -- Identity types -- Our own version of refl that makes 'a' explicit data _≡_ {ℓ} {A : Set ℓ} : (a b : A) → Set ℓ where refl : (a : A) → (a ≡ a) pathInd : ∀ {u ℓ} → {A : Set u} → (C : {x y : A} → x ≡ y → Set ℓ) → (c : (x : A) → C (refl x)) → ({x y : A} (p : x ≡ y) → C p) pathInd C c (refl x) = c x ------------------------------------------------------------------------------ -- Ch. 2 -- Lemma 2.1.1 ! : ∀ {u} → {A : Set u} {x y : A} → (x ≡ y) → (y ≡ x) ! = pathInd (λ {x} {y} _ → y ≡ x) refl -- Lemma 2.1.2 _∘_ : ∀ {u} → {A : Set u} → {x y z : A} → (x ≡ y) → (y ≡ z) → (x ≡ z) _∘_ {u} {A} {x} {y} {z} p q = pathInd (λ {x} {y} p → ((z : A) → (q : y ≡ z) → (x ≡ z))) (λ x z q → pathInd (λ {x} {z} _ → x ≡ z) refl {x} {z} q) {x} {y} p z q -- Lemma 2.1.4 -- p = p . refl unitTransR : {A : Set} {x y : A} → (p : x ≡ y) → (p ≡ p ∘ refl y) unitTransR {A} {x} {y} p = pathInd (λ {x} {y} p → p ≡ p ∘ (refl y)) (λ x → refl (refl x)) {x} {y} p -- p = refl . p unitTransL : {A : Set} {x y : A} → (p : x ≡ y) → (p ≡ refl x ∘ p) unitTransL {A} {x} {y} p = pathInd (λ {x} {y} p → p ≡ (refl x) ∘ p) (λ x → refl (refl x)) {x} {y} p -- ! p . p = refl invTransL : {A : Set} {x y : A} → (p : x ≡ y) → (! p ∘ p ≡ refl y) invTransL {A} {x} {y} p = pathInd (λ {x} {y} p → ! p ∘ p ≡ refl y) (λ x → refl (refl x)) {x} {y} p -- p . ! p = refl invTransR : ∀ {ℓ} {A : Set ℓ} {x y : A} → (p : x ≡ y) → (p ∘ ! p ≡ refl x) invTransR {ℓ} {A} {x} {y} p = pathInd (λ {x} {y} p → p ∘ ! p ≡ refl x) (λ x → refl (refl x)) {x} {y} p -- ! (! p) = p invId : {A : Set} {x y : A} → (p : x ≡ y) → (! (! p) ≡ p) invId {A} {x} {y} p = pathInd (λ {x} {y} p → ! (! p) ≡ p) (λ x → refl (refl x)) {x} {y} p -- p . (q . r) = (p . q) . r assocP : {A : Set} {x y z w : A} → (p : x ≡ y) → (q : y ≡ z) → (r : z ≡ w) → (p ∘ (q ∘ r) ≡ (p ∘ q) ∘ r) assocP {A} {x} {y} {z} {w} p q r = pathInd (λ {x} {y} p → (z : A) → (w : A) → (q : y ≡ z) → (r : z ≡ w) → p ∘ (q ∘ r) ≡ (p ∘ q) ∘ r) (λ x z w q r → pathInd (λ {x} {z} q → (w : A) → (r : z ≡ w) → (refl x) ∘ (q ∘ r) ≡ ((refl x) ∘ q) ∘ r) (λ x w r → pathInd (λ {x} {w} r → (refl x) ∘ ((refl x) ∘ r) ≡ ((refl x) ∘ (refl x)) ∘ r) (λ x → (refl (refl x))) {x} {w} r) {x} {z} q w r) {x} {y} p z w q r -- ! (p ∘ q) ≡ ! q ∘ ! p invComp : {A : Set} {x y z : A} → (p : x ≡ y) → (q : y ≡ z) → ! (p ∘ q) ≡ ! q ∘ ! p invComp {A} {x} {y} {z} p q = pathInd (λ {x} {y} p → (z : A) → (q : y ≡ z) → ! (p ∘ q) ≡ ! q ∘ ! p) (λ x z q → pathInd (λ {x} {z} q → ! (refl x ∘ q) ≡ ! q ∘ ! (refl x)) (λ x → refl (refl x)) {x} {z} q) {x} {y} p z q -- Introduce equational reasoning syntax to simplify proofs _≡⟨_⟩_ : ∀ {u} → {A : Set u} (x : A) {y z : A} → (x ≡ y) → (y ≡ z) → (x ≡ z) _ ≡⟨ p ⟩ q = p ∘ q bydef : ∀ {u} → {A : Set u} {x : A} → (x ≡ x) bydef {u} {A} {x} = refl x _∎ : ∀ {u} → {A : Set u} (x : A) → x ≡ x _∎ x = refl x ------------------------------------------------------------------------------ -- Functions are functors -- Lemma 2.2.1 -- computation rule: ap f (refl x) = refl (f x) ap : ∀ {ℓ ℓ'} → {A : Set ℓ} {B : Set ℓ'} {x y : A} → (f : A → B) → (x ≡ y) → (f x ≡ f y) ap {ℓ} {ℓ'} {A} {B} {x} {y} f p = pathInd (λ {x} {y} p → f x ≡ f y) (λ x → refl (f x)) {x} {y} p -- Lemma 2.2.2 -- f (p ∘ q) ≡ f p ∘ f q apfTrans : ∀ {u} → {A B : Set u} {x y z : A} → (f : A → B) → (p : x ≡ y) → (q : y ≡ z) → ap f (p ∘ q) ≡ (ap f p) ∘ (ap f q) apfTrans {u} {A} {B} {x} {y} {z} f p q = pathInd {u} (λ {x} {y} p → (z : A) → (q : y ≡ z) → ap f (p ∘ q) ≡ (ap f p) ∘ (ap f q)) (λ x z q → pathInd {u} (λ {x} {z} q → ap f (refl x ∘ q) ≡ (ap f (refl x)) ∘ (ap f q)) (λ x → refl (refl (f x))) {x} {z} q) {x} {y} p z q -- f (! p) ≡ ! (f p) apfInv : ∀ {u} → {A B : Set u} {x y : A} → (f : A → B) → (p : x ≡ y) → ap f (! p) ≡ ! (ap f p) apfInv {u} {A} {B} {x} {y} f p = pathInd {u} (λ {x} {y} p → ap f (! p) ≡ ! (ap f p)) (λ x → refl (ap f (refl x))) {x} {y} p -- g (f p) ≡ (g ○ f) p apfComp : {A B C : Set} {x y : A} → (f : A → B) → (g : B → C) → (p : x ≡ y) → ap g (ap f p) ≡ ap (g ○ f) p apfComp {A} {B} {C} {x} {y} f g p = pathInd (λ {x} {y} p → ap g (ap f p) ≡ ap (g ○ f) p) (λ x → refl (ap g (ap f (refl x)))) {x} {y} p -- id p ≡ p apfId : {A : Set} {x y : A} → (p : x ≡ y) → ap id p ≡ p apfId {A} {x} {y} p = pathInd (λ {x} {y} p → ap id p ≡ p) (λ x → refl (refl x)) {x} {y} p -- Transport -- Lemma 2.3.1 transport : ∀ {ℓ ℓ'} → {A : Set ℓ} {x y : A} → (P : A → Set ℓ') → (p : x ≡ y) → P x → P y transport {ℓ} {ℓ'} {A} {x} {y} P p = pathInd (λ {x} {y} p → (P x → P y)) (λ _ → id) {x} {y} p ------------------------------------------------------------------------------- -- Homotopies and equivalences _∼_ : ∀ {ℓ ℓ'} → {A : Set ℓ} {P : A → Set ℓ'} → (f g : (x : A) → P x) → Set (_⊔_ ℓ ℓ') _∼_ {ℓ} {ℓ'} {A} {P} f g = (x : A) → f x ≡ g x -- Quasi-inverses record qinv {ℓ ℓ'} {A : Set ℓ} {B : Set ℓ'} (f : A → B) : Set (_⊔_ ℓ ℓ') where constructor mkqinv field g : B → A α : (f ○ g) ∼ id β : (g ○ f) ∼ id -- Example 2.4.7 idqinv : ∀ {ℓ} → {A : Set ℓ} → qinv {ℓ} {ℓ} {A} {A} id idqinv = record { g = id ; α = λ b → refl b ; β = λ a → refl a } -- Equivalences record isequiv {ℓ ℓ'} {A : Set ℓ} {B : Set ℓ'} (f : A → B) : Set (_⊔_ ℓ ℓ') where constructor mkisequiv field g : B → A α : (f ○ g) ∼ id h : B → A β : (h ○ f) ∼ id equiv₁ : ∀ {ℓ ℓ'} → {A : Set ℓ} {B : Set ℓ'} {f : A → B} → qinv f → isequiv f equiv₁ (mkqinv qg qα qβ) = mkisequiv qg qα qg qβ _≃_ : ∀ {ℓ ℓ'} (A : Set ℓ) (B : Set ℓ') → Set (_⊔_ ℓ ℓ') A ≃ B = Σ (A → B) isequiv -- Lemma 2.4.12 idequiv : ∀ {ℓ} {A : Set ℓ} → A ≃ A idequiv = (id , equiv₁ idqinv) ------------------------------------------------------------------------------ -- Sec. 2.10: Universes; univalence idtoeqv : {A B : Set} → (A ≡ B) → (A ≃ B) idtoeqv {A} {B} p = pathInd (λ {A} {B} p → A ≃ B) (λ A → idequiv) {A} {B} p postulate univalence : {A B : Set} → (A ≡ B) ≃ (A ≃ B) ------------------------------------------------------------------------------ -- Sec. 2.11: Identity types -- Thm 2.11.3 transportId : {A B : Set} {y z : A} → (f g : A → B) → (p : y ≡ z) → (q : f y ≡ g y) → transport (λ x → f x ≡ g x) p q ≡ ! (ap f p) ∘ q ∘ (ap g p) transportId {A} {B} {y} {z} f g p q = pathInd (λ {y} {z} p → (q : f y ≡ g y) → transport (λ x → f x ≡ g x) p q ≡ ! (ap f p) ∘ q ∘ (ap g p)) (λ y q → q ≡⟨ unitTransR q ⟩ q ∘ refl (g y) ≡⟨ unitTransL (q ∘ refl (g y)) ⟩ refl (f y) ∘ q ∘ refl (g y) ∎) {y} {z} p q ------------------------------------------------------------------------------ -- Exercise: let's show that the following two definitions of the -- circle are "the same" {-- data S¹ where base : S¹ loop : base ≡ base data S¹' where south : S¹' north : S¹' east : south ≡ north west : south ≡ north --} module Circle1 where private data S¹* : Set where base* : S¹* S¹ : Set S¹ = S¹* base : S¹ base = base* postulate loop : base ≡ base recS¹ : {C : Set} → (cbase : C) → (cloop : cbase ≡ cbase) → S¹ → C recS¹ cbase cloop base* = cbase postulate βrecS¹ : {C : Set} → (cbase : C) → (cloop : cbase ≡ cbase) → ap (recS¹ cbase cloop) loop ≡ cloop indS¹ : {C : S¹ → Set} → (cbase : C base) → (cloop : transport C loop cbase ≡ cbase) → (circle : S¹) → C circle indS¹ cbase cloop base* = cbase open Circle1 public -- module Circle2 where private data S¹'* : Set where south* : S¹'* north* : S¹'* S¹' : Set S¹' = S¹'* south : S¹' south = south* north : S¹' north = north* postulate east : south ≡ north west : south ≡ north recS¹' : {C : Set} → (csouth cnorth : C) → (ceast cwest : csouth ≡ cnorth) → S¹' → C recS¹' csouth cnorth ceast cwest south* = csouth recS¹' csouth cnorth ceast cwest north* = cnorth postulate βreceastS¹' : {C : Set} → (csouth cnorth : C) → (ceast cwest : csouth ≡ cnorth) → ap (recS¹' csouth cnorth ceast cwest) east ≡ ceast βrecwestS¹' : {C : Set} → (csouth cnorth : C) → (ceast cwest : csouth ≡ cnorth) → ap (recS¹' csouth cnorth ceast cwest) west ≡ cwest indS¹' : {C : S¹' → Set} → (csouth : C south) → (cnorth : C north) → (ceast : transport C east csouth ≡ cnorth) → (cwest : transport C west csouth ≡ cnorth) → (circle : S¹') → C circle indS¹' csouth cnorth ceast cwest south* = csouth indS¹' csouth cnorth ceast cwest north* = cnorth open Circle2 public -- Maps between Circle1 and Circle2 and back -- fcircle (base) = south -- fcircle (loop) = east ∘ ! west fcircle : S¹ → S¹' fcircle = recS¹ south (east ∘ ! west) floop : ap fcircle loop ≡ (east ∘ ! west) floop = βrecS¹ south (east ∘ ! west) -- gcircle (south) = base -- gcircle (north) = base -- gcircle (east) = loop -- gcircle (west) = refl base gcircle : S¹' → S¹ gcircle = recS¹' base base loop (refl base) geast : ap gcircle east ≡ loop geast = βreceastS¹' base base loop (refl base) gwest : ap gcircle west ≡ (refl base) gwest = βrecwestS¹' base base loop (refl base) -- compose both ways -- gf (base) = base -- gf (loop) = loop gf : S¹ → S¹ gf = gcircle ○ fcircle gfloop : ap gf loop ≡ loop gfloop = ap gf loop ≡⟨ ! (apfComp fcircle gcircle loop) ⟩ ap gcircle (ap fcircle loop) ≡⟨ ap (ap gcircle) floop ⟩ ap gcircle (east ∘ ! west) ≡⟨ apfTrans gcircle east (! west) ⟩ ap gcircle east ∘ ap gcircle (! west) ≡⟨ ap (λ x → ap gcircle east ∘ x) (apfInv gcircle west) ⟩ ap gcircle east ∘ ! (ap gcircle west) ≡⟨ ap (λ x → ap gcircle east ∘ ! x) gwest ⟩ ap gcircle east ∘ (refl base) ≡⟨ ! (unitTransR (ap gcircle east)) ⟩ ap gcircle east ≡⟨ geast ⟩ loop ∎ αloop : transport (λ x → gf x ≡ x) loop (refl base) ≡ refl base αloop = transport (λ x → gf x ≡ x) loop (refl base) ≡⟨ transportId gf id loop (refl base) ⟩ -- Thm 2.11.3 ! (ap gf loop) ∘ refl base ∘ ap id loop ≡⟨ ap (λ x → ! (ap gf loop) ∘ refl base ∘ x) (apfId loop) ⟩ ! (ap gf loop) ∘ refl base ∘ loop ≡⟨ ap (λ x → ! (ap gf loop) ∘ x) (! (unitTransL loop)) ⟩ ! (ap gf loop) ∘ loop ≡⟨ ap (λ x → ! x ∘ loop) gfloop ⟩ ! loop ∘ loop ≡⟨ invTransL loop ⟩ refl base ∎ βcircle : gf ∼ id βcircle = indS¹ {λ x → gf x ≡ x} (refl base) αloop -- fg (south) = south -- fg (north) = south -- fg (east) = east ∘ ! west -- fg (west) = refl south fg : S¹' → S¹' fg = fcircle ○ gcircle fgeast : ap fg east ≡ east ∘ ! west fgeast = ap fg east ≡⟨ ! (apfComp gcircle fcircle east) ⟩ ap fcircle (ap gcircle east) ≡⟨ ap (ap fcircle) geast ⟩ ap fcircle loop ≡⟨ floop ⟩ (east ∘ ! west) ∎ fgwest : ap fg west ≡ refl south fgwest = ap fg west ≡⟨ ! (apfComp gcircle fcircle west) ⟩ ap fcircle (ap gcircle west) ≡⟨ ap (ap fcircle) gwest ⟩ ap fcircle (refl base) ≡⟨ bydef ⟩ refl south ∎ αeast : transport (λ x → fg x ≡ x) east (refl south) ≡ west αeast = transport (λ x → fg x ≡ x) east (refl south) ≡⟨ transportId fg id east (refl south) ⟩ -- Thm 2.11.3 ! (ap fg east) ∘ refl south ∘ ap id east ≡⟨ ap (λ x → ! (ap fg east) ∘ refl south ∘ x) (apfId east) ⟩ ! (ap fg east) ∘ refl south ∘ east ≡⟨ ap (λ x → ! (ap fg east) ∘ x) (! (unitTransL east)) ⟩ ! (ap fg east) ∘ east ≡⟨ ap (λ x → ! x ∘ east) fgeast ⟩ ! (east ∘ ! west) ∘ east ≡⟨ ap (λ x → x ∘ east) (invComp east (! west)) ⟩ (! (! west) ∘ ! east) ∘ east ≡⟨ ! (assocP (! (! west)) (! east) east) ⟩ ! (! west) ∘ ! east ∘ east ≡⟨ ap (λ x → ! (! west) ∘ x) (invTransL east) ⟩ ! (! west) ∘ refl north ≡⟨ ! (unitTransR (! (! west))) ⟩ ! (! west) ≡⟨ invId west ⟩ west ∎ αwest : transport (λ x → fg x ≡ x) west (refl south) ≡ west αwest = transport (λ x → fg x ≡ x) west (refl south) ≡⟨ transportId fg id west (refl south) ⟩ -- Thm 2.11.3 ! (ap fg west) ∘ refl south ∘ ap id west ≡⟨ ap (λ x → ! (ap fg west) ∘ refl south ∘ x) (apfId west) ⟩ ! (ap fg west) ∘ refl south ∘ west ≡⟨ ap (λ x → ! (ap fg west) ∘ x) (! (unitTransL west)) ⟩ ! (ap fg west) ∘ west ≡⟨ ap (λ x → ! x ∘ west) fgwest ⟩ ! (refl south) ∘ west ≡⟨ ! (unitTransL west) ⟩ west ∎ αcircle : fg ∼ id αcircle = indS¹' {λ x → fg x ≡ x} (refl south) west αeast αwest -- sequiv : S¹ ≃ S¹' sequiv = (fcircle , equiv₁ (mkqinv gcircle αcircle βcircle)) spath : S¹ ≡ S¹' spath with univalence ... \| (_ , eq) = isequiv.g eq sequiv ------------------------------------------------------------------------------	{ "alphanum_fraction": 0.4136978735, "avg_line_length": 27.3283018868, "ext": "agda", "hexsha": "f55b6f716648fff6d73eb9b7de0612b23a5c70ce", "lang": "Agda", "max_forks_count": 3, "max_forks_repo_forks_event_max_datetime": "2019-09-10T09:47:13.000Z", "max_forks_repo_forks_event_min_datetime": "2016-05-29T01:56:33.000Z", "max_forks_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1", "max_forks_repo_licenses": [ "BSD-2-Clause" ], "max_forks_repo_name": "JacquesCarette/pi-dual", "max_forks_repo_path": "OBT/Circle.agda", "max_issues_count": 4, "max_issues_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1", "max_issues_repo_issues_event_max_datetime": "2021-10-29T20:41:23.000Z", "max_issues_repo_issues_event_min_datetime": "2018-06-07T16:27:41.000Z", "max_issues_repo_licenses": [ "BSD-2-Clause" ], "max_issues_repo_name": "JacquesCarette/pi-dual", "max_issues_repo_path": "OBT/Circle.agda", "max_line_length": 80, "max_stars_count": 14, "max_stars_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1", "max_stars_repo_licenses": [ "BSD-2-Clause" ], "max_stars_repo_name": "JacquesCarette/pi-dual", "max_stars_repo_path": "OBT/Circle.agda", "max_stars_repo_stars_event_max_datetime": "2021-05-05T01:07:57.000Z", "max_stars_repo_stars_event_min_datetime": "2015-08-18T21:40:15.000Z", "num_tokens": 6050, "size": 14484 }
-- Andreas, 2015-03-17 -- Andreas, 2020-10-26 conform to Issue1428a open import Agda.Builtin.Size data ⊥ : Set where data SizeLt (i : Size) : Set where wrap : Size< i → SizeLt i -- This definition of size predecessor should be forbidden... module _ (i : Size) where postulate pred : Size< i -- ...otherwise the injectivity test loops here. iter : ∀ i → SizeLt i → ⊥ iter i (wrap j) = iter j (wrap (pred j)) loop : Size → ⊥ loop i = iter i (wrap (pred i)) absurd : ⊥ absurd = FIXME loop ∞ -- Testcase temporarily mutilated, original error: -- -- -Issue1428c.agda:... -- -We don't like postulated sizes in parametrized modules. -- -- +Issue1428c.agda:... -- +Not in scope: -- + FIXME at Issue1428c.agda:... -- +when scope checking FIXME	{ "alphanum_fraction": 0.6595744681, "avg_line_length": 21.4857142857, "ext": "agda", "hexsha": "8a5a573d330de89fa5ecbbc07d19daa66206ede1", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338", "max_forks_repo_licenses": [ "BSD-3-Clause" ], "max_forks_repo_name": "shlevy/agda", "max_forks_repo_path": "test/Fail/Issue1428c.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "BSD-3-Clause" ], "max_issues_repo_name": "shlevy/agda", "max_issues_repo_path": "test/Fail/Issue1428c.agda", "max_line_length": 61, "max_stars_count": null, "max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338", "max_stars_repo_licenses": [ "BSD-3-Clause" ], "max_stars_repo_name": "shlevy/agda", "max_stars_repo_path": "test/Fail/Issue1428c.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 238, "size": 752 }
------------------------------------------------------------------------------ -- Note on the equality type class using Kettelhoit's approach ------------------------------------------------------------------------------ {-# OPTIONS --exact-split #-} {-# OPTIONS --no-sized-types #-} {-# OPTIONS --no-universe-polymorphism #-} {-# OPTIONS --without-K #-} -- Adapted from Kettelhoit's thesis. module FOT.FOTC.TypeClasses.EqualityKettelhoit where open import FOTC.Base open import FOTC.Data.Bool open import FOTC.Data.Bool.Type open import FOTC.Data.Nat.Type ------------------------------------------------------------------------------ record Eq (P : D → Set) : Set₁ where field equal : ∀ {t₁ t₂} → P t₁ → P t₂ → Set open Eq {{...}} public boolEq : ∀ {b₁ b₂} → Bool b₁ → Bool b₂ → Set boolEq btrue btrue = Bool true boolEq bfalse bfalse = Bool true {-# CATCHALL #-} boolEq _ _ = Bool false nEq : ∀ {m n} → N m → N n → Set nEq nzero nzero = Bool true nEq (nsucc Nm) (nsucc Nn) = Bool true {-# CATCHALL #-} nEq _ _ = Bool false instance eqInstanceBool : Eq Bool eqInstanceBool = record { equal = boolEq } eqInstanceN : Eq N eqInstanceN = record { equal = nEq } test₁ : Set test₁ = equal nzero (nsucc nzero) test₂ : Set test₂ = equal bfalse bfalse eqN-sym : ∀ {m n} → (Nm : N m) → (Nn : N n) → equal Nm Nn → equal Nn Nm eqN-sym nzero nzero h = h eqN-sym nzero (nsucc Nn) h = h eqN-sym (nsucc Nm) nzero h = h eqN-sym (nsucc Nm) (nsucc Nn) h = h postulate eqN-sym' : ∀ {m n} → (Nm : N m) → (Nn : N n) → equal Nm Nn → equal Nn Nm -- {-# ATP prove eqN-sym' #-}	{ "alphanum_fraction": 0.5158020274, "avg_line_length": 28.4237288136, "ext": "agda", "hexsha": "6f272e8a048889a5946a103972ac223d56066c52", "lang": "Agda", "max_forks_count": 3, "max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z", "max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z", "max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "asr/fotc", "max_forks_repo_path": "notes/FOT/FOTC/TypeClasses/EqualityKettelhoit.agda", "max_issues_count": 2, "max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d", "max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z", "max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "asr/fotc", "max_issues_repo_path": "notes/FOT/FOTC/TypeClasses/EqualityKettelhoit.agda", "max_line_length": 82, "max_stars_count": 11, "max_stars_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "asr/fotc", "max_stars_repo_path": "notes/FOT/FOTC/TypeClasses/EqualityKettelhoit.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": 508, "size": 1677 }
-- 2014-03-05 Andreas, issue reported by James -- {-# OPTIONS -v tc.with.strip:60 -v:impossible:10 #-} data Nat : Set where zero : Nat pattern pzero = zero f : Nat → Nat f pzero with pzero f pzero \| pzero = pzero -- ERROR WAS: -- With clause pattern pzero is not an instance of its parent pattern -- when checking that the clause -- f pzero with pzero -- f pzero \| pzero = pzero -- has type Nat → Nat	{ "alphanum_fraction": 0.6789215686, "avg_line_length": 20.4, "ext": "agda", "hexsha": "e7660d87608c755c73ff48c644698eac0ef39ccd", "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/Issue1074.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/Issue1074.agda", "max_line_length": 69, "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/Issue1074.agda", "max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z", "max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z", "num_tokens": 126, "size": 408 }
{-# OPTIONS --without-K --safe #-} module Dodo.Binary.Functional where -- Stdlib imports open import Level using (Level; _⊔_) open import Relation.Binary using (Rel; REL) -- Local imports open import Dodo.Binary.Equality -- # Definitions # Functional : ∀ {a b ℓ₁ ℓ₂ : Level} {A : Set a} {B : Set b} → Rel B ℓ₁ → REL A B ℓ₂ --------------------- → Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) Functional _≈_ r = ∀ x y₁ y₂ → r x y₁ → r x y₂ → y₁ ≈ y₂ -- The /explicit/ x, y₁, and y₂ are crucial. If they're implicit, Agda will attempt to -- instantiate them when absent, which often fails to resolve. Not sure why. -- # Operations # module _ {a ℓ₁ ℓ₂ ℓ₃ : Level} {A : Set a} {≈ : Rel A ℓ₁} {P : Rel A ℓ₂} {Q : Rel A ℓ₃} where functional-⊆₂ : P ⊆₂ Q → Functional ≈ Q → Functional ≈ P functional-⊆₂ P⊆Q funcQ x y₁ y₂ Pxy₁ Pxy₂ = funcQ x y₁ y₂ (⊆₂-apply P⊆Q Pxy₁) (⊆₂-apply P⊆Q Pxy₂)	{ "alphanum_fraction": 0.614334471, "avg_line_length": 29.3, "ext": "agda", "hexsha": "6b8d380808192152c29324c14125393b7e57cd4f", "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/Binary/Functional.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/Binary/Functional.agda", "max_line_length": 99, "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/Binary/Functional.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 346, "size": 879 }
module Data.Environment {a} {A : Set a} where open import Algebra open import Data.Nat open import Data.Empty using (⊥-elim) open import Data.Pos using (ℕ⁺; suc; replicate⁺) open import Data.List as L using (List; []; _∷_; [_]; _++_; map; concatMap; replicate) open import Data.List.Any using (here; there) open import Data.List.Any.BagAndSetEquality as B using () open import Data.List.Any.Membership.Propositional public using (_∈_; _∼[_]_; bag) open import Data.Product using (Σ-syntax; ∃₂; _×_; proj₁; proj₂; _,_) open import Data.Sum using (_⊎_; inj₁; inj₂) open import Function using (_$_; flip) open import Function.Equality using (_⟨$⟩_) open import Function.Inverse using (id; sym; _∘_) open Function.Inverse.Inverse using (to; from) open import Relation.Binary.PropositionalEquality as P using (_≡_) private module ++ = Monoid (L.monoid A) bubble : (xs {ys} : List A) {x y z : A} → z ∈ xs ++ y ∷ x ∷ ys → z ∈ xs ++ x ∷ y ∷ ys bubble [] (here px) = there (here px) bubble [] (there (here px)) = here px bubble [] (there (there i)) = there (there i) bubble (x ∷ xs) (here px) = here px bubble (x ∷ xs) (there i) = there (bubble xs i) -- There is a bijection between indices into the environment -- ΓBAΔ and the environment ΓABΔ. This is called a 'bubble', -- because it swaps two adjacent elements, as in bubble -- sort. bbl : (xs {ys} : List A) {x y : A} → xs ++ y ∷ x ∷ ys ∼[ bag ] xs ++ x ∷ y ∷ ys bbl xs {ys} {x} {y} = record { to = P.→-to-⟶ (bubble xs) ; from = P.→-to-⟶ (bubble xs) ; inverse-of = record { left-inverse-of = inv xs ; right-inverse-of = inv xs } } where inv : (xs {ys} : List A) {x y z : A} → (i : z ∈ xs ++ y ∷ x ∷ ys) → bubble xs (bubble xs i) ≡ i inv [] (here px) = P.refl inv [] (there (here px)) = P.refl inv [] (there (there i)) = P.refl inv (x ∷ xs) (here px) = P.refl inv (x ∷ xs) (there i) = P.cong there (inv xs i) -- There is a bijection between indices into the environment -- ΓΔAΘ and the environment ΓAΔΘ. fwd : (xs ys {zs} : List A) {w : A} → xs ++ ys ++ w ∷ zs ∼[ bag ] xs ++ w ∷ ys ++ zs fwd (x ∷ xs) ys = B.∷-cong P.refl (fwd xs ys) fwd [] ys = fwd' ys where fwd' : (xs {ys} : List A) {w : A} → xs ++ w ∷ ys ∼[ bag ] w ∷ xs ++ ys fwd' [] = id fwd' (x ∷ xs) = bbl [] ∘ B.∷-cong P.refl (fwd' xs) bwd : (xs ys {zs} : List A) {w : A} → xs ++ w ∷ ys ++ zs ∼[ bag ] xs ++ ys ++ w ∷ zs bwd xs ys = sym (fwd xs ys) -- List all possible ways to split a list xs into two lists xs₁ and xs₂. allSplit : (xs : List A) → List (Σ[ xs₁ ∈ List A ] Σ[ xs₂ ∈ List A ] xs ≡ xs₁ ++ xs₂) allSplit [] = L.[ [] , [] , P.refl ] allSplit (x ∷ xs) = now ∷ later where now = ([] , x ∷ xs , P.refl) later = flip map (allSplit xs) $ λ{(xs₁ , xs₂ , p) → (x ∷ xs₁ , xs₂ , P.cong (x ∷_) p)} -- Test if allSplit does as advertised. {- private module _ where postulate x y z w : A test-allSplit : allSplit (x ∷ y ∷ z ∷ w ∷ []) ≡ ( ( [] , (x ∷ y ∷ z ∷ w ∷ []) , P.refl ) ∷ ( (x ∷ []) , (y ∷ z ∷ w ∷ []) , P.refl ) ∷ ( (x ∷ y ∷ []) , (z ∷ w ∷ []) , P.refl ) ∷ ( (x ∷ y ∷ z ∷ []) , (w ∷ []) , P.refl ) ∷ ( (x ∷ y ∷ z ∷ w ∷ [] ) , [] , P.refl ) ∷ [] ) test-allSplit = P.refl -} -- It is possible to list all environments Δ for which there -- exists a bijection between indices into the environment Γ -- and the environment Δ. all : (xs : List A) → List (Σ[ ys ∈ List A ] xs ∼[ bag ] ys) all [] = ([] , id) ∷ [] all (x ∷ xs) = concatMap insAll (all xs) where insAll : Σ[ ys ∈ List A ] xs ∼[ bag ] ys → List (Σ[ ys ∈ List A ] x ∷ xs ∼[ bag ] ys) insAll (ys , b) = map insOne (allSplit ys) where insOne : Σ[ ys₁ ∈ List A ] Σ[ ys₂ ∈ List A ] ys ≡ ys₁ ++ ys₂ → Σ[ zs ∈ List A ] x ∷ xs ∼[ bag ] zs insOne (ys₁ , ys₂ , p) = ys₁ ++ x ∷ ys₂ , bwd [] ys₁ {ys₂} {x} ∘ B.∷-cong P.refl (P.subst (ys ∼[ bag ]_) p id ∘ b) -- Any element which is contained in a list created using replicate -- is equal to the replicated element. ∈-replicate : {x y : A} (n : ℕ) → x ∈ y ∷ replicate n y → x ≡ y ∈-replicate zero (here px) = px ∈-replicate zero (there ()) ∈-replicate (suc n) (here px) = px ∈-replicate (suc n) (there m) = ∈-replicate n m -- Any bag which is equivalent to the bag created using replicate, -- is equal to the bag created using replicate. all-replicate : {xs : List A} {y : A} (n : ℕ) → xs ∼[ bag ] replicate n y → xs ≡ replicate n y all-replicate {[]} {y} zero b = P.refl all-replicate {[]} {y} (suc n) b with from b ⟨$⟩ here P.refl; ... \| () all-replicate {x ∷ xs} {y} zero b with to b ⟨$⟩ here P.refl; ... \| () all-replicate {x ∷ xs} {y} (suc n) b = P.cong₂ _∷_ x=y (all-replicate n b') where x=y : x ≡ y x=y = ∈-replicate n (to b ⟨$⟩ here P.refl) b' : xs ∼[ bag ] replicate n y b' = B.drop-cons (P.subst (λ x → x ∷ xs ∼[ bag ] y ∷ replicate n y) x=y b) -- The same lemma holds for replicate⁺. all-replicate⁺ : {xs : List A} {y : A} (n : ℕ⁺) → xs ∼[ bag ] replicate⁺ n y → xs ≡ replicate⁺ n y all-replicate⁺ {[]} {y} (suc n) b with from b ⟨$⟩ here P.refl; ... \| () all-replicate⁺ {x ∷ xs} {y} (suc n) b = P.cong₂ _∷_ x=y (all-replicate n b') where x=y : x ≡ y x=y = ∈-replicate n (to b ⟨$⟩ here P.refl) b' : xs ∼[ bag ] replicate n y b' = B.drop-cons (P.subst (λ x → x ∷ xs ∼[ bag ] y ∷ replicate n y) x=y b) -- There is a bijection between indices into the environment -- ΓΣΔΠ and the environment ΓΔΣΠ. swp₄ : (xs ys zs {ws} : List A) → xs ++ zs ++ ys ++ ws ∼[ bag ] xs ++ ys ++ zs ++ ws swp₄ xs [] zs = id swp₄ xs (y ∷ ys) zs = ( P.subst₂ _∼[ bag ]_ (++.assoc xs [ y ] _) (++.assoc xs [ y ] _) $ swp₄ (xs ++ [ y ]) ys zs ) ∘ fwd xs zs -- Alias for swp₄. swp = swp₄ -- There is a bijection between indices into the environment -- ΓΣΔ and the environment ΓΔΣ. This is mostly a convenience -- function because of the annoyance of using ++.identity -- in the logic proofs. swp₃ : (xs ys {zs} : List A) → xs ++ zs ++ ys ∼[ bag ] xs ++ ys ++ zs swp₃ xs ys {zs} = ( P.subst₂ (λ ys' zs' → xs ++ zs ++ ys' ∼[ bag ] xs ++ ys ++ zs') (proj₂ ++.identity ys) (proj₂ ++.identity zs) $ swp₄ xs ys zs ) -- There is a bijection between indices into the environment -- ΓΣΔ and the environment ΓΔΣ. This is mostly a convenience -- function because of the annoyance of using ++.identity -- in the logic proofs. swp₂ : (xs {ys} : List A) → ys ++ xs ∼[ bag ] xs ++ ys swp₂ = swp₃ [] _-_ : (xs : List A) {x : A} (i : x ∈ xs) → List A (x ∷ xs) - (here _) = xs (x ∷ xs) - (there i) = x ∷ xs - i del-[] : {x y : A} (i : y ∈ x ∷ []) → (x ∷ []) - i ≡ [] del-[] (here px) = P.refl del-[] (there ()) -- Given a proof of membership x ∈ xs, we can be sure that -- there are two lists xs₁ and xs₂ s.t. -- -- (1) xs = xs₁ ++ x ∷ xs₂; and -- (2) xs - i = xs₁ ++ xs₂. -- -- That is to say, that we can break the list xs into a prefix, -- the element x, and a suffix, and that if we delete that occurrence -- of x, we are left with the prefix and the suffix. ∈→++ : {xs : List A} {x : A} (i : x ∈ xs) → ∃₂ λ xs₁ xs₂ → xs ≡ xs₁ ++ x ∷ xs₂ × xs - i ≡ xs₁ ++ xs₂ ∈→++ {x ∷ xs} (here P.refl) = ([] , xs , P.refl , P.refl) ∈→++ {x ∷ xs} (there i) with ∈→++ {xs} i ... \| (xs₁ , xs₂ , p₁ , p₂) = (x ∷ xs₁ , xs₂ , P.cong (x ∷_) p₁ , P.cong (x ∷_) p₂) -- Given two lists which are bag-equal, we can prove that if we delete -- the same element from both lists, the resulting lists are also bag-equal. del-to : {xs ys : List A} {x : A} → (eq : xs ∼[ bag ] ys) (i : x ∈ xs) → xs - i ∼[ bag ] ys - (to eq ⟨$⟩ i) del-to {xs} {ys} {x} eq i with ∈→++ {xs} i ... \| (xs₁ , xs₂ , p₁ , p₂) rewrite p₁ \| p₂ with ∈→++ {ys} (to eq ⟨$⟩ i) ... \| (ys₁ , ys₂ , q₁ , q₂) rewrite q₁ \| q₂ = B.drop-cons (fwd [] ys₁ ∘ eq ∘ sym (fwd [] xs₁)) del-from : {xs ys : List A} {x : A} → (eq : ys ∼[ bag ] xs) (i : x ∈ xs) → ys - (from eq ⟨$⟩ i) ∼[ bag ] xs - i del-from {xs} {ys} {x} eq i with ∈→++ {xs} i ... \| (xs₁ , xs₂ , p₁ , p₂) rewrite p₁ \| p₂ with ∈→++ {ys} (from eq ⟨$⟩ i) ... \| (ys₁ , ys₂ , q₁ , q₂) rewrite q₁ \| q₂ = B.drop-cons (fwd [] xs₁ ∘ eq ∘ sym (fwd [] ys₁)) -- Split a environment based on a proof of membership (used as index). split : ∀ (xs {ys} : List A) {x : A} → (i : x ∈ xs ++ ys) → Σ[ j ∈ x ∈ xs ] ((xs ++ ys) - i ≡ xs - j ++ ys) ⊎ Σ[ j ∈ x ∈ ys ] ((xs ++ ys) - i ≡ xs ++ ys - j) split [] i = inj₂ (i , P.refl) split (_ ∷ xs) (here px) = inj₁ (here px , P.refl) split (_ ∷ xs) (there i) with split xs i ... \| inj₁ (j , p) = inj₁ (there j , P.cong (_ ∷_) p) ... \| inj₂ (j , p) = inj₂ (j , P.cong (_ ∷_) p) -- -} -- -} -- -} -- -} -- -}	{ "alphanum_fraction": 0.4965318536, "avg_line_length": 37.0395256917, "ext": "agda", "hexsha": "bb9db5bcf772e19b2ad3beb98d548970faa0cef5", "lang": "Agda", "max_forks_count": 1, "max_forks_repo_forks_event_max_datetime": "2018-09-05T08:58:13.000Z", "max_forks_repo_forks_event_min_datetime": "2018-09-05T08:58:13.000Z", "max_forks_repo_head_hexsha": "fb5e78d6182276e4d93c4c0e0d563b6b027bc5c2", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "pepijnkokke/nodcap", "max_forks_repo_path": "src/cpnd1/Data/Environment.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "fb5e78d6182276e4d93c4c0e0d563b6b027bc5c2", "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": "pepijnkokke/nodcap", "max_issues_repo_path": "src/cpnd1/Data/Environment.agda", "max_line_length": 117, "max_stars_count": 4, "max_stars_repo_head_hexsha": "fb5e78d6182276e4d93c4c0e0d563b6b027bc5c2", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "wenkokke/nodcap", "max_stars_repo_path": "src/cpnd1/Data/Environment.agda", "max_stars_repo_stars_event_max_datetime": "2019-09-24T20:16:35.000Z", "max_stars_repo_stars_event_min_datetime": "2018-09-05T08:58:11.000Z", "num_tokens": 3505, "size": 9371 }
module x06-747Connectives-hc where import Relation.Binary.PropositionalEquality as Eq open Eq using (_≡_; refl) open Eq.≡-Reasoning open import Data.Nat using (ℕ) open import Function using (_∘_) ------------------------------------------------------------------------------ -- BEGIN : Copied from 747Isomorphism. postulate extensionality : ∀ {A B : Set} {f g : A → B} → (∀ (x : A) → f x ≡ g x) ----------------------- → f ≡ g infix 0 _≃_ record _≃_ (A B : Set) : Set where constructor mk-≃ -- This has been added, not in PLFA field to : A → B from : B → A from∘to : ∀ (x : A) → from (to x) ≡ x to∘from : ∀ (y : B) → to (from y) ≡ y open _≃_ infix 0 _≲_ record _≲_ (A B : Set) : Set where field to : A → B from : B → A from∘to : ∀ (x : A) → from (to x) ≡ x open _≲_ record _⇔_ (A B : Set) : Set where field to : A → B from : B → A open _⇔_ -- You may copy over the various reasoning modules if you wish. -- END : Copied from 747Isomorphism. ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ -- logical AND is Cartesian product. data _×_ (A : Set) (B : Set) : Set where ⟨_,_⟩ : A → B ----- → A × B -- destructors (aka eliminators) for ×. proj₁ : ∀ {A B : Set} → A × B ----- → A proj₁ ⟨ a , _ ⟩ = a proj₂ : ∀ {A B : Set} → A × B ----- → B proj₂ ⟨ _ , b ⟩ = b -- equivalent construction using records record _×′_ (A B : Set) : Set where field proj₁′ : A proj₂′ : B open _×′_ -- eta-equivalence relates constructors and destructors η-× : ∀ {A B : Set} (w : A × B) → ⟨ proj₁ w , proj₂ w ⟩ ≡ w η-× ⟨ a , b ⟩ = refl -- type with two members infixr 2 _×_ data Bool : Set where true : Bool false : Bool -- type with three members (used in examples) data Tri : Set where aa : Tri bb : Tri cc : Tri -- Bool × Tri has six members ×-count : Bool × Tri → ℕ ×-count ⟨ true , aa ⟩ = 1 ×-count ⟨ true , bb ⟩ = 2 ×-count ⟨ true , cc ⟩ = 3 ×-count ⟨ false , aa ⟩ = 4 ×-count ⟨ false , bb ⟩ = 5 ×-count ⟨ false , cc ⟩ = 6 -- Cartesian product is commutative and associative up to isomorphism. swap : ∀ {A B : Set} → A × B → B × A swap ⟨ a , b ⟩ = ⟨ b , a ⟩ ×-comm : ∀ {A B : Set} → A × B ≃ B × A to ×-comm = swap from ×-comm = swap from∘to ×-comm ⟨ _ , _ ⟩ = refl to∘from ×-comm ⟨ _ , _ ⟩ = refl ×-assoc : ∀ {A B C : Set} → (A × B) × C ≃ A × (B × C) to ×-assoc ⟨ ⟨ a , b ⟩ , c ⟩ = ⟨ a , ⟨ b , c ⟩ ⟩ from ×-assoc ⟨ a , ⟨ b , c ⟩ ⟩ = ⟨ ⟨ a , b ⟩ , c ⟩ from∘to ×-assoc ⟨ ⟨ _ , _ ⟩ , _ ⟩ = refl to∘from ×-assoc ⟨ _ , ⟨ _ , _ ⟩ ⟩ = refl -- A ⇔ B is isomorphic to (A → B) × (B → A) iff-iso-if-onlyif : ∀ {A B : Set} → A ⇔ B ≃ (A → B) × (B → A) _≃_.to iff-iso-if-onlyif record { to = to ; from = from } = ⟨ to , from ⟩ to (_≃_.from iff-iso-if-onlyif ⟨ A→B , B→A ⟩) = A→B from (_≃_.from iff-iso-if-onlyif ⟨ A→B , B→A ⟩) = B→A from∘to iff-iso-if-onlyif record { to = to ; from = from } = refl to∘from iff-iso-if-onlyif ⟨ A→B , B→A ⟩ = refl ------------------------------------------------------------------------------ -- logical True is a type with one member (unit) data ⊤ : Set where tt : -- ⊤ η-⊤ : ∀ (w : ⊤) → tt ≡ w η-⊤ tt = refl ⊤-count : ⊤ → ℕ ⊤-count tt = 1 -- Unit is the left and right identity of product. ⊤-identityˡ : ∀ {A : Set} → ⊤ × A ≃ A to ⊤-identityˡ ⟨ ⊤ , a ⟩ = a from ⊤-identityˡ a = ⟨ tt , a ⟩ from∘to ⊤-identityˡ ⟨ tt , a ⟩ = refl to∘from ⊤-identityˡ a = refl ⊤-identityʳ : ∀ {A : Set} → (A × ⊤) ≃ A to ⊤-identityʳ ⟨ a , ⊤ ⟩ = a from ⊤-identityʳ a = ⟨ a , tt ⟩ from∘to ⊤-identityʳ ⟨ a , tt ⟩ = refl to∘from ⊤-identityʳ a = refl ------------------------------------------------------------------------------ -- logical OR (disjunction) is sum (disjoint union) data _⊎_ : Set → Set → Set where inj₁ : ∀ {A B : Set} → A ----- → A ⊎ B inj₂ : ∀ {A B : Set} → B ----- → A ⊎ B -- a way to eliminate a sum (but easier to use pattern-matching to eliminate sums) case-⊎ : ∀ {A B C : Set} → (A → C) → (B → C) → A ⊎ B ----------- → C case-⊎ f g (inj₁ x) = f x case-⊎ f g (inj₂ x) = g x -- eta equivalence for sums η-⊎ : ∀ {A B : Set} (w : A ⊎ B) → case-⊎ inj₁ inj₂ w ≡ w η-⊎ (inj₁ _) = refl η-⊎ (inj₂ _) = refl -- generalization uniq-⊎ : ∀ {A B C : Set} → (h : A ⊎ B → C) → (w : A ⊎ B) → case-⊎ (h ∘ inj₁) (h ∘ inj₂) w ≡ h w uniq-⊎ h (inj₁ _) = refl uniq-⊎ h (inj₂ _) = refl infix 1 _⊎_ -- Bool ⊎ Tri has five members ⊎-count : Bool ⊎ Tri → ℕ ⊎-count (inj₁ true) = 1 ⊎-count (inj₁ false) = 2 ⊎-count (inj₂ aa) = 3 ⊎-count (inj₂ bb) = 4 ⊎-count (inj₂ cc) = 5 -- Sum is commutative up to isomorphism. ⊎-comm : ∀ {A B : Set} → A ⊎ B ≃ B ⊎ A to ⊎-comm (inj₁ a) = inj₂ a to ⊎-comm (inj₂ b) = inj₁ b from ⊎-comm (inj₁ b) = inj₂ b from ⊎-comm (inj₂ a) = inj₁ a from∘to ⊎-comm (inj₁ _) = refl from∘to ⊎-comm (inj₂ _) = refl to∘from ⊎-comm (inj₁ _) = refl to∘from ⊎-comm (inj₂ _) = refl -- Sum is associative up to isomorphism. ⊎-assoc : ∀ {A B C : Set} → (A ⊎ B) ⊎ C ≃ A ⊎ (B ⊎ C) to ⊎-assoc (inj₁ (inj₁ a)) = inj₁ a to ⊎-assoc (inj₁ (inj₂ b)) = inj₂ (inj₁ b) to ⊎-assoc (inj₂ c) = inj₂ (inj₂ c) from ⊎-assoc (inj₁ a) = inj₁ (inj₁ a) from ⊎-assoc (inj₂ (inj₁ b)) = inj₁ (inj₂ b) from ⊎-assoc (inj₂ (inj₂ c)) = inj₂ c from∘to ⊎-assoc (inj₁ (inj₁ _)) = refl from∘to ⊎-assoc (inj₁ (inj₂ _)) = refl from∘to ⊎-assoc (inj₂ _) = refl to∘from ⊎-assoc (inj₁ _) = refl to∘from ⊎-assoc (inj₂ (inj₁ _)) = refl to∘from ⊎-assoc (inj₂ (inj₂ _)) = refl ------------------------------------------------------------------------------ -- logical False is the empty type ("bottom", "empty") data ⊥ : Set where -- no clauses -- Ex falso quodlibet "from falsehood, anything follows". ⊥-elim : ∀ {A : Set} → ⊥ -- → A ⊥-elim () uniq-⊥ : ∀ {C : Set} → (h : ⊥ → C) → (w : ⊥) → ⊥-elim w ≡ h w uniq-⊥ h () ⊥-count : ⊥ → ℕ ⊥-count () -- Empty is the left unit of sum up to isomorphism. ⊎-identityˡ : ∀ {A : Set} → ⊥ ⊎ A ≃ A to ⊎-identityˡ (inj₂ a) = a from ⊎-identityˡ a = inj₂ a from∘to ⊎-identityˡ (inj₂ _) = refl to∘from ⊎-identityˡ _ = refl -- Empty is the right unit of sum up to isomorphism. ⊎-identityʳ : ∀ {A : Set} → A ⊎ ⊥ ≃ A to ⊎-identityʳ (inj₁ a) = a from ⊎-identityʳ a = inj₁ a from∘to ⊎-identityʳ (inj₁ _) = refl to∘from ⊎-identityʳ _ = refl ------------------------------------------------------------------------------ -- logical implication (if-then) is the function TYPE constructor. -- Eliminating an if-then (modus ponens) is function application. →-elim : ∀ {A B : Set} → (A → B) → A ------- → B →-elim L M = L M -- →-elim works because eta-reduction for → is built in η-→ : ∀ {A B : Set} → (f : A → B) → (λ (x : A) → f x) ≡ f η-→ f = refl -- The function space A → B is called the exponential Bᴬ. -- Bool → Tri has 3² (9) members. →-count : (Bool → Tri) → ℕ →-count f with f true \| f false ... \| aa \| aa = 1 ... \| aa \| bb = 2 ... \| aa \| cc = 3 ... \| bb \| aa = 4 ... \| bb \| bb = 5 ... \| bb \| cc = 6 ... \| cc \| aa = 7 ... \| cc \| bb = 8 ... \| cc \| cc = 9 ------------------------------------------------------------------------------ -- "currying" : functions of multiple parameters -- math : (p ^ n) ^ m = p ^ (n * m) -- types : (A ^ B) ^ C ≃ A ^ (B × C) currying : ∀ {A B C : Set} → (A → B → C) ≃ (A × B → C) to currying f = λ { ⟨ a , b ⟩ → f a b } from currying f = λ a b → f ⟨ a , b ⟩ from∘to currying _ = refl to∘from currying f = extensionality λ { ⟨ x , y ⟩ → refl } -- math, : p ^ (n + m) = (p ^ n) * (p ^ m) -- types : (A ⊎ B → C) ≃ ((A → C) × (B → C)) →-distrib-⊎ : ∀ {A B C : Set} → (A ⊎ B → C) ≃ ((A → C) × (B → C)) to →-distrib-⊎ f = ⟨ (λ a → f (inj₁ a)) , (λ b → f (inj₂ b)) ⟩ from →-distrib-⊎ ⟨ A→C , B→C ⟩ = λ { (inj₁ a) → A→C a ; (inj₂ b) → B→C b } from∘to →-distrib-⊎ _ = extensionality λ { (inj₁ x) → refl ; (inj₂ x) → refl } to∘from →-distrib-⊎ = λ{ ⟨ g , h ⟩ → refl } -- math : (p * n) ^ m = (p ^ m) * (n ^ m) -- types : (A → B × C) ≃ (A → B) × (A → C) →-distrib-× : ∀ {A B C : Set} → (A → B × C) ≃ (A → B) × (A → C) to →-distrib-× f = ⟨ (λ a → proj₁ (f a)) , (λ a → proj₂ (f a)) ⟩ from →-distrib-× f = λ a → ⟨ proj₁ f a , proj₂ f a ⟩ from∘to →-distrib-× = λ a→b×c → extensionality λ a → η-× (a→b×c a) to∘from →-distrib-× = λ { ⟨ _ , _ ⟩ → refl } ×-distrib-⊎ : ∀ {A B C : Set} → (A ⊎ B) × C ≃ (A × C) ⊎ (B × C) to ×-distrib-⊎ ⟨ inj₁ a , c ⟩ = inj₁ ⟨ a , c ⟩ to ×-distrib-⊎ ⟨ inj₂ b , c ⟩ = inj₂ ⟨ b , c ⟩ from ×-distrib-⊎ (inj₁ ⟨ a , c ⟩) = ⟨ inj₁ a , c ⟩ from ×-distrib-⊎ (inj₂ ⟨ b , c ⟩) = ⟨ inj₂ b , c ⟩ from∘to ×-distrib-⊎ = λ { ⟨ inj₁ a , c ⟩ → refl ; ⟨ inj₂ b , c ⟩ → refl } to∘from ×-distrib-⊎ = λ { ( inj₁ ⟨ a , c ⟩) → refl ; ( inj₂ ⟨ b , c ⟩) → refl } -- Think of a counterexample to show this is not an isomorphism. TODO ⊎-distrib-× : ∀ {A B C : Set} → (A × B) ⊎ C ≲ (A ⊎ C) × (B ⊎ C) to ⊎-distrib-× (inj₁ ⟨ a , b ⟩) = ⟨ inj₁ a , inj₁ b ⟩ to ⊎-distrib-× (inj₂ c) = ⟨ inj₂ c , inj₂ c ⟩ from ⊎-distrib-× ⟨ inj₁ a , inj₁ b ⟩ = inj₁ ⟨ a , b ⟩ from ⊎-distrib-× ⟨ inj₁ a , inj₂ c ⟩ = inj₂ c from ⊎-distrib-× ⟨ inj₂ c , inj₁ b ⟩ = inj₂ c from ⊎-distrib-× ⟨ inj₂ c , inj₂ C ⟩ = inj₂ c -- inj₂ C also valid (loses info) from∘to ⊎-distrib-× = λ { (inj₁ ⟨ a , b ⟩) → refl ; (inj₂ c) → refl } ×-distrib-→ : ∀ {A B C : Set} → (C → (A × B)) ≃ (C → A) × (C → B) to ×-distrib-→ f = ⟨ (λ c → proj₁ (f c)) , (λ c → proj₂ (f c)) ⟩ from ×-distrib-→ f = λ c → ⟨ proj₁ f c , proj₂ f c ⟩ from∘to ×-distrib-→ = λ { c→a×b → extensionality λ c → η-× (c→a×b c) } to∘from ×-distrib-→ = λ { ⟨ c→a , c→b ⟩ → refl } ⊎-distrib-→ : ∀ {A B C : Set} → ((A ⊎ B) → C) ≃ (A → C) × (B → C) to ⊎-distrib-→ f = ⟨ (λ a → f (inj₁ a)) , (λ b → f (inj₂ b)) ⟩ from ⊎-distrib-→ f = λ { (inj₁ a) → (proj₁ f a) ; (inj₂ b) → (proj₂ f b) } --from∘to ⊎-distrib-→ f = extensionality λ a⊎b → {!!} -- TODO from∘to ⊎-distrib-→ = λ { a⊎b→c → extensionality λ { (inj₁ a) → refl ; (inj₂ b) → refl } } to∘from ⊎-distrib-→ = λ { ⟨ a→c , b→c ⟩ → refl } -- PLFA exercise: a weak distributive law. ⊎-weak-× : ∀ {A B C : Set} → (A ⊎ B) × C → A ⊎ (B × C) ⊎-weak-× ⟨ inj₁ a , c ⟩ = inj₁ a ⊎-weak-× ⟨ inj₂ b , c ⟩ = inj₂ ⟨ b , c ⟩ -- State and prove the strong law, and explain the relationship. TODO -- SumOfProdImpProdOfSum : disjunct of conjuncts implies a conjunct of disjuncts. ⊎×-implies-×⊎ : ∀ {A B C D : Set} → (A × B) ⊎ (C × D) → (A ⊎ C) × (B ⊎ D) ⊎×-implies-×⊎ (inj₁ ⟨ a , b ⟩) = ⟨ inj₁ a , inj₁ b ⟩ ⊎×-implies-×⊎ (inj₂ ⟨ c , d ⟩) = ⟨ inj₂ c , inj₂ d ⟩ -- the converse is NOT true ×⊎-implies-⊎×-not : ∀ {A B C D : Set} → (A ⊎ C) × (B ⊎ D) → (A × B) ⊎ (C × D) ×⊎-implies-⊎×-not ⟨ inj₁ a , inj₁ b ⟩ = inj₁ ⟨ a , b ⟩ ×⊎-implies-⊎×-not ⟨ inj₁ a , inj₂ d ⟩ = {!!} -- A × B ⊎ C × D -- not possible ×⊎-implies-⊎×-not ⟨ inj₂ c , inj₁ b ⟩ = {!!} -- A × B ⊎ C × D -- not possible ×⊎-implies-⊎×-not ⟨ inj₂ c , inj₂ d ⟩ = inj₂ ⟨ c , d ⟩	{ "alphanum_fraction": 0.4417214585, "avg_line_length": 30.6570680628, "ext": "agda", "hexsha": "5624a26ee44325d39cc1f4b33584b39fbc52a9ea", "lang": "Agda", "max_forks_count": 8, "max_forks_repo_forks_event_max_datetime": "2021-09-21T15:58:10.000Z", "max_forks_repo_forks_event_min_datetime": "2015-04-13T21:40:15.000Z", "max_forks_repo_head_hexsha": "3dc7abca7ad868316bb08f31c77fbba0d3910225", "max_forks_repo_licenses": [ "Unlicense" ], "max_forks_repo_name": "haroldcarr/learn-haskell-coq-ml-etc", "max_forks_repo_path": "agda/book/Programming_Language_Foundations_in_Agda/x06-747Connectives-hc.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "3dc7abca7ad868316bb08f31c77fbba0d3910225", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "Unlicense" ], "max_issues_repo_name": "haroldcarr/learn-haskell-coq-ml-etc", "max_issues_repo_path": "agda/book/Programming_Language_Foundations_in_Agda/x06-747Connectives-hc.agda", "max_line_length": 96, "max_stars_count": 36, "max_stars_repo_head_hexsha": "3dc7abca7ad868316bb08f31c77fbba0d3910225", "max_stars_repo_licenses": [ "Unlicense" ], "max_stars_repo_name": "haroldcarr/learn-haskell-coq-ml-etc", "max_stars_repo_path": "agda/book/Programming_Language_Foundations_in_Agda/x06-747Connectives-hc.agda", "max_stars_repo_stars_event_max_datetime": "2021-07-30T06:55:03.000Z", "max_stars_repo_stars_event_min_datetime": "2015-01-29T14:37:15.000Z", "num_tokens": 5018, "size": 11711 }
module PLDI14-List-of-Theorems where -- List of theorems in PLDI submission -- -- For hints about installation and execution, please refer -- to README.agda. -- -- Agda modules corresponding to definitions, lemmas and theorems -- are listed here with the most important names. For example, -- after this file type checks (C-C C-L), placing the cursor -- on the purple "Base.Change.Algebra" and pressing M-. will -- bring you to the file where change structures are defined. -- The name for change structures in that file is -- "ChangeAlgebra", given in the using-clause. -- Definition 2.1 (Change structures) open import Base.Change.Algebra using (ChangeAlgebra) ---- Carrier in record ChangeAlgebra --(a) open Base.Change.Algebra.ChangeAlgebra using (Change) --(b) open Base.Change.Algebra.ChangeAlgebra using (update) --(c) open Base.Change.Algebra.ChangeAlgebra using (diff) --(d) open Base.Change.Algebra.IsChangeAlgebra using (update-diff)--(e) -- Definition 2.2 (Nil change) -- IsChangeAlgebra.nil open Base.Change.Algebra using (IsChangeAlgebra) -- Lemma 2.3 (Behavior of nil) -- IsChangeAlgebra.update-nil open Base.Change.Algebra using (IsChangeAlgebra) -- Lemma 2.5 (Behavior of derivatives on nil) open import Base.Change.Equivalence using (deriv-zero) -- Definition 2.4 (Derivatives) open Base.Change.Algebra using (IsDerivative) -- Definition 2.6 (Carrier set of function changes) open Base.Change.Algebra.FunctionChanges -- Definition 2.7 (Operations on function changes) -- ChangeAlgebra.update FunctionChanges.changeAlgebra -- ChangeAlgebra.diff FunctionChanges.changeAlgebra open Base.Change.Algebra.FunctionChanges using (changeAlgebraFun) -- Theorem 2.8 (Function changes form a change structure) -- (In Agda, the proof of Theorem 2.8 has to be included in the -- definition of function changes, here -- FunctionChanges.changeAlgebra.) open Base.Change.Algebra.FunctionChanges using (changeAlgebraFun) -- Theorem 2.9 (Incrementalization) open Base.Change.Algebra.FunctionChanges using (incrementalization) -- Theorem 2.10 (Nil changes are derivatives) open Base.Change.Algebra.FunctionChanges using (nil-is-derivative) -- Definition 3.1 (Domains) import Parametric.Denotation.Value open Parametric.Denotation.Value.Structure using (⟦_⟧Type) -- Definition 3.2 (Environments) open import Base.Denotation.Environment using (⟦_⟧Context) -- Definition 3.3 (Evaluation) import Parametric.Denotation.Evaluation open Parametric.Denotation.Evaluation.Structure using (⟦_⟧Term) -- Definition 3.4 (Changes) -- Definition 3.5 (Change environments) import Parametric.Change.Validity open Parametric.Change.Validity.Structure using (change-algebra) open Parametric.Change.Validity.Structure using (environment-changes) -- Definition 3.6 (Change semantics) -- Lemma 3.7 (Change semantics is the derivative of semantics) import Parametric.Change.Specification open Parametric.Change.Specification.Structure using (⟦_⟧Δ) open Parametric.Change.Specification.Structure using (correctness) -- Definition 3.8 (Erasure) -- Lemma 3.9 (The erased version of a change is almost the same) import Parametric.Change.Implementation open Parametric.Change.Implementation.Structure using (_≈_) open Parametric.Change.Implementation.Structure using (carry-over) -- Lemma 3.10 (⟦ t ⟧Δ erases to Derive(t)) -- Theorem 3.11 (Correctness of differentiation) import Parametric.Change.Correctness open Parametric.Change.Correctness.Structure using (derive-correct-closed) open Parametric.Change.Correctness.Structure using (main-theorem)	{ "alphanum_fraction": 0.7772816076, "avg_line_length": 38.9456521739, "ext": "agda", "hexsha": "d9379e6c42fa7ae97d0409b0d3fcc919976cba17", "lang": "Agda", "max_forks_count": 1, "max_forks_repo_forks_event_max_datetime": "2016-02-18T12:26:44.000Z", "max_forks_repo_forks_event_min_datetime": "2016-02-18T12:26:44.000Z", "max_forks_repo_head_hexsha": "39bb081c6f192bdb87bd58b4a89291686d2d7d03", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "inc-lc/ilc-agda", "max_forks_repo_path": "PLDI14-List-of-Theorems.agda", "max_issues_count": 6, "max_issues_repo_head_hexsha": "39bb081c6f192bdb87bd58b4a89291686d2d7d03", "max_issues_repo_issues_event_max_datetime": "2017-05-04T13:53:59.000Z", "max_issues_repo_issues_event_min_datetime": "2015-07-01T18:09:31.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "inc-lc/ilc-agda", "max_issues_repo_path": "PLDI14-List-of-Theorems.agda", "max_line_length": 74, "max_stars_count": 10, "max_stars_repo_head_hexsha": "39bb081c6f192bdb87bd58b4a89291686d2d7d03", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "inc-lc/ilc-agda", "max_stars_repo_path": "PLDI14-List-of-Theorems.agda", "max_stars_repo_stars_event_max_datetime": "2019-07-19T07:06:59.000Z", "max_stars_repo_stars_event_min_datetime": "2015-03-04T06:09:20.000Z", "num_tokens": 890, "size": 3583 }
open import Data.Product using ( proj₁ ; proj₂ ) open import Data.Sum using ( inj₁ ; inj₂ ) open import Relation.Binary.PropositionalEquality using ( _≡_ ; refl ; sym ; cong ) open import Relation.Unary using ( _⊆_ ) open import Web.Semantic.DL.ABox using ( ABox ; ⟨ABox⟩ ; Assertions ) open import Web.Semantic.DL.ABox.Interp using ( ⌊_⌋ ; ind ) open import Web.Semantic.DL.ABox.Model using ( _⊨a_ ; bnodes ; _,_ ) open import Web.Semantic.DL.Category.Object using ( Object ; IN ; fin ; iface ) open import Web.Semantic.DL.Category.Morphism using ( impl ; _≣_ ; _⊑_ ; _,_ ) open import Web.Semantic.DL.Category.Tensor using ( _⊗_ ; _⟨⊗⟩_ ) open import Web.Semantic.DL.Category.Properties.Tensor.Lemmas using ( tensor-up ; tensor-down ; tensor-resp-⊨a ) open import Web.Semantic.DL.Category.Wiring using ( wiring ; wires-≈ ; wires-≈⁻¹ ; identity ; id✓ ) open import Web.Semantic.DL.Signature using ( Signature ) open import Web.Semantic.DL.TBox using ( TBox ) open import Web.Semantic.DL.TBox.Interp using ( Δ ; _⊨_≈_ ; ≈-refl ; ≈-refl′ ; ≈-trans ) open import Web.Semantic.Util using ( id ; _∘_ ; False ; elim ; inj⁻¹ ; _⊕_⊕_ ; inode ; bnode ; enode ) module Web.Semantic.DL.Category.Properties.Tensor.RespectsWiring {Σ : Signature} {S T : TBox Σ} where tensor-resp-wiring : ∀ (A₁ A₂ B₁ B₂ : Object S T) → (f₁ : IN B₁ → IN A₁) → (f₁✓ : Assertions (⟨ABox⟩ f₁ (iface B₁)) ⊆ Assertions (iface A₁)) → (f₂ : IN B₂ → IN A₂) → (f₂✓ : Assertions (⟨ABox⟩ f₂ (iface B₂)) ⊆ Assertions (iface A₂)) → (g : IN (B₁ ⊗ B₂) → IN (A₁ ⊗ A₂)) → (g✓ : Assertions (⟨ABox⟩ g (iface (B₁ ⊗ B₂))) ⊆ Assertions (iface (A₁ ⊗ A₂))) → (∀ x → inj₁ (f₁ x) ≡ g (inj₁ x)) → (∀ x → inj₂ (f₂ x) ≡ g (inj₂ x)) → ((wiring A₁ B₁ f₁ f₁✓ ⟨⊗⟩ wiring A₂ B₂ f₂ f₂✓) ≣ (wiring (A₁ ⊗ A₂) (B₁ ⊗ B₂) g g✓)) tensor-resp-wiring A₁ A₂ B₁ B₂ f₁ f₁✓ f₂ f₂✓ g g✓ f₁≡g₁ f₂≡g₂ = (LHS⊑RHS , RHS⊑LHS) where LHS⊑RHS : wiring A₁ B₁ f₁ f₁✓ ⟨⊗⟩ wiring A₂ B₂ f₂ f₂✓ ⊑ wiring (A₁ ⊗ A₂) (B₁ ⊗ B₂) g g✓ LHS⊑RHS I I⊨STA I⊨F = (elim , I⊨RHS) where lemma : ∀ x → ⌊ I ⌋ ⊨ ind I (inode (g x)) ≈ ind I (enode x) lemma (inj₁ x) = ≈-trans ⌊ I ⌋ (≈-refl′ ⌊ I ⌋ (cong (ind I ∘ inode) (sym (f₁≡g₁ x)))) (wires-≈ f₁ (proj₂ (fin B₁) x) (tensor-up (wiring A₁ B₁ f₁ f₁✓) (wiring A₂ B₂ f₂ f₂✓) I I⊨F)) lemma (inj₂ x) = ≈-trans ⌊ I ⌋ (≈-refl′ ⌊ I ⌋ (cong (ind I ∘ inode) (sym (f₂≡g₂ x)))) (wires-≈ f₂ (proj₂ (fin B₂) x) (tensor-down (wiring A₁ B₁ f₁ f₁✓) (wiring A₂ B₂ f₂ f₂✓) I I⊨F)) I⊨RHS : bnodes I elim ⊨a impl (wiring (A₁ ⊗ A₂) (B₁ ⊗ B₂) g g✓) I⊨RHS = wires-≈⁻¹ g lemma (proj₁ (fin (B₁ ⊗ B₂))) RHS⊑LHS : wiring (A₁ ⊗ A₂) (B₁ ⊗ B₂) g g✓ ⊑ wiring A₁ B₁ f₁ f₁✓ ⟨⊗⟩ wiring A₂ B₂ f₂ f₂✓ RHS⊑LHS I I⊨STA I⊨F = (elim ∘ inj⁻¹ , I⊨LHS) where lemma₁ : ∀ x → ⌊ I ⌋ ⊨ ind I (inode (inj₁ (f₁ x))) ≈ ind I (enode (inj₁ x)) lemma₁ x = ≈-trans ⌊ I ⌋ (≈-refl′ ⌊ I ⌋ (cong (ind I ∘ inode) (f₁≡g₁ x))) (wires-≈ g (proj₂ (fin (B₁ ⊗ B₂)) (inj₁ x)) I⊨F) lemma₂ : ∀ x → ⌊ I ⌋ ⊨ ind I (inode (inj₂ (f₂ x))) ≈ ind I (enode (inj₂ x)) lemma₂ x = ≈-trans ⌊ I ⌋ (≈-refl′ ⌊ I ⌋ (cong (ind I ∘ inode) (f₂≡g₂ x))) (wires-≈ g (proj₂ (fin (B₁ ⊗ B₂)) (inj₂ x)) I⊨F) I⊨LHS : bnodes I (elim ∘ inj⁻¹) ⊨a impl (wiring A₁ B₁ f₁ f₁✓ ⟨⊗⟩ wiring A₂ B₂ f₂ f₂✓) I⊨LHS = tensor-resp-⊨a (wiring A₁ B₁ f₁ f₁✓) (wiring A₂ B₂ f₂ f₂✓) (bnodes I (elim ∘ inj⁻¹)) (wires-≈⁻¹ f₁ lemma₁ (proj₁ (fin B₁))) (wires-≈⁻¹ f₂ lemma₂ (proj₁ (fin B₂)))	{ "alphanum_fraction": 0.5715093273, "avg_line_length": 46.5526315789, "ext": "agda", "hexsha": "b04bc840873ec9bc65772a38243d9aff2dd3b8b4", "lang": "Agda", "max_forks_count": 3, "max_forks_repo_forks_event_max_datetime": "2022-03-12T11:40:03.000Z", "max_forks_repo_forks_event_min_datetime": "2017-12-03T14:52:09.000Z", "max_forks_repo_head_hexsha": "38fbc3af7062ba5c3d7d289b2b4bcfb995d99057", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "bblfish/agda-web-semantic", "max_forks_repo_path": "src/Web/Semantic/DL/Category/Properties/Tensor/RespectsWiring.agda", "max_issues_count": 4, "max_issues_repo_head_hexsha": "38fbc3af7062ba5c3d7d289b2b4bcfb995d99057", "max_issues_repo_issues_event_max_datetime": "2021-01-04T20:57:19.000Z", "max_issues_repo_issues_event_min_datetime": "2018-11-14T02:32:28.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "bblfish/agda-web-semantic", "max_issues_repo_path": "src/Web/Semantic/DL/Category/Properties/Tensor/RespectsWiring.agda", "max_line_length": 97, "max_stars_count": 9, "max_stars_repo_head_hexsha": "8ddbe83965a616bff6fc7a237191fa261fa78bab", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "agda/agda-web-semantic", "max_stars_repo_path": "src/Web/Semantic/DL/Category/Properties/Tensor/RespectsWiring.agda", "max_stars_repo_stars_event_max_datetime": "2020-03-14T14:21:08.000Z", "max_stars_repo_stars_event_min_datetime": "2015-09-13T17:46:41.000Z", "num_tokens": 1716, "size": 3538 }
module ParserC where {- import Prelude import Equiv import Eq import Datoid import List import Bag open Prelude open Equiv open Eq open Datoid open List open Bag parserDatoid : (a, s : Datoid) -> Datoid parserDatoid a s = Bag (pairDatoid a (listDatoid s)) -- We use the following datatype instead of -- type Parsing s a = [s] -> Bag (a, [s]) data Parsing (s, a : Datoid) : Set1 where P : (List (El s) -> El (parserDatoid a s)) -> Parsing s a private unP : {s, a : Datoid} -> Parsing s a -> List (El s) -> El (parserDatoid a s) unP (P x) = x _<+>_ : {a : Datoid} -> El (Bag a) -> El (Bag a) -> El (Bag a) _<+>_ {a} x y = bagElim (\bs -> El (Bag a)) ? y (\z zs ih -> insert z ih) x concatMap : {a, b : Datoid} -> (El a -> El (Bag b)) -> El (Bag a) -> El (Bag b) concatMap {a} {b} f = bagElim (\bs -> El (Bag b)) ? empty (\x b ih -> f x <+> ih) symbol : {s : Datoid} -> Parsing s s symbol {s} = P symbol' where symbol' : List (El s) -> El (parserDatoid s s) symbol' nil = empty symbol' (x :: xs) = insert (pair x xs) empty fail : {s, a : Datoid} -> Parsing s a fail = P (\ss -> empty) (+++) : {s, a : Datoid} -> Parsing s a -> Parsing s a -> Parsing s a P p +++ P q = P (\s -> p s <+> q s) return : {s, a : Datoid} -> (x : El a) -> Parsing s a return = \x -> P (\s -> insert (pair x s) empty) -- data Traverse (a : Datoid) : Set where -- Empty : Traverse a -- Insert : (x : El a) -> (b : El (Bag a)) -> Traverse a -- run : {a : Datoid} -> Traverse a -> El (Bag a) -- traverse : {a : Datoid} -> El (Bag a) -> Traverse a -- traverseTraverses -- : {a : Datoid} -> (b : El (Bag a)) -> run (traverse b) =^= b -- insert : {a : Datoid} -> El a -> El (Bag a) -> El (Bag a) -- pairDatoid : Datoid -> Datoid -> Datoid --(empty {Bag (pairDatoid s (listDatoid s))}) -- bagElim -- : {a : Datoid} -- -> (P : El (Bag a) -> Set) -- -> P empty -- -> ((x : El a) -> (b : El (Bag a)) -> P b -> P (insert x b)) -- -> (b : El (Bag a)) -- -> P b (>>=) : {s, a, b : Datoid} -> Parsing s a -> (El a -> Parsing s b) -> Parsing s b (>>=) {s} {a} {b} (P p) k = P (\s -> concatMap (\y -> unP (k (fst y)) (snd y)) (p s)) {- parserDatoid : (a, s : Datoid) -> Datoid parserDatoid a s = Bag (pairDatoid a (listDatoid s)) -- We use the following datatype instead of -- type Parsing s a = [s] -> Bag (a, [s]) data Parsing (s, a : Datoid) : Set1 where P : (List (El s) -> El (parserDatoid a s)) -> Parsing s a -} -}	{ "alphanum_fraction": 0.504611837, "avg_line_length": 27.1041666667, "ext": "agda", "hexsha": "60517c1ec0ba204ea17eea329e50bb9c7ec1ddc7", "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": "examples/AIM4/bag/ParserC.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": "examples/AIM4/bag/ParserC.agda", "max_line_length": 85, "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": "examples/AIM4/bag/ParserC.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": 973, "size": 2602 }
{-# OPTIONS --without-K #-} module Test where open import Level infixl 4 _≡_ data _≡_ {a} {A : Set a} (x : A) : A → Set a where refl : x ≡ x J : {a b : Level} (A : Set a) (C : (x y : A) → x ≡ y → Set b) → ((x : A) → C x x refl) → (x y : A) (P : x ≡ y) → C x y P J A C b x .x refl = b x -- K : (A : Set) (x : A) (C : x ≡ x → Set) -- → C refl -- → (loop : x ≡ x) -- → C loop -- K A x C b p = {! p !} -- Lemma 2.1.1 (inversion of paths) infix 6 ¬_ ¬_ : {a : Level} {A : Set a} {x y : A} → x ≡ y → y ≡ x ¬_ {a} {A} {x} {y} p = J A D d x y p where D : (x y : A) (p : x ≡ y) → Set a D x y p = y ≡ x d : (x : A) → D x x refl d x = refl -- Lemma 2.1.2 (concatenation of paths) infixl 5 _∙_ _∙_ : {a : Level} {A : Set a} {x y z : A} → x ≡ y → y ≡ z → x ≡ z _∙_ {a} {A} {x} {y} {z} p q = J {a} {a} A D d x y p z q where -- the predicate D : (x y : A) (p : x ≡ y) → Set a D x y p = (z : A) (q : y ≡ z) → x ≡ z -- base case d : (x : A) → D x x refl d x z q = J A E e x z q where -- the predicate E : (x z : A) (q : x ≡ z) → Set a E x z q = x ≡ z -- base case e : (x : A) → E x x refl e x = refl -- Lemma 2.1.4.i (identity of path concatenation) ∙-identityʳ : {a : Level} {A : Set a} {x y : A} (p : x ≡ y) → p ≡ p ∙ refl ∙-identityʳ {a} {A} {x} {y} p = J A D d x y p where -- the predicate D : (x y : A) (p : x ≡ y) → Set a D x y p = p ≡ p ∙ refl -- base case d : (x : A) → D x x refl d x = refl ∙-identityˡ : {a : Level} {A : Set a} {x y : A} (p : x ≡ y) → p ≡ refl ∙ p ∙-identityˡ {a} {A} {x} {y} p = J A D d x y p where -- the predicate D : (x y : A) (p : x ≡ y) → Set a D x y p = p ≡ refl ∙ p -- base case d : (x : A) → D x x refl d x = refl -- Lemma 2.1.4.ii (identity of path inversion) ¬-identityʳ : {a : Level} {A : Set a} {x y : A} (p : x ≡ y) → ¬ p ∙ p ≡ refl ¬-identityʳ {a} {A} {x} {y} p = J A D d x y p where -- the predicate D : (x y : A) (p : x ≡ y) → Set a D x y p = ¬ p ∙ p ≡ refl -- base case d : (x : A) → D x x refl d x = refl ¬-identityˡ : {a : Level} {A : Set a} {x y : A} (p : x ≡ y) → p ∙ ¬ p ≡ refl ¬-identityˡ {a} {A} {x} {y} p = J A D d x y p where -- the predicate D : (x y : A) (p : x ≡ y) → Set a D x y p = p ∙ ¬ p ≡ refl -- base case d : (x : A) → D x x refl d x = refl -- Lemma 2.1.4.iii (involution of path inversion) involution : {A : Set} {x y : A} (p : x ≡ y) → ¬ ¬ p ≡ p involution {A} {x} {y} p = J A D d x y p where -- the predicate D : (x y : A) (p : x ≡ y) → Set D x y p = ¬ ¬ p ≡ p -- base case d : (x : A) → D x x refl d x = refl -- Lemma 2.1.4.iv (associativity of path concatenation) ∙-assoc : {a : Level} {A : Set a} {w x y z : A} → (p : w ≡ x) (q : x ≡ y) (r : y ≡ z) → p ∙ (q ∙ r) ≡ (p ∙ q) ∙ r ∙-assoc {a} {A} {w} {x} {y} {z} p q r = J A D d w x p y q z r where -- the predicate D : (w x : A) (p : w ≡ x) → Set a D w x p = (y : A) (q : x ≡ y) → (z : A) (r : y ≡ z) → p ∙ (q ∙ r) ≡ (p ∙ q) ∙ r -- base case d : (x : A) → D x x refl d x y q z r = J A E e x y q z r where -- the predicate E : (x y : A) (q : x ≡ y) → Set a E x y q = (z : A) (r : y ≡ z) → refl ∙ (q ∙ r) ≡ refl ∙ q ∙ r -- base case e : (x : A) → E x x refl e x z r = J A F f x z r where -- the predicate F : (y z : A) (r : y ≡ z) → Set a F y z r = refl ∙ (refl ∙ r) ≡ refl ∙ refl ∙ r -- base case f : (x : A) → F x x refl f x = {! !}	{ "alphanum_fraction": 0.397311828, "avg_line_length": 24.6357615894, "ext": "agda", "hexsha": "4bed8fc67385a11db50395a6b5339a5e395ff724", "lang": "Agda", "max_forks_count": 18, "max_forks_repo_forks_event_max_datetime": "2019-11-21T10:12:31.000Z", "max_forks_repo_forks_event_min_datetime": "2015-05-24T04:15:44.000Z", "max_forks_repo_head_hexsha": "67d4db3b1050e6acfbdfdc05f8a656fd4c1f0b07", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "erydo/agda-mode", "max_forks_repo_path": "test/asset/Test.agda", "max_issues_count": 126, "max_issues_repo_head_hexsha": "67d4db3b1050e6acfbdfdc05f8a656fd4c1f0b07", "max_issues_repo_issues_event_max_datetime": "2020-12-23T23:00:13.000Z", "max_issues_repo_issues_event_min_datetime": "2015-02-02T05:47:54.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "erydo/agda-mode", "max_issues_repo_path": "test/asset/Test.agda", "max_line_length": 76, "max_stars_count": 58, "max_stars_repo_head_hexsha": "67d4db3b1050e6acfbdfdc05f8a656fd4c1f0b07", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "erydo/agda-mode", "max_stars_repo_path": "test/asset/Test.agda", "max_stars_repo_stars_event_max_datetime": "2021-06-11T01:42:34.000Z", "max_stars_repo_stars_event_min_datetime": "2015-01-10T10:24:09.000Z", "num_tokens": 1728, "size": 3720 }
{-# OPTIONS --without-K --safe #-} module Definition.Typed.Consequences.Equality where open import Definition.Untyped open import Definition.Typed open import Definition.Typed.Properties open import Definition.Typed.EqRelInstance open import Definition.LogicalRelation open import Definition.LogicalRelation.Irrelevance open import Definition.LogicalRelation.ShapeView open import Definition.LogicalRelation.Fundamental.Reducibility open import Tools.Product import Tools.PropositionalEquality as PE U≡A′ : ∀ {A Γ l} ([U] : Γ ⊩⟨ l ⟩U) → Γ ⊩⟨ l ⟩ U ≡ A / (U-intr [U]) → A PE.≡ U U≡A′ (noemb [U]) [U≡A] = [U≡A] U≡A′ (emb 0<1 [U]) [U≡A] = U≡A′ [U] [U≡A] -- If A is judgmentally equal to U, then A is propositionally equal to U. U≡A : ∀ {A Γ} → Γ ⊢ U ≡ A → A PE.≡ U U≡A {A} U≡A with reducibleEq U≡A U≡A {A} U≡A \| [U] , [A] , [U≡A] = U≡A′ (U-elim [U]) (irrelevanceEq [U] (U-intr (U-elim [U])) [U≡A]) ℕ≡A′ : ∀ {A Γ l} ([ℕ] : Γ ⊩⟨ l ⟩ℕ ℕ) → Γ ⊩⟨ l ⟩ ℕ ≡ A / (ℕ-intr [ℕ]) → Whnf A → A PE.≡ ℕ ℕ≡A′ (noemb x) [ℕ≡A] whnfA = whnfRed* [ℕ≡A] whnfA ℕ≡A′ (emb 0<1 [ℕ]) [ℕ≡A] whnfA = ℕ≡A′ [ℕ] [ℕ≡A] whnfA -- If A in WHNF is judgmentally equal to ℕ, then A is propositionally equal to ℕ. ℕ≡A : ∀ {A Γ} → Γ ⊢ ℕ ≡ A → Whnf A → A PE.≡ ℕ ℕ≡A {A} ℕ≡A whnfA with reducibleEq ℕ≡A ℕ≡A {A} ℕ≡A whnfA \| [ℕ] , [A] , [ℕ≡A] = ℕ≡A′ (ℕ-elim [ℕ]) (irrelevanceEq [ℕ] (ℕ-intr (ℕ-elim [ℕ])) [ℕ≡A]) whnfA -- If A in WHNF is judgmentally equal to Empty, then A is propositionally equal to Empty. Empty≡A′ : ∀ {A Γ l} ([Empty] : Γ ⊩⟨ l ⟩Empty Empty) → Γ ⊩⟨ l ⟩ Empty ≡ A / (Empty-intr [Empty]) → Whnf A → A PE.≡ Empty Empty≡A′ (noemb x) [Empty≡A] whnfA = whnfRed* [Empty≡A] whnfA Empty≡A′ (emb 0<1 [Empty]) [Empty≡A] whnfA = Empty≡A′ [Empty] [Empty≡A] whnfA Empty≡A : ∀ {A Γ} → Γ ⊢ Empty ≡ A → Whnf A → A PE.≡ Empty Empty≡A {A} Empty≡A whnfA with reducibleEq Empty≡A Empty≡A {A} Empty≡A whnfA \| [Empty] , [A] , [Empty≡A] = Empty≡A′ (Empty-elim [Empty]) (irrelevanceEq [Empty] (Empty-intr (Empty-elim [Empty])) [Empty≡A]) whnfA Unit≡A′ : ∀ {A Γ l} ([Unit] : Γ ⊩⟨ l ⟩Unit Unit) → Γ ⊩⟨ l ⟩ Unit ≡ A / (Unit-intr [Unit]) → Whnf A → A PE.≡ Unit Unit≡A′ (noemb x) [Unit≡A] whnfA = whnfRed* [Unit≡A] whnfA Unit≡A′ (emb 0<1 [Unit]) [Unit≡A] whnfA = Unit≡A′ [Unit] [Unit≡A] whnfA Unit≡A : ∀ {A Γ} → Γ ⊢ Unit ≡ A → Whnf A → A PE.≡ Unit Unit≡A {A} Unit≡A whnfA with reducibleEq Unit≡A Unit≡A {A} Unit≡A whnfA \| [Unit] , [A] , [Unit≡A] = Unit≡A′ (Unit-elim [Unit]) (irrelevanceEq [Unit] (Unit-intr (Unit-elim [Unit])) [Unit≡A]) whnfA ne≡A′ : ∀ {A K Γ l} → ([K] : Γ ⊩⟨ l ⟩ne K) → Γ ⊩⟨ l ⟩ K ≡ A / (ne-intr [K]) → Whnf A → ∃ λ M → Neutral M × A PE.≡ M ne≡A′ (noemb [K]) (ne₌ M D′ neM K≡M) whnfA = M , neM , (whnfRed* (red D′) whnfA) ne≡A′ (emb 0<1 [K]) [K≡A] whnfA = ne≡A′ [K] [K≡A] whnfA -- If A in WHNF is judgmentally equal to K, then there exists a M such that -- A is propositionally equal to M. ne≡A : ∀ {A K Γ} → Neutral K → Γ ⊢ K ≡ A → Whnf A → ∃ λ M → Neutral M × A PE.≡ M ne≡A {A} neK ne≡A whnfA with reducibleEq ne≡A ne≡A {A} neK ne≡A whnfA \| [ne] , [A] , [ne≡A] = ne≡A′ (ne-elim neK [ne]) (irrelevanceEq [ne] (ne-intr (ne-elim neK [ne])) [ne≡A]) whnfA B≡A′ : ∀ {A F G Γ l} W ([W] : Γ ⊩⟨ l ⟩B⟨ W ⟩ ⟦ W ⟧ F ▹ G) → Γ ⊩⟨ l ⟩ ⟦ W ⟧ F ▹ G ≡ A / (B-intr W [W]) → Whnf A → ∃₂ λ H E → A PE.≡ ⟦ W ⟧ H ▹ E B≡A′ W (noemb [W]) (B₌ F′ G′ D′ A≡B [F≡F′] [G≡G′]) whnfA = F′ , G′ , whnfRed* D′ whnfA B≡A′ W (emb 0<1 [W]) [W≡A] whnfA = B≡A′ W [W] [W≡A] whnfA Π≡A′ : ∀ {A F G Γ l} → _ Π≡A′ {A} {F} {G} {Γ} {l} = B≡A′ {A} {F} {G} {Γ} {l} BΠ Σ≡A′ : ∀ {A F G Γ l} → _ Σ≡A′ {A} {F} {G} {Γ} {l} = B≡A′ {A} {F} {G} {Γ} {l} BΣ -- If A is judgmentally equal to Π F ▹ G, then there exists H and E such that -- A is propositionally equal to Π H ▹ E. B≡A : ∀ {A F G Γ} W → Γ ⊢ ⟦ W ⟧ F ▹ G ≡ A → Whnf A → ∃₂ λ H E → A PE.≡ ⟦ W ⟧ H ▹ E B≡A {A} W W≡A whnfA with reducibleEq W≡A B≡A {A} W W≡A whnfA \| [W] , [A] , [W≡A] = B≡A′ W (B-elim W [W]) (irrelevanceEq [W] (B-intr W (B-elim W [W])) [W≡A]) whnfA Π≡A : ∀ {A F G Γ} → _ Π≡A {A} {F} {G} {Γ} = B≡A {A} {F} {G} {Γ} BΠ Σ≡A : ∀ {A F G Γ} → _ Σ≡A {A} {F} {G} {Γ} = B≡A {A} {F} {G} {Γ} BΣ	{ "alphanum_fraction": 0.5328312544, "avg_line_length": 33.4566929134, "ext": "agda", "hexsha": "29a9f15743b0b3b1ee980681c280407766f7f878", "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": "4746894adb5b8edbddc8463904ee45c2e9b29b69", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "Vtec234/logrel-mltt", "max_forks_repo_path": "Definition/Typed/Consequences/Equality.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "4746894adb5b8edbddc8463904ee45c2e9b29b69", "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": "Vtec234/logrel-mltt", "max_issues_repo_path": "Definition/Typed/Consequences/Equality.agda", "max_line_length": 105, "max_stars_count": null, "max_stars_repo_head_hexsha": "4746894adb5b8edbddc8463904ee45c2e9b29b69", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "Vtec234/logrel-mltt", "max_stars_repo_path": "Definition/Typed/Consequences/Equality.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 2232, "size": 4249 }
{- Cubical Agda - A Dependently Typed PL with Univalence and HITs ============================================================== Anders Mörtberg Every Proof Assistant - September 17, 2020 Link to slides: https://staff.math.su.se/anders.mortberg/slides/EPA2020.pdf Link to video: https://vimeo.com/459020971 -} -- To make Agda cubical add the following options {-# OPTIONS --cubical --no-import-sorts --safe #-} module Cubical.Talks.EPA2020 where -- The "Foundations" package contain a lot of important results (in -- particular the univalence theorem) open import Cubical.Foundations.Prelude open import Cubical.Foundations.Equiv open import Cubical.Foundations.Isomorphism open import Cubical.Foundations.Univalence open import Cubical.Data.Int open import Cubical.Data.Prod.Base -- The interval in Cubical Agda is written I and the endpoints i0 and i1. apply0 : (A : Type) (p : I → A) → A apply0 A p = p i0 -- We omit the universe level ℓ for simplicity in this talk. In the -- library everything is maximally universe polymorphic. -- We can write functions out of the interval using λ-abstraction: refl' : {A : Type} (x : A) → x ≡ x refl' x = λ i → x -- In fact, x ≡ y is short for PathP (λ _ → A) x y refl'' : {A : Type} (x : A) → PathP (λ _ → A) x x refl'' x = λ _ → x -- In general PathP A x y has A : I → Type, x : A i0 and y : A i1 -- PathP = Dependent paths (Path over a Path) -- We cannot pattern-match on interval variables as I is not inductively defined -- foo : {A : Type} → I → A -- foo r = {!r!} -- Try typing C-c C-c -- cong has a direct proof cong' : {A B : Type} (f : A → B) {x y : A} → x ≡ y → f x ≡ f y cong' f p i = f (p i) -- function extensionality also has a direct proof. -- It also has computational content: swap the arguments. funExt' : {A B : Type} {f g : A → B} (p : (x : A) → f x ≡ g x) → f ≡ g funExt' p i x = p x i -- Transport is more complex as ≡ isn't inductively defined (so we -- can't define it by pattern-matching on p) transport' : {A B : Type} → A ≡ B → A → B transport' p a = transp (λ i → p i) i0 a -- This lets us define subst (which is called "transport" in the HoTT book) subst' : {A : Type} (P : A → Type) {x y : A} (p : x ≡ y) → P x → P y subst' P p pa = transport (λ i → P (p i)) pa -- The transp operation reduces differently for different types -- formers. For paths it reduces to another primitive operation called -- hcomp. -- We can also define the J eliminator (aka path induction) J' : {A : Type} {B : A → Type} {x : A} (P : (z : A) → x ≡ z → Type) (d : P x refl) {y : A} (p : x ≡ y) → P y p J' P d p = transport (λ i → P (p i) (λ j → p (i ∧ j))) d -- So J is provable, but it doesn't satisfy computation rule -- definitionally. This is almost never a problem in practice as the -- cubical primitives satisfy many new definitional equalities. -- Another key concept in HoTT/UF is the Univalence Axiom. In Cubical -- Agda this is provable, we hence refer to it as the Univalence -- Theorem. -- The univalence theorem: equivalences of types give paths of types ua' : {A B : Type} → A ≃ B → A ≡ B ua' = ua -- Any isomorphism of types gives rise to an equivalence isoToEquiv' : {A B : Type} → Iso A B → A ≃ B isoToEquiv' = isoToEquiv -- And hence to a path isoToPath' : {A B : Type} → Iso A B → A ≡ B isoToPath' e = ua' (isoToEquiv' e) -- ua satisfies the following computation rule -- This suffices to be able to prove the standard formulation of univalence. uaβ' : {A B : Type} (e : A ≃ B) (x : A) → transport (ua' e) x ≡ fst e x uaβ' e x = transportRefl (equivFun e x) -- Time for an example! -- Booleans data Bool : Type where false true : Bool not : Bool → Bool not false = true not true = false notPath : Bool ≡ Bool notPath = isoToPath' (iso not not rem rem) where rem : (b : Bool) → not (not b) ≡ b rem false = refl rem true = refl _ : transport notPath true ≡ false _ = refl -- Another example, integers: sucPath : Int ≡ Int sucPath = isoToPath' (iso sucInt predInt sucPred predSuc) _ : transport sucPath (pos 0) ≡ pos 1 _ = refl _ : transport (sucPath ∙ sucPath) (pos 0) ≡ pos 2 _ = refl _ : transport (sym sucPath) (pos 0) ≡ negsuc 0 _ = refl ----------------------------------------------------------------------------- -- Higher inductive types -- The following definition of finite multisets is due to Vikraman -- Choudhury and Marcelo Fiore. infixr 5 _∷_ data FMSet (A : Type) : Type where [] : FMSet A _∷_ : (x : A) → (xs : FMSet A) → FMSet A comm : (x y : A) (xs : FMSet A) → x ∷ y ∷ xs ≡ y ∷ x ∷ xs -- trunc : (xs ys : FMSet A) (p q : xs ≡ ys) → p ≡ q -- We need to add the trunc constructor for FMSets to be sets, omitted -- here for simplicity. _++_ : ∀ {A : Type} (xs ys : FMSet A) → FMSet A [] ++ ys = ys (x ∷ xs) ++ ys = x ∷ xs ++ ys comm x y xs i ++ ys = comm x y (xs ++ ys) i -- trunc xs zs p q i j ++ ys = -- trunc (xs ++ ys) (zs ++ ys) (cong (_++ ys) p) (cong (_++ ys) q) i j unitr-++ : {A : Type} (xs : FMSet A) → xs ++ [] ≡ xs unitr-++ [] = refl unitr-++ (x ∷ xs) = cong (x ∷_) (unitr-++ xs) unitr-++ (comm x y xs i) j = comm x y (unitr-++ xs j) i -- unitr-++ (trunc xs ys x y i j) = {!!} -- This is a special case of set quotients! Very useful for -- programming and set level mathematics data _/_ (A : Type) (R : A → A → Type) : Type where [_] : A → A / R eq/ : (a b : A) → R a b → [ a ] ≡ [ b ] trunc : (a b : A / R) (p q : a ≡ b) → p ≡ q -- Proving that they are effective ((a b : A) → [ a ] ≡ [ b ] → R a b) -- requires univalence for propositions. ------------------------------------------------------------------------- -- Topological examples of things that are not sets -- We can define the circle as the following simple data declaration: data S¹ : Type where base : S¹ loop : base ≡ base -- We can write functions on S¹ using pattern-matching equations: double : S¹ → S¹ double base = base double (loop i) = (loop ∙ loop) i helix : S¹ → Type helix base = Int helix (loop i) = sucPathInt i ΩS¹ : Type ΩS¹ = base ≡ base winding : ΩS¹ → Int winding p = subst helix p (pos 0) _ : winding (λ i → double ((loop ∙ loop) i)) ≡ pos 4 _ = refl -- We can define the Torus as: data Torus : Type where point : Torus line1 : point ≡ point line2 : point ≡ point square : PathP (λ i → line1 i ≡ line1 i) line2 line2 -- And prove that it is equivalent to two circle: t2c : Torus → S¹ × S¹ t2c point = (base , base) t2c (line1 i) = (loop i , base) t2c (line2 j) = (base , loop j) t2c (square i j) = (loop i , loop j) c2t : S¹ × S¹ → Torus c2t (base , base) = point c2t (loop i , base) = line1 i c2t (base , loop j) = line2 j c2t (loop i , loop j) = square i j c2t-t2c : (t : Torus) → c2t (t2c t) ≡ t c2t-t2c point = refl c2t-t2c (line1 _) = refl c2t-t2c (line2 _) = refl c2t-t2c (square _ _) = refl t2c-c2t : (p : S¹ × S¹) → t2c (c2t p) ≡ p t2c-c2t (base , base) = refl t2c-c2t (base , loop _) = refl t2c-c2t (loop _ , base) = refl t2c-c2t (loop _ , loop _) = refl -- Using univalence we get the following equality: Torus≡S¹×S¹ : Torus ≡ S¹ × S¹ Torus≡S¹×S¹ = isoToPath' (iso t2c c2t t2c-c2t c2t-t2c) windingTorus : point ≡ point → Int × Int windingTorus l = ( winding (λ i → proj₁ (t2c (l i))) , winding (λ i → proj₂ (t2c (l i)))) _ : windingTorus (line1 ∙ sym line2) ≡ (pos 1 , negsuc 0) _ = refl -- We have many more topological examples, including Klein bottle, RP^n, -- higher spheres, suspensions, join, wedges, smash product: open import Cubical.HITs.KleinBottle open import Cubical.HITs.RPn open import Cubical.HITs.S2 open import Cubical.HITs.S3 open import Cubical.HITs.Susp open import Cubical.HITs.Join open import Cubical.HITs.Wedge open import Cubical.HITs.SmashProduct -- There's also a proof of the "3x3 lemma" for pushouts in less than -- 200LOC. In HoTT-Agda this took about 3000LOC. For details see: -- https://github.com/HoTT/HoTT-Agda/tree/master/theorems/homotopy/3x3 open import Cubical.HITs.Pushout -- We also defined the Hopf fibration and proved that its total space -- is S³ in about 300LOC: open import Cubical.HITs.Hopf -- There is also some integer cohomology: open import Cubical.ZCohomology.Everything -- To compute cohomology groups of various spaces we need a bunch of -- interesting theorems: Freudenthal suspension theorem, -- Mayer-Vietoris sequence... open import Cubical.Homotopy.Freudenthal open import Cubical.ZCohomology.MayerVietorisUnreduced ------------------------------------------------------------------------- -- The structure identity principle -- A more efficient version of finite multisets based on association lists open import Cubical.HITs.AssocList.Base -- data AssocList (A : Type) : Type where -- ⟨⟩ : AssocList A -- ⟨_,_⟩∷_ : (a : A) (n : ℕ) (xs : AssocList A) → AssocList A -- per : (a b : A) (m n : ℕ) (xs : AssocList A) -- → ⟨ a , m ⟩∷ ⟨ b , n ⟩∷ xs ≡ ⟨ b , n ⟩∷ ⟨ a , m ⟩∷ xs -- agg : (a : A) (m n : ℕ) (xs : AssocList A) -- → ⟨ a , m ⟩∷ ⟨ a , n ⟩∷ xs ≡ ⟨ a , m + n ⟩∷ xs -- del : (a : A) (xs : AssocList A) → ⟨ a , 0 ⟩∷ xs ≡ xs -- trunc : (xs ys : AssocList A) (p q : xs ≡ ys) → p ≡ q -- Programming and proving is more complicated with AssocList compared -- to FMSet. This kind of example occurs everywhere in programming and -- mathematics: one representation is easier to work with, but not -- efficient, while another is efficient but difficult to work with. -- Solution: substitute using univalence substIso : {A B : Type} (P : Type → Type) (e : Iso A B) → P A → P B substIso P e = subst P (isoToPath e) -- Can transport for example Monoid structure from FMSet to AssocList -- this way, but the achieved Monoid structure is not very efficient -- to work with. A better solution is to prove that FMSet and -- AssocList are equal as monoids, but how to do this? -- Solution: structure identity principle (SIP) -- This is a very useful consequence of univalence open import Cubical.Foundations.SIP sip' : {ℓ : Level} {S : Type ℓ → Type ℓ} {ι : StrEquiv S ℓ} (θ : UnivalentStr S ι) (A B : TypeWithStr ℓ S) → A ≃[ ι ] B → A ≡ B sip' = sip -- The tricky thing is to prove that (S,ι) is a univalent structure. -- Luckily we provide automation for this in the library, see for example: open import Cubical.Algebra.Monoid.Base -- Another cool application of the SIP: matrices represented as -- functions out of pairs of Fin's and vectors are equal as abelian -- groups: open import Cubical.Algebra.Matrix -- The end, back to slides!	{ "alphanum_fraction": 0.628761272, "avg_line_length": 30.8040935673, "ext": "agda", "hexsha": "12b37d9c29d3ed147e74cbf6e28996aee663280e", "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/Talks/EPA2020.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/Talks/EPA2020.agda", "max_line_length": 80, "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/Talks/EPA2020.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 3549, "size": 10535 }
module Structure.Sets.Relators where	{ "alphanum_fraction": 0.8648648649, "avg_line_length": 18.5, "ext": "agda", "hexsha": "134367bbfc51f3e9acaa5136a5fbcf628f06a338", "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/Sets/Relators.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/Sets/Relators.agda", "max_line_length": 36, "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/Sets/Relators.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": 8, "size": 37 }
module Prelude.Monoid where open import Prelude.Function open import Prelude.Maybe open import Prelude.List open import Prelude.Semiring open import Prelude.Applicative open import Prelude.Functor record Monoid {a} (A : Set a) : Set a where infixr 6 _<>_ field mempty : A _<>_ : A → A → A open Monoid {{...}} public {-# DISPLAY Monoid.mempty _ = mempty #-} {-# DISPLAY Monoid._<>_ _ a b = a <> b #-} mconcat : ∀ {a} {A : Set a} {{MonA : Monoid A}} → List A → A mconcat = foldr _<>_ mempty --- Instances --- instance MonoidList : ∀ {a} {A : Set a} → Monoid (List A) mempty {{MonoidList}} = [] _<>_ {{MonoidList}} = _++_ MonoidFun : ∀ {a b} {A : Set a} {B : A → Set b} {{_ : ∀ {x} → Monoid (B x)}} → Monoid (∀ x → B x) mempty {{MonoidFun}} _ = mempty _<>_ {{MonoidFun}} f g x = f x <> g x MonoidMaybe : ∀ {a} {A : Set a} → Monoid (Maybe A) mempty {{MonoidMaybe}} = nothing _<>_ {{MonoidMaybe}} nothing y = y _<>_ {{MonoidMaybe}} (just x) _ = just x record Sum {a} (A : Set a) : Set a where constructor mkSum field getSum : A open Sum public instance MonoidSum : ∀ {a} {A : Set a} {{_ : Semiring A}} → Monoid (Sum A) getSum (mempty {{MonoidSum}}) = zro getSum (_<>_ {{MonoidSum}} x y) = getSum x + getSum y record Product {a} (A : Set a) : Set a where constructor mkProduct field getProduct : A open Product public instance MonoidProduct : ∀ {a} {A : Set a} {{_ : Semiring A}} → Monoid (Product A) getProduct (mempty {{MonoidProduct}}) = one getProduct (_<>_ {{MonoidProduct}} x y) = getProduct x * getProduct y record Const {a b} (A : Set a) (B : Set b) : Set a where constructor mkConst field getConst : A open Const public module _ {a b} {A : Set a} {{MonA : Monoid A}} where instance FunctorConst : Functor {a = b} (Const A) getConst (fmap {{FunctorConst}} f x) = getConst x ApplicativeConst : Applicative (Const A) getConst (pure {{ApplicativeConst}} x) = mempty getConst (_<*>_ {{ApplicativeConst}} wf wx) = getConst wf <> getConst wx	{ "alphanum_fraction": 0.6107350097, "avg_line_length": 26.8571428571, "ext": "agda", "hexsha": "12a6238220386af3b23191863a9b1cfa45afea31", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "75016b4151ed601e28f4462cd7b6b1aaf5d0d1a6", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "lclem/agda-prelude", "max_forks_repo_path": "src/Prelude/Monoid.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "75016b4151ed601e28f4462cd7b6b1aaf5d0d1a6", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "lclem/agda-prelude", "max_issues_repo_path": "src/Prelude/Monoid.agda", "max_line_length": 99, "max_stars_count": null, "max_stars_repo_head_hexsha": "75016b4151ed601e28f4462cd7b6b1aaf5d0d1a6", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "lclem/agda-prelude", "max_stars_repo_path": "src/Prelude/Monoid.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 714, "size": 2068 }
{-# OPTIONS --safe #-} module Cubical.Algebra.Group.Instances.NProd where open import Cubical.Foundations.Prelude open import Cubical.Foundations.HLevels open import Cubical.Data.Nat using (ℕ) open import Cubical.Algebra.Group private variable ℓ : Level open GroupStr NProd-Group : (G : (n : ℕ) → Type ℓ) → (Gstr : (n : ℕ) → GroupStr (G n)) → Group ℓ fst (NProd-Group G Gstr) = (n : ℕ) → G n 1g (snd (NProd-Group G Gstr)) = λ n → 1g (Gstr n) GroupStr._·_ (snd (NProd-Group G Gstr)) = λ f g n → Gstr n ._·_ (f n) (g n) inv (snd (NProd-Group G Gstr)) = λ f n → (Gstr n).inv (f n) isGroup (snd (NProd-Group G Gstr)) = makeIsGroup (isSetΠ (λ _ → is-set (Gstr _))) (λ f g h → funExt λ n → ·Assoc (Gstr n) _ _ _) (λ f → funExt λ n → ·IdR (Gstr n) _) (λ f → funExt λ n → ·IdL (Gstr n) _) (λ f → funExt λ n → ·InvR (Gstr n) _) λ f → funExt λ n → ·InvL (Gstr n) _	{ "alphanum_fraction": 0.4887285843, "avg_line_length": 41.0740740741, "ext": "agda", "hexsha": "8169e1da5fed15cc28ed752d38e4c186ee879601", "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/Group/Instances/NProd.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/Group/Instances/NProd.agda", "max_line_length": 95, "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/Group/Instances/NProd.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 352, "size": 1109 }
------------------------------------------------------------------------ -- An abstraction: term-like things ------------------------------------------------------------------------ open import Data.Universe.Indexed module deBruijn.Context.Term-like {i u e} (Uni : IndexedUniverse i u e) where import Axiom.Extensionality.Propositional as E open import Data.Product import deBruijn.Context.Basics as Basics import deBruijn.Context.Extension.Right as Right open import Function.Base hiding (_∋_) open import Level using (_⊔_) open import Relation.Binary using (Setoid) open import Relation.Binary.PropositionalEquality as P using (_≡_) open Basics Uni open Right Uni open P.≡-Reasoning ------------------------------------------------------------------------ -- Term-like things record Term-like ℓ : Set (i ⊔ u ⊔ e ⊔ Level.suc ℓ) where infix 3 _⊢_ field _⊢_ : (Γ : Ctxt) → Type Γ → Set ℓ ⟦_⟧ : ∀ {Γ σ} → Γ ⊢ σ → Value Γ σ -- Equality of term-like things. record [⊢] : Set (i ⊔ u ⊔ e ⊔ ℓ) where constructor [_] field {Γ} : Ctxt {σ} : Type Γ t : Γ ⊢ σ infix 4 _≅-⊢_ _≅-⊢_ : ∀ {Γ₁ σ₁} (t₁ : Γ₁ ⊢ σ₁) {Γ₂ σ₂} (t₂ : Γ₂ ⊢ σ₂) → Set _ t₁ ≅-⊢ t₂ = _≡_ {A = [⊢]} [ t₁ ] [ t₂ ] ≅-⊢-⇒-≡ : ∀ {Γ σ} {t₁ t₂ : Γ ⊢ σ} → t₁ ≅-⊢ t₂ → t₁ ≡ t₂ ≅-⊢-⇒-≡ P.refl = P.refl -- Certain uses of substitutivity can be removed. drop-subst-⊢ : ∀ {a} {A : Set a} {x₁ x₂ : A} {Γ} (f : A → Type Γ) {t} (eq : x₁ ≡ x₂) → P.subst (λ x → Γ ⊢ f x) eq t ≅-⊢ t drop-subst-⊢ f P.refl = P.refl -- A congruence lemma. ⟦⟧-cong : ∀ {Γ₁ σ₁} {t₁ : Γ₁ ⊢ σ₁} {Γ₂ σ₂} {t₂ : Γ₂ ⊢ σ₂} → t₁ ≅-⊢ t₂ → ⟦ t₁ ⟧ ≅-Value ⟦ t₂ ⟧ ⟦⟧-cong P.refl = P.refl -- Values are term-like. Val : Term-like _ Val = record { _⊢_ = Value; ⟦_⟧ = id } -- Variables are term-like. Var : Term-like _ Var = record { _⊢_ = _∋_; ⟦_⟧ = lookup } ------------------------------------------------------------------------ -- Families of functions which, on the semantic side, correspond to -- the application of a given context morphism record [_⟶_] {t₁ t₂} (T₁ : Term-like t₁) (T₂ : Term-like t₂) {Γ Δ : Ctxt} (ρ̂ : Γ ⇨̂ Δ) : Set (i ⊔ u ⊔ e ⊔ t₁ ⊔ t₂) where constructor _,_ open Term-like T₁ renaming (_⊢_ to _⊢₁_; ⟦_⟧ to ⟦_⟧₁) open Term-like T₂ renaming (_⊢_ to _⊢₂_; ⟦_⟧ to ⟦_⟧₂) field function : ∀ σ → Γ ⊢₁ σ → Δ ⊢₂ σ /̂ ρ̂ corresponds : ∀ σ (t : Γ ⊢₁ σ) → ⟦ t ⟧₁ /̂Val ρ̂ ≅-Value ⟦ function σ t ⟧₂ -- Functions which do not change the context or type. [_⟶⁼_] : ∀ {t₁ t₂} → Term-like t₁ → Term-like t₂ → Set _ [ T₁ ⟶⁼ T₂ ] = ∀ {Γ} → [ T₁ ⟶ T₂ ] îd[ Γ ] -- Projections. (The fields above have explicit σ's to avoid some -- problems; the projections below have implicit σ's.) infixl 9 _·_ _·_ : ∀ {t₁ t₂} {T₁ : Term-like t₁} {T₂ : Term-like t₂} → let open Term-like T₁ renaming (_⊢_ to _⊢₁_) open Term-like T₂ renaming (_⊢_ to _⊢₂_) in ∀ {Γ Δ σ} {ρ̂ : Γ ⇨̂ Δ} → [ T₁ ⟶ T₂ ] ρ̂ → Γ ⊢₁ σ → Δ ⊢₂ σ /̂ ρ̂ _·_ f = [_⟶_].function f _ corresponds : ∀ {t₁ t₂} {T₁ : Term-like t₁} {T₂ : Term-like t₂} → let open Term-like T₁ renaming (_⊢_ to _⊢₁_; ⟦_⟧ to ⟦_⟧₁) open Term-like T₂ renaming (⟦_⟧ to ⟦_⟧₂) in ∀ {Γ Δ : Ctxt} {ρ̂ : Γ ⇨̂ Δ} {σ} (f : [ T₁ ⟶ T₂ ] ρ̂) (t : Γ ⊢₁ σ) → ⟦ t ⟧₁ /̂Val ρ̂ ≅-Value ⟦ f · t ⟧₂ corresponds f = [_⟶_].corresponds f _ -- Weakening of variables (the successor function). weaken∋ : ∀ {Γ} {σ : Type Γ} → [ Var ⟶ Var ] ŵk[ σ ] weaken∋ = record { function = λ _ → suc ; corresponds = λ _ _ → P.refl } weaken∋[_] : ∀ {Γ} (σ : Type Γ) → [ Var ⟶ Var ] ŵk[ σ ] weaken∋[ _ ] = weaken∋ -- Lifts a function on variables, f, to a function which leaves a -- prefix of the context unchanged and otherwise behaves as f. lift : ∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} → [ Var ⟶ Var ] ρ̂ → ∀ Γ⁺ → [ Var ⟶ Var ] (ρ̂ ↑̂⁺ Γ⁺) lift f ε = f lift {Γ} {Δ} {ρ̂} f (Γ⁺ ▻ σ) = record { function = function ; corresponds = corr } where function : ∀ τ → Γ ++⁺ Γ⁺ ▻ σ ∋ τ → Δ ++⁺ (Γ⁺ ▻ σ) /̂⁺ ρ̂ ∋ τ /̂ ρ̂ ↑̂⁺ (Γ⁺ ▻ σ) function ._ zero = zero function ._ (suc x) = suc (lift f Γ⁺ · x) abstract corr : ∀ τ (x : Γ ++⁺ Γ⁺ ▻ σ ∋ τ) → lookup x /̂Val ρ̂ ↑̂⁺ (Γ⁺ ▻ σ) ≅-Value lookup (function _ x) corr ._ zero = P.refl corr ._ (suc x) = begin [ lookup x /̂Val ρ̂ ↑̂⁺ Γ⁺ /̂Val ŵk ] ≡⟨ /̂Val-cong (corresponds (lift f Γ⁺) x) P.refl ⟩ [ lookup (lift f Γ⁺ · x) /̂Val ŵk ] ≡⟨ P.refl ⟩ [ lookup (suc (lift f Γ⁺ · x)) ] ∎ ------------------------------------------------------------------------ -- Equality for the functions introduced above -- Note that the definition of equality does not take the -- "corresponds" proof into account. record [⟶] {t₁ t₂} (T₁ : Term-like t₁) (T₂ : Term-like t₂) : Set (i ⊔ u ⊔ e ⊔ t₁ ⊔ t₂) where constructor [_] open Term-like T₁ renaming (_⊢_ to _⊢₁_) open Term-like T₂ renaming (_⊢_ to _⊢₂_) field {Γ Δ} : Ctxt {ρ̂} : Γ ⇨̂ Δ f : ∀ σ → Γ ⊢₁ σ → Δ ⊢₂ σ /̂ ρ̂ [_]⟶ : ∀ {t₁ t₂} {T₁ : Term-like t₁} {T₂ : Term-like t₂} {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} → [ T₁ ⟶ T₂ ] ρ̂ → [⟶] T₁ T₂ [ f ]⟶ = [ [_⟶_].function f ] -- Equality is defined as a record type to make it possible to infer -- ρ₁ and ρ₂ from a value of type ρ₁ ≅-⟶ ρ₂. infix 4 _≅-⟶_ record _≅-⟶_ {t₁ t₂} {T₁ : Term-like t₁} {T₂ : Term-like t₂} {Γ₁ Δ₁ : Ctxt} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} (f₁ : [ T₁ ⟶ T₂ ] ρ̂₁) {Γ₂ Δ₂ : Ctxt} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} (f₂ : [ T₁ ⟶ T₂ ] ρ̂₂) : Set (i ⊔ u ⊔ e ⊔ t₁ ⊔ t₂) where constructor [_] field [f₁]⟶≡[f₂]⟶ : [ f₁ ]⟶ ≡ [ f₂ ]⟶ -- Some equational reasoning combinators. module ≅-⟶-Reasoning {t₁ t₂} {T₁ : Term-like t₁} {T₂ : Term-like t₂} where infix 3 _∎-⟶ infixr 2 _≅-⟶⟨_⟩_ _≅-⟶⟨_⟩_ : ∀ {Γ₁ Δ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} {Γ₂ Δ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} {Γ₃ Δ₃} {ρ̂₃ : Γ₃ ⇨̂ Δ₃} (f₁ : [ T₁ ⟶ T₂ ] ρ̂₁) {f₂ : [ T₁ ⟶ T₂ ] ρ̂₂} {f₃ : [ T₁ ⟶ T₂ ] ρ̂₃} → f₁ ≅-⟶ f₂ → f₂ ≅-⟶ f₃ → f₁ ≅-⟶ f₃ _ ≅-⟶⟨ [ f₁≅f₂ ] ⟩ [ f₂≅f₃ ] = [ P.trans f₁≅f₂ f₂≅f₃ ] _∎-⟶ : ∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} (f : [ T₁ ⟶ T₂ ] ρ̂) → f ≅-⟶ f _ ∎-⟶ = [ P.refl ] sym-⟶ : ∀ {Γ₁ Δ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} {f₁ : [ T₁ ⟶ T₂ ] ρ̂₁} {Γ₂ Δ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} {f₂ : [ T₁ ⟶ T₂ ] ρ̂₂} → f₁ ≅-⟶ f₂ → f₂ ≅-⟶ f₁ sym-⟶ [ f₁≅f₂ ] = [ P.sym f₁≅f₂ ] open ≅-⟶-Reasoning public -- A setoid for [_⟶_]. [_⟶_]-setoid : ∀ {t₁ t₂} (T₁ : Term-like t₁) (T₂ : Term-like t₂) → ∀ {Γ Δ} → Γ ⇨̂ Δ → Setoid _ _ [ T₁ ⟶ T₂ ]-setoid ρ̂ = record { Carrier = [ T₁ ⟶ T₂ ] ρ̂ ; _≈_ = λ f₁ f₂ → f₁ ≅-⟶ f₂ ; isEquivalence = record { refl = _ ∎-⟶ ; sym = sym-⟶ ; trans = λ p q → _ ≅-⟶⟨ p ⟩ q } } -- A congruence lemma. ·-cong : ∀ {t₁ t₂} {T₁ : Term-like t₁} {T₂ : Term-like t₂} → let open Term-like T₁ renaming (_⊢_ to _⊢₁_; _≅-⊢_ to _≅-⊢₁_) open Term-like T₂ renaming (_⊢_ to _⊢₂_; _≅-⊢_ to _≅-⊢₂_) in ∀ {Γ₁ Δ₁ σ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} {f₁ : [ T₁ ⟶ T₂ ] ρ̂₁} {t₁ : Γ₁ ⊢₁ σ₁} {Γ₂ Δ₂ σ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} {f₂ : [ T₁ ⟶ T₂ ] ρ̂₂} {t₂ : Γ₂ ⊢₁ σ₂} → f₁ ≅-⟶ f₂ → t₁ ≅-⊢₁ t₂ → f₁ · t₁ ≅-⊢₂ f₂ · t₂ ·-cong {f₁ = _ , _} {f₂ = ._ , _} [ P.refl ] P.refl = P.refl abstract -- Two variants of extensional equality (assuming ordinary -- extensional equality). extensional-equality₁ : ∀ {t₁ t₂} {T₁ : Term-like t₁} {T₂ : Term-like t₂} → let open Term-like T₁ renaming (_⊢_ to _⊢₁_) open Term-like T₂ renaming (_≅-⊢_ to _≅-⊢₂_) in E.Extensionality (i ⊔ u ⊔ e ⊔ t₁) (t₁ ⊔ t₂) → ∀ {Γ Δ₁} {ρ̂₁ : Γ ⇨̂ Δ₁} {f₁ : [ T₁ ⟶ T₂ ] ρ̂₁} {Δ₂} {ρ̂₂ : Γ ⇨̂ Δ₂} {f₂ : [ T₁ ⟶ T₂ ] ρ̂₂} → ρ̂₁ ≅-⇨̂ ρ̂₂ → (∀ {σ} (t : Γ ⊢₁ σ) → f₁ · t ≅-⊢₂ f₂ · t) → f₁ ≅-⟶ f₂ extensional-equality₁ {t₁} {t₂} {T₂ = T₂} ext P.refl f₁≅f₂ = [ P.cong [_] (ext₁ λ σ → ext₂ λ t → ≅-⊢₂-⇒-≡ (f₁≅f₂ t)) ] where open Term-like T₂ using () renaming (≅-⊢-⇒-≡ to ≅-⊢₂-⇒-≡) ext₁ : E.Extensionality (i ⊔ u ⊔ e) (t₁ ⊔ t₂) ext₁ = E.lower-extensionality t₁ Level.zero ext ext₂ : E.Extensionality t₁ t₂ ext₂ = E.lower-extensionality (i ⊔ u ⊔ e) t₁ ext extensional-equality₂ : ∀ {t₁ t₂} {T₁ : Term-like t₁} {T₂ : Term-like t₂} → let open Term-like T₁ renaming (_≅-⊢_ to _≅-⊢₁_; _⊢_ to _⊢₁_) open Term-like T₂ renaming (_≅-⊢_ to _≅-⊢₂_) in E.Extensionality (i ⊔ u ⊔ e ⊔ t₁) (t₁ ⊔ t₂) → ∀ {Γ₁ Δ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} {f₁ : [ T₁ ⟶ T₂ ] ρ̂₁} {Γ₂ Δ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} {f₂ : [ T₁ ⟶ T₂ ] ρ̂₂} → ρ̂₁ ≅-⇨̂ ρ̂₂ → (∀ {σ₁} {t₁ : Γ₁ ⊢₁ σ₁} {σ₂} {t₂ : Γ₂ ⊢₁ σ₂} → t₁ ≅-⊢₁ t₂ → f₁ · t₁ ≅-⊢₂ f₂ · t₂) → f₁ ≅-⟶ f₂ extensional-equality₂ {T₁ = T₁} ext P.refl f₁≅f₂ = extensional-equality₁ ext P.refl (λ t → f₁≅f₂ (P.refl {x = [ t ]})) where open Term-like T₁ using ([_]) -- lift ∘ weaken∋ sort of commutes with a lifted version of itself. lift-weaken∋-lift-lift-weaken∋ : ∀ {Γ} σ Γ⁺ τ Γ⁺⁺ {υ} (x : Γ ++⁺ Γ⁺ ++⁺ Γ⁺⁺ ∋ υ) → lift weaken∋[ τ /̂ ŵk ↑̂⁺ Γ⁺ ] (Γ⁺⁺ /̂⁺ ŵk ↑̂⁺ Γ⁺) · (lift (lift weaken∋[ σ ] Γ⁺) Γ⁺⁺ · x) ≅-∋ lift (lift weaken∋[ σ ] (Γ⁺ ▻ τ)) (Γ⁺⁺ /̂⁺ ŵk) · (lift weaken∋[ τ ] Γ⁺⁺ · x) lift-weaken∋-lift-lift-weaken∋ σ Γ⁺ τ ε x = P.refl lift-weaken∋-lift-lift-weaken∋ σ Γ⁺ τ (Γ⁺⁺ ▻ υ) zero = zero-cong (/̂-↑̂⁺-/̂-ŵk-↑̂⁺ τ (ŵk ↑̂⁺ Γ⁺) Γ⁺⁺ υ) lift-weaken∋-lift-lift-weaken∋ σ Γ⁺ τ (Γ⁺⁺ ▻ υ) (suc x) = suc-cong (/̂-↑̂⁺-/̂-ŵk-↑̂⁺ τ (ŵk ↑̂⁺ Γ⁺) Γ⁺⁺ υ) (lift-weaken∋-lift-lift-weaken∋ σ Γ⁺ τ Γ⁺⁺ x) ------------------------------------------------------------------------ -- Term-like t and [_⟶_] form a category -- At least if we ignore the context morphism index. -- Identity. [id] : ∀ {t} {T : Term-like t} {Γ} → [ T ⟶ T ] îd[ Γ ] [id] = record { function = λ _ → id; corresponds = λ _ _ → P.refl } -- Composition. infixl 9 _[∘]_ _[∘]_ : ∀ {t₁ t₂ t₃} {T₁ : Term-like t₁} {T₂ : Term-like t₂} {T₃ : Term-like t₃} {Γ Δ Ε} {ρ̂₁ : Γ ⇨̂ Δ} {ρ̂₂ : Δ ⇨̂ Ε} → [ T₂ ⟶ T₃ ] ρ̂₂ → [ T₁ ⟶ T₂ ] ρ̂₁ → [ T₁ ⟶ T₃ ] (ρ̂₁ ∘̂ ρ̂₂) _[∘]_ {T₁ = T₁} {T₂} {T₃} {ρ̂₁ = ρ̂₁} {ρ̂₂} f g = record { function = λ _ → _·_ f ∘ _·_ g ; corresponds = corr } where open P.≡-Reasoning open Term-like T₁ renaming (⟦_⟧ to ⟦_⟧₁; _⊢_ to _⊢₁_) open Term-like T₂ renaming (⟦_⟧ to ⟦_⟧₂) open Term-like T₃ renaming (⟦_⟧ to ⟦_⟧₃) abstract corr : ∀ σ (t : _ ⊢₁ σ) → ⟦ t ⟧₁ /̂Val ρ̂₁ ∘̂ ρ̂₂ ≅-Value ⟦ f · (g · t) ⟧₃ corr = λ σ t → begin [ ⟦ t ⟧₁ /̂Val ρ̂₁ ∘̂ ρ̂₂ ] ≡⟨ /̂Val-cong (corresponds g t) P.refl ⟩ [ ⟦ g · t ⟧₂ /̂Val ρ̂₂ ] ≡⟨ corresponds f (g · t) ⟩ [ ⟦ f · (g · t) ⟧₃ ] ∎ -- [id] and _[∘]_ preserve equality. [id]-cong : ∀ {t} {T : Term-like t} {Γ₁ Γ₂} → Γ₁ ≅-Ctxt Γ₂ → [id] {T = T} {Γ = Γ₁} ≅-⟶ [id] {T = T} {Γ = Γ₂} [id]-cong P.refl = [ P.refl ] private module Dummy {t₁ t₂} {T₁ : Term-like t₁} {T₂ : Term-like t₂} where [∘]-cong : ∀ {t₃} {T₃ : Term-like t₃} {Γ₁ Δ₁ Ε₁} {ρ̂₁₁ : Γ₁ ⇨̂ Δ₁} {ρ̂₂₁ : Δ₁ ⇨̂ Ε₁} {f₁₁ : [ T₁ ⟶ T₂ ] ρ̂₁₁} {f₂₁ : [ T₂ ⟶ T₃ ] ρ̂₂₁} {Γ₂ Δ₂ Ε₂} {ρ̂₁₂ : Γ₂ ⇨̂ Δ₂} {ρ̂₂₂ : Δ₂ ⇨̂ Ε₂} {f₁₂ : [ T₁ ⟶ T₂ ] ρ̂₁₂} {f₂₂ : [ T₂ ⟶ T₃ ] ρ̂₂₂} → f₁₁ ≅-⟶ f₁₂ → f₂₁ ≅-⟶ f₂₂ → f₂₁ [∘] f₁₁ ≅-⟶ f₂₂ [∘] f₁₂ [∘]-cong {f₁₁ = _ , _} {f₂₁ = _ , _} {f₁₂ = ._ , _} {f₂₂ = ._ , _} [ P.refl ] [ P.refl ] = [ P.refl ] -- [id] is a left and right identity of _[∘]_, which is associative. [id]-[∘] : ∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} (f : [ T₁ ⟶ T₂ ] ρ̂) → [id] [∘] f ≅-⟶ f [id]-[∘] f = [ P.refl ] [∘]-[id] : ∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} (f : [ T₁ ⟶ T₂ ] ρ̂) → f [∘] [id] ≅-⟶ f [∘]-[id] f = [ P.refl ] [∘]-[∘] : ∀ {t₃ t₄} {T₃ : Term-like t₃} {T₄ : Term-like t₄} {Γ Δ Ε Ζ} {ρ̂₁ : Γ ⇨̂ Δ} {ρ̂₂ : Δ ⇨̂ Ε} {ρ̂₃ : Ε ⇨̂ Ζ} (f₃ : [ T₃ ⟶ T₄ ] ρ̂₃) (f₂ : [ T₂ ⟶ T₃ ] ρ̂₂) (f₁ : [ T₁ ⟶ T₂ ] ρ̂₁) → f₃ [∘] (f₂ [∘] f₁) ≅-⟶ (f₃ [∘] f₂) [∘] f₁ [∘]-[∘] f₃ f₂ f₁ = [ P.refl ] open Dummy public	{ "alphanum_fraction": 0.4594773953, "avg_line_length": 32.4059139785, "ext": "agda", "hexsha": "3cbf85d0a8cc0b227de995674128d4f31c156fef", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "nad/dependently-typed-syntax", "max_forks_repo_path": "deBruijn/Context/Term-like.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "nad/dependently-typed-syntax", "max_issues_repo_path": "deBruijn/Context/Term-like.agda", "max_line_length": 97, "max_stars_count": 5, "max_stars_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "nad/dependently-typed-syntax", "max_stars_repo_path": "deBruijn/Context/Term-like.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": 6147, "size": 12055 }
module Logic.Propositional.Proofs.Structures where import Data.Tuple as Tuple import Lvl open import Functional open import Logic open import Logic.Propositional import Logic.Propositional.Theorems as Theorems open import Structure.Operator.Properties open import Structure.Relator.Equivalence open import Structure.Relator.Properties open import Structure.Setoid open import Type open import Logic.Propositional.Equiv public private variable ℓ ℓ₁ ℓ₂ ℓₑ ℓₑ₁ ℓₑ₂ : Lvl.Level private variable T A B : Type{ℓ} instance [→]-reflexivity : Reflexivity{ℓ₂ = ℓ}(_→ᶠ_) [→]-reflexivity = intro Theorems.[→]-reflexivity instance [→]-transitivity : Transitivity{ℓ₂ = ℓ}(_→ᶠ_) [→]-transitivity = intro Theorems.[→]-transitivity module _ where [←]-reflexivity : Reflexivity{ℓ₂ = ℓ}(_←_) [←]-reflexivity = intro Theorems.[→]-reflexivity module _ where [←]-transitivity : Transitivity{ℓ₂ = ℓ}(_←_) [←]-transitivity = intro (swap Theorems.[→]-transitivity) instance [↔]-antisymmetry : Antisymmetry{ℓ₂ = ℓ}(_→ᶠ_)(_↔_) [↔]-antisymmetry = intro(swap [↔]-intro) open import Structure.Relator open import Structure.Function open import Structure.Operator module _ ⦃ equiv : Equiv{ℓₑ}(T) ⦄ {P : T → Type{ℓ}} where relator-function₁ : UnaryRelator(P) ↔ Function ⦃ equiv-B = [↔]-equiv ⦄ (P) UnaryRelator.substitution (Tuple.left relator-function₁ (intro congruence)) xy = [↔]-to-[→] (congruence xy) Function.congruence (Tuple.right relator-function₁ (intro substitution)) xy = [↔]-intro (substitution(symmetry(_≡_) xy)) (substitution xy) module _ ⦃ equiv-A : Equiv{ℓₑ₁}(A) ⦄ ⦃ equiv-B : Equiv{ℓₑ₂}(B) ⦄ {P : A → B → Type{ℓ}} where relator-function₂ : BinaryRelator(P) ↔ BinaryOperator ⦃ equiv-B = [↔]-equiv ⦄ (P) BinaryRelator.substitution (Tuple.left relator-function₂ (intro congruence)) xy1 xy2 = [↔]-to-[→] (congruence xy1 xy2) BinaryOperator.congruence (Tuple.right relator-function₂ (intro substitution)) xy1 xy2 = [↔]-intro (substitution(symmetry(_≡_) xy1) (symmetry(_≡_) xy2)) (substitution xy1 xy2) {- TODO: Maybe a general Equiv and Transitivity for (_↔_) is possible with indexed relation structures? What I mean by indexed: test : ∀{ℓ₁ ℓ₂}{T : TYPE ℓ₁}{ℓ : T → Lvl.Level} → ((x : T) → TYPE(ℓ x)) → TYPE ℓ₂ test2 : TYPE Lvl.𝟎 test2 = test{T = Lvl.Level}{ℓ = Lvl.𝐒} (\ℓ → TYPE ℓ) instead of: test : ∀{ℓ₁ ℓ₂}{T : TYPE ℓ₁}{ℓ : Lvl.Level} → TYPE ℓ → TYPE ℓ₂ Then all special cases for (_→_) and (_↔_) would finally be redundant. Also, substitution could be a special case of congruence, so Relator would be special cases of Operator -} instance [∧]-symmetry : Symmetry{ℓ₂ = ℓ}(_∧_) [∧]-symmetry = intro Theorems.[∧]-symmetry instance [∨]-symmetry : Symmetry{ℓ₂ = ℓ}(_∨_) [∨]-symmetry = intro Theorems.[∨]-symmetry instance [∧][↔]-sub : (_∧_) ⊆₂ (_↔_ {ℓ₁}{ℓ₂}) [∧][↔]-sub = intro Theorems.[∧]-to-[↔] instance [∧][→]-sub : (_∧_) ⊆₂ (_→ᶠ_ {ℓ₁}{ℓ₂}) [∧][→]-sub = intro Theorems.[∧]-to-[→] instance [∧][←]-sub : (_∧_) ⊆₂ (_←_ {ℓ₁}{ℓ₂}) [∧][←]-sub = intro Theorems.[∧]-to-[←] instance [∧][∨]-sub : (_∧_) ⊆₂ (_∨_ {ℓ₁}{ℓ₂}) [∧][∨]-sub = intro Theorems.[∧]-to-[∨] instance [∧]-associativity : Associativity ⦃ [↔]-equiv ⦄ (_∧_ {ℓ}) [∧]-associativity = intro Theorems.[∧]-associativity instance [∧]-operator : BinaryOperator ⦃ [↔]-equiv{ℓ₁} ⦄ ⦃ [↔]-equiv{ℓ₂} ⦄ ⦃ [↔]-equiv ⦄ (_∧_) BinaryOperator.congruence [∧]-operator = Theorems.[∧]-map-[↔] instance [∨]-operator : BinaryOperator ⦃ [↔]-equiv{ℓ₁} ⦄ ⦃ [↔]-equiv{ℓ₂} ⦄ ⦃ [↔]-equiv ⦄ (_∨_) BinaryOperator.congruence [∨]-operator = Theorems.[∨]-map-[↔] instance [→]-operator : BinaryOperator ⦃ [↔]-equiv{ℓ₁} ⦄ ⦃ [↔]-equiv{ℓ₂} ⦄ ⦃ [↔]-equiv ⦄ (_→ᶠ_) BinaryOperator.congruence [→]-operator = Theorems.[→]-map-[↔] instance [↔]-operator : BinaryOperator ⦃ [↔]-equiv{ℓ₁} ⦄ ⦃ [↔]-equiv{ℓ₂} ⦄ ⦃ [↔]-equiv ⦄ (_↔_) BinaryOperator.congruence [↔]-operator = Theorems.[↔]-map-[↔]	{ "alphanum_fraction": 0.6533945891, "avg_line_length": 35.9449541284, "ext": "agda", "hexsha": "99e83434143373e9ac593b8fd86591bfb5ae0da3", "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": "Logic/Propositional/Proofs/Structures.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": "Logic/Propositional/Proofs/Structures.agda", "max_line_length": 178, "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": "Logic/Propositional/Proofs/Structures.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": 1586, "size": 3918 }
{-# OPTIONS --prop --rewriting #-} module Examples.Sorting.Parallel where open import Examples.Sorting.Parallel.Comparable open import Calf costMonoid open import Calf.Types.Nat open import Calf.Types.List open import Relation.Binary.PropositionalEquality as Eq using (_≡_) open import Data.Product using (_,_) open import Data.Nat using (z≤n; s≤s) test/forward = 1 ∷ 2 ∷ 3 ∷ 4 ∷ 5 ∷ 6 ∷ 7 ∷ 8 ∷ 9 ∷ 10 ∷ 11 ∷ 12 ∷ 13 ∷ 14 ∷ 15 ∷ 16 ∷ [] test/backward = 16 ∷ 15 ∷ 14 ∷ 13 ∷ 12 ∷ 11 ∷ 10 ∷ 9 ∷ 8 ∷ 7 ∷ 6 ∷ 5 ∷ 4 ∷ 3 ∷ 2 ∷ 1 ∷ [] test/shuffled = 4 ∷ 8 ∷ 12 ∷ 16 ∷ 13 ∷ 3 ∷ 5 ∷ 14 ∷ 9 ∷ 6 ∷ 7 ∷ 10 ∷ 11 ∷ 1 ∷ 2 ∷ 15 ∷ [] module Ex/InsertionSort where import Examples.Sorting.Parallel.InsertionSort NatComparable as Sort list' = list nat ex/insert : cmp (F list') ex/insert = Sort.insert 3 (1 ∷ 2 ∷ 4 ∷ []) ex/sort : cmp (F list') ex/sort = Sort.sort (1 ∷ 5 ∷ 3 ∷ 1 ∷ 2 ∷ []) ex/sort/forward : cmp (F list') ex/sort/forward = Sort.sort test/forward -- cost: 15 , 15 ex/sort/backward : cmp (F list') ex/sort/backward = Sort.sort test/backward -- cost: 120 , 120 ex/sort/shuffled : cmp (F list') ex/sort/shuffled = Sort.sort test/shuffled -- cost: 76 , 76 module Ex/MergeSort where import Examples.Sorting.Parallel.MergeSort NatComparable as Sort list' = list nat ex/split : cmp (F Sort.pair) ex/split = Sort.split (6 ∷ 2 ∷ 8 ∷ 3 ∷ 1 ∷ 8 ∷ 5 ∷ []) ex/merge : cmp (F list') ex/merge = Sort.merge (2 ∷ 3 ∷ 6 ∷ 8 ∷ [] , 1 ∷ 5 ∷ 8 ∷ []) ex/sort : cmp (F list') ex/sort = Sort.sort (1 ∷ 5 ∷ 3 ∷ 1 ∷ 2 ∷ []) ex/sort/forward : cmp (F list') ex/sort/forward = Sort.sort test/forward -- cost: 32, 15 ex/sort/backward : cmp (F list') ex/sort/backward = Sort.sort test/backward -- cost: 32, 15 ex/sort/shuffled : cmp (F list') ex/sort/shuffled = Sort.sort test/shuffled -- cost: 47, 26 module Ex/MergeSortPar where import Examples.Sorting.Parallel.MergeSortPar NatComparable as Sort list' = list nat ex/split : cmp (F Sort.pair) ex/split = Sort.split (6 ∷ 2 ∷ 8 ∷ 3 ∷ 1 ∷ 8 ∷ 5 ∷ []) ex/splitMid : cmp (F Sort.triple) ex/splitMid = Sort.splitMid test/forward (s≤s z≤n) ex/splitBy : cmp (F Sort.pair) ex/splitBy = Sort.splitBy test/forward 5 ex/merge : cmp (F list') ex/merge = Sort.merge (2 ∷ 3 ∷ 6 ∷ 8 ∷ [] , 1 ∷ 5 ∷ 8 ∷ []) ex/sort : cmp (F list') ex/sort = Sort.sort (1 ∷ 5 ∷ 3 ∷ 1 ∷ 2 ∷ []) ex/sort/forward : cmp (F list') ex/sort/forward = Sort.sort test/forward -- cost: 40, 21 ex/sort/backward : cmp (F list') ex/sort/backward = Sort.sort test/backward -- cost: 40, 21 ex/sort/shuffled : cmp (F list') ex/sort/shuffled = Sort.sort test/shuffled -- cost: 43, 17 module SortEquivalence (M : Comparable) where open Comparable M open import Examples.Sorting.Parallel.Core M import Examples.Sorting.Parallel.InsertionSort M as ISort import Examples.Sorting.Parallel.MergeSort M as MSort import Examples.Sorting.Parallel.MergeSortPar M as PSort isort≡msort : ◯ (ISort.sort ≡ MSort.sort) isort≡msort = IsSort⇒≡ ISort.sort ISort.sort/correct MSort.sort MSort.sort/correct msort≡psort : ◯ (MSort.sort ≡ PSort.sort) msort≡psort = IsSort⇒≡ MSort.sort MSort.sort/correct PSort.sort PSort.sort/correct	{ "alphanum_fraction": 0.6391465677, "avg_line_length": 31.0961538462, "ext": "agda", "hexsha": "1a796c9bfdc15dc94d53d24daa3d43c197ffcebb", "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/Parallel.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/Parallel.agda", "max_line_length": 89, "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/Parallel.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": 1266, "size": 3234 }
module Day3 where open import Data.String as String open import Data.Maybe open import Foreign.Haskell using (Unit) open import Data.List as List hiding (fromMaybe) open import Data.Nat open import Data.Nat.DivMod open import Data.Nat.Properties import Data.Nat.Show as ℕs open import Data.Char open import Data.Vec as Vec renaming (_>>=_ to _VV=_ ; toList to VecToList) open import Data.Product open import Relation.Nullary open import Data.Nat.Properties open import Data.Bool.Base open import AocIO open import AocUtil open import AocVec open import Relation.Binary.PropositionalEquality open import EvenOdd printUsage : String → IO Unit printUsage name = printString ("Usage: " String.++ name String.++ " NUMBER\n(NUMBER > 0)") sqr : (l : ℕ) → Σ[ k ∈ ℕ ] (k ≡ l * l) sqr l = l * l , refl first-larger-odd-square : {m : ℕ} → (n : ℕ) → suc m ≡ n → Σ[ k ∈ ℕ ] (n ≤ (k * k) × Odd k) first-larger-odd-square {m} n n-is-suc = helper 1 m n-is-suc oddOne where helper : (m diff : ℕ) → (m + diff) ≡ n → Odd m → Σ[ k ∈ ℕ ] (n ≤ (k * k) × Odd k) helper m (suc (suc diff)) p m-is-odd with sqr m ... \| (m² , m²≡mm) with n ≤? m² ... \| yes n≤m² rewrite m²≡mm = m , n≤m² , m-is-odd ... \| no _ = helper (suc (suc m)) diff rewr-p (oddSuc m-is-odd) where rewr-p : suc (suc m + diff) ≡ n rewr-p with (+-suc m diff) \| (+-suc m (suc diff)) ... \| s \| t rewrite (sym s) \| t = p helper m zero p m-is-odd rewrite (+-identityʳ m) with (sqr m) ... \| (m² , q) = m , (my-proof n refl) , m-is-odd where my-proof : (k : ℕ) → k ≡ n → n ≤ m * m my-proof k p₁ rewrite sym p₁ with k ... \| zero = z≤n ... \| suc kk rewrite p with (m≤m+n kk (kk * suc kk)) ... \| kk≤kk+junk = s≤s kk≤kk+junk helper zero (suc zero) p () helper (suc zero) (suc zero) p m-is-odd rewrite sym p = 3 , (s≤s (s≤s z≤n) , oddSuc oddOne) helper (suc (suc m)) (suc zero) p m-is-odd = (suc (suc m)) , my-proof n refl , m-is-odd where my-proof : (k : ℕ) → k ≡ n → n ≤ suc (suc (m + suc (suc (m + m * suc (suc m))))) my-proof k p₁ rewrite sym p₁ with k ... \| zero = z≤n -- we replace with p and get an expression 1 + m ≤ suc (suc m + junk) -- +-comm m 1 turns 1 + m into suc m -- sym +-suc turns m + suc junk into suc (m + junk) to match the number on the other side -- finally we cancel suc on both sides and use m ≤ m + junk ... \| suc kk rewrite sym p \| +-comm m 1 \| +-suc m (suc (m + m * suc (suc m))) = s≤s (s≤s (s≤s (m≤m+n m (suc (m + m * suc (suc m)))))) oddness : ∀ {n} → Odd n → ℕ oddness oddOne = 1 oddness (oddSuc v) = suc (oddness v) ring-for-square# : {m : ℕ} → (n : ℕ) → suc m ≡ n → Σ[ k ∈ ℕ ] Odd k × ℕ ring-for-square# zero () ring-for-square# (suc n) p with (first-larger-odd-square (suc n) (cong suc refl)) ... \| k , proj₄ , k-odd = k , k-odd , (oddness k-odd) ring-corners : {m : ℕ} → Odd m → ℕ × ℕ × ℕ × ℕ × ℕ ring-corners oddOne = 1 , (1 , (1 , 1 , 1)) ring-corners {(suc (suc n))} (oddSuc _) = (n * n) , ((proj₁ first-corner) , ((proj₁ second-corner) , ((proj₁ third-corner) , (proj₁ fourth-corner)))) where first-corner : Σ[ k ∈ ℕ ] k ≡ suc ((n * n) + n) first-corner = suc (n * n + n) , refl second-corner : Σ[ k ∈ ℕ ] k ≡ suc (suc ((n * n) + n + n)) second-corner = (suc (suc (n * n + n + n))) , refl third-corner : Σ[ k ∈ ℕ ] k ≡ suc (suc (suc ((n * n) + n + n + n))) third-corner = suc (suc (suc (n * n + n + n + n))) , refl fourth-corner : Σ[ k ∈ ℕ ] k ≡ suc (suc (n + suc (suc (n + n * suc (suc n))))) fourth-corner = sqr (suc (suc n)) ring-length : Σ[ k ∈ ℕ ] k ≡ (2 * (suc (suc n))) + (2 * n) ring-length = (2 * (suc (suc n)) + 2 * n) , refl -- proof that fourth-corner = ring-length + prev-fourth-corner ring-length-proof : {m l : ℕ} → m ≡ suc (suc (n + suc (suc (n + n * suc (suc n))))) → l ≡ (2 * (suc (suc n))) + (2 * n) → l + (n * n) ≡ m ring-length-proof p q rewrite p \| q = cong suc (cong suc my-proof) where halp : n + n + (n + n) ≡ n + n + n + n halp = begin n + n + (n + n) ≡⟨ sym (+-assoc (n + n) n n) ⟩ n + n + n + n ∎ where open ≡-Reasoning halp-again : n * n + (n + n + n + n) ≡ n * n + n + n + n + n halp-again with +-assoc (n * n) (n + n + n) n ... \| p₁ rewrite sym p₁ with +-assoc (n * n) (n + n) n ... \| p₂ rewrite sym p₂ with +-assoc (n * n) n n ... \| p₃ rewrite sym p₃ = refl my-proof : n + suc (suc (n + 0)) + (n + (n + 0)) + n * n ≡ n + suc (suc (n + n * suc (suc n))) my-proof rewrite +-identityʳ n \| +--suc n (suc n) \| +--suc n n with +-comm n (suc (suc n)) \| +-comm n (suc (suc (n + (n + (n + n * n))))) ... \| p₁ \| p₂ rewrite p₁ \| p₂ with +-comm n (n + n * n) \| +-comm n (n + n * n + n) \| +-comm n (n * n) \| +-comm (n + n + (n + n)) (n * n) ... \| p₃ \| p₄ \| p₅ \| p₆ rewrite p₃ \| p₄ \| p₅ \| p₆ \| halp \| halp-again = cong suc (cong suc refl) -- Here I'd like a proof that the distance between the corners add up to the length abs-diff : (n m : ℕ) → ℕ abs-diff zero m = m abs-diff (suc n) zero = suc n abs-diff (suc n) (suc m) = abs-diff n m min-5 : (a b c d e : ℕ) → ℕ min-5 a b c d e with a ⊓ b \| c ⊓ d ... \| min-ab \| min-cd with min-ab ⊓ min-cd ... \| min-abcd = min-abcd ⊓ e dist-to-closest-ring-corner : {k : ℕ} → (n : ℕ) → suc k ≡ n → ℕ dist-to-closest-ring-corner zero () dist-to-closest-ring-corner (suc k) p with (ring-for-square# (suc k) p) \| (suc k) ... \| corner-root , corner-root-odd , ring# \| n with ring-corners corner-root-odd ... \| c₀ , c₁ , c₂ , c₃ , c₄ with abs-diff n c₀ \| abs-diff n c₁ \| abs-diff n c₂ \| abs-diff n c₃ \| abs-diff n c₄ ... \| n-c₀ \| n-c₁ \| n-c₂ \| n-c₃ \| n-c₄ = min-5 n-c₀ n-c₁ n-c₂ n-c₃ n-c₄ dist-to-center : {k : ℕ} → (n : ℕ) → suc k ≡ n → ℕ dist-to-center zero () dist-to-center (suc k) p with (ring-for-square# (suc k) p) \| (suc k) ... \| corner-root , corner-root-odd , ring# \| n with dist-to-closest-ring-corner (suc k) refl ... \| dist = abs-diff dist (2 * (pred ring#)) infixr 5 _+++_ _+++_ : String → String → String _+++_ s1 s2 = s1 String.++ " " String.++ s2 print-corners : {k : ℕ} → (n : ℕ) → suc k ≡ n → IO Unit print-corners zero () print-corners (suc k) p with (ring-for-square# (suc k) p) \| (suc k) ... \| corner-root , corner-root-odd , ring# \| n with ring-corners corner-root-odd ... \| c₀ , c₁ , c₂ , c₃ , c₄ with abs-diff n c₀ \| abs-diff n c₁ \| abs-diff n c₂ \| abs-diff n c₃ \| abs-diff n c₄ ... \| n-c₀ \| n-c₁ \| n-c₂ \| n-c₃ \| n-c₄ with ℕs.show n-c₀ \| ℕs.show n-c₁ \| ℕs.show n-c₂ \| ℕs.show n-c₃ \| ℕs.show n-c₄ \| ℕs.show corner-root \| ℕs.show ring# ... \| s0 \| s1 \| s2 \| s3 \| s4 \| s5 \| s6 = printString (s0 +++ s1 +++ s2 +++ s3 +++ s4 +++ "==" +++ s5 +++ s6) main : IO Unit main = mainBuilder main' where main' : String → (List String) → IO Unit main' name (numS ∷ []) with (unsafeParseNat (String.toList numS)) ... \| 0 = printUsage name ... \| (suc n) = printString (ℕs.show (dist-to-center (suc n) (cong suc refl))) main' name _ = printUsage name	{ "alphanum_fraction": 0.5383426966, "avg_line_length": 46.2337662338, "ext": "agda", "hexsha": "82743da45bf400c2317d5ded5b0b2a0d1ab3db72", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "37956e581dc51bf78008d7dd902bb18d2ee481f6", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "Zalastax/adventofcode2017", "max_forks_repo_path": "day-3/Day3.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "37956e581dc51bf78008d7dd902bb18d2ee481f6", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "Zalastax/adventofcode2017", "max_issues_repo_path": "day-3/Day3.agda", "max_line_length": 154, "max_stars_count": null, "max_stars_repo_head_hexsha": "37956e581dc51bf78008d7dd902bb18d2ee481f6", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "Zalastax/adventofcode2017", "max_stars_repo_path": "day-3/Day3.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 2778, "size": 7120 }
{-# OPTIONS --without-K --rewriting #-} open import HoTT module experimental.NConnected where lemma₁ : ∀ {i j} {A : Type i} {B : Type j} (f : A → B) {n : ℕ₋₂} → is-connected n A → is-connected (S n) B → has-conn-fibers n f lemma₁ f cA cB = λ b → Σ-conn cA (λ a → path-conn cB) lemma₂ : ∀ {i} {A B C : Type i} → (f : A → B) (g : B → C) {n : ℕ₋₂} → has-conn-fibers n (g ∘ f) → has-conn-fibers (S n) g → has-conn-fibers n f lemma₂ f g {n} cA cB b = equiv-preserves-conn (eqv b idp ⁻¹) (lemma₁-f′ (g b) (b , idp)) where f′ : ∀ c → hfiber (g ∘ f) c → hfiber g c f′ c (a , p) = (f a , p) -- We first show [∀ b → is-connected n (hfiber (f′ (g b) (b , idp))) ] lemma₁-f′ : ∀ c → has-conn-fibers n (f′ c) lemma₁-f′ c = lemma₁ (f′ c) (cA c) (cB c) -- The remaining shows [hfiber (f′ (g b) (b , idp))] -- is the same as [hfiber f b] to : ∀ b p → hfiber f b → hfiber (f′ (g b)) (b , p) to ._ p (a , idp) = ((a , p) , idp) from′ : ∀ b a → f a == b → hfiber f b from′ ._ a idp = (a , idp) from : ∀ b p → hfiber (f′ (g b)) (b , p) → hfiber f b from b p ((a , q) , r) = from′ b a (fst= r) from-to : ∀ b p x → from b p (to b p x) == x from-to ._ p (a , idp) = idp to-from : ∀ b p x → to b p (from b p x) == x to-from b p ((a , q) , r) = to b p (from b p ((a , q) , r)) =⟨ pair=-η r \|in-ctx (λ r → to b p (from b p ((a , q) , r))) ⟩ to b p (from b p ((a , q) , pair= (fst= r) (snd= r))) =⟨ lemma b p a q (fst= r) (snd= r) ⟩ ((a , q) , pair= (fst= r) (snd= r)) =⟨ ! (pair=-η r) \|in-ctx (λ r → ((a , q) , r)) ⟩ ((a , q) , r) ∎ where lemma : ∀ b p a (q : g (f a) == g b) → (r : f a == b) (s : q == p [ (λ b′ → g b′ == g b) ↓ r ]) → to b p (from b p ((a , q) , pair= r s)) == ((a , q) , pair= r s) lemma ._ ._ a q idp idp = idp eqv : ∀ b p → hfiber f b ≃ hfiber (f′ (g b)) (b , p) eqv b p = equiv (to b p) (from b p) (to-from b p) (from-to b p) lemma₃ : ∀ {i j} {A : Type i} {B : Type j} (f : A → B) → A ≃ Σ B (hfiber f) lemma₃ {A = A} {B} f = equiv to from to-from from-to where to : A → Σ B (hfiber f) to a = (f a , (a , idp)) from : Σ B (hfiber f) → A from (_ , (a , p)) = a to-from : ∀ s → to (from s) == s to-from (._ , (a , idp)) = idp from-to : ∀ a → from (to a) == a from-to a = idp {- ∘-conn : ∀ {i j k} {A : Type i} {B : Type j} {C : Type k} → (f : A → B) → (g : B → C) → {n : ℕ₋₂} → has-conn-fibers n f → has-conn-fibers n g → has-conn-fibers n (g ∘ f) ∘-conn f g {⟨-2⟩} cf cg c = -2-conn _ ∘-conn f g {S n } cf cg c = Trunc-rec {P = is-connected (hfiber (g ∘ f) c)} (prop-has-level-S n (is-connected-is-prop n A)) (λ c ) (cg c) -} {- lemma₃-path : ∀ {i j} {A : Type i} {B : Type j} (f : A → B) → A == Σ B (hfiber f) lemma₃-path = λ f → ua (lemma₃ f) -}	{ "alphanum_fraction": 0.4139922978, "avg_line_length": 31.7959183673, "ext": "agda", "hexsha": "df9db6d4aa8d7194f181591437946aacad07c90a", "lang": "Agda", "max_forks_count": 50, "max_forks_repo_forks_event_max_datetime": "2022-02-14T03:03:25.000Z", "max_forks_repo_forks_event_min_datetime": "2015-01-10T01:48:08.000Z", "max_forks_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "timjb/HoTT-Agda", "max_forks_repo_path": "theorems/stash/NConnected.agda", "max_issues_count": 31, "max_issues_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e", "max_issues_repo_issues_event_max_datetime": "2021-10-03T19:15:25.000Z", "max_issues_repo_issues_event_min_datetime": "2015-03-05T20:09:00.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "timjb/HoTT-Agda", "max_issues_repo_path": "theorems/stash/NConnected.agda", "max_line_length": 80, "max_stars_count": 294, "max_stars_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "timjb/HoTT-Agda", "max_stars_repo_path": "theorems/stash/NConnected.agda", "max_stars_repo_stars_event_max_datetime": "2022-03-20T13:54:45.000Z", "max_stars_repo_stars_event_min_datetime": "2015-01-09T16:23:23.000Z", "num_tokens": 1314, "size": 3116 }
------------------------------------------------------------------------ -- The Agda standard library -- -- The basic code for equational reasoning with a single relation ------------------------------------------------------------------------ {-# OPTIONS --without-K --safe #-} open import Relation.Binary module Relation.Binary.Reasoning.Base.Single {a ℓ} {A : Set a} (_∼_ : Rel A ℓ) (refl : Reflexive _∼_) (trans : Transitive _∼_) where ------------------------------------------------------------------------ -- Reasoning combinators -- Re-export combinators from partial reasoning open import Relation.Binary.Reasoning.Base.Partial _∼_ trans public hiding (_∎⟨_⟩) -- Redefine the terminating combinator now that we have reflexivity infix 3 _∎ _∎ : ∀ x → x IsRelatedTo x x ∎ = relTo refl	{ "alphanum_fraction": 0.5185185185, "avg_line_length": 27, "ext": "agda", "hexsha": "d8957b78f6af00591f434601d511ccb510442274", "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": "agda-stdlib/src/Relation/Binary/Reasoning/Base/Single.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": "agda-stdlib/src/Relation/Binary/Reasoning/Base/Single.agda", "max_line_length": 72, "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": "agda-stdlib/src/Relation/Binary/Reasoning/Base/Single.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": 180, "size": 810 }
{-# OPTIONS --universe-polymorphism #-} module Issue227 where open import Common.Level data D (a p b : Level) (A : Set a) (P : A → Set p) : Set (p ⊔ a ⊔ b) where d : ((x : A) → P x) → D a p b A P -- Unsolved trivial constraint: Set (a ⊔ p) =< Set (p ⊔ a). OK : ∀ {a} {A : Set a} → (A → Set) → A → Set _ OK P = P NotOK : ∀ {a} {A : Set a} → (P : A → Set) → A → Set _ NotOK P = P -- Unsolved constraint: -- \/ (Set (a ⊔ suc zero)) (Set (a ⊔ suc zero)) = \/ (Set (a ⊔ suc zero)) (Set (a ⊔ suc zero))	{ "alphanum_fraction": 0.5138888889, "avg_line_length": 28, "ext": "agda", "hexsha": "b5334e00eb83db032381da85860d212407577c94", "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/Issue227.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/Issue227.agda", "max_line_length": 94, "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/Issue227.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": 202, "size": 504 }
------------------------------------------------------------------------------ -- Induction principles for the total natural numbers inductive predicate ------------------------------------------------------------------------------ {-# OPTIONS --exact-split #-} {-# OPTIONS --no-sized-types #-} {-# OPTIONS --no-universe-polymorphism #-} {-# OPTIONS --without-K #-} module FOT.FOTC.Data.Nat.Type where open import FOTC.Base hiding ( succ₁ ) ------------------------------------------------------------------------------ -- We define succ₁ outside an abstract block. succ₁ : D → D succ₁ n = succ · n module ConstantAndUnaryFunction where -- N using the constant succ. data N : D → Set where nzero : N zero nsucc : ∀ {n} → N n → N (succ · n) N-ind : (A : D → Set) → A zero → (∀ {n} → A n → A (succ · n)) → ∀ {n} → N n → A n N-ind A A0 h nzero = A0 N-ind A A0 h (nsucc Nn) = h (N-ind A A0 h Nn) -- N using the unary function succ₁. data N₁ : D → Set where nzero₁ : N₁ zero nsucc₁ : ∀ {n} → N₁ n → N₁ (succ₁ n) N-ind₁ : (A : D → Set) → A zero → (∀ {n} → A n → A (succ₁ n)) → ∀ {n} → N₁ n → A n N-ind₁ A A0 h nzero₁ = A0 N-ind₁ A A0 h (nsucc₁ Nn) = h (N-ind₁ A A0 h Nn) ---------------------------------------------------------------------------- -- From N/N₁ to N₁/N. N→N₁ : ∀ {n} → N n → N₁ n N→N₁ nzero = nzero₁ N→N₁ (nsucc {n} Nn) = nsucc₁ (N→N₁ Nn) N₁→N : ∀ {n} → N₁ n → N n N₁→N nzero₁ = nzero N₁→N (nsucc₁ {n} N₁n) = nsucc (N₁→N N₁n) ---------------------------------------------------------------------------- -- From N-ind → N-ind₁. N-ind₁' : (A : D → Set) → A zero → (∀ {n} → A n → A (succ₁ n)) → ∀ {n} → N₁ n → A n N-ind₁' A A0 h Nn₁ = N-ind A A0 h' (N₁→N Nn₁) where h' : ∀ {n} → A n → A (succ · n) h' {n} An = h An ---------------------------------------------------------------------------- -- From N-ind₁ → N-ind. N-ind' : (A : D → Set) → A zero → (∀ {n} → A n → A (succ · n)) → ∀ {n} → N n → A n N-ind' A A0 h Nn = N-ind₁ A A0 h' (N→N₁ Nn) where h' : ∀ {n} → A n → A (succ₁ n) h' {n} An = h An ------------------------------------------------------------------------------ module AdditionalHypotheis where data N : D → Set where nzero : N zero nsucc : ∀ {n} → N n → N (succ₁ n) -- The induction principle generated by Coq 8.4pl4 when we define -- the data type N in Prop. N-ind₁ : (A : D → Set) → A zero → (∀ {n} → N n → A n → A (succ₁ n)) → ∀ {n} → N n → A n N-ind₁ A A0 h nzero = A0 N-ind₁ A A0 h (nsucc Nn) = h Nn (N-ind₁ A A0 h Nn) -- The induction principle removing the hypothesis N n from the -- inductive step (see Martin-Löf 1971, p. 190). N-ind₂ : (A : D → Set) → A zero → (∀ {n} → A n → A (succ₁ n)) → ∀ {n} → N n → A n N-ind₂ A A0 h nzero = A0 N-ind₂ A A0 h (nsucc Nn) = h (N-ind₂ A A0 h Nn) ---------------------------------------------------------------------------- -- N-ind₂ from N-ind₁. N-ind₂' : (A : D → Set) → A zero → (∀ {n} → A n → A (succ₁ n)) → ∀ {n} → N n → A n N-ind₂' A A0 h = N-ind₁ A A0 (λ _ → h) ---------------------------------------------------------------------------- -- N-ind₁ from N-ind₂. N-ind₁' : (A : D → Set) → A zero → (∀ {n} → N n → A n → A (succ₁ n)) → ∀ {n} → N n → A n N-ind₁' A A0 h {n} Nn = ∧-proj₂ (N-ind₂ B B0 h' Nn) where B : D → Set B n = N n ∧ A n B0 : B zero B0 = nzero , A0 h' : ∀ {m} → B m → B (succ₁ m) h' (Nm , Am) = nsucc Nm , h Nm Am ------------------------------------------------------------------------------ -- References -- -- Martin-Löf, P. (1971). Hauptsatz for the Intuitionistic Theory of -- Iterated Inductive Definitions. In: Proceedings of the Second -- Scandinavian Logic Symposium. Ed. by Fenstad, -- J. E. Vol. 63. Studies in Logic and the Foundations of -- Mathematics. North-Holland Publishing Company, pp. 179–216.	{ "alphanum_fraction": 0.3912326184, "avg_line_length": 30.7463768116, "ext": "agda", "hexsha": "9028e7d935ee6ca0bd8b567c2b66bcf0a8bf64a2", "lang": "Agda", "max_forks_count": 3, "max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z", "max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z", "max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "asr/fotc", "max_forks_repo_path": "notes/FOT/FOTC/Data/Nat/Type.agda", "max_issues_count": 2, "max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d", "max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z", "max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "asr/fotc", "max_issues_repo_path": "notes/FOT/FOTC/Data/Nat/Type.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": "notes/FOT/FOTC/Data/Nat/Type.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": 1387, "size": 4243 }
{-# OPTIONS --without-K #-} open import HoTT.Base open import HoTT.Identity module HoTT.Homotopy where open variables private variable f g : A → B -- Lemma 2.4.3 ~-natural : (α : f ~ g) {x y : A} (p : x == y) → α x ∙ ap g p == ap f p ∙ α y ~-natural α {x} refl rewrite α x = refl ~-natural-id : (α : f ~ id) {x y : A} (p : x == y) → α x ∙ p == ap f p ∙ α y ~-natural-id α {x} refl rewrite α x = refl -- Corollary 2.4.4 ~-natural-comm : {f : A → A} (α : f ~ id) → α ∘ f ~ ap f ∘ α ~-natural-comm {f = f} α x = cancelᵣ (α (f x) ∙ₗ ap-id (α x) ⁻¹ ∙ ~-natural α (α x)) module ~-Reasoning where _~⟨_⟩_ : (f : Π A P) {g h : Π A P} → f ~ g → g ~ h → f ~ h x ~⟨ α ⟩ β = α ∙ₕ β infixr 2 _~⟨_⟩_ _∎ : (f : Π A P) → f ~ f _ ∎ = reflₕ infix 3 _∎	{ "alphanum_fraction": 0.5066489362, "avg_line_length": 25.9310344828, "ext": "agda", "hexsha": "292c830abb899876b30072a04e35ddcba3c72600", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508", "max_forks_repo_licenses": [ "0BSD" ], "max_forks_repo_name": "michaelforney/hott", "max_forks_repo_path": "HoTT/Homotopy.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "0BSD" ], "max_issues_repo_name": "michaelforney/hott", "max_issues_repo_path": "HoTT/Homotopy.agda", "max_line_length": 84, "max_stars_count": null, "max_stars_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508", "max_stars_repo_licenses": [ "0BSD" ], "max_stars_repo_name": "michaelforney/hott", "max_stars_repo_path": "HoTT/Homotopy.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 349, "size": 752 }
module UniDB.Morph.Unit where open import UniDB.Spec -------------------------------------------------------------------------------- data Unit : MOR where unit : {γ : Dom} → Unit γ γ instance iUpUnit : Up Unit _↑₁ {{iUpUnit}} unit = unit _↑_ {{iUpUnit}} unit δ = unit ↑-zero {{iUpUnit}} unit = refl ↑-suc {{iUpUnit}} unit δ = refl iIdmUnit : Idm Unit idm {{iIdmUnit}} _ = unit iCompUnit : Comp Unit _⊙_ {{iCompUnit}} unit unit = unit iUpIdmUnit : UpIdm Unit idm-↑₁ {{iUpIdmUnit}} = refl module _ {T : STX} {{vrT : Vr T}} where instance iLkUnit : Lk T Unit lk {{iLkUnit}} unit = vr {T = T} iLkUpUnit : {{wkT : Wk T}} {{wkVrT : WkVr T}} → LkUp T Unit lk-↑₁-zero {{iLkUpUnit}} unit = refl lk-↑₁-suc {{iLkUpUnit}} unit i = sym (wk₁-vr {T = T} i) iLkIdmUnit : LkIdm T Unit lk-idm {{iLkIdmUnit}} i = refl --------------------------------------------------------------------------------	{ "alphanum_fraction": 0.4905263158, "avg_line_length": 23.1707317073, "ext": "agda", "hexsha": "f78293244babd44fc98db8ae5dde1f4e22bd165f", "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": "7ae52205db44ad4f463882ba7e5082120fb76349", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "skeuchel/unidb-agda", "max_forks_repo_path": "UniDB/Morph/Unit.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "7ae52205db44ad4f463882ba7e5082120fb76349", "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": "skeuchel/unidb-agda", "max_issues_repo_path": "UniDB/Morph/Unit.agda", "max_line_length": 80, "max_stars_count": null, "max_stars_repo_head_hexsha": "7ae52205db44ad4f463882ba7e5082120fb76349", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "skeuchel/unidb-agda", "max_stars_repo_path": "UniDB/Morph/Unit.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 340, "size": 950 }
{-# OPTIONS --safe #-} module Cubical.Categories.Functor.Base where open import Cubical.Foundations.Prelude open import Cubical.Data.Sigma open import Cubical.Categories.Category private variable ℓC ℓC' ℓD ℓD' : Level record Functor (C : Category ℓC ℓC') (D : Category ℓD ℓD') : Type (ℓ-max (ℓ-max ℓC ℓC') (ℓ-max ℓD ℓD')) where no-eta-equality open Category field F-ob : C .ob → D .ob F-hom : {x y : C .ob} → C [ x , y ] → D [ F-ob x , F-ob y ] F-id : {x : C .ob} → F-hom (C .id) ≡ D .id {x = F-ob x} F-seq : {x y z : C .ob} (f : C [ x , y ]) (g : C [ y , z ]) → F-hom (f ⋆⟨ C ⟩ g) ≡ (F-hom f) ⋆⟨ D ⟩ (F-hom g) isFull = (x y : _) (F[f] : D [ F-ob x , F-ob y ]) → ∃[ f ∈ C [ x , y ] ] F-hom f ≡ F[f] isFaithful = (x y : _) (f g : C [ x , y ]) → F-hom f ≡ F-hom g → f ≡ g isEssentiallySurj = (d : D .ob) → Σ[ c ∈ C .ob ] CatIso D (F-ob c) d private variable ℓ ℓ' : Level C D E : Category ℓ ℓ' open Category open Functor -- Helpful notation -- action on objects infix 30 _⟅_⟆ _⟅_⟆ : (F : Functor C D) → C .ob → D .ob _⟅_⟆ = F-ob -- action on morphisms infix 30 _⟪_⟫ -- same infix level as on objects since these will never be used in the same context _⟪_⟫ : (F : Functor C D) → ∀ {x y} → C [ x , y ] → D [(F ⟅ x ⟆) , (F ⟅ y ⟆)] _⟪_⟫ = F-hom -- Functor constructions 𝟙⟨_⟩ : ∀ (C : Category ℓ ℓ') → Functor C C 𝟙⟨ C ⟩ .F-ob x = x 𝟙⟨ C ⟩ .F-hom f = f 𝟙⟨ C ⟩ .F-id = refl 𝟙⟨ C ⟩ .F-seq _ _ = refl -- functor composition funcComp : ∀ (G : Functor D E) (F : Functor C D) → Functor C E (funcComp G F) .F-ob c = G ⟅ F ⟅ c ⟆ ⟆ (funcComp G F) .F-hom f = G ⟪ F ⟪ f ⟫ ⟫ (funcComp G F) .F-id = cong (G ⟪_⟫) (F .F-id) ∙ G .F-id (funcComp G F) .F-seq f g = cong (G ⟪_⟫) (F .F-seq _ _) ∙ G .F-seq _ _ infixr 30 funcComp syntax funcComp G F = G ∘F F _^opF : Functor C D → Functor (C ^op) (D ^op) (F ^opF) .F-ob = F .F-ob (F ^opF) .F-hom = F .F-hom (F ^opF) .F-id = F .F-id (F ^opF) .F-seq f g = F .F-seq g f	{ "alphanum_fraction": 0.513540128, "avg_line_length": 25.3875, "ext": "agda", "hexsha": "871dd6d72eba1d7958133aaa4c5dff4b3d7e0ff9", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "58f2d0dd07e51f8aa5b348a522691097b6695d1c", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "Seanpm2001-web/cubical", "max_forks_repo_path": "Cubical/Categories/Functor/Base.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "58f2d0dd07e51f8aa5b348a522691097b6695d1c", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "Seanpm2001-web/cubical", "max_issues_repo_path": "Cubical/Categories/Functor/Base.agda", "max_line_length": 98, "max_stars_count": 1, "max_stars_repo_head_hexsha": "9acdecfa6437ec455568be4e5ff04849cc2bc13b", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "FernandoLarrain/cubical", "max_stars_repo_path": "Cubical/Categories/Functor/Base.agda", "max_stars_repo_stars_event_max_datetime": "2022-03-05T00:28:39.000Z", "max_stars_repo_stars_event_min_datetime": "2022-03-05T00:28:39.000Z", "num_tokens": 921, "size": 2031 }
module Prelude.Monoid where open import Prelude.Function open import Prelude.Maybe open import Prelude.List open import Prelude.Semiring open import Prelude.Semigroup public open import Prelude.Applicative open import Prelude.Functor open import Prelude.Equality open import Prelude.Variables record Monoid {a} (A : Set a) : Set a where field {{super}} : Semigroup A mempty : A open Monoid {{...}} public hiding (super) {-# DISPLAY Monoid.mempty _ = mempty #-} record Monoid/Laws {ℓ} (A : Set ℓ) : Set ℓ where field overlap {{super}} : Monoid A left-identity : (e : A) → mempty <> e ≡ e right-identity : (e : A) → e <> mempty ≡ e -- Using Semigroup/Laws instance creates inference problems -- Maby we can do this in a better way? monoid-assoc : (a b c : A) → (a <> b) <> c ≡ a <> (b <> c) open Monoid/Laws {{...}} public hiding (super) mconcat : ∀ {a} {A : Set a} {{MonA : Monoid A}} → List A → A mconcat = foldr _<>_ mempty --- Instances --- instance MonoidList : ∀ {a} {A : Set a} → Monoid (List A) Monoid.super MonoidList = it mempty {{MonoidList}} = [] MonoidFun : ∀ {a b} {A : Set a} {B : A → Set b} {{_ : ∀ {x} → Monoid (B x)}} → Monoid (∀ x → B x) Monoid.super (MonoidFun {a} {b} {A} {B} {{SG}}) = SemigroupFun {a} {b} {A} {B} {{Monoid.super SG}} mempty {{MonoidFun}} _ = mempty MonoidMaybe : ∀ {a} {A : Set a} → Monoid (Maybe A) Monoid.super MonoidMaybe = it mempty {{MonoidMaybe}} = nothing -- Temporarily here, better version comes in the list update Monoid/LawsList : Monoid/Laws (List A) Monoid/Laws.super Monoid/LawsList = it left-identity {{Monoid/LawsList}} _ = refl right-identity {{Monoid/LawsList}} [] = refl right-identity {{Monoid/LawsList}} (x ∷ xs) = cong (x ∷_) (right-identity xs) monoid-assoc {{Monoid/LawsList}} [] ys zs = refl monoid-assoc {{Monoid/LawsList}} (x ∷ xs) ys zs = cong (x ∷_) (monoid-assoc xs ys zs) record Sum {a} (A : Set a) : Set a where constructor mkSum field getSum : A open Sum public instance SemigroupSum : ∀ {a} {A : Set a} {{_ : Semiring A}} → Semigroup (Sum A) getSum (_<>_ {{SemigroupSum}} x y) = getSum x + getSum y MonoidSum : ∀ {a} {A : Set a} {{_ : Semiring A}} → Monoid (Sum A) Monoid.super MonoidSum = it getSum (mempty {{MonoidSum}}) = zro record Product {a} (A : Set a) : Set a where constructor mkProduct field getProduct : A open Product public instance SemigroupProduct : ∀ {a} {A : Set a} {{_ : Semiring A}} → Semigroup (Product A) getProduct (_<>_ {{SemigroupProduct}} x y) = getProduct x * getProduct y MonoidProduct : ∀ {a} {A : Set a} {{_ : Semiring A}} → Monoid (Product A) Monoid.super MonoidProduct = it getProduct (mempty {{MonoidProduct}}) = one record Const {a b} (A : Set a) (B : Set b) : Set a where constructor mkConst field getConst : A open Const public module _ {a b} {A : Set a} {{MonA : Monoid A}} where instance FunctorConst : Functor {a = b} (Const A) getConst (fmap {{FunctorConst}} f x) = getConst x ApplicativeConst : Applicative (Const A) getConst (pure {{ApplicativeConst}} x) = mempty getConst (_<*>_ {{ApplicativeConst}} wf wx) = getConst wf <> getConst wx	{ "alphanum_fraction": 0.6341917468, "avg_line_length": 29.3, "ext": "agda", "hexsha": "8cab9b38ab60c3a2800eef333c2fbf4d9403a3c8", "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/Monoid.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/Monoid.agda", "max_line_length": 99, "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/Monoid.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": 1084, "size": 3223 }
{-# OPTIONS --without-K #-} module T where open import Level open import Relation.Binary.PropositionalEquality using (_≡_; refl; sym; trans; cong; subst; module ≡-Reasoning) open import Data.Nat using (ℕ; _+_) open import Data.Fin using (Fin) data Exp : Set where ONE : Exp PLUS : Exp → Exp → Exp val : Exp → ℕ val ONE = 1 val (PLUS e₁ e₂) = val e₁ + val e₂ data eqExp : Exp → Exp → Set where idExp : {e : Exp} → eqExp e e transExp : {e₁ e₂ e₃ : Exp} → (eqExp e₁ e₂) → (eqExp e₂ e₃) → (eqExp e₁ e₃) val≡ : {e₁ e₂ : Exp} → (eqExp e₁ e₂) → (val e₁ ≡ val e₂) val≡ idExp = refl val≡ (transExp α₁ α₂) = trans (val≡ α₁) (val≡ α₂) trans-assoc : {A : Set} {x y z w : A} → (p : x ≡ y) (q : y ≡ z) (r : z ≡ w) → trans (trans p q) r ≡ trans p (trans q r) trans-assoc refl refl refl = refl subst-trans : (P : ℕ → Set) (p : (n : ℕ) → P n) {e₁ e₂ e₃ : Exp} → (α : eqExp e₁ e₂) (β : eqExp e₂ e₃) (v : P (val e₁)) → subst P (trans (val≡ α) (val≡ β)) v ≡ subst P (val≡ β) (subst P (val≡ α) v) subst-trans P p idExp β v = refl subst-trans P p (transExp α₁ α₂) β v = begin (subst P (trans (trans (val≡ α₁) (val≡ α₂)) (val≡ β)) v ≡⟨ cong (λ x → subst P x v) (trans-assoc (val≡ α₁) (val≡ α₂) (val≡ β)) ⟩ subst P (trans (val≡ α₁) (trans (val≡ α₂) (val≡ β))) v ≡⟨ refl ⟩ subst P (trans (val≡ α₁) (val≡ (transExp α₂ β))) v ≡⟨ subst-trans P p α₁ (transExp α₂ β) v ⟩ subst P (val≡ (transExp α₂ β)) (subst P (val≡ α₁) v) ≡⟨ refl ⟩ subst P (trans (val≡ α₂) (val≡ β)) (subst P (val≡ α₁) v) ≡⟨ subst-trans P p α₂ β (subst P (val≡ α₁) v) ⟩ subst P (val≡ β) (subst P (val≡ α₂) (subst P (val≡ α₁) v)) ≡⟨ cong (λ x → subst P (val≡ β) x) (sym (subst-trans P p α₁ α₂ v)) ⟩ subst P (val≡ β) (subst P (trans (val≡ α₁) (val≡ α₂)) v) ≡⟨ refl ⟩ subst P (val≡ β) (subst P (val≡ (transExp α₁ α₂)) v) ∎) where open ≡-Reasoning pr : {P : ℕ → Set} {p : (n : ℕ) → P n} {e₁ e₂ : Exp} {α : eqExp e₁ e₂} → subst P (val≡ α) (p (val e₁)) ≡ p (val e₂) pr {P} {p} {e} {.e} {idExp} = refl pr {P} {p} {e₁} {e₃} {transExp {e₂ = e₂} α β} = begin (subst P (val≡ (transExp α β)) (p (val e₁)) ≡⟨ refl ⟩ subst P (trans (val≡ α) (val≡ β)) (p (val e₁)) ≡⟨ subst-trans P p α β (p (val e₁)) ⟩ subst P (val≡ β) (subst P (val≡ α) (p (val e₁))) ≡⟨ cong (λ x → subst P (val≡ β) x) (pr {P} {p} {e₁} {e₂} {α}) ⟩ subst P (val≡ β) (p (val e₂)) ≡⟨ pr {P} {p} {e₂} {e₃} {β} ⟩ p (val e₃) ∎) where open ≡-Reasoning	{ "alphanum_fraction": 0.4915824916, "avg_line_length": 38.7391304348, "ext": "agda", "hexsha": "748581ee2fbf589898800b2383dba06650a18c59", "lang": "Agda", "max_forks_count": 3, "max_forks_repo_forks_event_max_datetime": "2019-09-10T09:47:13.000Z", "max_forks_repo_forks_event_min_datetime": "2016-05-29T01:56:33.000Z", "max_forks_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1", "max_forks_repo_licenses": [ "BSD-2-Clause" ], "max_forks_repo_name": "JacquesCarette/pi-dual", "max_forks_repo_path": "Univalence/Obsolete/T.agda", "max_issues_count": 4, "max_issues_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1", "max_issues_repo_issues_event_max_datetime": "2021-10-29T20:41:23.000Z", "max_issues_repo_issues_event_min_datetime": "2018-06-07T16:27:41.000Z", "max_issues_repo_licenses": [ "BSD-2-Clause" ], "max_issues_repo_name": "JacquesCarette/pi-dual", "max_issues_repo_path": "Univalence/Obsolete/T.agda", "max_line_length": 78, "max_stars_count": 14, "max_stars_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1", "max_stars_repo_licenses": [ "BSD-2-Clause" ], "max_stars_repo_name": "JacquesCarette/pi-dual", "max_stars_repo_path": "Univalence/Obsolete/T.agda", "max_stars_repo_stars_event_max_datetime": "2021-05-05T01:07:57.000Z", "max_stars_repo_stars_event_min_datetime": "2015-08-18T21:40:15.000Z", "num_tokens": 1186, "size": 2673 }
{- This file contains: - Some basic properties of Rijke finite types. -} {-# OPTIONS --safe #-} module Cubical.Data.FinType.Properties where open import Cubical.Foundations.Prelude open import Cubical.Foundations.Isomorphism open import Cubical.Foundations.Equiv open import Cubical.Foundations.Equiv.Properties open import Cubical.HITs.SetTruncation open import Cubical.Data.Nat open import Cubical.Data.FinSet open import Cubical.Data.FinSet.Constructors open import Cubical.Data.FinType.Base private variable ℓ ℓ' : Level n : ℕ X : Type ℓ Y : Type ℓ' EquivPresIsFinType : (n : ℕ) → X ≃ Y → isFinType n X → isFinType n Y EquivPresIsFinType 0 e = EquivPresIsFinSet (isoToEquiv (setTruncIso (equivToIso e))) EquivPresIsFinType (suc n) e (p , q) .fst = EquivPresIsFinType 0 e p EquivPresIsFinType (suc n) e (p , q) .snd a b = EquivPresIsFinType n (invEquiv (congEquiv (invEquiv e))) (q _ _) isFinSet→isFinType : (n : ℕ) → isFinSet X → isFinType n X isFinSet→isFinType 0 p = EquivPresIsFinSet (invEquiv (setTruncIdempotent≃ (isFinSet→isSet p))) p isFinSet→isFinType (suc n) p .fst = isFinSet→isFinType 0 p isFinSet→isFinType (suc n) p .snd a b = isFinSet→isFinType n (isFinSet≡ (_ , p) _ _) isPathConnected→isFinType0 : isContr ∥ X ∥₂ → isFinType 0 X isPathConnected→isFinType0 p = isContr→isFinSet p	{ "alphanum_fraction": 0.7441685478, "avg_line_length": 30.9069767442, "ext": "agda", "hexsha": "befeba15a6899449bba2ac710230efb970c2b9ae", "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/Data/FinType/Properties.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/Data/FinType/Properties.agda", "max_line_length": 96, "max_stars_count": 1, "max_stars_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "thomas-lamiaux/cubical", "max_stars_repo_path": "Cubical/Data/FinType/Properties.agda", "max_stars_repo_stars_event_max_datetime": "2021-10-31T17:32:49.000Z", "max_stars_repo_stars_event_min_datetime": "2021-10-31T17:32:49.000Z", "num_tokens": 476, "size": 1329 }
{-# OPTIONS --universe-polymorphism #-} module Categories.Monoidal.Braided where open import Level open import Level using (_⊔_) open import Categories.Category open import Categories.Bifunctor using (Bifunctor) open import Categories.NaturalIsomorphism open import Categories.NaturalTransformation using (_∘₁_) renaming (_≡_ to _≡ⁿ_) open import Categories.Monoidal.Helpers open import Categories.Monoidal.Braided.Helpers open import Categories.Monoidal record Braided {o ℓ e} {C : Category o ℓ e} (M : Monoidal C) : Set (o ⊔ ℓ ⊔ e) where private module C = Category C private module M = Monoidal M open C hiding (id; identityˡ; identityʳ; assoc) open M open MonoidalHelperFunctors C ⊗ id open BraidedHelperFunctors C ⊗ id field braid : NaturalIsomorphism x⊗y y⊗x open Braiding identityˡ identityʳ assoc braid field -- NB: Triangle is redundant, proof coming soon... .hexagon₁ : (Hexagon1SideB ∘₁ (Hexagon1TopB ∘₁ Hexagon1TopA)) ≡ⁿ (Hexagon1BottomB ∘₁ (Hexagon1BottomA ∘₁ Hexagon1SideA)) .hexagon₂ : (Hexagon2SideB ∘₁ (Hexagon2TopB ∘₁ Hexagon2TopA)) ≡ⁿ (Hexagon2BottomB ∘₁ (Hexagon2BottomA ∘₁ Hexagon2SideA))	{ "alphanum_fraction": 0.7519446845, "avg_line_length": 33.0571428571, "ext": "agda", "hexsha": "2e714243fd3fc13c6d03b09a1d4a0a25dc89bc3c", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2", "max_forks_repo_licenses": [ "BSD-3-Clause" ], "max_forks_repo_name": "p-pavel/categories", "max_forks_repo_path": "Categories/Monoidal/Braided.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "BSD-3-Clause" ], "max_issues_repo_name": "p-pavel/categories", "max_issues_repo_path": "Categories/Monoidal/Braided.agda", "max_line_length": 124, "max_stars_count": 1, "max_stars_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2", "max_stars_repo_licenses": [ "BSD-3-Clause" ], "max_stars_repo_name": "p-pavel/categories", "max_stars_repo_path": "Categories/Monoidal/Braided.agda", "max_stars_repo_stars_event_max_datetime": "2018-12-29T21:51:57.000Z", "max_stars_repo_stars_event_min_datetime": "2018-12-29T21:51:57.000Z", "num_tokens": 376, "size": 1157 }
module DaraisPhoas where open import Agda.Primitive using (_⊔_) module Prelude where infixr 3 ∃𝑠𝑡 infixl 5 _∨_ infixr 20 _∷_ data 𝔹 : Set where T : 𝔹 F : 𝔹 data _∨_ {ℓ₁ ℓ₂} (A : Set ℓ₁) (B : Set ℓ₂) : Set (ℓ₁ ⊔ ℓ₂) where Inl : A → A ∨ B Inr : B → A ∨ B syntax ∃𝑠𝑡 A (λ x → B) = ∃ x ⦂ A 𝑠𝑡 B data ∃𝑠𝑡 {ℓ₁ ℓ₂} (A : Set ℓ₁) (B : A → Set ℓ₂) : Set (ℓ₁ ⊔ ℓ₂) where ⟨∃_,_⟩ : ∀ (x : A) → B x → ∃ x ⦂ A 𝑠𝑡 B x data ⟬_⟭ {ℓ} (A : Set ℓ) : Set ℓ where [] : ⟬ A ⟭ _∷_ : A → ⟬ A ⟭ → ⟬ A ⟭ open Prelude infixr 15 _⟨→⟩_ data type : Set where ⟨ℕ⟩ : type _⟨→⟩_ : type → type → type infixl 15 _⟨∙⟩_ data exp-phoas (var : type → ⟬ type ⟭ → Set) : ∀ (Γ : ⟬ type ⟭) (τ : type) → Set where Var : ∀ {Γ τ} (x : var τ Γ) → exp-phoas var Γ τ ⟨λ⟩ : ∀ {Γ τ₁ τ₂} (e : var τ₁ (τ₁ ∷ Γ) → exp-phoas var (τ₁ ∷ Γ) τ₂) → exp-phoas var Γ (τ₁ ⟨→⟩ τ₂) _⟨∙⟩_ : ∀ {Γ τ₁ τ₂} (e₁ : exp-phoas var Γ (τ₁ ⟨→⟩ τ₂)) (e₂ : exp-phoas var Γ τ₁) → exp-phoas var Γ τ₂ infix 10 _∈_ data _∈_ {ℓ} {A : Set ℓ} (x : A) : ∀ (xs : ⟬ A ⟭) → Set ℓ where Z : ∀ {xs} → x ∈ x ∷ xs S : ∀ {x′ xs} → x ∈ xs → x ∈ x′ ∷ xs infix 10 _⊢_ data _⊢_ : ∀ (Γ : ⟬ type ⟭) (τ : type) → Set where Var : ∀ {Γ τ} (x : τ ∈ Γ) → Γ ⊢ τ ⟨λ⟩ : ∀ {Γ τ₁ τ₂} (e : τ₁ ∷ Γ ⊢ τ₂) → Γ ⊢ τ₁ ⟨→⟩ τ₂ _⟨∙⟩_ : ∀ {Γ τ₁ τ₂} (e₁ : Γ ⊢ τ₁ ⟨→⟩ τ₂) (e₂ : Γ ⊢ τ₁) → Γ ⊢ τ₂ ⟦_⟧₁ : ∀ {Γ τ} (e : exp-phoas _∈_ Γ τ) → Γ ⊢ τ ⟦ Var x ⟧₁ = Var x ⟦ ⟨λ⟩ e ⟧₁ = ⟨λ⟩ ⟦ e Z ⟧₁ ⟦ e₁ ⟨∙⟩ e₂ ⟧₁ = ⟦ e₁ ⟧₁ ⟨∙⟩ ⟦ e₂ ⟧₁ ⟦_⟧₂ : ∀ {Γ τ} (e : Γ ⊢ τ) → exp-phoas _∈_ Γ τ ⟦ Var x ⟧₂ = Var x ⟦ ⟨λ⟩ e ⟧₂ = ⟨λ⟩ (λ _ → ⟦ e ⟧₂) ⟦ e₁ ⟨∙⟩ e₂ ⟧₂ = ⟦ e₁ ⟧₂ ⟨∙⟩ ⟦ e₂ ⟧₂ Ch : type Ch = (⟨ℕ⟩ ⟨→⟩ ⟨ℕ⟩) ⟨→⟩ ⟨ℕ⟩ ⟨→⟩ ⟨ℕ⟩ twoDB : [] ⊢ Ch twoDB = ⟨λ⟩ (⟨λ⟩ (Var (S Z) ⟨∙⟩ (Var (S Z) ⟨∙⟩ Var Z))) twoPH : exp-phoas _∈_ [] Ch twoPH = ⟨λ⟩ (λ f → ⟨λ⟩ (λ x → Var f ⟨∙⟩ (Var f ⟨∙⟩ Var x))) {- /Users/wadler/sf/src/extra/DaraisPhoas.agda:82,9-60 ⟨ℕ⟩ ⟨→⟩ ⟨ℕ⟩ != ⟨ℕ⟩ of type type when checking that the expression ⟨λ⟩ (λ f → ⟨λ⟩ (λ x → Var f ⟨∙⟩ (Var f ⟨∙⟩ Var x))) has type exp-phoas _∈_ [] Ch -}	{ "alphanum_fraction": 0.4388489209, "avg_line_length": 22.9120879121, "ext": "agda", "hexsha": "b513d70d9a25a82492c0e5a024c9769f510f0993", "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": "8a2c2ace545092fd0e04bf5831ed458267f18ae4", "max_forks_repo_licenses": [ "CC-BY-4.0" ], "max_forks_repo_name": "manikdv/plfa.github.io", "max_forks_repo_path": "extra/extra/DaraisPhoas.agda", "max_issues_count": 323, "max_issues_repo_head_hexsha": "8a2c2ace545092fd0e04bf5831ed458267f18ae4", "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": "manikdv/plfa.github.io", "max_issues_repo_path": "extra/extra/DaraisPhoas.agda", "max_line_length": 86, "max_stars_count": 1003, "max_stars_repo_head_hexsha": "8a2c2ace545092fd0e04bf5831ed458267f18ae4", "max_stars_repo_licenses": [ "CC-BY-4.0" ], "max_stars_repo_name": "manikdv/plfa.github.io", "max_stars_repo_path": "extra/extra/DaraisPhoas.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": 1221, "size": 2085 }
module All where open import Prelude open import T open import SubstTheory open import DynTheory open import Progress open import HT open import Examples open import Eq open import DenotCommutes	{ "alphanum_fraction": 0.8418367347, "avg_line_length": 16.3333333333, "ext": "agda", "hexsha": "06383780fc7bb2802794d27643875873e98a68f1", "lang": "Agda", "max_forks_count": 3, "max_forks_repo_forks_event_max_datetime": "2021-05-04T22:37:18.000Z", "max_forks_repo_forks_event_min_datetime": "2015-04-26T11:39:14.000Z", "max_forks_repo_head_hexsha": "7412725cf27873b2b23f7e411a236a97dd99ef91", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "msullivan/godels-t", "max_forks_repo_path": "All.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "7412725cf27873b2b23f7e411a236a97dd99ef91", "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": "msullivan/godels-t", "max_issues_repo_path": "All.agda", "max_line_length": 25, "max_stars_count": 4, "max_stars_repo_head_hexsha": "7412725cf27873b2b23f7e411a236a97dd99ef91", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "msullivan/godels-t", "max_stars_repo_path": "All.agda", "max_stars_repo_stars_event_max_datetime": "2021-03-22T00:28:03.000Z", "max_stars_repo_stars_event_min_datetime": "2016-12-25T01:52:57.000Z", "num_tokens": 46, "size": 196 }
{- Problem #53 Given premises: (all x)[(F x) -> (some y)((F y) & (G x y))] justification = 1.0 Ultimate epistemic interests: (all x)[(F x) -> (some y)(some z)((G x y) & (G y z))] interest = 1.0 -} open import Prelude postulate U : Set F : U → Set G : U → U → Set record Premise {x : U} (Fx : F x) : Set where field pY : U pF : F pY pG : G x pY open Premise record Conclusion {x : U} (Fx : F x) : Set where field cY : U cZ : U cGxy : G x cY cGyz : G cY cZ open Conclusion premise = ∀ x → (Fx : F x) → Premise Fx conclusion = ∀ x → (Fx : F x) → Conclusion Fx proof1 : premise → conclusion proof1 p x Fx = record { cY = _ ; cZ = _ ; cGxy = pG p1 ; cGyz = pG p2 } where p1 = p x Fx p2 = p (pY p1) (pF p1) {- postulate U : Set F : U → Set G : U → U → Set ∃ : ∀ {a b} {A : Set a} (B : A → Set b) → Set (a ⊔ b) ∃ = Σ _ premise = ∀ x → F x → ∃ λ y → (F y × G x y) conclusion = ∀ x → F x → ∃ λ y → ∃ λ z → (G x y × G y z) pY : premise → ∀ x → F x → _ pY p x Fx = fst (p x Fx) pF : premise → ∀ x → F x → F y -- y is not in scope! pF p x Fx = {!fst (snd (p x Fx))!} pG : premise → ∀ x → F x → _ pG p x Fx = {!snd (snd (p x Fx))!} proof1 : premise → conclusion proof1 p x Fx = y , z , Gxy , Gyz where y : U y = {!!} z : U z = {!!} Gxy : G x y Gxy = {!!} Gyz : G y z Gyz = {!!} -}	{ "alphanum_fraction": 0.4759856631, "avg_line_length": 16.6071428571, "ext": "agda", "hexsha": "605f96e99b470405a868ea63cce39e46beecc8bf", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb", "max_forks_repo_licenses": [ "RSA-MD" ], "max_forks_repo_name": "m0davis/oscar", "max_forks_repo_path": "archive/lisp-revised/Problem53.agda", "max_issues_count": 1, "max_issues_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb", "max_issues_repo_issues_event_max_datetime": "2019-05-11T23:33:04.000Z", "max_issues_repo_issues_event_min_datetime": "2019-04-29T00:35:04.000Z", "max_issues_repo_licenses": [ "RSA-MD" ], "max_issues_repo_name": "m0davis/oscar", "max_issues_repo_path": "archive/lisp-revised/Problem53.agda", "max_line_length": 75, "max_stars_count": null, "max_stars_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb", "max_stars_repo_licenses": [ "RSA-MD" ], "max_stars_repo_name": "m0davis/oscar", "max_stars_repo_path": "archive/lisp-revised/Problem53.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 616, "size": 1395 }
module Issue384 where postulate D : (A : Set) → A → Set data I : Set where i : I D′ : (A : Set) → A → I → Set D′ A x i = D A x postulate Q : (A : Set) → A → Set q : ∀ j A (x : A) → D′ A x j → Q A x A : Set x : A d : D A x P : (A : Set) → A → Set p : P (Q _ _) (q _ _ _ d)	{ "alphanum_fraction": 0.430976431, "avg_line_length": 12.9130434783, "ext": "agda", "hexsha": "c5457a466043c43acc5f8e1389d8905f289cc53d", "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/Issue384.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/Issue384.agda", "max_line_length": 38, "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/Issue384.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": 141, "size": 297 }
module Issue168 where postulate X : Set open import Issue168b open Membership X postulate P : Nat → Set lemma : ∀ n → P (id n) foo : P zero foo = lemma _	{ "alphanum_fraction": 0.6687116564, "avg_line_length": 10.8666666667, "ext": "agda", "hexsha": "442c2d9fbfd5c29b88734d432c3ced70a796a4de", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "asr/agda-kanso", "max_forks_repo_path": "test/succeed/Issue168.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "asr/agda-kanso", "max_issues_repo_path": "test/succeed/Issue168.agda", "max_line_length": 24, "max_stars_count": null, "max_stars_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "asr/agda-kanso", "max_stars_repo_path": "test/succeed/Issue168.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 52, "size": 163 }
------------------------------------------------------------------------ -- The Agda standard library -- -- List Literals ------------------------------------------------------------------------ {-# OPTIONS --without-K --safe #-} module Data.List.Literals where open import Agda.Builtin.FromString open import Data.Unit open import Agda.Builtin.Char open import Agda.Builtin.List open import Data.String.Base using (toList) isString : IsString (List Char) isString = record { Constraint = λ _ → ⊤ ; fromString = λ s → toList s }	{ "alphanum_fraction": 0.5250463822, "avg_line_length": 24.5, "ext": "agda", "hexsha": "7172cec21dcc1b24242a08fb00774a8f5b053bd8", "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/List/Literals.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/List/Literals.agda", "max_line_length": 72, "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/List/Literals.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": 109, "size": 539 }
------------------------------------------------------------------------------ -- The relation of divisibility on partial natural numbers ------------------------------------------------------------------------------ {-# OPTIONS --exact-split #-} {-# OPTIONS --no-sized-types #-} {-# OPTIONS --no-universe-polymorphism #-} {-# OPTIONS --without-K #-} module FOTC.Data.Nat.Divisibility.By0 where open import FOTC.Base open import FOTC.Data.Nat infix 4 _∣_ ------------------------------------------------------------------------------ -- The relation of divisibility (the symbol is '\mid' not '\|') -- -- It seems there is not agreement about if 0∣0: -- -- Hardy and Wright 1975, p. 1: 0∤0 -- -- Knuth 1977, p. 40: 0∤0 -- -- Agda standard library 0.8.1: 0\|0 -- -- Coq 8.4pl4: 0∣0 -- -- Isabelle2014: 0∣0 -- In our definition 0∣0, which is used to prove properties of the gcd -- as it is in GHC ≥ 7.2.1, where gcd 0 0 = 0 (see -- http://hackage.haskell.org/trac/ghc/ticket/3304). -- Note that @k@ should be a total natural number. _∣_ : D → D → Set m ∣ n = ∃[ k ] N k ∧ n ≡ k * m {-# ATP definition _∣_ #-} ------------------------------------------------------------------------------ -- References: -- -- Hardy, G. H. and Wright, E. M. (1975). An Introduction to the -- Theory of Numbers. 4th ed. Oxford University Press. -- -- Knuth, Donald E. (1997). The Art of Computer Programming. 3rd -- ed. Vol. 1. Fundamental Algorithms. Addison-Wesley Professional.	{ "alphanum_fraction": 0.497671324, "avg_line_length": 30.6734693878, "ext": "agda", "hexsha": "d6f1f6abcf1d77a73b4c325d1211709bcc6474c5", "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/Data/Nat/Divisibility/By0.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/Data/Nat/Divisibility/By0.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/fot/FOTC/Data/Nat/Divisibility/By0.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": 405, "size": 1503 }
------------------------------------------------------------------------ -- Compiler correctness ------------------------------------------------------------------------ {-# OPTIONS --cubical --sized-types #-} module Lambda.Partiality-monad.Inductive.Compiler-correctness where open import Equality.Propositional.Cubical open import Prelude hiding (⊥) open import Bijection equality-with-J using (_↔_) open import Maybe equality-with-J as Maybe open import Monad equality-with-J open import Vec.Function equality-with-J open import Partiality-monad.Inductive open import Partiality-monad.Inductive.Monad open import Lambda.Compiler open import Lambda.Partiality-monad.Inductive.Interpreter open import Lambda.Partiality-monad.Inductive.Virtual-machine open import Lambda.Syntax open import Lambda.Virtual-machine private module C = Closure Code module T = Closure Tm -- Compiler correctness. mutual ⟦⟧-correct : ∀ {n} t {ρ : T.Env n} {c s} {k : ℕ → T.Value → M C.Value} {n} → (∀ v → steps ⟨ c , val (comp-val v) ∷ s , comp-env ρ ⟩ ≳[ n ] λ n → run (k n v)) → steps ⟨ comp t c , s , comp-env ρ ⟩ ≳[ n ] λ n → run (⟦ t ⟧′ ρ n >>= k n) ⟦⟧-correct (con i) {ρ} {c} {s} {k} hyp = steps ⟨ con i ∷ c , s , comp-env ρ ⟩ ≳⟨ step⇓ ⟩ steps ⟨ c , val (comp-val (T.con i)) ∷ s , comp-env ρ ⟩ ≳⟨ hyp (T.con i) ⟩ (λ n → run (k n (T.con i))) ≡⟨ sym now->>= ⟩≳ (λ n → run (⟦ con i ⟧′ ρ n >>= k n)) ∎≳ ⟦⟧-correct (var x) {ρ} {c} {s} {k} hyp = steps ⟨ var x ∷ c , s , comp-env ρ ⟩ ≳⟨ step⇓ ⟩ steps ⟨ c , val (comp-val (ρ x)) ∷ s , comp-env ρ ⟩ ≳⟨ hyp (ρ x) ⟩ (λ n → run (k n (ρ x))) ≡⟨ sym now->>= ⟩≳ (λ n → run (⟦ var x ⟧′ ρ n >>= k n)) ∎≳ ⟦⟧-correct (ƛ t) {ρ} {c} {s} {k} hyp = steps ⟨ clo (comp t (ret ∷ [])) ∷ c , s , comp-env ρ ⟩ ≳⟨ step⇓ ⟩ steps ⟨ c , val (comp-val (T.ƛ t ρ)) ∷ s , comp-env ρ ⟩ ≳⟨ hyp (T.ƛ t ρ) ⟩ (λ n → run (k n (T.ƛ t ρ))) ≡⟨ sym now->>= ⟩≳ (λ n → run (⟦ ƛ t ⟧′ ρ n >>= k n)) ∎≳ ⟦⟧-correct (t₁ · t₂) {ρ} {c} {s} {k} {n} hyp = steps ⟨ comp t₁ (comp t₂ (app ∷ c)) , s , comp-env ρ ⟩ ≳⟨ (⟦⟧-correct t₁ {n = n} λ v₁ → ⟦⟧-correct t₂ λ v₂ → ∙-correct v₁ v₂ hyp) ⟩ (λ n → run (⟦ t₁ ⟧′ ρ n >>= λ v₁ → ⟦ t₂ ⟧′ ρ n >>= λ v₂ → (v₁ ∙ v₂) n >>= k n)) ≡⟨ cong (λ f → run (⟦ t₁ ⟧′ ρ n >>= f)) (⟨ext⟩ λ v₁ → Monad.associativity tr (⟦ t₂ ⟧′ ρ n) _ _) ⟩≳ (λ n → run (⟦ t₁ ⟧′ ρ n >>= λ v₁ → (⟦ t₂ ⟧′ ρ n >>= λ v₂ → (v₁ ∙ v₂) n) >>= k n)) ≡⟨ cong MaybeT.run $ Monad.associativity tr (⟦ t₁ ⟧′ ρ n) _ _ ⟩≳ (λ n → run (⟦ t₁ · t₂ ⟧′ ρ n >>= k n)) ∎≳ where tr = Monad-transformer.transform (Maybe.monad-transformer ext) ∙-correct : ∀ {n} v₁ v₂ {ρ : T.Env n} {c s} {k : ℕ → T.Value → M C.Value} {n} → (∀ v → steps ⟨ c , val (comp-val v) ∷ s , comp-env ρ ⟩ ≳[ n ] λ n → run (k n v)) → steps ⟨ app ∷ c , val (comp-val v₂) ∷ val (comp-val v₁) ∷ s , comp-env ρ ⟩ ≳[ n ] λ n → run ((v₁ ∙ v₂) n >>= k n) ∙-correct (T.con i) v₂ {ρ} {c} {s} {k} hyp = steps ⟨ app ∷ c , val (comp-val v₂) ∷ val (C.con i) ∷ s , comp-env ρ ⟩ ≳⟨⟩ const (run fail) ≡⟨ sym now->>= ⟩≳ (λ n → run ((T.con i ∙ v₂) n >>= k n)) ∎≳ ∙-correct (T.ƛ t₁ ρ₁) v₂ {ρ} {c} {s} {k} {zero} hyp = steps ⟨ app ∷ c , val (comp-val v₂) ∷ val (comp-val (T.ƛ t₁ ρ₁)) ∷ s , comp-env ρ ⟩ ≡⟨ refl ⟩≳ const never ≡⟨ sym never->>= ⟩≳ const (never >>= _) ≡⟨ cong (_>>= maybe (MaybeT.run ∘ k 0) (return nothing) ⦂ (_ ⊥ → _)) (sym never->>=) ⟩≳ (λ n → run ((T.ƛ t₁ ρ₁ ∙ v₂) n >>= k n)) ∎≳ ∙-correct (T.ƛ t₁ ρ₁) v₂ {ρ} {c} {s} {k} {suc n} hyp = later ( steps ⟨ app ∷ c , val (comp-val v₂) ∷ val (comp-val (T.ƛ t₁ ρ₁)) ∷ s , comp-env ρ ⟩ ∘ suc ≳⟨⟩ steps ⟨ comp t₁ (ret ∷ []) , ret c (comp-env ρ) ∷ s , cons (comp-val v₂) (comp-env ρ₁) ⟩ ∀≡⟨ (λ n → cong (λ ρ′ → steps ⟨ comp t₁ (ret ∷ []) , ret c (comp-env ρ) ∷ s , ρ′ ⟩ n) $ sym comp-cons) ⟩≳ steps ⟨ comp t₁ (ret ∷ []) , ret c (comp-env ρ) ∷ s , comp-env (cons v₂ ρ₁) ⟩ ≳⟨ (⟦⟧-correct t₁ {n = n} λ v → steps ⟨ ret ∷ [] , val (comp-val v) ∷ ret c (comp-env ρ) ∷ s , comp-env (cons v₂ ρ₁) ⟩ ≳⟨ step⇓ ⟩ steps ⟨ c , val (comp-val v) ∷ s , comp-env ρ ⟩ ≳⟨ hyp v ⟩ (λ n → run (k n v)) ≳⟨ step⇓ ⟩ (λ n → run (k (suc n) v)) ∎≳) ⟩ (λ n → run (⟦ t₁ ⟧′ (cons v₂ ρ₁) n >>= k (suc n))) ≳⟨⟩ (λ n → run ((T.ƛ t₁ ρ₁ ∙ v₂) (suc n) >>= k (suc n))) ∎≳) -- Note that the equality that is used here is syntactic. correct : ∀ t → wrap (exec ⟨ comp t [] , [] , nil ⟩) ≡ (⟦ t ⟧ nil >>= λ v → return (comp-val v)) correct t = wrap (exec ⟨ comp t [] , [] , nil ⟩) ≡⟨ cong (λ ρ → wrap (exec ⟨ comp t [] , [] , ρ ⟩)) $ sym comp-nil ⟩ wrap (exec ⟨ comp t [] , [] , comp-env nil ⟩) ≡⟨⟩ wrap (⨆ (stepsˢ ⟨ comp t [] , [] , comp-env nil ⟩)) ≡⟨ cong wrap (≳→⨆≡⨆ 0 $ ⟦⟧-correct t λ v → const (MaybeT.run (return (comp-val v))) ∎≳) ⟩ wrap (⨆ (⟦ t ⟧ˢ nil >>=ˢ λ v → constˢ (MaybeT.run (return (comp-val v))))) ≡⟨ cong (λ s → wrap (⨆ s)) (_↔_.to equality-characterisation-increasing (λ _ → refl)) ⟩ wrap (⨆ (maybe (λ v → MaybeT.run (return (comp-val v))) (return nothing) ∗-inc ⟦ t ⟧ˢ nil)) ≡⟨ cong wrap (sym ⨆->>=) ⟩∎ (⟦ t ⟧ nil >>= λ v → return (comp-val v)) ∎	{ "alphanum_fraction": 0.3845448992, "avg_line_length": 41.7070063694, "ext": "agda", "hexsha": "8dfe87fc08411a5b0c5a3692b3f5d2252a464a96", "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": "f69749280969f9093e5e13884c6feb0ad2506eae", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "nad/partiality-monad", "max_forks_repo_path": "src/Lambda/Partiality-monad/Inductive/Compiler-correctness.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "f69749280969f9093e5e13884c6feb0ad2506eae", "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/partiality-monad", "max_issues_repo_path": "src/Lambda/Partiality-monad/Inductive/Compiler-correctness.agda", "max_line_length": 145, "max_stars_count": 2, "max_stars_repo_head_hexsha": "f69749280969f9093e5e13884c6feb0ad2506eae", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "nad/partiality-monad", "max_stars_repo_path": "src/Lambda/Partiality-monad/Inductive/Compiler-correctness.agda", "max_stars_repo_stars_event_max_datetime": "2020-07-03T08:56:08.000Z", "max_stars_repo_stars_event_min_datetime": "2020-05-21T22:59:18.000Z", "num_tokens": 2416, "size": 6548 }
module BHeap.Properties {A : Set}(_≤_ : A → A → Set) where open import Bound.Lower A open import Bound.Lower.Order _≤_ open import BHeap _≤_ open import Data.List open import Data.Nat open import Data.Sum open import Nat.Sum open import List.Permutation.Base A open import List.Permutation.Base.Concatenation A open import List.Permutation.Base.Equivalence A open import List.Properties A open import Relation.Binary.Core open import Relation.Binary.PropositionalEquality lemma-merge-lf : {b : Bound}(tot≤ : Total _≤_)(h : BHeap b) → merge tot≤ h lf ≡ h lemma-merge-lf _ lf = refl lemma-merge-lf _ (nd b≤x l r) = refl lemma-merge# : {b : Bound}(tot≤ : Total _≤_)(l r : BHeap b) → # (merge tot≤ l r) ≡ # l + # r lemma-merge# _ lf r = refl lemma-merge# tot≤ l lf rewrite lemma-merge-lf tot≤ l \| +id (# l) = refl lemma-merge# tot≤ (nd {x = y} x≤y l r) (nd {x = y'} x≤y' l' r') with tot≤ y y' ... \| inj₁ y≤y' rewrite lemma-merge# tot≤ l r = refl ... \| inj₂ y'≤y rewrite lemma-merge# tot≤ l' r' \| +assoc (# l + # r) (# l' + # r') = refl lemma-merge≤′ : {b : Bound}{x : A}(tot≤ : Total _≤_)(b≤x : LeB b (val x))(l r : BHeap (val x)) → suc (# (merge tot≤ l r)) ≤′ # (nd b≤x l r) lemma-merge≤′ tot≤ b≤x l r rewrite lemma-merge# tot≤ l r = ≤′-refl lemma-merge∼ : {b : Bound}(tot≤ : Total _≤_)(l r : BHeap b) → flatten (merge tot≤ l r) ∼ (flatten l ++ flatten r) lemma-merge∼ _ lf r = refl∼ lemma-merge∼ tot≤ l lf rewrite lemma-merge-lf tot≤ l \| ++id (flatten l) = refl∼ lemma-merge∼ tot≤ (nd {x = y} b≤x l r) (nd {x = y'} b≤y' l' r') with tot≤ y y' ... \| inj₁ y≤y' = lemma++∼r (∼x /head /head (lemma-merge∼ tot≤ l r)) ... \| inj₂ y'≤y = trans∼ (lemma++∼l {xs = y' ∷ (y ∷ flatten l ++ flatten r)} (lemma-merge∼ tot≤ l' r')) (∼x /head (lemma++/ {xs = y ∷ flatten l ++ flatten r}) refl∼)	{ "alphanum_fraction": 0.6128133705, "avg_line_length": 46.0256410256, "ext": "agda", "hexsha": "33f3a49df229bde81e36210219064c5eb40fa071", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "bgbianchi/sorting", "max_forks_repo_path": "agda/BHeap/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/BHeap/Properties.agda", "max_line_length": 165, "max_stars_count": 6, "max_stars_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "bgbianchi/sorting", "max_stars_repo_path": "agda/BHeap/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": 731, "size": 1795 }
-- Andreas, 2012-10-30 Sections -- Reported by guillaume.brunerie, Oct 24 2012 module Issue735 where import Common.Level open import Common.Prelude using (Nat; zero; suc) {- I often want to use something like sections in Coq. I usually use parametrized modules but this has at least two issues that Coq does not have: 1) I need to give a name to the module, and there is often no meaningful name to be given 2) It exports the module, so I cannot define a module in another file with the same name I guess I can workaround 2) by declaring the module private, but this will mean that everything will be indented further (again) and I really want to avoid that. I think this can easily be fixed by adding a kind of anonymous modules. An anonymous module would be declared by naming it `_`, and the following code module _ params where declarations would be translated to: private module Fresh params where declarations open Fresh public where Fresh is a new name. -} -- Andreas: this translation is not necessary, because Agda -- has a concept of sections internally (in Abstract syntax). -- However, the translation and the actual implementation should -- have the same semantics, except that a name 'Fresh' is never generated. -- An empty section with no parameters module _ where -- A section with a non-hidden parameter module _ {a} (A : Set a) where data List : Set a where [] : List _∷_ : (x : A) (xs : List) → List -- A section with all hidden parameters module _ {a} {A : Set a} where _++_ : List A → List A → List A [] ++ ys = ys (x ∷ xs) ++ ys = x ∷ (xs ++ ys) module _ (default : A) where head : List A → A head [] = default head (x ∷ _) = x test : List Nat test = head 1 [] ∷ ((2 ∷ []) ++ (3 ∷ []))	{ "alphanum_fraction": 0.686285397, "avg_line_length": 24.6712328767, "ext": "agda", "hexsha": "91b4680ba4a294310f12cdad167339f664efa34a", "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/Issue735.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/Issue735.agda", "max_line_length": 74, "max_stars_count": 1989, "max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338", "max_stars_repo_licenses": [ "BSD-3-Clause" ], "max_stars_repo_name": "shlevy/agda", "max_stars_repo_path": "test/Succeed/Issue735.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": 488, "size": 1801 }
module ImpossiblePattern where f : ? f (_ _) = ?	{ "alphanum_fraction": 0.6153846154, "avg_line_length": 7.4285714286, "ext": "agda", "hexsha": "c2065e84749a61672340e4bd0904f03a971f3f08", "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/bugs/ImpossiblePattern.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/bugs/ImpossiblePattern.agda", "max_line_length": 30, "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/bugs/ImpossiblePattern.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": 14, "size": 52 }
open import Issue2959.M Set r : R r = ?	{ "alphanum_fraction": 0.6341463415, "avg_line_length": 8.2, "ext": "agda", "hexsha": "3666f9520a710b3afbf1c2e71c5e51dd3f793232", "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/Issue2959.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/Issue2959.agda", "max_line_length": 27, "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/Issue2959.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": 15, "size": 41 }
------------------------------------------------------------------------------ -- Example of a nested recursive function using the Agda standard -- library ------------------------------------------------------------------------------ {-# OPTIONS --exact-split #-} {-# OPTIONS --no-sized-types #-} {-# OPTIONS --no-universe-polymorphism #-} {-# OPTIONS --without-K #-} -- From: Ana Bove and Venanzio Capretta. Nested general recursion and -- partiality in type theory. vol 2152 LNCS. 2001. module FOT.FOTC.Program.Nest.NestSL where open import Data.Nat renaming (suc to succ) open import Relation.Binary.PropositionalEquality ------------------------------------------------------------------------------ {-# TERMINATING #-} nest : ℕ → ℕ nest 0 = 0 nest (succ n) = nest (nest n) {-# TERMINATING #-} nest-x≡0 : ∀ n → nest n ≡ zero nest-x≡0 zero = refl nest-x≡0 (succ n) = nest-x≡0 (nest n)	{ "alphanum_fraction": 0.4761904762, "avg_line_length": 31.5, "ext": "agda", "hexsha": "e2e9d5591910b897db1f4b5a07f80b4908e30a86", "lang": "Agda", "max_forks_count": 3, "max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z", "max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z", "max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "asr/fotc", "max_forks_repo_path": "notes/FOT/FOTC/Program/Nest/NestSL.agda", "max_issues_count": 2, "max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d", "max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z", "max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "asr/fotc", "max_issues_repo_path": "notes/FOT/FOTC/Program/Nest/NestSL.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": "notes/FOT/FOTC/Program/Nest/NestSL.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": 203, "size": 945 }
-- Andreas, 2022-03-09, issue #5819, reported by Zilin Chen -- -- This test uncovered an unsound optimization (8e0fca895b9c6740d9d6c1751ed1e0ecefe63473) -- in the termination checker which replaced a (stripAllProjections . normalize) -- by a (iteratively reduce . stripAllProjections). -- Those reductions on now ill-formed terms triggered the __IMPOSSIBLE__: -- Incomplete pattern matching when applying Issue5819.dl-iso open import Agda.Builtin.Unit using (⊤; tt) open import Agda.Builtin.Nat renaming (Nat to ℕ) open import Agda.Builtin.Equality open import Agda.Builtin.Sigma renaming (fst to proj₁; snd to proj₂) data ⊥ : Set where ∃ : {A : Set} (B : A → Set) → Set ∃ B = Σ _ B _×_ : (A B : Set) → Set A × B = Σ A λ _ → B sym : {A : Set} {x y : A} → x ≡ y → y ≡ x sym refl = refl _≢_ : {A : Set} (x y : A) → Set x ≢ y = x ≡ y → ⊥ record Inverse (A B : Set) : Set where field f : A → B f⁻¹ : B → A inverse : ∀ x → f (f⁻¹ x) ≡ x open Inverse data DList : Set Fresh : (a : ℕ) → (l : DList) → Set data DList where dnil : DList dcons : (a : ℕ) → (l : DList) → Fresh a l → DList Fresh a dnil = ⊤ Fresh a (dcons b l _) = (a ≢ b) × Fresh a l data List′ : Set where nil′ : List′ cons′ : ℕ → List′ → List′ Fresh′ : ℕ → List′ → Set Fresh′ a nil′ = ⊤ Fresh′ a (cons′ b l) = (a ≢ b) × Fresh′ a l AllFresh : List′ → Set AllFresh nil′ = ⊤ AllFresh (cons′ a l) = Fresh′ a l × AllFresh l data DList′ : List′ → Set → Set₁ where dnil′ : DList′ nil′ ⊤ dcons′ : ∀{l}{prf} → (a : ℕ) → DList′ l prf → DList′ (cons′ a l) (Fresh′ a l × prf) data DList″ : Set where dl″ : (l : List′) → AllFresh l → DList″ undl″-l : DList″ → List′ undl″-l (dl″ l _) = l undl″-p : DList″ → ∃ AllFresh undl″-p (dl″ l p) = l , p -- dl-iso : DList ↔ DList″ dl-iso : Inverse DList DList″ -- f-dl-iso : DList → DList″ -- g-dl-iso : DList″ → DList -- inverse-dl-iso : ∀ x → f-dl-iso (g-dl-iso x) ≡ x Fresh→Fresh′ : ∀{a}{l}{l″} → (f dl-iso l ≡ l″) → Fresh a l → Fresh′ a (undl″-l l″) Fresh→AllFresh : ∀{a}{l}{l″} → (f dl-iso l ≡ l″) → Fresh a l → AllFresh (undl″-l l″) All/Fresh′→Fresh : ∀{a}{l}{l″} → (l ≡ f⁻¹ dl-iso l″) → Fresh′ a (undl″-l l″) × AllFresh (undl″-l l″) → Fresh a l f dl-iso dnil = dl″ nil′ tt f dl-iso (dcons a l p) = dl″ (cons′ a (undl″-l (f dl-iso l))) ((Fresh→Fresh′ {l = l}{l″ = f dl-iso l} refl p) , (Fresh→AllFresh {a = a}{l = l}{l″ = f dl-iso l} refl p)) f⁻¹ dl-iso (dl″ nil′ p) = dnil f⁻¹ dl-iso (dl″ (cons′ a l′) p) = dcons a (f⁻¹ dl-iso (dl″ l′ (proj₂ p))) (All/Fresh′→Fresh {l″ = dl″ l′ (proj₂ p)} refl p) -- Can't do any further, otherwise an Agda bug occurs. inverse dl-iso x = invˡ where invˡ : ∀{x} → f dl-iso (f⁻¹ dl-iso x) ≡ x invˡ {dl″ nil′ _} = refl invˡ {dl″ (cons′ a l) p} rewrite invˡ {dl″ l {!!}} = {!!} -- add "rewrite invˡ {dl″ l ?}" (w/o quotes) to the left of the = sign and C-c C-l Fresh→Fresh′ {a} {dnil} eq p rewrite sym eq = tt Fresh→Fresh′ {a} {dcons a₁ l x} eq p rewrite sym eq = proj₁ p , Fresh→Fresh′ {l″ = f dl-iso l} refl (proj₂ p) Fresh→AllFresh {l = dnil} eq p rewrite sym eq = tt Fresh→AllFresh {l = dcons a l x} eq p rewrite sym eq = (Fresh→Fresh′ {l″ = f dl-iso l} refl x) , Fresh→AllFresh {a = a}{l = l}{l″ = f dl-iso l} refl x All/Fresh′→Fresh {a} {l″ = dl″ nil′ x} eq p rewrite eq = tt All/Fresh′→Fresh {a} {l″ = dl″ (cons′ b l) x} eq p rewrite eq = (proj₁ (proj₁ p)) , {!All/Fresh′→Fresh!} -- put "All/Fresh′→Fresh" in the hole and C-c C-r -- WAS: internal error in reduction machinery -- SHOULD: fail with termination error	{ "alphanum_fraction": 0.563299755, "avg_line_length": 29.6209677419, "ext": "agda", "hexsha": "a895809ccf0bcc4e46036d3418d93cea774c6d64", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75", "max_forks_repo_licenses": [ "BSD-2-Clause" ], "max_forks_repo_name": "KDr2/agda", "max_forks_repo_path": "test/Fail/Issue5819.agda", "max_issues_count": 6, "max_issues_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75", "max_issues_repo_issues_event_max_datetime": "2021-11-24T08:31:10.000Z", "max_issues_repo_issues_event_min_datetime": "2021-10-18T08:12:24.000Z", "max_issues_repo_licenses": [ "BSD-2-Clause" ], "max_issues_repo_name": "KDr2/agda", "max_issues_repo_path": "test/Fail/Issue5819.agda", "max_line_length": 143, "max_stars_count": null, "max_stars_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75", "max_stars_repo_licenses": [ "BSD-2-Clause" ], "max_stars_repo_name": "KDr2/agda", "max_stars_repo_path": "test/Fail/Issue5819.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 1509, "size": 3673 }
{-# OPTIONS --without-K #-} open import HoTT open import homotopy.HSpace module homotopy.EM1HSpace where module EM₁HSpace {i} (A : Group i) (A-abelian : is-abelian A) where module A = Group A open EM₁ A mult-loop : (g : A.El) (x : EM₁) → x == x mult-loop g = EM₁-elim {P = λ x → x == x} (λ _ → =-preserves-level _ emlevel) (emloop g) loop' (set-↓-has-all-paths-↓ (emlevel embase embase)) (λ _ _ → set-↓-has-all-paths-↓ (emlevel embase embase)) where abstract loop' : (g' : A.El) → emloop g == emloop g [ (λ x → x == x) ↓ emloop g' ] loop' g' = ↓-idf=idf-in $ emloop g ∙ emloop g' =⟨ ! (emloop-comp g g') ⟩ emloop (A.comp g g') =⟨ ap emloop (A-abelian g g') ⟩ emloop (A.comp g' g) =⟨ emloop-comp g' g ⟩ emloop g' ∙ emloop g =⟨ ∙=∙' (emloop g') (emloop g) ⟩ emloop g' ∙' emloop g ∎ mult-hom : GroupHom A (Ω^S-group 0 ((EM₁ → EM₁) , (λ x → x)) (Π-level (λ _ → emlevel))) mult-hom = record {f = f; pres-comp = pres-comp} where f = λ g → λ= (mult-loop g) pres-comp = λ g₁ g₂ → ap λ= (λ= (EM₁-elim {P = λ x → mult-loop (A.comp g₁ g₂) x == mult-loop g₁ x ∙ mult-loop g₂ x} (λ _ → =-preserves-level _ (=-preserves-level _ emlevel)) (emloop-comp g₁ g₂) (λ _ → prop-has-all-paths-↓ (emlevel _ _ _ _)) (set-↓-has-all-paths-↓ (=-preserves-level _ (emlevel _ _))) (λ _ _ → set-↓-has-all-paths-↓ (=-preserves-level _ (emlevel _ _))))) ∙ ! (∙-λ= _ _) mult : EM₁ → EM₁ → EM₁ mult = EM₁-rec {C = EM₁ → EM₁} (Π-level (λ _ → emlevel)) (λ x → x) mult-hom H-EM₁ : HSpaceStructure EM₁ H-EM₁ = record { e = embase; μ = mult; μ-e-l = μ-e-l; μ-e-r = μ-e-r; μ-coh = μ-coh } where μ-e-l : (x : EM₁) → mult embase x == x μ-e-l = EM₁-elim {P = λ x → mult embase x == x} (λ _ → =-preserves-level 1 emlevel) idp (λ g → ↓-app=idf-in $ ∙'-unit-l (emloop g) ∙ (! (ap-idf (emloop g))) ∙ ! (∙-unit-r (ap (mult embase) (emloop g)))) (set-↓-has-all-paths-↓ (emlevel _ _)) (λ _ _ → set-↓-has-all-paths-↓ (emlevel _ _)) μ-e-r : (x : EM₁) → mult x embase == x μ-e-r = EM₁-elim {P = λ x → mult x embase == x} (λ _ → =-preserves-level 1 emlevel) idp (λ g → ↓-app=idf-in $ idp ∙' emloop g =⟨ ∙'-unit-l (emloop g) ⟩ emloop g =⟨ ! (app=-β (mult-loop g) embase) ⟩ app= (λ= (mult-loop g)) embase =⟨ ! (EM₁Rec.emloop-β {C = EM₁ → EM₁} (Π-level (λ _ → emlevel)) (λ x → x) mult-hom g) \|in-ctx (λ w → app= w embase) ⟩ app= (ap mult (emloop g)) embase =⟨ ∘-ap (λ f → f embase) mult (emloop g) ⟩ ap (λ z → mult z embase) (emloop g) =⟨ ! (∙-unit-r (ap (λ z → mult z embase) (emloop g))) ⟩ ap (λ z → mult z embase) (emloop g) ∙ idp ∎) (set-↓-has-all-paths-↓ (emlevel _ _)) (λ _ _ → set-↓-has-all-paths-↓ (emlevel _ _)) μ-coh : μ-e-l embase == μ-e-r embase μ-coh = idp open HSpaceStructure H-EM₁	{ "alphanum_fraction": 0.488061127, "avg_line_length": 34.9, "ext": "agda", "hexsha": "ec1ae3f3d26b8382e9d4290538eee81466a0d825", "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/homotopy/EM1HSpace.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/homotopy/EM1HSpace.agda", "max_line_length": 86, "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/homotopy/EM1HSpace.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 1251, "size": 3141 }
------------------------------------------------------------------------ -- The Agda standard library -- -- Format strings for Printf and Scanf ------------------------------------------------------------------------ {-# OPTIONS --without-K --safe #-} module Text.Format where open import Level using (0ℓ) open import Category.Applicative open import Data.List.Base as List open import Data.Product open import Data.Product.Nary.NonDependent open import Data.Sum.Base import Data.Sum.Categorical.Left as Sumₗ open import Function open import Function.Nary.NonDependent using (0ℓs; Sets) open import Strict -- Formatted types open import Data.Char.Base open import Data.Integer.Base open import Data.Float open import Data.Nat.Base open import Data.String.Base ------------------------------------------------------------------------ -- Basic types data Chunk : Set where `ℕ `ℤ `Float `Char `String : Chunk Raw : String → Chunk Format : Set Format = List Chunk ------------------------------------------------------------------------ -- Semantics size : Format → ℕ size = List.sum ∘′ List.map λ { (Raw _) → 0; _ → 1 } -- Meaning of a format as a list of value types ⟦_⟧ : (fmt : Format) → Sets (size fmt) 0ℓs ⟦ [] ⟧ = _ ⟦ `ℕ ∷ cs ⟧ = ℕ , ⟦ cs ⟧ ⟦ `ℤ ∷ cs ⟧ = ℤ , ⟦ cs ⟧ ⟦ `Float ∷ cs ⟧ = Float , ⟦ cs ⟧ ⟦ `Char ∷ cs ⟧ = Char , ⟦ cs ⟧ ⟦ `String ∷ cs ⟧ = String , ⟦ cs ⟧ ⟦ Raw _ ∷ cs ⟧ = ⟦ cs ⟧ ------------------------------------------------------------------------ -- Lexer: from Strings to Formats -- Lexing may fail. To have a useful error message, we defined the following -- enumerated type data Error : Set where UnexpectedEndOfString : String → Error -- ^ expected a type declaration; found an empty string InvalidType : String → Char → String → Error -- ^ invalid type declaration -- return a focus: prefix processed, character causing failure, rest lexer : String → Error ⊎ List Chunk lexer input = loop [] [] (toList input) where open RawApplicative (Sumₗ.applicative Error 0ℓ) -- Type synonyms used locally to document the code RevWord = List Char -- Mere characters accumulated so far Prefix = RevWord -- Prefix of the input String already read toRevString : RevWord → String toRevString = fromList ∘′ reverse -- Push a Raw token if we have accumulated some mere characters push : RevWord → List Chunk → List Chunk push [] ks = ks push cs ks = Raw (toRevString cs) ∷ ks -- Main loop loop : RevWord → Prefix → List Char → Error ⊎ List Chunk type : Prefix → List Char → Error ⊎ List Chunk loop acc bef [] = pure (push acc []) -- escaped '%' character: treat like a mere character loop acc bef ('%' ∷ '%' ∷ cs) = loop ('%' ∷ acc) ('%' ∷ '%' ∷ bef) cs -- non escaped '%': type declaration following loop acc bef ('%' ∷ cs) = push acc <$> type ('%' ∷ bef) cs -- mere character: push onto the accumulator loop acc bef (c ∷ cs) = loop (c ∷ acc) (c ∷ bef) cs type bef [] = inj₁ (UnexpectedEndOfString input) type bef (c ∷ cs) = _∷_ <$> chunk c ⊛ loop [] (c ∷ bef) cs where chunk : Char → Error ⊎ Chunk chunk 'd' = pure `ℤ chunk 'i' = pure `ℤ chunk 'u' = pure `ℕ chunk 'f' = pure `Float chunk 'c' = pure `Char chunk 's' = pure `String chunk _ = force′ (toRevString bef) $′ λ prefix → force′ (fromList cs) $′ λ suffix → inj₁ (InvalidType prefix c suffix)	{ "alphanum_fraction": 0.5612332287, "avg_line_length": 31.5585585586, "ext": "agda", "hexsha": "3c2b9cd2f8a80efedd194ce0ec20da6ded6a5eab", "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": "agda-stdlib/src/Text/Format.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": "agda-stdlib/src/Text/Format.agda", "max_line_length": 76, "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": "agda-stdlib/src/Text/Format.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": 961, "size": 3503 }
------------------------------------------------------------------------------ -- Testing Agsy without using the Agda standard library ------------------------------------------------------------------------------ {-# OPTIONS --allow-unsolved-metas #-} {-# OPTIONS --exact-split #-} {-# OPTIONS --no-sized-types #-} {-# OPTIONS --no-universe-polymorphism #-} {-# OPTIONS --without-K #-} -- Tested with the development version of Agda on 15 June 2012. module FOT.Agsy.NoStd.AgsyNoStd where -- The equational reasoning from the Agda standard library 0.8.1. -- open import Relation.Binary.PropositionalEquality -- open ≡-Reasoning -- My equational reasoning. open import FOT.Agsy.NoStd.MyPropositionalEquality open ≡-Reasoning -- We add 3 to the fixities of the Agda standard library 0.8.1 (see -- Data/Nat.agda). infixl 9 _+_ ------------------------------------------------------------------------------ data ℕ : Set where zero : ℕ suc : ℕ → ℕ _+_ : ℕ → ℕ → ℕ zero + n = n suc m + n = suc (m + n) +-assoc : ∀ m n o → m + n + o ≡ m + (n + o) +-assoc zero n o = refl -- via Agsy +-assoc (suc m) n o = {!!} -- Agsy fails using my propositional equality	{ "alphanum_fraction": 0.5074135091, "avg_line_length": 30.35, "ext": "agda", "hexsha": "9e790ecaf60db73c770b6d5316628b495363872e", "lang": "Agda", "max_forks_count": 3, "max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z", "max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z", "max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "asr/fotc", "max_forks_repo_path": "notes/FOT/Agsy/NoStd/AgsyNoStd.agda", "max_issues_count": 2, "max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d", "max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z", "max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "asr/fotc", "max_issues_repo_path": "notes/FOT/Agsy/NoStd/AgsyNoStd.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": "notes/FOT/Agsy/NoStd/AgsyNoStd.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": 304, "size": 1214 }
module Tactic.Nat.Subtract.Simplify where open import Prelude hiding (abs) open import Builtin.Reflection open import Tactic.Reflection.Quote open import Tactic.Reflection open import Control.Monad.State open import Tactic.Nat.Reflect open import Tactic.Nat.NF open import Tactic.Nat.Exp open import Tactic.Nat.Auto open import Tactic.Nat.Auto.Lemmas open import Tactic.Nat.Simpl.Lemmas open import Tactic.Nat.Simpl open import Tactic.Nat.Reflect open import Tactic.Nat.Subtract.Exp open import Tactic.Nat.Subtract.Reflect open import Tactic.Nat.Subtract.Lemmas open import Tactic.Nat.Less.Lemmas simplifySubEqn : ∀ eqn ρ → c⟦ eqn ⟧eqn ρ → ⟦ eqn ⟧eqn ρ simplifySubEqn (a :≡ b) = simplifySubEq a b simplifySubEqn (a :< b) = simplifySubLess a b complicateSubEqn : ∀ eqn ρ → ⟦ eqn ⟧eqn ρ → c⟦ eqn ⟧eqn ρ complicateSubEqn (a :≡ b) = complicateSubEq a b complicateSubEqn (a :< b) = complicateSubLess a b ⟦_⟧sh : List Eqn → Env Var → Set ⟦ [] ⟧sh ρ = ⊥ ⟦ h ∷ [] ⟧sh ρ = ⟦ h ⟧eqn ρ ⟦ h ∷ g ⟧sh ρ = ⟦ h ⟧eqn ρ → ⟦ g ⟧sh ρ ⟦_⟧shs : List Eqn → Env Var → Set ⟦ [] ⟧shs ρ = ⊥ ⟦ h ∷ [] ⟧shs ρ = c⟦ h ⟧eqn ρ ⟦ h ∷ g ⟧shs ρ = c⟦ h ⟧eqn ρ → ⟦ g ⟧shs ρ simplifySubH : ∀ goal ρ → ⟦ goal ⟧shs ρ → ⟦ goal ⟧sh ρ simplifySubH [] ρ () simplifySubH (h ∷ []) ρ H = simplifySubEqn h ρ H simplifySubH (h ∷ h₂ ∷ g) ρ H = λ H₁ → simplifySubH (h₂ ∷ g) ρ $ H (complicateSubEqn h ρ H₁) simplifysub-tactic : Term → Type → TC Term simplifysub-tactic prf g = inferType prf >>= λ h → let t = pi (vArg h) (abs "_" (weaken 1 g)) in caseM termToSubHyps t of λ { nothing → pure $ failedProof (quote invalidGoal) t ; (just (goal , Γ)) → pure $ def (quote flip) $ vArg (def (quote simplifySubH) ( vArg (` goal) ∷ vArg (quotedEnv Γ) ∷ [] )) ∷ vArg prf ∷ [] } simplifygoal-tactic : Type → TC Term simplifygoal-tactic t = caseM termToSubHyps t of λ { nothing → pure $ failedProof (quote invalidGoal) t ; (just (goal , Γ)) → pure $ def (quote simplifySubH) $ vArg (` goal) ∷ vArg (quotedEnv Γ) ∷ [] }	{ "alphanum_fraction": 0.6319543509, "avg_line_length": 29.6197183099, "ext": "agda", "hexsha": "64029d5388ceee8b6c1742ff42bb260f8ebb43f7", "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/Tactic/Nat/Subtract/Simplify.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/Tactic/Nat/Subtract/Simplify.agda", "max_line_length": 92, "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/Tactic/Nat/Subtract/Simplify.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": 827, "size": 2103 }
{-# OPTIONS --safe --experimental-lossy-unification #-} module Cubical.ZCohomology.Groups.WedgeOfSpheres where open import Cubical.Foundations.Prelude open import Cubical.Foundations.Isomorphism open import Cubical.Data.Sigma.Base open import Cubical.ZCohomology.Base open import Cubical.ZCohomology.GroupStructure open import Cubical.ZCohomology.Groups.Unit open import Cubical.ZCohomology.Groups.Sn open import Cubical.ZCohomology.Groups.Wedge open import Cubical.ZCohomology.Groups.Connected open import Cubical.Data.Int renaming (_+_ to _ℤ+_) open import Cubical.HITs.Sn open import Cubical.HITs.S1 open import Cubical.HITs.Susp open import Cubical.HITs.Wedge open import Cubical.HITs.Pushout open import Cubical.HITs.Truncation renaming (elim to trElim) hiding (map ; elim2) open import Cubical.Algebra.Group renaming (ℤ to ℤGroup ; Bool to BoolGroup ; Unit to UnitGroup) open import Cubical.HITs.SetTruncation renaming (rec to sRec ; rec2 to sRec2 ; elim to sElim) S¹⋁S¹ : Type₀ S¹⋁S¹ = S₊∙ 1 ⋁ S₊∙ 1 S²⋁S¹⋁S¹ : Type₀ S²⋁S¹⋁S¹ = S₊∙ 2 ⋁ (S¹⋁S¹ , inl base) ------------- H⁰(S¹⋁S¹) ------------ H⁰-S¹⋁S¹ : GroupIso (coHomGr 0 S¹⋁S¹) ℤGroup H⁰-S¹⋁S¹ = H⁰-connected (inl base) (wedgeConnected _ _ (Sn-connected 0) (Sn-connected 0)) ------------- H¹(S¹⋁S¹) ------------ H¹-S¹⋁S¹ : GroupIso (coHomGr 1 S¹⋁S¹) (DirProd ℤGroup ℤGroup) H¹-S¹⋁S¹ = (Hⁿ-⋁ _ _ 0) □ GroupIsoDirProd coHom1S1≃ℤ coHom1S1≃ℤ ------------- H⁰(S²⋁S¹⋁S¹) --------- H⁰-S²⋁S¹⋁S¹ : GroupIso (coHomGr 0 S²⋁S¹⋁S¹) ℤGroup H⁰-S²⋁S¹⋁S¹ = H⁰-connected (inl north) (wedgeConnected _ _ (Sn-connected 1) (wedgeConnected _ _ (Sn-connected 0) (Sn-connected 0))) ------------- H¹(S²⋁S¹⋁S¹) --------- H¹-S²⋁S¹⋁S¹ : GroupIso (coHomGr 1 S²⋁S¹⋁S¹) (DirProd ℤGroup ℤGroup) H¹-S²⋁S¹⋁S¹ = Hⁿ-⋁ (S₊∙ 2) (S¹⋁S¹ , inl base) 0 □ GroupIsoDirProd (H¹-Sⁿ≅0 0) H¹-S¹⋁S¹ □ lUnitGroupIso ------------- H²(S²⋁S¹⋁S¹) --------- H²-S²⋁S¹⋁S¹ : GroupIso (coHomGr 2 S²⋁S¹⋁S¹) ℤGroup H²-S²⋁S¹⋁S¹ = compGroupIso (Hⁿ-⋁ _ _ 1) (GroupIsoDirProd {B = UnitGroup} (Hⁿ-Sⁿ≅ℤ 1) ((Hⁿ-⋁ _ _ 1) □ GroupIsoDirProd (Hⁿ-S¹≅0 0) (Hⁿ-S¹≅0 0) □ rUnitGroupIso) □ rUnitGroupIso) private open IsGroupHom open Iso to₂ : coHom 2 S²⋁S¹⋁S¹ → ℤ to₂ = fun (fst H²-S²⋁S¹⋁S¹) from₂ : ℤ → coHom 2 S²⋁S¹⋁S¹ from₂ = inv (fst H²-S²⋁S¹⋁S¹) to₁ : coHom 1 S²⋁S¹⋁S¹ → ℤ × ℤ to₁ = fun (fst H¹-S²⋁S¹⋁S¹) from₁ : ℤ × ℤ → coHom 1 S²⋁S¹⋁S¹ from₁ = inv (fst H¹-S²⋁S¹⋁S¹) to₀ : coHom 0 S²⋁S¹⋁S¹ → ℤ to₀ = fun (fst H⁰-S²⋁S¹⋁S¹) from₀ : ℤ → coHom 0 S²⋁S¹⋁S¹ from₀ = inv (fst H⁰-S²⋁S¹⋁S¹) {- -- Compute pretty fast test1 : to₁ (from₁ (1 , 0) +ₕ from₁ (0 , 1)) ≡ (1 , 1) test1 = refl -- Computes, but only when computing some smaller numbers first test2 : to₁ (from₁ (50 , 3) +ₕ from₁ (2 , -2)) ≡ (52 , 1) test2 = refl test3 : to₂ (from₂ 0) ≡ 0 test3 = refl test4 : to₂ (from₂ 3) ≡ 3 test4 = refl test5 : to₂ (from₂ 1 +ₕ from₂ 1) ≡ 2 test5 = refl -} g : S²⋁S¹⋁S¹ → ∥ Susp S¹ ∥ 4 g (inl x) = ∣ x ∣ g (inr x) = 0ₖ _ g (push a i) = 0ₖ _ G = ∣ g ∣₂ {- Does not compute: test₀ : to₂ (G +ₕ G) ≡ 2 test₀ = refl but this does: test₀ : to₂ (G +'ₕ G) ≡ 2 test₀ = refl -}	{ "alphanum_fraction": 0.6269718528, "avg_line_length": 26.9416666667, "ext": "agda", "hexsha": "cdc616371c53fd4503a63a624e1bc1e46ec202c6", "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/ZCohomology/Groups/WedgeOfSpheres.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/ZCohomology/Groups/WedgeOfSpheres.agda", "max_line_length": 96, "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/ZCohomology/Groups/WedgeOfSpheres.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 1586, "size": 3233 }
------------------------------------------------------------------------ -- Vectors, defined as functions from finite sets ------------------------------------------------------------------------ {-# OPTIONS --without-K --safe #-} open import Equality module Vec.Function {reflexive} (eq : ∀ {a p} → Equality-with-J a p reflexive) where open import Prelude open import Bijection eq using (_↔_) open Derived-definitions-and-properties eq open import Function-universe eq hiding (id; _∘_) open import List eq using (length) open import Surjection eq using (_↠_; ↠-≡) private variable a : Level A B : Type a n : ℕ k : Kind ------------------------------------------------------------------------ -- The type -- Vectors. Vec : ∀ {a} → Type a → ℕ → Type a Vec A n = Fin n → A -- Nil. nil : Vec A zero nil = λ () -- Cons. cons : A → Vec A n → Vec A (suc n) cons x xs = [ const x , xs ] ------------------------------------------------------------------------ -- Some simple functions -- Finds the element at the given position. index : Vec A n → Fin n → A index = id -- Applies the function to every element in the vector. map : (A → B) → Vec A n → Vec B n map f xs = f ∘ xs -- Constructs a vector containing a certain number of copies of the -- given element. replicate : A → Vec A n replicate = const -- The head of the vector. head : Vec A (suc n) → A head = _$ fzero -- The tail of the vector. tail : Vec A (suc n) → Vec A n tail = _∘ fsuc -- Updates the element at the given position. infix 3 _[_≔_] _[_≔_] : Vec A n → Fin n → A → Vec A n _[_≔_] {n = zero} _ () _ _[_≔_] {n = suc _} xs fzero x = cons x (tail xs) _[_≔_] {n = suc _} xs (fsuc i) x = cons (head xs) (tail xs [ i ≔ x ]) ------------------------------------------------------------------------ -- Some properties -- Empty lists are equal to nil (assuming extensionality). empty≡nil : {A : Type a} → Extensionality lzero a → {xs : Vec A zero} → xs ≡ nil empty≡nil ext = apply-ext ext λ () -- A non-empty list is equal to its head consed onto its tail -- (assuming extensionality). non-empty≡cons-head-tail : {A : Type a} → Extensionality lzero a → (xs : Vec A (suc n)) → xs ≡ cons (head xs) (tail xs) non-empty≡cons-head-tail ext _ = apply-ext ext [ (λ _ → refl _) , (λ _ → refl _) ] ------------------------------------------------------------------------ -- Conversions to and from lists -- Vectors can be converted to lists. to-list : Vec A n → List A to-list {n = zero} _ = [] to-list {n = suc _} xs = head xs ∷ to-list (tail xs) -- Lists can be converted to vectors. from-list : (xs : List A) → Vec A (length xs) from-list [] = nil from-list (x ∷ xs) = cons x (from-list xs) -- There is a split surjection from ∃ (Vec A) to List A. ∃Vec↠List : ∃ (Vec A) ↠ List A ∃Vec↠List {A = A} = record { logical-equivalence = record { to = to-list ∘ proj₂ ; from = λ xs → length xs , from-list xs } ; right-inverse-of = to∘from } where to∘from : (xs : List A) → to-list (from-list xs) ≡ xs to∘from [] = refl _ to∘from (x ∷ xs) = cong (x ∷_) (to∘from xs) -- ∃ (Vec A) is equivalent to List A (assuming extensionality). ∃Vec≃List : {A : Type a} → ∃ (Vec A) ↝[ lzero ∣ a ] List A ∃Vec≃List {a = a} {A = A} = generalise-ext? (_↠_.logical-equivalence ∃Vec↠List) (λ ext → _↠_.right-inverse-of ∃Vec↠List , uncurry (from∘to ext)) where tail′ : A → ∃ (Vec A) ↠ ∃ (Vec A) tail′ y = record { logical-equivalence = record { to = λ where (suc n , xs) → n , tail xs xs@(zero , _) → xs ; from = Σ-map suc (cons y) } ; right-inverse-of = refl } from∘to : Extensionality lzero a → ∀ n (xs : Vec A n) → (length (to-list xs) , from-list (to-list xs)) ≡ (n , xs) from∘to ext zero xs = (length {A = A} [] , nil) ≡⟨ cong (zero ,_) $ sym $ empty≡nil ext ⟩∎ (zero , xs) ∎ from∘to ext (suc n) xs = $⟨ from∘to ext n (tail xs) ⟩ (length (to-list (tail xs)) , from-list (to-list (tail xs))) ≡ (n , tail xs) ↝⟨ _↠_.from $ ↠-≡ (tail′ (head xs)) ⟩ (length (to-list xs) , from-list (to-list xs)) ≡ (suc n , cons (head xs) (tail xs)) ↝⟨ ≡⇒↝ _ $ cong (λ ys → (_ , from-list (to-list xs)) ≡ (_ , ys)) $ sym $ non-empty≡cons-head-tail ext xs ⟩□ (length (to-list xs) , from-list (to-list xs)) ≡ (suc n , xs) □	{ "alphanum_fraction": 0.4867690994, "avg_line_length": 26.1787709497, "ext": "agda", "hexsha": "ba4c909f716c68e3a04298ca1944e81686770f33", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "nad/equality", "max_forks_repo_path": "src/Vec/Function.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "nad/equality", "max_issues_repo_path": "src/Vec/Function.agda", "max_line_length": 138, "max_stars_count": 3, "max_stars_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "nad/equality", "max_stars_repo_path": "src/Vec/Function.agda", "max_stars_repo_stars_event_max_datetime": "2021-09-02T17:18:15.000Z", "max_stars_repo_stars_event_min_datetime": "2020-05-21T22:58:50.000Z", "num_tokens": 1453, "size": 4686 }
{-# OPTIONS --without-K --rewriting #-} open import HoTT import homotopy.ConstantToSetExtendsToProp as ConstExt {- q[_]ᴳ G/Q ↞------ G ↑ ↑ φ₂ ╎ ╎ inject ↑ ↑ H ↞------- P φ₁ Then, H ≃ᴳ P/Q. -} module groups.PropQuotUniqueFactorization {i j l₁ l₂} {G : Group i} {H : Group j} (P : SubgroupProp G l₁) (Q : NormalSubgroupProp G l₂) (φ₁ : Subgroup P →ᴳ H) (φ₁-is-surj : is-surjᴳ φ₁) (φ₂ : H →ᴳ QuotGroup Q) (φ₂-is-inj : is-injᴳ φ₂) (φ-comm : ∀ p → GroupHom.f (φ₂ ∘ᴳ φ₁) p == q[ fst p ]) where private module G = Group G module H = Group H module P = Subgroup P module φ₁ = GroupHom φ₁ module φ₂ = GroupHom φ₂ P/Q-prop : NormalSubgroupProp (Subgroup P) l₂ P/Q-prop = quot-of-sub P Q P/Q : Group (lmax i (lmax l₁ l₂)) P/Q = QuotGroup P/Q-prop module P/Q = Group P/Q module _ (k : Group.El H) where H-to-P/Q-f' : hfiber φ₁.f k → P/Q.El H-to-P/Q-f' (p , _) = q[ p ] abstract H-to-P/Q-f'-const : (hf₁ hf₂ : hfiber φ₁.f k) → H-to-P/Q-f' hf₁ == H-to-P/Q-f' hf₂ H-to-P/Q-f'-const (h₁ , r₁) (h₂ , r₂) = quot-relᴳ {P = P/Q-prop} $ <– (quot-relᴳ-equiv {P = Q}) $ ! (φ-comm h₁) ∙ ap φ₂.f (r₁ ∙ ! r₂) ∙ φ-comm h₂ module HToP/Q = ConstExt P/Q.El-is-set H-to-P/Q-f' H-to-P/Q-f'-const H-to-P/Q-f : Trunc -1 (hfiber φ₁.f k) → P/Q.El H-to-P/Q-f = HToP/Q.ext H-to-P/Q-f-is-const : ∀ hf₁ hf₂ → H-to-P/Q-f hf₁ == H-to-P/Q-f hf₂ H-to-P/Q-f-is-const = HToP/Q.ext-is-const abstract H-to-P/Q-f-comp : (k₁ k₂ : H.El) → (hf₁₂ : Trunc -1 (hfiber φ₁.f (H.comp k₁ k₂))) → (hf₁ : Trunc -1 (hfiber φ₁.f k₁)) → (hf₂ : Trunc -1 (hfiber φ₁.f k₂)) → H-to-P/Q-f (H.comp k₁ k₂) hf₁₂ == P/Q.comp (H-to-P/Q-f k₁ hf₁) (H-to-P/Q-f k₂ hf₂) H-to-P/Q-f-comp k₁ k₂ hf₁₂ = Trunc-elim (λ hf₁ → Π-is-prop λ hf₂ → P/Q.El-is-set _ (P/Q.comp (H-to-P/Q-f k₁ hf₁) (H-to-P/Q-f k₂ hf₂))) (λ{(p₁ , r₁) → Trunc-elim (λ hf₂ → P/Q.El-is-set _ (P/Q.comp q[ p₁ ] (H-to-P/Q-f k₂ hf₂))) (λ{(p₂ , r₂) → H-to-P/Q-f-is-const (H.comp k₁ k₂) hf₁₂ [ P.comp p₁ p₂ , φ₁.pres-comp p₁ p₂ ∙ ap2 H.comp r₁ r₂ ]})}) H-to-P/Q : H →ᴳ P/Q H-to-P/Q = record { f = λ k → H-to-P/Q-f k (φ₁-is-surj k); pres-comp = λ k₁ k₂ → H-to-P/Q-f-comp k₁ k₂ (φ₁-is-surj (H.comp k₁ k₂)) (φ₁-is-surj k₁) (φ₁-is-surj k₂)} H-iso-P/Q : H ≃ᴳ P/Q H-iso-P/Q = H-to-P/Q , is-eq to from to-from from-to where to : H.El → P/Q.El to = λ k → H-to-P/Q-f k (φ₁-is-surj k) from : P/Q.El → H.El from = SetQuot-rec H.El-is-set (λ p → φ₁.f p) (λ {p₁} {p₂} q'p₁p₂⁻¹ → φ₂-is-inj (φ₁.f p₁) (φ₁.f p₂) $ φ-comm p₁ ∙ quot-relᴳ {P = Q} q'p₁p₂⁻¹ ∙ ! (φ-comm p₂)) abstract to-from : ∀ p/q → to (from p/q) == p/q to-from = SetQuot-elim (λ p/q → raise-level -1 $ P/Q.El-is-set _ p/q) (λ p → H-to-P/Q-f-is-const (φ₁.f p) (φ₁-is-surj (φ₁.f p)) [ p , idp ]) (λ _ → prop-has-all-paths-↓ $ P/Q.El-is-set _ _) from-to' : ∀ k (hf : Trunc -1 (hfiber φ₁.f k)) → from (H-to-P/Q-f k hf) == k from-to' k = Trunc-elim (λ hf → H.El-is-set (from (H-to-P/Q-f k hf)) k) (λ{(p , r) → r}) from-to : ∀ k → from (to k) == k from-to k = from-to' k (φ₁-is-surj k)	{ "alphanum_fraction": 0.4952857985, "avg_line_length": 32.9514563107, "ext": "agda", "hexsha": "e61e98d5fb6d521b1836a9fdd4072bdda7c9c2fe", "lang": "Agda", "max_forks_count": 1, "max_forks_repo_forks_event_max_datetime": "2018-12-26T21:31:57.000Z", "max_forks_repo_forks_event_min_datetime": "2018-12-26T21:31:57.000Z", "max_forks_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "mikeshulman/HoTT-Agda", "max_forks_repo_path": "theorems/groups/PropQuotUniqueFactorization.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "mikeshulman/HoTT-Agda", "max_issues_repo_path": "theorems/groups/PropQuotUniqueFactorization.agda", "max_line_length": 94, "max_stars_count": null, "max_stars_repo_head_hexsha": "e7d663b63d89f380ab772ecb8d51c38c26952dbb", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "mikeshulman/HoTT-Agda", "max_stars_repo_path": "theorems/groups/PropQuotUniqueFactorization.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 1432, "size": 3394 }
{-# OPTIONS --safe --without-K #-} open import Generics.Prelude open import Generics.Telescope open import Generics.Desc open import Agda.Builtin.Reflection module Generics.Helpers P I {levelArgRel : Level → Level} (ArgRel : ∀ {a} → Set a → Set (levelArgRel a)) {levelArgIrr : Level → Level} (ArgIrr : ∀ {a} → Set a → Set (levelArgIrr a)) (Ind : ∀ {V} (C : ConDesc P V I) → Setω) where data ConHelper p {V} : ConDesc P V I → Setω where instance var : ∀ {f} → ConHelper p (var f) pi-irr : ∀ {ℓ n v q} {S : ⟦ P , V ⟧xtel → Set ℓ} (let ai = n , arg-info v (modality irrelevant q)) {C : ConDesc P (V ⊢< ai > S) I} → ⦃ ∀ {v} → ArgIrr (S (p , v)) ⦄ → ⦃ ConHelper p C ⦄ → ConHelper p (π ai S C) pi-rel : ∀ {ℓ n v q} {S : ⟦ P , V ⟧xtel → Set ℓ} (let ai = n , arg-info v (modality relevant q)) {C : ConDesc P (V ⊢< ai > S) I} → ⦃ ∀ {v} → ArgRel (S (p , v)) ⦄ → ⦃ ConHelper p C ⦄ → ConHelper p (π ai S C) prod : {A B : ConDesc P V I} → ⦃ Ind A ⦄ → ⦃ ConHelper p B ⦄ → ConHelper p (A ⊗ B) data Helpers p : {n : ℕ} → DataDesc P I n → Setω where instance nil : Helpers p [] cons : ∀ {n} {C : ConDesc P ε I} {D : DataDesc P I n} → ⦃ ConHelper p C ⦄ → ⦃ Helpers p D ⦄ → Helpers p (C ∷ D) lookupHelper : ∀ {n} {D : DataDesc P I n} {p} (HD : Helpers p D) (k : Fin n) → ConHelper p (lookupCon D k) lookupHelper (cons ⦃ HC ⦄ ⦃ HD ⦄) zero = HC lookupHelper (cons ⦃ HC ⦄ ⦃ HD ⦄) (suc k) = lookupHelper HD k	{ "alphanum_fraction": 0.402281746, "avg_line_length": 36.6545454545, "ext": "agda", "hexsha": "bc3419170d682e1fbca649d177884c4a61d506b3", "lang": "Agda", "max_forks_count": 3, "max_forks_repo_forks_event_max_datetime": "2022-01-14T10:35:16.000Z", "max_forks_repo_forks_event_min_datetime": "2021-04-08T08:32:42.000Z", "max_forks_repo_head_hexsha": "db764f858d908aa39ea4901669a6bbce1525f757", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "flupe/generics", "max_forks_repo_path": "src/Generics/Helpers.agda", "max_issues_count": 4, "max_issues_repo_head_hexsha": "db764f858d908aa39ea4901669a6bbce1525f757", "max_issues_repo_issues_event_max_datetime": "2022-01-14T10:48:30.000Z", "max_issues_repo_issues_event_min_datetime": "2021-09-13T07:33:50.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "flupe/generics", "max_issues_repo_path": "src/Generics/Helpers.agda", "max_line_length": 71, "max_stars_count": 11, "max_stars_repo_head_hexsha": "db764f858d908aa39ea4901669a6bbce1525f757", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "flupe/generics", "max_stars_repo_path": "src/Generics/Helpers.agda", "max_stars_repo_stars_event_max_datetime": "2022-02-05T09:35:17.000Z", "max_stars_repo_stars_event_min_datetime": "2021-04-08T15:10:20.000Z", "num_tokens": 641, "size": 2016 }
open import Common.Prelude hiding (_>>=_) open import Common.Reflection open import Common.Equality set₀ = sort (lit 0) set! = sort unknown -- Definitions added by tactics always use the original context, and thus are not -- affected by inContext and extendContext. The reason for this is that they are added -- to the module of the macro call, so they need to live in the context of that module -- or things break. freshFun : Type → List Clause → Tactic freshFun t cs hole = freshName "fresh" >>= λ n → inContext [] (define (vArg n) (funDef t cs)) >>= λ _ → unify hole (def n []) macro ack : Tactic ack = freshFun set! (clause [] set₀ ∷ []) theA : Tactic theA = freshFun set₀ (clause [] (var 0 []) ∷ []) module Foo (A : Set) where foo : Set foo = theA bar : Set₁ bar = ack check : {A : Set} → Foo.foo A ≡ A check = refl	{ "alphanum_fraction": 0.6643192488, "avg_line_length": 23.6666666667, "ext": "agda", "hexsha": "faf01473ca1f767f408bffc146614ea05a8b1d1f", "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/Issue1827.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/Issue1827.agda", "max_line_length": 86, "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/Issue1827.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": 254, "size": 852 }
{-# OPTIONS --universe-polymorphism #-} module Categories.NaturalTransformation.Core where open import Level open import Relation.Binary using (Rel; IsEquivalence) open import Categories.Support.Equivalence open import Categories.Category open import Categories.Functor.Core renaming (id to idF; _∘_ to _∘F_) record NaturalTransformation {o ℓ e o′ ℓ′ e′} {C : Category o ℓ e} {D : Category o′ ℓ′ e′} (F G : Functor C D) : Set (o ⊔ ℓ ⊔ e ⊔ o′ ⊔ ℓ′ ⊔ e′) where private module C = Category C private module D = Category D private module F = Functor F private module G = Functor G open F using (F₀; F₁) open G using () renaming (F₀ to G₀; F₁ to G₁) field η : ∀ X → D [ F₀ X , G₀ X ] .commute : ∀ {X Y} (f : C [ X , Y ]) → D.CommutativeSquare (F₁ f) (η X) (η Y) (G₁ f) op : NaturalTransformation G.op F.op op = record { η = η ; commute = λ f → D.Equiv.sym (commute f) } id : ∀ {o ℓ e o′ ℓ′ e′} {C : Category o ℓ e} {D : Category o′ ℓ′ e′} {F : Functor C D} → NaturalTransformation F F id {C = C} {D} {F} = record { η = λ _ → D.id ; commute = commute′ } where module C = Category C module D = Category D module F = Functor F open F .commute′ : ∀ {X Y} (f : C [ X , Y ]) → D [ D [ D.id ∘ F₁ f ] ≡ D [ F₁ f ∘ D.id ] ] commute′ f = begin D [ D.id ∘ F₁ f ] ↓⟨ D.identityˡ ⟩ F₁ f ↑⟨ D.identityʳ ⟩ D [ F₁ f ∘ D.id ] ∎ where open D.HomReasoning infixr 9 _∘₁_ _∘₀_ -- "Vertical composition" _∘₁_ : ∀ {o₀ ℓ₀ e₀ o₁ ℓ₁ e₁} {C : Category o₀ ℓ₀ e₀} {D : Category o₁ ℓ₁ e₁} {F G H : Functor C D} → NaturalTransformation G H → NaturalTransformation F G → NaturalTransformation F H _∘₁_ {C = C} {D} {F} {G} {H} X Y = record { η = λ q → D [ X.η q ∘ Y.η q ] ; commute = commute′ } where module C = Category C module D = Category D module F = Functor F module G = Functor G module H = Functor H module X = NaturalTransformation X module Y = NaturalTransformation Y open F open G renaming (F₀ to G₀; F₁ to G₁) open H renaming (F₀ to H₀; F₁ to H₁) .commute′ : ∀ {A B} (f : C [ A , B ]) → D [ D [ D [ X.η B ∘ Y.η B ] ∘ F₁ f ] ≡ D [ H₁ f ∘ D [ X.η A ∘ Y.η A ] ] ] commute′ {A} {B} f = begin D [ D [ X.η B ∘ Y.η B ] ∘ F₁ f ] ↓⟨ D.assoc ⟩ D [ X.η B ∘ D [ Y.η B ∘ F₁ f ] ] ↓⟨ D.∘-resp-≡ʳ (Y.commute f) ⟩ D [ X.η B ∘ D [ G₁ f ∘ Y.η A ] ] ↑⟨ D.assoc ⟩ D [ D [ X.η B ∘ G₁ f ] ∘ Y.η A ] ↓⟨ D.∘-resp-≡ˡ (X.commute f) ⟩ D [ D [ H₁ f ∘ X.η A ] ∘ Y.η A ] ↓⟨ D.assoc ⟩ D [ H₁ f ∘ D [ X.η A ∘ Y.η A ] ] ∎ where open D.HomReasoning -- "Horizontal composition" _∘₀_ : ∀ {o₀ ℓ₀ e₀ o₁ ℓ₁ e₁ o₂ ℓ₂ e₂} {C : Category o₀ ℓ₀ e₀} {D : Category o₁ ℓ₁ e₁} {E : Category o₂ ℓ₂ e₂} {F G : Functor C D} {H I : Functor D E} → NaturalTransformation H I → NaturalTransformation F G → NaturalTransformation (H ∘F F) (I ∘F G) _∘₀_ {C = C} {D} {E} {F} {G} {H} {I} Y X = record { η = λ q → E [ I₁ (X.η q) ∘ Y.η (F₀ q) ] ; commute = commute′ } where module C = Category C module D = Category D module E = Category E module F = Functor F module G = Functor G module H = Functor H module I = Functor I module X = NaturalTransformation X module Y = NaturalTransformation Y open F open G renaming (F₀ to G₀; F₁ to G₁; F-resp-≡ to G-resp-≡) open H renaming (F₀ to H₀; F₁ to H₁; F-resp-≡ to H-resp-≡) open I renaming (F₀ to I₀; F₁ to I₁; F-resp-≡ to I-resp-≡) .commute′ : ∀ {A B} (f : C [ A , B ]) → E [ E [ E [ I₁ (X.η B) ∘ Y.η (F₀ B) ] ∘ H₁ (F₁ f) ] ≡ E [ I₁ (G₁ f) ∘ E [ I₁ (X.η A) ∘ Y.η (F₀ A) ] ] ] commute′ {A} {B} f = begin E [ E [ I₁ (X.η B) ∘ Y.η (F₀ B) ] ∘ H₁ (F₁ f) ] ↓⟨ E.assoc ⟩ E [ I₁ (X.η B) ∘ E [ Y.η (F₀ B) ∘ H₁ (F₁ f) ] ] ↓⟨ E.∘-resp-≡ʳ (Y.commute (F₁ f)) ⟩ E [ I₁ (X.η B) ∘ E [ I₁ (F₁ f) ∘ Y.η (F₀ A) ] ] ↑⟨ E.assoc ⟩ E [ E [ I₁ (X.η B) ∘ I₁ (F₁ f) ] ∘ Y.η (F₀ A) ] ↑⟨ E.∘-resp-≡ˡ I.homomorphism ⟩ E [ I₁ (D [ X.η B ∘ F₁ f ]) ∘ Y.η (F₀ A) ] ↓⟨ E.∘-resp-≡ˡ (I-resp-≡ (X.commute f)) ⟩ E [ I₁ (D [ G₁ f ∘ X.η A ]) ∘ Y.η (F₀ A) ] ↓⟨ E.∘-resp-≡ˡ I.homomorphism ⟩ E [ E [ I₁ (G₁ f) ∘ I₁ (X.η A) ] ∘ Y.η (F₀ A) ] ↓⟨ E.assoc ⟩ E [ I₁ (G₁ f) ∘ E [ I₁ (X.η A) ∘ Y.η (F₀ A) ] ] ∎ where open E.HomReasoning infix 4 _≡_ _≡_ : ∀ {o ℓ e o′ ℓ′ e′} {C : Category o ℓ e} {D : Category o′ ℓ′ e′} {F G : Functor C D} → Rel (NaturalTransformation F G) (o ⊔ e′) _≡_ {D = D} X Y = ∀ {x} → D [ NaturalTransformation.η X x ≡ NaturalTransformation.η Y x ] .equiv : ∀ {o ℓ e o′ ℓ′ e′} {C : Category o ℓ e} {D : Category o′ ℓ′ e′} {F G : Functor C D} → IsEquivalence (_≡_ {F = F} {G}) equiv {C = C} {D} {F} {G} = record { refl = refl ; sym = λ f → sym f ; trans = λ f g → trans f g } where open Category.Equiv D setoid : ∀ {o ℓ e o′ ℓ′ e′} {C : Category o ℓ e} {D : Category o′ ℓ′ e′} {F G : Functor C D} → Setoid _ _ setoid {F = F} {G} = record { Carrier = NaturalTransformation F G ; _≈_ = _≡_ ; isEquivalence = equiv {F = F} }	{ "alphanum_fraction": 0.4865611193, "avg_line_length": 33.3251533742, "ext": "agda", "hexsha": "21d3429bc17d0c0c77bc2b93c7b46847b1d513ba", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2", "max_forks_repo_licenses": [ "BSD-3-Clause" ], "max_forks_repo_name": "p-pavel/categories", "max_forks_repo_path": "Categories/NaturalTransformation/Core.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "BSD-3-Clause" ], "max_issues_repo_name": "p-pavel/categories", "max_issues_repo_path": "Categories/NaturalTransformation/Core.agda", "max_line_length": 145, "max_stars_count": 1, "max_stars_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2", "max_stars_repo_licenses": [ "BSD-3-Clause" ], "max_stars_repo_name": "p-pavel/categories", "max_stars_repo_path": "Categories/NaturalTransformation/Core.agda", "max_stars_repo_stars_event_max_datetime": "2018-12-29T21:51:57.000Z", "max_stars_repo_stars_event_min_datetime": "2018-12-29T21:51:57.000Z", "num_tokens": 2288, "size": 5432 }
------------------------------------------------------------------------ -- INCREMENTAL λ-CALCULUS -- -- Incrementalization as term-to-term transformation with the Nehemiah plugin. ------------------------------------------------------------------------ module Nehemiah.Change.Derive where open import Nehemiah.Syntax.Type open import Nehemiah.Syntax.Term open import Nehemiah.Change.Type open import Nehemiah.Change.Term open import Data.Integer import Parametric.Change.Derive Const ΔBase as Derive derive-const : Derive.Structure derive-const (intlit-const n) = intlit (+ 0) derive-const add-const = absV 4 (λ s ds t dt → add ds dt) derive-const minus-const = absV 2 (λ t dt → minus dt) derive-const empty-const = empty derive-const insert-const = absV 4 (λ s ds t dt → insert (s ⊕₍ int ₎ ds) (t ⊕₍ bag ₎ dt) ⊝ insert s t) derive-const union-const = absV 4 (λ s ds t dt → union ds dt) derive-const negate-const = absV 2 (λ t dt → negate dt) derive-const flatmap-const = absV 4 (λ s ds t dt → flatmap (s ⊕₍ int ⇒ bag ₎ ds) (t ⊕₍ bag ₎ dt) ⊝ flatmap s t) derive-const sum-const = absV 2 (λ t dt → sum dt) open Derive.Structure derive-const public	{ "alphanum_fraction": 0.6076794658, "avg_line_length": 37.4375, "ext": "agda", "hexsha": "21149a18e05d1a806bc9f49ec251495f16f1c0ab", "lang": "Agda", "max_forks_count": 1, "max_forks_repo_forks_event_max_datetime": "2016-02-18T12:26:44.000Z", "max_forks_repo_forks_event_min_datetime": "2016-02-18T12:26:44.000Z", "max_forks_repo_head_hexsha": "39bb081c6f192bdb87bd58b4a89291686d2d7d03", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "inc-lc/ilc-agda", "max_forks_repo_path": "Nehemiah/Change/Derive.agda", "max_issues_count": 6, "max_issues_repo_head_hexsha": "39bb081c6f192bdb87bd58b4a89291686d2d7d03", "max_issues_repo_issues_event_max_datetime": "2017-05-04T13:53:59.000Z", "max_issues_repo_issues_event_min_datetime": "2015-07-01T18:09:31.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "inc-lc/ilc-agda", "max_issues_repo_path": "Nehemiah/Change/Derive.agda", "max_line_length": 78, "max_stars_count": 10, "max_stars_repo_head_hexsha": "39bb081c6f192bdb87bd58b4a89291686d2d7d03", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "inc-lc/ilc-agda", "max_stars_repo_path": "Nehemiah/Change/Derive.agda", "max_stars_repo_stars_event_max_datetime": "2019-07-19T07:06:59.000Z", "max_stars_repo_stars_event_min_datetime": "2015-03-04T06:09:20.000Z", "num_tokens": 348, "size": 1198 }
module InferrableFields where data ℕ : Set where zero : ℕ suc : ℕ → ℕ data Vec A : ℕ → Set where [] : Vec A zero _∷_ : ∀ {n} → A → Vec A n → Vec A (suc n) record SomeVec A : Set where field n : ℕ unpack : Vec A n open SomeVec using (unpack) pack : ∀ {A n} → Vec A n -> SomeVec A pack xs = record { unpack = xs } data _≡_ {A : Set}(x : A) : A → Set where refl : x ≡ x lemPack : ∀ {A}(xs : SomeVec A) → pack (unpack xs) ≡ xs lemPack xs = refl	{ "alphanum_fraction": 0.5567226891, "avg_line_length": 18.3076923077, "ext": "agda", "hexsha": "fd83fa80359e7e191d9107ae843c9e9e61e8c429", "lang": "Agda", "max_forks_count": 1, "max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z", "max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z", "max_forks_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016", "max_forks_repo_licenses": [ "BSD-3-Clause" ], "max_forks_repo_name": "redfish64/autonomic-agda", "max_forks_repo_path": "test/Succeed/InferrableFields.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "BSD-3-Clause" ], "max_issues_repo_name": "redfish64/autonomic-agda", "max_issues_repo_path": "test/Succeed/InferrableFields.agda", "max_line_length": 55, "max_stars_count": 3, "max_stars_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016", "max_stars_repo_licenses": [ "BSD-3-Clause" ], "max_stars_repo_name": "redfish64/autonomic-agda", "max_stars_repo_path": "test/Succeed/InferrableFields.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": 179, "size": 476 }
-- {-# OPTIONS -v scope.operators:100 #-} module Issue675 where data D : Set where d : D → D Foo : {x : D} → Set₁ Foo {x = D.d x} = Set -- qualified constructors should also work in hidden arguments	{ "alphanum_fraction": 0.645320197, "avg_line_length": 20.3, "ext": "agda", "hexsha": "53beaeb30d2e0c56fff4ebd657bc8222d84dbfb5", "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/Issue675.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/Issue675.agda", "max_line_length": 62, "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/Issue675.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": 62, "size": 203 }
module Functor where open import Level import Data.Nat as N open import Basic open import Category open Category.Category record Functor {c₀ c₁ ℓ c₀′ c₁′ ℓ′} (C : Category c₀ c₁ ℓ) (D : Category c₀′ c₁′ ℓ′) : Set (suc (c₀ ⊔ c₀′ ⊔ c₁ ⊔ c₁′ ⊔ ℓ ⊔ ℓ′)) where field fobj : Obj C → Obj D fmapsetoid : {A B : Obj C} → Map.Map (Homsetoid C A B) (Homsetoid D (fobj A) (fobj B)) fmap : {A B : Obj C} → Hom C A B → Hom D (fobj A) (fobj B) fmap {A} {B} = Map.Map.mapping (fmapsetoid {A} {B}) field preserveId : {A : Obj C} → D [ fmap (id C {A}) ≈ id D {fobj A} ] preserveComp : {a b c : Obj C} {f : Hom C b c} {g : Hom C a b} → D [ fmap (C [ f ∘ g ]) ≈ (D [ fmap f ∘ fmap g ]) ] open Functor preserveEq : ∀ {c₀ c₁ ℓ c₀′ c₁′ ℓ′} {C : Category c₀ c₁ ℓ} {D : Category c₀′ c₁′ ℓ′} {A B : Obj C} {x y : Hom C A B} (F : Functor C D) → C [ x ≈ y ] → D [ fmap F x ≈ fmap F y ] preserveEq F xy = Map.Map.preserveEq (fmapsetoid F) xy compose : ∀ {c₀ c₁ ℓ c₀′ c₁′ ℓ′ c₀″ c₁″ ℓ″} {C : Category c₀ c₁ ℓ} {D : Category c₀′ c₁′ ℓ′} {E : Category c₀″ c₁″ ℓ″} → Functor {c₀′} {c₁′} {ℓ′} {c₀″} {c₁″} {ℓ″} D E → Functor {c₀} {c₁} {ℓ} {c₀′} {c₁′} {ℓ′} C D → Functor {c₀} {c₁} {ℓ} {c₀″} {c₁″} {ℓ″} C E compose {C = C} {D} {E} G F = record { fobj = λ x → fobj G (fobj F x); fmapsetoid = record { mapping = λ f → fmap G (fmap F f) ; preserveEq = λ {x} {y} x≈y → begin⟨ E ⟩ fmap G (fmap F x) ≈⟨ preserveEq G (begin⟨ D ⟩ fmap F x ≈⟨ preserveEq F x≈y ⟩ fmap F y ∎) ⟩ fmap G (fmap F y) ∎ }; preserveId = begin⟨ E ⟩ fmap G (fmap F (id C)) ≈⟨ preserveEq G (preserveId F) ⟩ fmap G (id D) ≈⟨ preserveId G ⟩ (id E) ∎; preserveComp = λ {_} {_} {_} {f} {g} → begin⟨ E ⟩ fmap G (fmap F (C [ f ∘ g ])) ≈⟨ preserveEq G (preserveComp F) ⟩ fmap G (D [ fmap F f ∘ fmap F g ]) ≈⟨ preserveComp G ⟩ (E [ fmap G (fmap F f) ∘ fmap G (fmap F g) ]) ∎ } identity : ∀ {c₀ c₁ ℓ} (C : Category c₀ c₁ ℓ) → Functor {c₀} {c₁} {ℓ} {c₀} {c₁} {ℓ} C C identity C = record { fobj = λ x → x ; fmapsetoid = record { mapping = λ x → x ; preserveEq = λ x₁ → x₁ } ; preserveId = refl-hom C ; preserveComp = refl-hom C } exp : ∀ {c₀ c₁ ℓ} {C : Category c₀ c₁ ℓ} → Functor C C → N.ℕ → Functor C C exp {C = C} F N.zero = identity C exp F (N.suc N.zero) = F exp F (N.suc n) = compose F (exp F n) data _[_~_] {C₀ C₁ ℓ : Level} (C : Category C₀ C₁ ℓ) {A B : Obj C} (f : Hom C A B) : ∀{X Y : Obj C} → Hom C X Y → Set (suc (C₀ ⊔ C₁ ⊔ ℓ)) where eqArrow : {g : Hom C A B} → C [ f ≈ g ] → C [ f ~ g ] eqArrowRefl : ∀ {c₀ c₁ ℓ} (C : Category c₀ c₁ ℓ) {A B : Obj C} {f : Hom C A B} → C [ f ~ f ] eqArrowRefl C = eqArrow (refl-hom C) eqArrowSym : ∀ {c₀ c₁ ℓ} (C : Category c₀ c₁ ℓ) {X Y Z W : Obj C} {f : Hom C X Y} {g : Hom C Z W} → C [ f ~ g ] → C [ g ~ f ] eqArrowSym C (eqArrow f~g) = eqArrow (sym-hom C f~g) eqArrowTrans : ∀ {c₀ c₁ ℓ} (C : Category c₀ c₁ ℓ) {X Y Z W S T : Obj C} {f : Hom C X Y} {g : Hom C Z W} {h : Hom C S T} → C [ f ~ g ] → C [ g ~ h ] → C [ f ~ h ] eqArrowTrans C (eqArrow f~g) (eqArrow g~h) = eqArrow (trans-hom C f~g g~h) eqArrowFmap : ∀ {c₀ c₁ ℓ c₀′ c₁′ ℓ′} {C : Category c₀ c₁ ℓ} {D : Category c₀′ c₁′ ℓ′} {X Y Z W : Obj C} {x : Category.Hom C X Y} {y : Category.Hom C Z W} (F : Functor C D) → C [ x ~ y ] → D [ fmap F x ~ fmap F y ] eqArrowFmap F (eqArrow x~y) = eqArrow (preserveEq F x~y) equality : ∀ {c₀ c₁ ℓ} {C D : Category c₀ c₁ ℓ} → (F G : Functor C D) → _ equality {C = C} {D} F G = ∀ {A B : Obj C} (f : Hom C A B) → D [ fmap F f ~ fmap G f ] Cat : ∀ {c₀ c₁ ℓ} → Category (suc (c₀ ⊔ c₁ ⊔ ℓ)) _ _ Cat {c₀} {c₁} {ℓ} = record { Obj = Category c₀ c₁ ℓ; Homsetoid = λ A B → record { Carrier = Functor A B ; _≈_ = equality ; isEquivalence = record { refl = λ f → eqArrowRefl B ; sym = λ x f → eqArrowSym B (x f); trans = λ x x₁ f → eqArrowTrans B (x f) (x₁ f) } }; comp = compose; id = λ {A} → identity A; leftId = λ {A} {B} {f} f₁ → eqArrow (refl-hom B); rightId = λ {A} {B} {f} f₁ → eqArrow (refl-hom B); assoc = λ {A} {B} {C} {D} {f} {g} {h} f₁ → eqArrow (begin⟨ D ⟩ fmap (compose (compose h g) f) f₁ ≈⟨ refl-hom D ⟩ fmap h (fmap g (fmap f f₁)) ≈⟨ refl-hom D ⟩ fmap (compose h (compose g f)) f₁ ∎); ≈-composite = λ {A} {B} {C} {f} {g} {h} {i} f~g h~i f₁ → eqArrowTrans C (f~g (fmap h f₁)) (eqArrowFmap g (h~i f₁)) }	{ "alphanum_fraction": 0.5287329795, "avg_line_length": 44.2142857143, "ext": "agda", "hexsha": "6f1f36cd84452d76867b7ee1f7cf5930bf28b137", "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": "59004994acdbc65fb4f8abf0baa1777a8dbe758e", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "myuon/agda-cate", "max_forks_repo_path": "src/Functor.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "59004994acdbc65fb4f8abf0baa1777a8dbe758e", "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": "myuon/agda-cate", "max_issues_repo_path": "src/Functor.agda", "max_line_length": 256, "max_stars_count": 2, "max_stars_repo_head_hexsha": "59004994acdbc65fb4f8abf0baa1777a8dbe758e", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "myuon/agda-cate", "max_stars_repo_path": "src/Functor.agda", "max_stars_repo_stars_event_max_datetime": "2019-11-02T07:30:47.000Z", "max_stars_repo_stars_event_min_datetime": "2018-07-28T04:59:31.000Z", "num_tokens": 2008, "size": 4333 }
-- Bi-Cartesian closed structure of families module SOAS.Families.BCCC {T : Set} where open import SOAS.Common open import SOAS.Context {T} open import SOAS.Sorting {T} open import SOAS.Families.Core {T} open import SOAS.Families.Isomorphism {T} import Categories.Category.CartesianClosed.Canonical as Canonical import Categories.Category.CartesianClosed as CCC import Categories.Category.Cartesian as Cart open import Categories.Category.Cocartesian open import Categories.Category.BicartesianClosed import Categories.Object.Initial as Initial open import Categories.Category.Monoidal import Data.Unit as Unit import Data.Empty as Empty -- \| Unsorted -- Category of families is Cartesian closed 𝔽am-CanCCC : Canonical.CartesianClosed 𝔽amilies 𝔽am-CanCCC = record { ⊤ = λ Γ → Unit.⊤ ; _×_ = λ X Y Γ → X Γ × Y Γ ; ! = λ _ → Unit.tt ; π₁ = proj₁ ; π₂ = proj₂ ; ⟨_,_⟩ = λ f g x → f x , g x ; !-unique = λ f → refl ; π₁-comp = refl ; π₂-comp = refl ; ⟨,⟩-unique = λ p₁ p₂ {Γ}{x} → sym (cong₂ _,_ p₁ p₂) ; _^_ = λ X Y Γ → Y Γ → X Γ ; eval = λ{ (f , x) → f x} ; curry = λ f x y → f (x , y) ; eval-comp = refl ; curry-resp-≈ = λ{X}{Y}{Z}{f}{g} p → ext (λ x → p) ; curry-unique = λ p → ext (λ x → p) } 𝔽am-CCC : CCC.CartesianClosed 𝔽amilies 𝔽am-CCC = Canonical.Equivalence.fromCanonical _ 𝔽am-CanCCC module 𝔽am-CCC = CCC.CartesianClosed 𝔽am-CCC -- Category of families is co-Cartesian 𝔽am-Cocartesian : Cocartesian 𝔽amilies 𝔽am-Cocartesian = record { initial = record { ⊥ = λ Γ → Empty.⊥ ; ⊥-is-initial = record { ! = λ () ; !-unique = λ{ f {Γ} {()}} } } ; coproducts = record { coproduct = λ{X}{Y} → record { A+B = λ Γ → X Γ ⊎ Y Γ ; i₁ = inj₁ ; i₂ = inj₂ ; [_,_] = λ{ f g (inj₁ x) → f x ; f g (inj₂ y) → g y} ; inject₁ = refl ; inject₂ = refl ; unique = λ{ p₁ p₂ {Γ} {inj₁ x} → sym p₁ ; p₁ p₂ {Γ} {inj₂ y} → sym p₂} } } } module 𝔽am-Cocart = Cocartesian 𝔽am-Cocartesian -- Category of families is bi-Cartesian closed 𝔽am-BCCC : BicartesianClosed 𝔽amilies 𝔽am-BCCC = record { cartesianClosed = 𝔽am-CCC ; cocartesian = 𝔽am-Cocartesian } module 𝔽am-BCCC = BicartesianClosed 𝔽am-BCCC -- Shorthand for family product and sum and exponential _×ₘ_ : Family → Family → Family _×ₘ_ = 𝔽am-CCC._×_ _+ₘ_ : Family → Family → Family _+ₘ_ = 𝔽am-Cocart._+_ _⇨_ : Family → Family → Family _⇨_ = 𝔽am-CCC._⇨_ infixr 25 _⇨_ ⊤ₘ : Family ⊤ₘ Γ = Unit.⊤ private variable X Y Z W : Family curryₘ-iso : (X ×ₘ Y ⇾ Z) ≅ₛ (X ⇾ Y ⇨ Z) curryₘ-iso = record { from = λ f x y → f (x , y) ; to = λ{ f (x , y) → f x y } ; iso = record { isoˡ = refl ; isoʳ = refl } } -- Congruence for indexed families of functions ⇾-cong : X ≅ₘ Y → W ≅ₘ Z → (X ⇾ W) ≅ₛ (Y ⇾ Z) ⇾-cong X≅Y W≅Z = record { from = λ f y → _≅ₘ_.from W≅Z (f (_≅ₘ_.to X≅Y y)) ; to = λ g x → _≅ₘ_.to W≅Z (g (_≅ₘ_.from X≅Y x)) ; iso = record { isoˡ = λ {f} → dext′ (trans (_≅ₘ_.isoˡ W≅Z) (cong f (_≅ₘ_.isoˡ X≅Y))) ; isoʳ = λ {g} → dext′ (trans (_≅ₘ_.isoʳ W≅Z) (cong g (_≅ₘ_.isoʳ X≅Y))) } } ⇾-≅dom : X ≅ₘ Y → (X ⇾ W) ≅ₛ (Y ⇾ W) ⇾-≅dom X≅Y = ⇾-cong X≅Y ≅ₘ.refl ⇾-≅cod : W ≅ₘ Z → (X ⇾ W) ≅ₛ (X ⇾ Z) ⇾-≅cod W≅Z = ⇾-cong ≅ₘ.refl W≅Z -- \| Sorted -- Category of sorted families is Cartesian closed 𝔽amₛ-CanCCC : Canonical.CartesianClosed 𝔽amiliesₛ 𝔽amₛ-CanCCC = 𝕊orted-CanCCC 𝔽am-CanCCC 𝔽amₛ-CCC : CCC.CartesianClosed 𝔽amiliesₛ 𝔽amₛ-CCC = Canonical.Equivalence.fromCanonical _ 𝔽amₛ-CanCCC -- Category of sorted families is co-Cartesian 𝔽amₛ-Cocartesian : Cocartesian 𝔽amiliesₛ 𝔽amₛ-Cocartesian = 𝕊orted-Cocartesian 𝔽am-Cocartesian -- Category of sorted families is bi-Cartesian closed 𝔽amₛ-BCCC : BicartesianClosed 𝔽amiliesₛ 𝔽amₛ-BCCC = 𝕊orted-BCCC 𝔽am-BCCC module 𝔽amₛ-CCC = CCC.CartesianClosed 𝔽amₛ-CCC module 𝔽amₛ-Cocart = Cocartesian 𝔽amₛ-Cocartesian 𝔽amₛ-Mon : Monoidal 𝔽amiliesₛ 𝔽amₛ-Mon = Cart.CartesianMonoidal.monoidal 𝔽amiliesₛ 𝔽amₛ-CCC.cartesian -- Shorthand for sorted family product and sum and exponential _×̣ₘ_ : Familyₛ → Familyₛ → Familyₛ _×̣ₘ_ = 𝔽amₛ-CCC._×_ _+̣ₘ_ : Familyₛ → Familyₛ → Familyₛ _+̣ₘ_ = 𝔽amₛ-Cocart._+_ _⇨̣_ : Familyₛ → Familyₛ → Familyₛ _⇨̣_ = 𝔽amₛ-CCC._⇨_ infixr 25 _⇨̣_	{ "alphanum_fraction": 0.6489874638, "avg_line_length": 28.2176870748, "ext": "agda", "hexsha": "2b273fac2bf8d1ace452a764f53e13f4724d1fb8", "lang": "Agda", "max_forks_count": 4, "max_forks_repo_forks_event_max_datetime": "2022-01-24T12:49:17.000Z", "max_forks_repo_forks_event_min_datetime": "2021-11-09T20:39:59.000Z", "max_forks_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "JoeyEremondi/agda-soas", "max_forks_repo_path": "SOAS/Families/BCCC.agda", "max_issues_count": 1, "max_issues_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8", "max_issues_repo_issues_event_max_datetime": "2021-11-21T12:19:32.000Z", "max_issues_repo_issues_event_min_datetime": "2021-11-21T12:19:32.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "JoeyEremondi/agda-soas", "max_issues_repo_path": "SOAS/Families/BCCC.agda", "max_line_length": 108, "max_stars_count": 39, "max_stars_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "JoeyEremondi/agda-soas", "max_stars_repo_path": "SOAS/Families/BCCC.agda", "max_stars_repo_stars_event_max_datetime": "2022-03-19T17:33:12.000Z", "max_stars_repo_stars_event_min_datetime": "2021-11-09T20:39:55.000Z", "num_tokens": 1856, "size": 4148 }
module test where open import Relation.Binary.PropositionalEquality module NewCodata where open import Data.Nat open import Data.List open import Data.Maybe record Pair (A B : Set) : Set where field fst : A snd : B record Stream (A : Set) : Set where coinductive field hd : A tl : Stream A open Stream repeat : ∀ {A : Set} → A → Stream A hd (repeat x) = x tl (repeat x) = repeat x nth : ∀ {A : Set} → ℕ → Stream A → A nth zero s = hd s nth (suc n) s = nth n (tl s) mutual data μColist (A : Set) : Set where [] : μColist A _∷_ : (x : A) (xs : νColist A) → μColist A record νColist (A : Set) : Set where coinductive field out : μColist A open νColist record νTree (A : Set) : Set where coinductive field label : A subs : List (νTree A) open νTree append : {A : Set} → List A → νColist A → νColist A out (append [] ys) = out ys out (append (x ∷ xs) ys) = x ∷ append xs ys appendS : {A : Set} → List A → Stream A → Stream A hd (appendS [] s) = hd s hd (appendS (x ∷ xs) s) = x tl (appendS [] s) = tl s tl (appendS (x ∷ xs) s) = tl (appendS xs s) record Pi (A : Set) (B : A → Set) : Set where field _$_ : (x : A) → B x infixl 20 _$_ open Pi _→'_ : Set → Set → Set A →' B = Pi A (λ _ → B) infixr 20 _→'_ plus2 : ℕ →' ℕ plus2 $ x = suc (suc x) plus : ℕ →' ℕ →' ℕ plus $ 0 $ m = m plus $ (suc n) $ m = suc (plus $ n $ m) data Vec (A : Set) : ℕ → Set where nil : Vec A 0 _:::_ : {n : ℕ} → A → Vec A n → Vec A (suc n) test : Vec ℕ 2 test = 2 ::: (2 ::: nil) repeat2V : Pi ℕ (λ n → Vec ℕ n) repeat2V $ 0 = nil repeat2V $ suc n = 2 ::: (repeat2V $ n) {- bf : {A : Set} → List (νTree A) → νColist A out (bf []) = [] out (bf (t ∷ ts)) = label t ∷ append (map label ts) (bf (concatMap subs (t ∷ ts))) -} record ℕ∞ : Set where coinductive field pred∞ : Maybe ℕ∞ open ℕ∞ infinity : ℕ∞ pred∞ infinity = just infinity zero∞ : ℕ∞ pred∞ zero∞ = nothing one∞ : ℕ∞ pred∞ one∞ = just zero∞ suc∞ : ℕ∞ → ℕ∞ pred∞ (suc∞ x) = just x plus∞ : ℕ∞ → ℕ∞ → ℕ∞ pred∞ (plus∞ n m) with pred∞ n ... \| nothing = pred∞ m ... \| just n' = just (plus∞ n' m) {- record PStr (A : Set) (n : ℕ∞) : Set where coinductive field phd : (k : ℕ∞) → PStr A (suc∞ k) → A ptl : (k : ℕ∞) → PStr A (suc∞ k) → PStr A k -} module OldCodata where open import Codata.Musical.Notation open import Data.Nat data Stream (A : Set) : Set where cons : A → ∞ (Stream A) → Stream A repeat : {A : Set} → A → Stream A repeat x = cons x (♯ (repeat x)) nth : {A : Set} → ℕ → Stream A → A nth 0 (cons x _) = x nth (suc n) (cons _ xs) = nth n (♭ xs) data ℕ∞ : Set where zero∞ : ℕ∞ suc∞ : ∞ (ℕ∞) → ℕ∞ infinity : ℕ∞ infinity = suc∞ (♯ infinity) module NonTerminating where open import Data.Nat {- _/_ : ℕ → ℕ → ℕ zero / y = zero suc x / y = suc ( (x ∸ y) / y) -} module PositiveSizedTypes where open import Agda.Builtin.Size data ℕ : Size → Set where zero : {i : Size} → ℕ i suc : {i : Size} → ℕ i → ℕ (↑ i) one : ℕ ∞ one = suc zero two : ℕ ∞ two = suc one three : ℕ ∞ three = suc two four : ℕ ∞ four = suc three five : ℕ ∞ five = suc four _-_ : {i : Size} → ℕ i → ℕ ∞ → ℕ i zero - _ = zero n - zero = n (suc n) - (suc m) = n - m infixl 20 _-_ -test₁ : five - two ≡ three -test₁ = refl _/_ : {i : Size} → ℕ i → ℕ ∞ → ℕ i zero / _ = zero suc x / y = suc ( (x - y) / y) infixl 30 _/_ _+_ : ℕ ∞ → ℕ ∞ → ℕ ∞ zero + y = y suc x + y = suc (x + y) infixl 20 _+_ __ : ℕ ∞ → ℕ ∞ → ℕ ∞ zero _ = zero suc x * y = x + x * y infixl 30 __ min : {i : Size} → ℕ i → ℕ i → ℕ i min zero _ = zero min _ zero = zero min (suc m) (suc n) = suc (min m n) test₁ : zero / zero ≡ zero test₁ = refl test₂ : zero / five ≡ zero test₂ = refl test₃ : one / one ≡ one test₃ = refl test₄ : two / two ≡ one test₄ = refl test₅ : five / five ≡ one test₅ = refl test₆ : one / zero ≡ one test₆ = refl test₇ : two / one ≡ one test₇ = refl test₈ : four / two ≡ two test₈ = refl module NegativSizedTypes where open import Agda.Builtin.Size open import Data.Nat open import Data.Bool using (if_then_else_) open import Relation.Nullary.Decidable using (⌊_⌋) record Stream (i : Size) (A : Set) : Set where coinductive field hd : A tl : ∀ {j : Size< i} → Stream j A open Stream cons : {i : Size} {A : Set} → A -> Stream i A → Stream i A hd (cons x _) = x tl (cons _ xs) = xs map : {A B : Set} {i : Size} → (A → B) → Stream i A → Stream i B hd (map f xs) = f (hd xs) tl (map f xs) = map f (tl xs) merge : {i : Size} → Stream i ℕ → Stream i ℕ → Stream i ℕ hd (merge xs ys) = hd xs ⊓ hd ys tl (merge xs ys) = if ⌊ hd xs ≤? hd ys ⌋ then cons (hd ys) (merge (tl xs) (tl ys)) else cons (hd xs) (merge (tl xs) (tl ys)) ham : {i : Size} → Stream i ℕ hd ham = 1 tl ham = (merge (map (__ 2) ham) (map (_*_ 3) ham))	{ "alphanum_fraction": 0.503948853, "avg_line_length": 21.272, "ext": "agda", "hexsha": "1aff282ebdecfdb8002d87d17de46eb12a9401fd", "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": "68afff2b0a7183751737ef20e713df1fef3d4cf2", "max_forks_repo_licenses": [ "BSD-3-Clause" ], "max_forks_repo_name": "StillerHarpo/masterarbeit", "max_forks_repo_path": "doc/test.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "68afff2b0a7183751737ef20e713df1fef3d4cf2", "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": "StillerHarpo/masterarbeit", "max_issues_repo_path": "doc/test.agda", "max_line_length": 66, "max_stars_count": null, "max_stars_repo_head_hexsha": "68afff2b0a7183751737ef20e713df1fef3d4cf2", "max_stars_repo_licenses": [ "BSD-3-Clause" ], "max_stars_repo_name": "StillerHarpo/masterarbeit", "max_stars_repo_path": "doc/test.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 2141, "size": 5318 }
{-# OPTIONS --show-implicit #-} module BottomUp1 where record R (_ : Set) : Set where no-eta-equality record S (F : Set → Set) ⦃ _ : {A : Set} → R (F A) ⦄ : Set where module M0 where private postulate F : Set → Set instance Ri : {A : Set} → R (F A) instance Si : S F module M1 (_ : Set) where private postulate F : Set → Set instance Ri : {A : Set} → R (F A) instance Si-works : S F ⦃ Ri ⦄ instance Si-fails : S F {- No instance of type R (F A) was found in scope. -}	{ "alphanum_fraction": 0.5317604356, "avg_line_length": 20.4074074074, "ext": "agda", "hexsha": "ced1fb32ee21c7a4909f3d3b60ebac4e62fb1fca", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb", "max_forks_repo_licenses": [ "RSA-MD" ], "max_forks_repo_name": "m0davis/oscar", "max_forks_repo_path": "archive/agda-1/BottomUp1.agda", "max_issues_count": 1, "max_issues_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb", "max_issues_repo_issues_event_max_datetime": "2019-05-11T23:33:04.000Z", "max_issues_repo_issues_event_min_datetime": "2019-04-29T00:35:04.000Z", "max_issues_repo_licenses": [ "RSA-MD" ], "max_issues_repo_name": "m0davis/oscar", "max_issues_repo_path": "archive/agda-1/BottomUp1.agda", "max_line_length": 59, "max_stars_count": null, "max_stars_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb", "max_stars_repo_licenses": [ "RSA-MD" ], "max_stars_repo_name": "m0davis/oscar", "max_stars_repo_path": "archive/agda-1/BottomUp1.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 187, "size": 551 }
open import Data.ByteString using ( lazy ; strict ) open import System.IO using ( _>>_ ; _>>=_ ; getBytes ; putStr ; commit ) module System.IO.Examples.DevNull where main = getBytes {lazy} >>= λ bs → putStr "Done.\n" >> commit	{ "alphanum_fraction": 0.6638297872, "avg_line_length": 23.5, "ext": "agda", "hexsha": "a5c768af937385ec538265dbae0c4edc52ed3553", "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": "d06c219c7b7afc85aae3b1d4d66951b889aa7371", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "ilya-fiveisky/agda-system-io", "max_forks_repo_path": "src/System/IO/Examples/DevNull.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "d06c219c7b7afc85aae3b1d4d66951b889aa7371", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "ilya-fiveisky/agda-system-io", "max_issues_repo_path": "src/System/IO/Examples/DevNull.agda", "max_line_length": 73, "max_stars_count": null, "max_stars_repo_head_hexsha": "d06c219c7b7afc85aae3b1d4d66951b889aa7371", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "ilya-fiveisky/agda-system-io", "max_stars_repo_path": "src/System/IO/Examples/DevNull.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 67, "size": 235 }
module Data.Fin.Substitution.Lemmas.Extra where import Function as Fun open import Data.Nat open import Data.Fin hiding (_+_) open import Data.Fin.Substitution open import Data.Fin.Substitution.Lemmas open import Data.Vec.Properties open import Data.Vec open import Data.Star using (_◅_ ; ε) open import Function hiding (id) open import Relation.Binary.PropositionalEquality open ≡-Reasoning module AdditionalLemmas {T} (lemmas : TermLemmas T) where open TermLemmas lemmas module Var = VarSubst -- Weakening commutes with single-variable substitution weaken-sub : ∀ {n} (a : T (1 + n)) (b : T n) → weaken (a / sub b) ≡ a / wk ↑ / sub (weaken b) weaken-sub a b = begin weaken (a / sub b) ≡⟨ sym (/-wk′ (a / sub b)) ⟩ a / sub b / wk ≡⟨ sub-commutes a ⟩ a / wk ↑ / sub (b / wk) ≡⟨ cong (λ c → a / wk ↑ / sub c) (/-wk′ b) ⟩ a / wk ↑ / sub (weaken b) ∎ where /-wk′ : ∀ {n} (a : T n) → a / wk ≡ weaken a /-wk′ a = /-wk {t = a} -- Weakening commutes with reverse composition of substitutions. map-weaken-⊙ : ∀ {m n k} (σ₁ : Sub T m n) (σ₂ : Sub T n k) → map weaken (σ₁ ⊙ σ₂) ≡ (map weaken σ₁) ⊙ (σ₂ ↑) map-weaken-⊙ σ₁ σ₂ = begin map weaken (σ₁ ⊙ σ₂) ≡⟨ map-weaken ⟩ (σ₁ ⊙ σ₂) ⊙ wk ≡⟨ sym ⊙-assoc ⟩ σ₁ ⊙ (σ₂ ⊙ wk) ≡⟨ cong (λ σ₂ → σ₁ ⊙ σ₂) ⊙-wk ⟩ σ₁ ⊙ (wk ⊙ (σ₂ ↑)) ≡⟨ ⊙-assoc ⟩ (σ₁ ⊙ wk) ⊙ (σ₂ ↑) ≡⟨ cong (λ σ₁ → σ₁ ⊙ (σ₂ ↑)) (sym map-weaken) ⟩ (map weaken σ₁) ⊙ (σ₂ ↑) ∎ weaken⋆↑ : ∀ {ν μ} (x : T ν) (s : Sub T ν μ) → (weaken x) / (s ↑) ≡ weaken (x / s) weaken⋆↑ x s = begin (weaken x) / (s ↑) ≡⟨ cong (λ u → u / (s ↑)) (sym /-wk) ⟩ x / wk / (s ↑) ≡⟨ sym (/-⊙ x) ⟩ x / (wk ⊙ (s ↑)) ≡⟨ cong (_/_ x) (sym ⊙-wk) ⟩ x / (s ⊙ wk) ≡⟨ /-⊙ x ⟩ x / s / wk ≡⟨ /-wk ⟩ weaken (x / s) ∎ weaken-sub-vanishes : ∀ {ν} {a b : T ν} → (weaken a) / (sub b) ≡ a weaken-sub-vanishes {ν} {a} {b} = begin (weaken a) / (sub b) ≡⟨ cong (flip _/_ (sub b)) (sym $ /-wk {t = a}) ⟩ a / wk / (sub b) ≡⟨ wk-sub-vanishes a ⟩ a ∎ -- make /Var usable from lemmas open TermSubst termSubst using (_/Var_) public private var⋆weaken : ∀ {n} → _≗_ {A = Fin n} (var ∘ suc) (weaken ∘ var) var⋆weaken n = begin var (suc n) ≡⟨ sym $ lookup-wk n ⟩ lookup n wk ≡⟨ sym $ var-/ ⟩ (var n) / wk ≡⟨ /-wk ⟩ weaken (var n) ∎ map-var⋆weaken : ∀ {n m} {v : Vec (Fin n) m} → map var (map suc v) ≡ map weaken (map var v) map-var⋆weaken {v = v} = begin map var (map suc v) ≡⟨ sym $ map-∘ var suc v ⟩ map (var ∘ suc) v ≡⟨ map-cong var⋆weaken v ⟩ map (weaken ∘ var) v ≡⟨ map-∘ weaken var v ⟩ map weaken (map var v) ∎ map-var-varid≡id : ∀ {n} → map var (Var.id {n}) ≡ id {n} map-var-varid≡id {zero} = refl map-var-varid≡id {suc n} = begin var zero ∷ (map var $ map suc Var.id) ≡⟨ cong (_∷_ (var zero)) map-var⋆weaken ⟩ var zero ∷ (map weaken $ map var Var.id) ≡⟨ cong (λ u → var zero ∷ (map weaken u)) map-var-varid≡id ⟩ id ↑ ∎ map-var-varwk≡wk : ∀ {n} → map var (Var.wk {n}) ≡ wk {n} map-var-varwk≡wk {zero} = refl map-var-varwk≡wk {suc n} = begin map var (map suc Var.id) ≡⟨ map-var⋆weaken ⟩ map weaken (map var Var.id) ≡⟨ cong (map weaken) map-var-varid≡id ⟩ wk ∎ map-var-↑ : ∀ {n m} {s : Vec (Fin n) m} {s'} → map var s ≡ s' → map var (s Var.↑) ≡ s' ↑ map-var-↑ {s = s} {s' = s'} eq = begin var zero ∷ (map var $ map suc s) ≡⟨ cong (_∷_ $ var zero) map-var⋆weaken ⟩ var zero ∷ (map weaken $ map var s) ≡⟨ cong (λ u → var zero ∷ (map weaken u)) eq ⟩ s' ↑ ∎ a/wk↑/sub0≡a : ∀ {ν} (a : T (suc ν)) → a / wk ↑ / (sub $ var zero) ≡ a a/wk↑/sub0≡a a = begin a / wk ↑ / (sub $ var zero) ≡⟨ sym $ /-⊙ a ⟩ a / (var zero / (sub $ var zero) ∷ map /-var-zero (map weaken wk)) ≡⟨ cong (λ u → a / (u ∷ map /-var-zero (map weaken wk))) var-/ ⟩ a / (var zero ∷ map /-var-zero (map weaken wk)) ≡⟨ cong' (sym $ map-∘ /-var-zero weaken wk) ⟩ a / (var zero ∷ map (λ t → (weaken t) / (sub $ var zero)) wk) ≡⟨ cong' (map-cong (λ t → weaken-sub-vanishes) wk) ⟩ a / (var zero ∷ map Fun.id wk) ≡⟨ cong' (map-id wk) ⟩ a / ((var zero ∷ wk)) ≡⟨ id-vanishes a ⟩ a ∎ where /-var-zero = (λ t → t / (sub $ var zero)) cong' : ∀ {x y} → x ≡ y → a / (var zero ∷ x) ≡ a / (var zero ∷ y) cong' = λ rest → cong (λ u → a / (var zero ∷ u)) rest lookup-lift-∷ : ∀ {v w} k x {b}{ρ : Sub T v w} → lookup (lift k suc x) ((b ∷ ρ) ↑⋆ k) ≡ lookup x (ρ ↑⋆ k) lookup-lift-∷ zero zero = refl lookup-lift-∷ zero (suc x) = refl lookup-lift-∷ (suc k) zero = refl lookup-lift-∷ (suc k) (suc x) {b} {ρ} = begin lookup (lift k suc x) (map (λ t → t /Var Var.wk) ((b ∷ ρ) ↑⋆ k)) ≡⟨ lookup-map (lift k suc x) (λ t → t /Var Var.wk) ((b ∷ ρ) ↑⋆ k) ⟩ lookup (lift k suc x) ((b ∷ ρ) ↑⋆ k) /Var Var.wk ≡⟨ cong (λ t → t /Var Var.wk) (lookup-lift-∷ k x) ⟩ lookup x (ρ ↑⋆ k) /Var Var.wk ≡⟨ sym (lookup-map x (λ t → t /Var Var.wk) (ρ ↑⋆ k)) ⟩ lookup x (map (λ t → t /Var Var.wk) (ρ ↑⋆ k)) ∎ wk-∷ : ∀ {ν ν'} (a : T ν)(ρ : Sub T ν ν'){b} → a / wk / (b ∷ ρ) ≡ a / ρ wk-∷ a ρ {b} = begin a / wk / (b ∷ ρ) ≡⟨ /✶-↑✶ ((b ∷ ρ) ◅ wk ◅ ε) (ρ ◅ ε) (λ k x → begin (var x) /✶ ((b ∷ ρ) ◅ wk ◅ ε) ↑✶ k ≡⟨ refl ⟩ (var x) / wk ↑⋆ k / (b ∷ ρ) ↑⋆ k ≡⟨ cong (flip _/_ ((b ∷ ρ) ↑⋆ k)) var-/ ⟩ (lookup x (wk ↑⋆ k)) / (b ∷ ρ) ↑⋆ k ≡⟨ cong (flip _/_ ((b ∷ ρ) ↑⋆ k)) (lookup-wk-↑⋆ k x) ⟩ (var (lift k suc x)) / (b ∷ ρ) ↑⋆ k ≡⟨ var-/ ⟩ lookup (lift k suc x) ((b ∷ ρ) ↑⋆ k) ≡⟨ lookup-lift-∷ k x ⟩ lookup x (ρ ↑⋆ k) ≡⟨ sym var-/ ⟩ (var x) /✶ (ρ ◅ ε) ↑✶ k ∎) 0 a ⟩ a / ρ ∎ wk⋆-++ : ∀ {ν ν'} μ (a : T ν)(ρ : Sub T ν ν'){ρ'} → a / wk⋆ μ / (ρ' ++ ρ) ≡ a / ρ wk⋆-++ zero a ρ {[]} = cong (λ t → t / ρ) (id-vanishes a) wk⋆-++ (suc μ) a ρ {_ ∷ ρ'} = begin a / wk⋆ (suc μ) / (_ ∷ ρ' ++ ρ) ≡⟨ cong (λ φ → a / φ / (_ ∷ ρ' ++ ρ)) map-weaken ⟩ a / (wk⋆ μ ⊙ wk) / (_ ∷ ρ' ++ ρ) ≡⟨ cong (λ t → _/_ t (_ ∷ ρ' ++ ρ)) (/-⊙ a) ⟩ a / wk⋆ μ / wk / (_ ∷ ρ' ++ ρ) ≡⟨ wk-∷ (a / wk⋆ μ) (ρ' ++ ρ) ⟩ a / wk⋆ μ / (ρ' ++ ρ) ≡⟨ wk⋆-++ μ a ρ ⟩ a / ρ ∎	{ "alphanum_fraction": 0.4643590959, "avg_line_length": 38.1144578313, "ext": "agda", "hexsha": "2a1b2a8decc180c8a31a094ffb979a4879098a12", "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/Data/Fin/Substitution/Lemmas/Extra.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/Data/Fin/Substitution/Lemmas/Extra.agda", "max_line_length": 107, "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/Data/Fin/Substitution/Lemmas/Extra.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": 3006, "size": 6327 }
module Ual.Either where infix 10 _∨_ data _∨_ (A B : Set) : Set where orL : A → A ∨ B orR : B → A ∨ B	{ "alphanum_fraction": 0.5607476636, "avg_line_length": 15.2857142857, "ext": "agda", "hexsha": "199476c1802e31da8805087f59e1079b7870c558", "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": "ea0260e1a0612ba581e4283dfb187f531a944dfd", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "brunoczim/ual", "max_forks_repo_path": "Either.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "ea0260e1a0612ba581e4283dfb187f531a944dfd", "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": "brunoczim/ual", "max_issues_repo_path": "Either.agda", "max_line_length": 32, "max_stars_count": null, "max_stars_repo_head_hexsha": "ea0260e1a0612ba581e4283dfb187f531a944dfd", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "brunoczim/ual", "max_stars_repo_path": "Either.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 52, "size": 107 }
------------------------------------------------------------------------------ -- Group theory congruence proofs using pattern matching ------------------------------------------------------------------------------ {-# OPTIONS --exact-split #-} {-# OPTIONS --no-sized-types #-} {-# OPTIONS --no-universe-polymorphism #-} {-# OPTIONS --without-K #-} module LogicalFramework.GroupCongruence where open import GroupTheory.Base ·-cong : ∀ {a b c d} → a ≡ b → c ≡ d → a · c ≡ b · d ·-cong refl refl = refl ·-leftCong : ∀ {a b c} → a ≡ b → a · c ≡ b · c ·-leftCong refl = refl ·-rightCong : ∀ {a b c} → b ≡ c → a · b ≡ a · c ·-rightCong refl = refl ⁻¹-cong : ∀ {a b} → a ≡ b → a ⁻¹ ≡ b ⁻¹ ⁻¹-cong refl = refl	{ "alphanum_fraction": 0.4278074866, "avg_line_length": 29.92, "ext": "agda", "hexsha": "95828cf7d3eb48616e557e204832d091ab7a8dcb", "lang": "Agda", "max_forks_count": 3, "max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z", "max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z", "max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "asr/fotc", "max_forks_repo_path": "notes/thesis/report/LogicalFramework/GroupCongruence.agda", "max_issues_count": 2, "max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d", "max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z", "max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "asr/fotc", "max_issues_repo_path": "notes/thesis/report/LogicalFramework/GroupCongruence.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": "notes/thesis/report/LogicalFramework/GroupCongruence.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": 208, "size": 748 }
------------------------------------------------------------------------ -- The Agda standard library -- -- Lists where at least one element satisfies a given property ------------------------------------------------------------------------ module Data.List.Any where open import Data.Empty open import Data.Fin open import Function open import Function.Equality using (_⟨$⟩_) open import Function.Equivalence as Equiv using (module Equivalence) open import Function.Related as Related hiding (_∼[_]_) open import Data.List as List using (List; []; _∷_) open import Data.Product as Prod using (∃; _×_; _,_) open import Level using (Level; _⊔_) open import Relation.Nullary import Relation.Nullary.Decidable as Dec open import Relation.Unary using (Decidable) renaming (_⊆_ to _⋐_) open import Relation.Binary hiding (Decidable) import Relation.Binary.InducedPreorders as Ind open import Relation.Binary.List.Pointwise as ListEq using ([]; _∷_) open import Relation.Binary.PropositionalEquality as PropEq using (_≡_) -- Any P xs means that at least one element in xs satisfies P. data Any {a p} {A : Set a} (P : A → Set p) : List A → Set (a ⊔ p) where here : ∀ {x xs} (px : P x) → Any P (x ∷ xs) there : ∀ {x xs} (pxs : Any P xs) → Any P (x ∷ xs) -- Map. map : ∀ {a p q} {A : Set a} {P : A → Set p} → {Q : A → Set q} → P ⋐ Q → Any P ⋐ Any Q map g (here px) = here (g px) map g (there pxs) = there (map g pxs) -- If the head does not satisfy the predicate, then the tail will. tail : ∀ {a p} {A : Set a} {x : A} {xs : List A} {P : A → Set p} → ¬ P x → Any P (x ∷ xs) → Any P xs tail ¬px (here px) = ⊥-elim (¬px px) tail ¬px (there pxs) = pxs -- Decides Any. any : ∀ {a p} {A : Set a} {P : A → Set p} → Decidable P → Decidable (Any P) any p [] = no λ() any p (x ∷ xs) with p x any p (x ∷ xs) \| yes px = yes (here px) any p (x ∷ xs) \| no ¬px = Dec.map′ there (tail ¬px) (any p xs) -- index x∈xs is the list position (zero-based) which x∈xs points to. index : ∀ {a p} {A : Set a} {P : A → Set p} {xs} → Any P xs → Fin (List.length xs) index (here px) = zero index (there pxs) = suc (index pxs) ------------------------------------------------------------------------ -- List membership and some related definitions module Membership {c ℓ : Level} (S : Setoid c ℓ) where private open module S = Setoid S using (_≈_) renaming (Carrier to A) open module LS = Setoid (ListEq.setoid S) using () renaming (_≈_ to _≋_) -- If a predicate P respects the underlying equality then Any P -- respects the list equality. lift-resp : ∀ {p} {P : A → Set p} → P Respects _≈_ → Any P Respects _≋_ lift-resp resp [] () lift-resp resp (x≈y ∷ xs≈ys) (here px) = here (resp x≈y px) lift-resp resp (x≈y ∷ xs≈ys) (there pxs) = there (lift-resp resp xs≈ys pxs) -- List membership. infix 4 _∈_ _∉_ _∈_ : A → List A → Set _ x ∈ xs = Any (_≈_ x) xs _∉_ : A → List A → Set _ x ∉ xs = ¬ x ∈ xs -- Subsets. infix 4 _⊆_ _⊈_ _⊆_ : List A → List A → Set _ xs ⊆ ys = ∀ {x} → x ∈ xs → x ∈ ys _⊈_ : List A → List A → Set _ xs ⊈ ys = ¬ xs ⊆ ys -- Equality is respected by the predicate which is used to define -- _∈_. ∈-resp-≈ : ∀ {x} → (_≈_ x) Respects _≈_ ∈-resp-≈ = flip S.trans -- List equality is respected by _∈_. ∈-resp-list-≈ : ∀ {x} → _∈_ x Respects _≋_ ∈-resp-list-≈ = lift-resp ∈-resp-≈ -- _⊆_ is a preorder. ⊆-preorder : Preorder _ _ _ ⊆-preorder = Ind.InducedPreorder₂ (ListEq.setoid S) _∈_ ∈-resp-list-≈ module ⊆-Reasoning where import Relation.Binary.PreorderReasoning as PreR open PreR ⊆-preorder public renaming (_∼⟨_⟩_ to _⊆⟨_⟩_) infix 1 _∈⟨_⟩_ _∈⟨_⟩_ : ∀ x {xs ys} → x ∈ xs → xs IsRelatedTo ys → x ∈ ys x ∈⟨ x∈xs ⟩ xs⊆ys = (begin xs⊆ys) x∈xs -- A variant of List.map. map-with-∈ : ∀ {b} {B : Set b} (xs : List A) → (∀ {x} → x ∈ xs → B) → List B map-with-∈ [] f = [] map-with-∈ (x ∷ xs) f = f (here S.refl) ∷ map-with-∈ xs (f ∘ there) -- Finds an element satisfying the predicate. find : ∀ {p} {P : A → Set p} {xs} → Any P xs → ∃ λ x → x ∈ xs × P x find (here px) = (_ , here S.refl , px) find (there pxs) = Prod.map id (Prod.map there id) (find pxs) lose : ∀ {p} {P : A → Set p} {x xs} → P Respects _≈_ → x ∈ xs → P x → Any P xs lose resp x∈xs px = map (flip resp px) x∈xs -- The code above instantiated (and slightly changed) for -- propositional equality, along with some additional definitions. module Membership-≡ where private open module M {a} {A : Set a} = Membership (PropEq.setoid A) public hiding (lift-resp; lose; ⊆-preorder; module ⊆-Reasoning) lose : ∀ {a p} {A : Set a} {P : A → Set p} {x xs} → x ∈ xs → P x → Any P xs lose {P = P} = M.lose (PropEq.subst P) -- _⊆_ is a preorder. ⊆-preorder : ∀ {a} → Set a → Preorder _ _ _ ⊆-preorder A = Ind.InducedPreorder₂ (PropEq.setoid (List A)) _∈_ (PropEq.subst (_∈_ _)) -- Set and bag equality and related preorders. open Related public using (Kind; Symmetric-kind) renaming ( implication to subset ; reverse-implication to superset ; equivalence to set ; injection to subbag ; reverse-injection to superbag ; bijection to bag ) [_]-Order : Kind → ∀ {a} → Set a → Preorder _ _ _ [ k ]-Order A = Related.InducedPreorder₂ k (_∈_ {A = A}) [_]-Equality : Symmetric-kind → ∀ {a} → Set a → Setoid _ _ [ k ]-Equality A = Related.InducedEquivalence₂ k (_∈_ {A = A}) infix 4 _∼[_]_ _∼[_]_ : ∀ {a} {A : Set a} → List A → Kind → List A → Set _ _∼[_]_ {A = A} xs k ys = Preorder._∼_ ([ k ]-Order A) xs ys -- Bag equality implies the other relations. bag-=⇒ : ∀ {k a} {A : Set a} {xs ys : List A} → xs ∼[ bag ] ys → xs ∼[ k ] ys bag-=⇒ xs≈ys = ↔⇒ xs≈ys -- "Equational" reasoning for _⊆_. module ⊆-Reasoning where import Relation.Binary.PreorderReasoning as PreR private open module PR {a} {A : Set a} = PreR (⊆-preorder A) public renaming (_∼⟨_⟩_ to _⊆⟨_⟩_; _≈⟨_⟩_ to _≡⟨_⟩_) infixr 2 _∼⟨_⟩_ infix 1 _∈⟨_⟩_ _∈⟨_⟩_ : ∀ {a} {A : Set a} x {xs ys : List A} → x ∈ xs → xs IsRelatedTo ys → x ∈ ys x ∈⟨ x∈xs ⟩ xs⊆ys = (begin xs⊆ys) x∈xs _∼⟨_⟩_ : ∀ {k a} {A : Set a} xs {ys zs : List A} → xs ∼[ ⌊ k ⌋→ ] ys → ys IsRelatedTo zs → xs IsRelatedTo zs xs ∼⟨ xs≈ys ⟩ ys≈zs = xs ⊆⟨ ⇒→ xs≈ys ⟩ ys≈zs ------------------------------------------------------------------------ -- Another function -- If any element satisfies P, then P is satisfied. satisfied : ∀ {a p} {A : Set a} {P : A → Set p} {xs} → Any P xs → ∃ P satisfied = Prod.map id Prod.proj₂ ∘ Membership-≡.find	{ "alphanum_fraction": 0.5429398986, "avg_line_length": 30.9641255605, "ext": "agda", "hexsha": "89a0255c3bf8075bcc8b74931042744c7f3d602e", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "9d4c43b1609d3f085636376fdca73093481ab882", "max_forks_repo_licenses": [ "Apache-2.0" ], "max_forks_repo_name": "qwe2/try-agda", "max_forks_repo_path": "agda-stdlib-0.9/src/Data/List/Any.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "9d4c43b1609d3f085636376fdca73093481ab882", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "Apache-2.0" ], "max_issues_repo_name": "qwe2/try-agda", "max_issues_repo_path": "agda-stdlib-0.9/src/Data/List/Any.agda", "max_line_length": 72, "max_stars_count": 1, "max_stars_repo_head_hexsha": "9d4c43b1609d3f085636376fdca73093481ab882", "max_stars_repo_licenses": [ "Apache-2.0" ], "max_stars_repo_name": "qwe2/try-agda", "max_stars_repo_path": "agda-stdlib-0.9/src/Data/List/Any.agda", "max_stars_repo_stars_event_max_datetime": "2016-10-20T15:52:05.000Z", "max_stars_repo_stars_event_min_datetime": "2016-10-20T15:52:05.000Z", "num_tokens": 2476, "size": 6905 }
------------------------------------------------------------------------ -- The Agda standard library -- -- Well-founded induction ------------------------------------------------------------------------ {-# OPTIONS --without-K --safe #-} open import Relation.Binary module Induction.WellFounded where open import Data.Product open import Function open import Induction open import Level open import Relation.Unary -- When using well-founded recursion you can recurse arbitrarily, as -- long as the arguments become smaller, and "smaller" is -- well-founded. WfRec : ∀ {a r} {A : Set a} → Rel A r → ∀ {ℓ} → RecStruct A ℓ _ WfRec _<_ P x = ∀ y → y < x → P y -- The accessibility predicate: x is accessible if everything which is -- smaller than x is also accessible (inductively). data Acc {a ℓ} {A : Set a} (_<_ : Rel A ℓ) (x : A) : Set (a ⊔ ℓ) where acc : (rs : WfRec _<_ (Acc _<_) x) → Acc _<_ x -- The accessibility predicate encodes what it means to be -- well-founded; if all elements are accessible, then _<_ is -- well-founded. WellFounded : ∀ {a ℓ} {A : Set a} → Rel A ℓ → Set _ WellFounded _<_ = ∀ x → Acc _<_ x Well-founded = WellFounded {-# WARNING_ON_USAGE Well-founded "Warning: Well-founded was deprecated in v0.15. Please use WellFounded instead." #-} ------------------------------------------------------------------------ -- Well-founded induction for the subset of accessible elements: module Some {a lt} {A : Set a} {_<_ : Rel A lt} {ℓ} where wfRecBuilder : SubsetRecursorBuilder (Acc _<_) (WfRec _<_ {ℓ = ℓ}) wfRecBuilder P f x (acc rs) = λ y y<x → f y (wfRecBuilder P f y (rs y y<x)) wfRec : SubsetRecursor (Acc _<_) (WfRec _<_) wfRec = subsetBuild wfRecBuilder wfRec-builder = wfRecBuilder {-# WARNING_ON_USAGE wfRec-builder "Warning: wfRec-builder was deprecated in v0.15. Please use wfRecBuilder instead." #-} ------------------------------------------------------------------------ -- Well-founded induction for all elements, assuming they are all -- accessible: module All {a lt} {A : Set a} {_<_ : Rel A lt} (wf : WellFounded _<_) ℓ where wfRecBuilder : RecursorBuilder (WfRec _<_ {ℓ = ℓ}) wfRecBuilder P f x = Some.wfRecBuilder P f x (wf x) wfRec : Recursor (WfRec _<_) wfRec = build wfRecBuilder wfRec-builder = wfRecBuilder {-# WARNING_ON_USAGE wfRec-builder "Warning: wfRec-builder was deprecated in v0.15. Please use wfRecBuilder instead." #-} ------------------------------------------------------------------------ -- It might be useful to establish proofs of Acc or Well-founded using -- combinators such as the ones below (see, for instance, -- "Constructing Recursion Operators in Intuitionistic Type Theory" by -- Lawrence C Paulson). module Subrelation {a ℓ₁ ℓ₂} {A : Set a} {_<₁_ : Rel A ℓ₁} {_<₂_ : Rel A ℓ₂} (<₁⇒<₂ : ∀ {x y} → x <₁ y → x <₂ y) where accessible : Acc _<₂_ ⊆ Acc _<₁_ accessible (acc rs) = acc (λ y y<x → accessible (rs y (<₁⇒<₂ y<x))) wellFounded : WellFounded _<₂_ → WellFounded _<₁_ wellFounded wf = λ x → accessible (wf x) well-founded = wellFounded {-# WARNING_ON_USAGE well-founded "Warning: well-founded was deprecated in v0.15. Please use wellFounded instead." #-} module InverseImage {a b ℓ} {A : Set a} {B : Set b} {_<_ : Rel B ℓ} (f : A → B) where accessible : ∀ {x} → Acc _<_ (f x) → Acc (_<_ on f) x accessible (acc rs) = acc (λ y fy<fx → accessible (rs (f y) fy<fx)) wellFounded : WellFounded _<_ → WellFounded (_<_ on f) wellFounded wf = λ x → accessible (wf (f x)) well-founded = wellFounded {-# WARNING_ON_USAGE well-founded "Warning: well-founded was deprecated in v0.15. Please use wellFounded instead." #-} module TransitiveClosure {a ℓ} {A : Set a} (_<_ : Rel A ℓ) where infix 4 _<⁺_ data _<⁺_ : Rel A (a ⊔ ℓ) where [_] : ∀ {x y} (x<y : x < y) → x <⁺ y trans : ∀ {x y z} (x<y : x <⁺ y) (y<z : y <⁺ z) → x <⁺ z downwardsClosed : ∀ {x y} → Acc _<⁺_ y → x <⁺ y → Acc _<⁺_ x downwardsClosed (acc rs) x<y = acc (λ z z<x → rs z (trans z<x x<y)) mutual accessible : ∀ {x} → Acc _<_ x → Acc _<⁺_ x accessible acc-x = acc (accessible′ acc-x) accessible′ : ∀ {x} → Acc _<_ x → WfRec _<⁺_ (Acc _<⁺_) x accessible′ (acc rs) y [ y<x ] = accessible (rs y y<x) accessible′ acc-x y (trans y<z z<x) = downwardsClosed (accessible′ acc-x _ z<x) y<z wellFounded : WellFounded _<_ → WellFounded _<⁺_ wellFounded wf = λ x → accessible (wf x) downwards-closed = downwardsClosed {-# WARNING_ON_USAGE downwards-closed "Warning: downwards-closed was deprecated in v0.15. Please use downwardsClosed instead." #-} well-founded = wellFounded {-# WARNING_ON_USAGE well-founded "Warning: well-founded was deprecated in v0.15. Please use wellFounded instead." #-} module Lexicographic {a b ℓ₁ ℓ₂} {A : Set a} {B : A → Set b} (RelA : Rel A ℓ₁) (RelB : ∀ x → Rel (B x) ℓ₂) where data _<_ : Rel (Σ A B) (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where left : ∀ {x₁ y₁ x₂ y₂} (x₁<x₂ : RelA x₁ x₂) → (x₁ , y₁) < (x₂ , y₂) right : ∀ {x y₁ y₂} (y₁<y₂ : RelB x y₁ y₂) → (x , y₁) < (x , y₂) mutual accessible : ∀ {x y} → Acc RelA x → (∀ {x} → WellFounded (RelB x)) → Acc _<_ (x , y) accessible accA wfB = acc (accessible′ accA (wfB _) wfB) accessible′ : ∀ {x y} → Acc RelA x → Acc (RelB x) y → (∀ {x} → WellFounded (RelB x)) → WfRec _<_ (Acc _<_) (x , y) accessible′ (acc rsA) _ wfB ._ (left x′<x) = accessible (rsA _ x′<x) wfB accessible′ accA (acc rsB) wfB ._ (right y′<y) = acc (accessible′ accA (rsB _ y′<y) wfB) wellFounded : WellFounded RelA → (∀ {x} → WellFounded (RelB x)) → WellFounded _<_ wellFounded wfA wfB p = accessible (wfA (proj₁ p)) wfB well-founded = wellFounded {-# WARNING_ON_USAGE well-founded "Warning: well-founded was deprecated in v0.15. Please use wellFounded instead." #-} ------------------------------------------------------------------------ -- DEPRECATED NAMES ------------------------------------------------------------------------ -- Please use the new names as continuing support for the old names is -- not guaranteed. -- Version 1.0 module Inverse-image = InverseImage module Transitive-closure = TransitiveClosure	{ "alphanum_fraction": 0.5717841033, "avg_line_length": 32.3065326633, "ext": "agda", "hexsha": "7f0ea62de59db5a0ff3fdff9fccb9aa3803a538e", "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/Induction/WellFounded.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/Induction/WellFounded.agda", "max_line_length": 80, "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/Induction/WellFounded.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 1974, "size": 6429 }
open import FRP.LTL.RSet.Core using ( RSet ) module FRP.LTL.RSet.Stateless where infixr 1 _⇒_ _⇒_ : RSet → RSet → RSet (A ⇒ B) t = A t → B t	{ "alphanum_fraction": 0.6413793103, "avg_line_length": 14.5, "ext": "agda", "hexsha": "33cb88eee7a2b890b9becfeb89093bf8ca36cfd0", "lang": "Agda", "max_forks_count": 3, "max_forks_repo_forks_event_max_datetime": "2022-03-12T11:39:04.000Z", "max_forks_repo_forks_event_min_datetime": "2015-03-01T07:33:00.000Z", "max_forks_repo_head_hexsha": "e88107d7d192cbfefd0a94505e6a5793afe1a7a5", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "agda/agda-frp-ltl", "max_forks_repo_path": "src/FRP/LTL/RSet/Stateless.agda", "max_issues_count": 2, "max_issues_repo_head_hexsha": "e88107d7d192cbfefd0a94505e6a5793afe1a7a5", "max_issues_repo_issues_event_max_datetime": "2015-03-02T15:23:53.000Z", "max_issues_repo_issues_event_min_datetime": "2015-03-01T07:01:31.000Z", "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "agda/agda-frp-ltl", "max_issues_repo_path": "src/FRP/LTL/RSet/Stateless.agda", "max_line_length": 44, "max_stars_count": 21, "max_stars_repo_head_hexsha": "e88107d7d192cbfefd0a94505e6a5793afe1a7a5", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "agda/agda-frp-ltl", "max_stars_repo_path": "src/FRP/LTL/RSet/Stateless.agda", "max_stars_repo_stars_event_max_datetime": "2020-06-15T02:51:13.000Z", "max_stars_repo_stars_event_min_datetime": "2015-07-02T20:25:05.000Z", "num_tokens": 62, "size": 145 }
------------------------------------------------------------------------ -- The Agda standard library -- -- Properties of binary trees ------------------------------------------------------------------------ {-# OPTIONS --without-K --safe #-} module Data.Tree.Binary.Properties where open import Level using (Level) open import Data.Nat.Base using (suc; _+_) open import Data.Tree.Binary open import Function.Base open import Relation.Binary.PropositionalEquality private variable a b : Level A : Set a B : Set b size-map : ∀ (f : A → B) t → size (map f t) ≡ size t size-map f leaf = refl size-map f (node l m r) = cong₂ (λ l r → l + suc r) (size-map f l) (size-map f r) map-id : ∀ (t : Tree A) → map id t ≡ t map-id leaf = refl map-id (node l v r) = cong₂ (flip node v) (map-id l) (map-id r)	{ "alphanum_fraction": 0.5222623345, "avg_line_length": 26.8064516129, "ext": "agda", "hexsha": "d23b24aa198706814eaf1073e1fed3e2d509a703", "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": "agda-stdlib/src/Data/Tree/Binary/Properties.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": "agda-stdlib/src/Data/Tree/Binary/Properties.agda", "max_line_length": 72, "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": "agda-stdlib/src/Data/Tree/Binary/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": 215, "size": 831 }
{-# OPTIONS --without-K --exact-split #-} module ideals where import abelian-subgroups import rings open abelian-subgroups public open rings public {- Subsets of rings -} subset-Ring : (l : Level) {l1 : Level} (R : Ring l1) → UU ((lsuc l) ⊔ l1) subset-Ring l R = type-Ring R → UU-Prop l is-set-subset-Ring : (l : Level) {l1 : Level} (R : Ring l1) → is-set (subset-Ring l R) is-set-subset-Ring l R = is-set-function-type (is-set-UU-Prop l) {- Closure properties of subsets of rings -} is-additive-subgroup-subset-Ring : {l1 l2 : Level} (R : Ring l1) (P : subset-Ring l2 R) → UU (l1 ⊔ l2) is-additive-subgroup-subset-Ring R = is-subgroup-Ab (ab-Ring R) is-closed-under-mul-left-subset-Ring : {l1 l2 : Level} (R : Ring l1) (P : subset-Ring l2 R) → UU (l1 ⊔ l2) is-closed-under-mul-left-subset-Ring R P = (x : type-Ring R) (y : type-Ring R) → type-Prop (P y) → type-Prop (P (mul-Ring R x y)) is-closed-under-mul-right-subset-Ring : {l1 l2 : Level} (R : Ring l1) (P : subset-Ring l2 R) → UU (l1 ⊔ l2) is-closed-under-mul-right-subset-Ring R P = (x : type-Ring R) (y : type-Ring R) → type-Prop (P x) → type-Prop (P (mul-Ring R x y)) {- The definition of left and right ideals -} is-left-ideal-subset-Ring : {l1 l2 : Level} (R : Ring l1) (P : subset-Ring l2 R) → UU (l1 ⊔ l2) is-left-ideal-subset-Ring R P = is-additive-subgroup-subset-Ring R P × is-closed-under-mul-left-subset-Ring R P Left-Ideal-Ring : (l : Level) {l1 : Level} (R : Ring l1) → UU ((lsuc l) ⊔ l1) Left-Ideal-Ring l R = Σ (subset-Ring l R) (is-left-ideal-subset-Ring R) is-right-ideal-subset-Ring : {l1 l2 : Level} (R : Ring l1) (P : subset-Ring l2 R) → UU (l1 ⊔ l2) is-right-ideal-subset-Ring R P = is-additive-subgroup-subset-Ring R P × is-closed-under-mul-right-subset-Ring R P Right-Ideal-Ring : (l : Level) {l1 : Level} (R : Ring l1) → UU ((lsuc l) ⊔ l1) Right-Ideal-Ring l R = Σ (subset-Ring l R) (is-right-ideal-subset-Ring R) is-two-sided-ideal-subset-Ring : {l1 l2 : Level} (R : Ring l1) (P : subset-Ring l2 R) → UU (l1 ⊔ l2) is-two-sided-ideal-subset-Ring R P = is-additive-subgroup-subset-Ring R P × ( is-closed-under-mul-left-subset-Ring R P × is-closed-under-mul-right-subset-Ring R P) Two-Sided-Ideal-Ring : (l : Level) {l1 : Level} (R : Ring l1) → UU ((lsuc l) ⊔ l1) Two-Sided-Ideal-Ring l R = Σ (subset-Ring l R) (is-two-sided-ideal-subset-Ring R) {- Special ideals -}	{ "alphanum_fraction": 0.6391880696, "avg_line_length": 32.1866666667, "ext": "agda", "hexsha": "d377147d8c90aee2ff9e2997cb8d8268bd7b34d4", "lang": "Agda", "max_forks_count": 30, "max_forks_repo_forks_event_max_datetime": "2022-03-16T00:33:50.000Z", "max_forks_repo_forks_event_min_datetime": "2018-09-26T09:08:57.000Z", "max_forks_repo_head_hexsha": "1e1f8def50f9359928e52ebb2ee53ed1166487d9", "max_forks_repo_licenses": [ "CC-BY-4.0" ], "max_forks_repo_name": "UlrikBuchholtz/HoTT-Intro", "max_forks_repo_path": "Agda/ideals.agda", "max_issues_count": 8, "max_issues_repo_head_hexsha": "1e1f8def50f9359928e52ebb2ee53ed1166487d9", "max_issues_repo_issues_event_max_datetime": "2020-10-16T15:27:01.000Z", "max_issues_repo_issues_event_min_datetime": "2019-06-18T04:16:04.000Z", "max_issues_repo_licenses": [ "CC-BY-4.0" ], "max_issues_repo_name": "UlrikBuchholtz/HoTT-Intro", "max_issues_repo_path": "Agda/ideals.agda", "max_line_length": 73, "max_stars_count": 333, "max_stars_repo_head_hexsha": "1e1f8def50f9359928e52ebb2ee53ed1166487d9", "max_stars_repo_licenses": [ "CC-BY-4.0" ], "max_stars_repo_name": "UlrikBuchholtz/HoTT-Intro", "max_stars_repo_path": "Agda/ideals.agda", "max_stars_repo_stars_event_max_datetime": "2022-03-22T23:50:15.000Z", "max_stars_repo_stars_event_min_datetime": "2018-09-26T08:33:30.000Z", "num_tokens": 934, "size": 2414 }
open import Auto.Prelude -- using a type argument as a proof h0 : (x₁ x₂ : ⊥) → x₁ ≡ x₂ h0 = {!!} --h0 = λ x₁ → λ () -- using dependent pair to define non-dep pair module DND where _×_ : Set → Set → Set A × B = Σ A (λ _ → B) h1-2 : ∀ {A B} → A × B → B × A -- h1-2 = {!!} -- no solution found h1-2 = λ h → Σ-i {!!} {!!} -- h1-2 = λ h → Σ-i (Σ.prf h) (Σ.wit h)	{ "alphanum_fraction": 0.4906666667, "avg_line_length": 15, "ext": "agda", "hexsha": "6da444fb9174e373a32c37e48f66b23d6bf8ad8f", "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/interaction/Auto-Misc.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/interaction/Auto-Misc.agda", "max_line_length": 46, "max_stars_count": 1, "max_stars_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "masondesu/agda", "max_stars_repo_path": "test/interaction/Auto-Misc.agda", "max_stars_repo_stars_event_max_datetime": "2018-10-10T17:08:44.000Z", "max_stars_repo_stars_event_min_datetime": "2018-10-10T17:08:44.000Z", "num_tokens": 165, "size": 375 }
{-# OPTIONS --safe --without-K #-} open import Relation.Binary module Data.List.Membership.Setoid.Distinct where open import Data.List as List using (List; []; _∷_; _++_) open import Data.List.Any as Any hiding (map; head; tail) open import Data.List.Any.Properties open import Relation.Binary.PropositionalEquality as P using (_≡_) open import Function open import Function.Equivalence using (_⇔_; equivalence) open import Function.Equality using (_⟨$⟩_) open import Function.Inverse using () open import Function.Injection using (_↣_; Injection) open import Data.Product hiding (map) open import Data.Sum hiding (map) import Level as L open import Data.Fin as Fin using (Fin) open import Data.Nat as ℕ module _ {a p} {S : Setoid a p} where open Setoid S renaming (Carrier to A) open import Data.List.Membership.Setoid (S) open import Data.List.Membership.Setoid.Properties open import Data.List.Membership.Setoid.Disjoint (S) renaming (Disjoint to _⋈_) open import Data.List.Membership.Setoid.Trans (S) open import Data.Empty data Distinct : List A → Set (a L.⊔ p) where distinct-[] : Distinct [] _distinct-∷_by_ : ∀ x {xs} → Distinct xs → x ∉ xs → Distinct (x ∷ xs) head : ∀ {x}{xs : List A} → Distinct (x ∷ xs) → A head (x distinct-∷ _ by _) = x tail : ∀ {x}{xs : List A} → Distinct (x ∷ xs) → Distinct xs tail (_ distinct-∷ dis by _) = dis head∉tail : ∀ {x}{xs : List A} → Distinct (x ∷ xs) → x ∉ xs head∉tail (_ distinct-∷ _ by x∉xs) = x∉xs distinct-[_] : ∀ x → Distinct (List.[ x ]) distinct-[ x ] = x distinct-∷ distinct-[] by (λ ()) ⋈-++ : ∀ (xs ys : List A) → Distinct (xs ++ ys) ⇔ (Distinct xs × Distinct ys × xs ⋈ ys) ⋈-++ xs ys = equivalence to from where to : ∀ {xs ys : List A} → Distinct (xs ++ ys) → (Distinct xs × Distinct ys × xs ⋈ ys) to {[]} dys = distinct-[] , dys , disjoint-[]ʳ to {x ∷ xs} {ys} (.x distinct-∷ dis by x∉xsys) with to {xs = xs} dis ... \| dxs , dys , xs⋈ys = x distinct-∷ dxs by (λ x∈xs → x∉xsys (++⁺ˡ x∈xs)) , dys , λ { (here px) ∈ys → x∉xsys (++⁺ʳ xs (≈-trans-∈ (sym px) ∈ys)) ; (there ∈xs) ∈ys → xs⋈ys ∈xs ∈ys} from : ∀ {xs ys : List A} → (Distinct xs × Distinct ys × xs ⋈ ys) → Distinct (xs ++ ys) from (distinct-[] , dys , xs⋈ys) = dys from {xs = .x ∷ xs} ((x distinct-∷ dxs by x∉xs) , dys , xxs⋈ys) with from (dxs , dys , xxs⋈ys ∘ there) ... \| dxsys = x distinct-∷ dxsys by λ x∈xsys → case ++⁻ xs x∈xsys of λ { (inj₁ x∈xs) → x∉xs x∈xs ; (inj₂ x∈ys) → xxs⋈ys (here refl) x∈ys} lookup-injective : {xs : List A}(dxs : Distinct xs) → ∀ {i j} → List.lookup xs i ≡ List.lookup xs j → i ≡ j lookup-injective distinct-[] {()} {()} _ lookup-injective (x distinct-∷ dxs by x∉xs) {Fin.zero} {Fin.zero} _ = P.refl lookup-injective (x distinct-∷ dxs by x∉xs) {Fin.suc i} {Fin.suc j} eq = P.cong Fin.suc (lookup-injective dxs eq) lookup-injective {xs} (x distinct-∷ dxs by x∉xs) {Fin.zero} {Fin.suc j} eq rewrite eq = ⊥-elim (x∉xs (∈-lookup S _ j)) lookup-injective (x distinct-∷ dxs by x∉xs) {Fin.suc i} {Fin.zero} eq rewrite P.sym eq = ⊥-elim (x∉xs (∈-lookup S _ i)) module _ {a₁ a₂ p₁ p₂}{S₁ : Setoid a₁ p₁} {S₂ : Setoid a₂ p₂} where open Setoid S₁ renaming (Carrier to A) using () open Setoid S₂ renaming (Carrier to B) using () open import Data.List.Membership.Setoid (S₂) renaming (_∉_ to _∉₂_) using () open import Data.List.Membership.Setoid.Properties open import Data.List.Membership.Setoid.Trans (S₁) map : (f : Injection S₁ S₂) → ∀ {xs : List A} → Distinct {S = S₁} xs → Distinct {S = S₂} (List.map (Injection.to f ⟨$⟩_) xs) map f {[]} distinct-[] = distinct-[] map f {.x ∷ xs} (x distinct-∷ dis by x∉xs) = fx distinct-∷ map f dis by lemma where fx = Injection.to f ⟨$⟩ x lemma : fx ∉₂ List.map (Injection.to f ⟨$⟩_) xs lemma p with ∈-map⁻ S₁ S₂ p ... \| _ , y∈xs , fx≈fy = x∉xs (≈-trans-∈ (Injection.injective f fx≈fy) y∈xs)	{ "alphanum_fraction": 0.5965686275, "avg_line_length": 48, "ext": "agda", "hexsha": "3f688f384bbed4e8ea1c1fa10a98678740095c96", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "d4cd2a3442a9b58e6139499d16a2b31268f27f80", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "tizmd/agda-distinct-disjoint", "max_forks_repo_path": "src/Data/List/Membership/Setoid/Distinct.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "d4cd2a3442a9b58e6139499d16a2b31268f27f80", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "tizmd/agda-distinct-disjoint", "max_issues_repo_path": "src/Data/List/Membership/Setoid/Distinct.agda", "max_line_length": 136, "max_stars_count": null, "max_stars_repo_head_hexsha": "d4cd2a3442a9b58e6139499d16a2b31268f27f80", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "tizmd/agda-distinct-disjoint", "max_stars_repo_path": "src/Data/List/Membership/Setoid/Distinct.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 1466, "size": 4080 }
module StateSized.GUI.BitMaps where open import StateSizedIO.GUI.WxBindingsFFI ship : Bitmap ship = bitmap "./StateSized/GUI/ship.ico" rock : Bitmap rock = bitmap "./StateSized/GUI/rock.ico"	{ "alphanum_fraction": 0.7680412371, "avg_line_length": 19.4, "ext": "agda", "hexsha": "951aae4e24daff87f21ac3dca69ce63ca503b8c0", "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": "examples/StateSized/GUI/BitMaps.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": "examples/StateSized/GUI/BitMaps.agda", "max_line_length": 42, "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": "examples/StateSized/GUI/BitMaps.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": 56, "size": 194 }
-- Andreas, 2020-04-15, issue #4586 -- Better error message when `let` contains a `where` clause. foo : Set₁ foo = let x = Set where y = Set in Set -- WAS: -- Not a valid let-declaration -- when scope checking -- let x = Set -- where -- y = Set -- in Set -- EXPECTED: -- No `where' clauses allowed in let binding -- when scope checking -- let x = Set -- where -- y = Set -- in Set	{ "alphanum_fraction": 0.5612009238, "avg_line_length": 18.0416666667, "ext": "agda", "hexsha": "a3ec1d94475608beb2a37d2fab9be18e801fcb84", "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/Issue4586WhereInLet.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/Issue4586WhereInLet.agda", "max_line_length": 61, "max_stars_count": 1989, "max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338", "max_stars_repo_licenses": [ "BSD-3-Clause" ], "max_stars_repo_name": "shlevy/agda", "max_stars_repo_path": "test/Fail/Issue4586WhereInLet.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": 130, "size": 433 }
------------------------------------------------------------------------ -- The Agda standard library -- -- Least common multiple ------------------------------------------------------------------------ {-# OPTIONS --without-K --safe #-} module Data.Nat.LCM where open import Algebra open import Data.Nat.Base open import Data.Nat.Coprimality using (Coprime) open import Data.Nat.Divisibility open import Data.Nat.DivMod open import Data.Nat.Properties open import Data.Nat.Solver open import Data.Nat.GCD open import Data.Product open import Data.Sum.Base using (_⊎_; inj₁; inj₂) open import Function open import Relation.Binary.PropositionalEquality as P using (_≡_; refl; sym; trans; cong; cong₂; module ≡-Reasoning) open import Relation.Binary open import Relation.Nullary.Decidable using (False; fromWitnessFalse) open +--Solver private gcd≢0′ : ∀ m n → False (gcd (suc m) n ≟ 0) gcd≢0′ m n = fromWitnessFalse (gcd[m,n]≢0 (suc m) n (inj₁ (λ()))) ------------------------------------------------------------------------ -- Definition lcm : ℕ → ℕ → ℕ lcm zero n = zero lcm m@(suc m-1) n = m (n / gcd m n) {gcd≢0′ m-1 n} ------------------------------------------------------------------------ -- Core properties private rearrange : ∀ m-1 n → lcm (suc m-1) n ≡ ((suc m-1) * n / gcd (suc m-1) n) {gcd≢0′ m-1 n} rearrange m-1 n = sym (-/-assoc m {n} {gcd m n} {gcd≢0′ m-1 n} (gcd[m,n]∣n m n)) where m = suc m-1 m∣lcm[m,n] : ∀ m n → m ∣ lcm m n m∣lcm[m,n] zero n = 0 ∣0 m∣lcm[m,n] m@(suc _) n = m∣mn (n / gcd m n) n∣lcm[m,n] : ∀ m n → n ∣ lcm m n n∣lcm[m,n] zero n = n ∣0 n∣lcm[m,n] m@(suc m-1) n = begin n ∣⟨ m∣mn (m / gcd m n) ⟩ n (m / gcd m n) ≡⟨ sym (-/-assoc n {≢0 = gcd≢0′ m-1 n} (gcd[m,n]∣m m n)) ⟩ n m / gcd m n ≡⟨ cong (λ v → (v / gcd m n) {gcd≢0′ m-1 n}) (-comm n m) ⟩ m n / gcd m n ≡⟨ sym (rearrange m-1 n) ⟩ m * (n / gcd m n) ∎ where open ∣-Reasoning lcm-least : ∀ {m n c} → m ∣ c → n ∣ c → lcm m n ∣ c lcm-least {zero} {n} {c} 0∣c _ = 0∣c lcm-least {m@(suc m-1)} {n} {c} m∣c n∣c = P.subst (_∣ c) (sym (rearrange m-1 n)) (m∣no⇒m/n∣o {n≢0 = gcd≢0′ m-1 n} gcd[m,n]∣mn mn∣cgcd) where open ∣-Reasoning gcd[m,n]∣mn : gcd m n ∣ m * n gcd[m,n]∣mn = ∣-trans (gcd[m,n]∣m m n) (m∣mn n) mn∣cgcd : m n ∣ c * gcd m n mn∣cgcd = begin m n ∣⟨ gcd-greatest (P.subst (_∣ c * m) (-comm n m) (-monoˡ-∣ m n∣c)) (-monoˡ-∣ n m∣c) ⟩ gcd (c m) (c * n) ≡⟨ sym (cgcd[m,n]≡gcd[cm,cn] c m n) ⟩ c gcd m n ∎ ------------------------------------------------------------------------ -- Other properties -- Note that all other properties of `gcd` should be inferable from the -- 3 core properties above. gcdlcm : ∀ m n → gcd m n lcm m n ≡ m * n gcdlcm zero n = -zeroʳ (gcd 0 n) gcdlcm m@(suc m-1) n = trans (cong (gcd m n _) (rearrange m-1 n)) (m[n/m]≡n {gcd m n} (begin gcd m n ∣⟨ gcd[m,n]∣m m n ⟩ m ∣⟨ m∣mn n ⟩ m * n ∎)) where open ∣-Reasoning lcm[0,n]≡0 : ∀ n → lcm 0 n ≡ 0 lcm[0,n]≡0 n = 0∣⇒≡0 (m∣lcm[m,n] 0 n) lcm[n,0]≡0 : ∀ n → lcm n 0 ≡ 0 lcm[n,0]≡0 n = 0∣⇒≡0 (n∣lcm[m,n] n 0) lcm-comm : ∀ m n → lcm m n ≡ lcm n m lcm-comm m n = ∣-antisym (lcm-least (n∣lcm[m,n] n m) (m∣lcm[m,n] n m)) (lcm-least (n∣lcm[m,n] m n) (m∣lcm[m,n] m n)) ------------------------------------------------------------------------ -- Least common multiple (lcm). module LCM where -- Specification of the least common multiple (lcm) of two natural -- numbers. record LCM (i j lcm : ℕ) : Set where field -- The lcm is a common multiple. commonMultiple : i ∣ lcm × j ∣ lcm -- The lcm divides all common multiples, i.e. the lcm is the least -- common multiple according to the partial order _∣_. least : ∀ {m} → i ∣ m × j ∣ m → lcm ∣ m open LCM public -- The lcm is unique. unique : ∀ {d₁ d₂ m n} → LCM m n d₁ → LCM m n d₂ → d₁ ≡ d₂ unique d₁ d₂ = ∣-antisym (LCM.least d₁ (LCM.commonMultiple d₂)) (LCM.least d₂ (LCM.commonMultiple d₁)) open LCM public using (LCM) hiding (module LCM) ------------------------------------------------------------------------ -- Calculating the LCM lcm-LCM : ∀ m n → LCM m n (lcm m n) lcm-LCM m n = record { commonMultiple = m∣lcm[m,n] m n , n∣lcm[m,n] m n ; least = uncurry′ lcm-least } mkLCM : ∀ m n → ∃ λ d → LCM m n d mkLCM m n = lcm m n , lcm-LCM m n GCDLCM : ∀ {m n g l} → GCD m n g → LCM m n l → m n ≡ g * l GCDLCM {m} {n} {g} {l} gc lc = sym (begin g l ≡⟨ cong₂ __ (GCD.unique gc (gcd-GCD m n)) (LCM.unique lc (lcm-LCM m n)) ⟩ gcd m n lcm m n ≡⟨ gcdlcm m n ⟩ m n ∎) where open ≡-Reasoning	{ "alphanum_fraction": 0.4918759232, "avg_line_length": 32.2380952381, "ext": "agda", "hexsha": "4d2d3b1f2a0ea6f201f3f92a1a240558df37774b", "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": "agda-stdlib/src/Data/Nat/LCM.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": "agda-stdlib/src/Data/Nat/LCM.agda", "max_line_length": 111, "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": "agda-stdlib/src/Data/Nat/LCM.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": 1910, "size": 4739 }
_ : (@0 Set → Set) → (@ω Set → Set) _ = λ f → f	{ "alphanum_fraction": 0.3958333333, "avg_line_length": 16, "ext": "agda", "hexsha": "6d383eb684aa5c9bf147c850131d225c48d30a37", "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/Issue5251-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/Fail/Issue5251-2.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/Fail/Issue5251-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": 22, "size": 48 }
-- Andreas, 2012-04-18, bug reported by pumpkingod on 2012-04-16 module Issue610 where import Common.Level open import Common.Equality data ⊥ : Set where record ⊤ : Set where record A : Set₁ where constructor set field .a : Set .get : A → Set get x = helper x module R where helper : .A -> Set helper x = A.a x ack : A → Set ack x = R.helper x x -- Expected error: -- Identifier R.helper is declared irrelevant, so it cannot be used here hah : set ⊤ ≡ set ⊥ hah = refl .moo : ⊥ moo with cong ack hah moo \| q = subst (λ x → x) q _ baa : .⊥ → ⊥ baa () yoink : ⊥ yoink = baa moo	{ "alphanum_fraction": 0.6416666667, "avg_line_length": 15.3846153846, "ext": "agda", "hexsha": "cce06a4dfb29c4c752263e32910325ba00270fe3", "lang": "Agda", "max_forks_count": 1, "max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z", "max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z", "max_forks_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016", "max_forks_repo_licenses": [ "BSD-3-Clause" ], "max_forks_repo_name": "redfish64/autonomic-agda", "max_forks_repo_path": "test/Fail/Issue610.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "BSD-3-Clause" ], "max_issues_repo_name": "redfish64/autonomic-agda", "max_issues_repo_path": "test/Fail/Issue610.agda", "max_line_length": 72, "max_stars_count": 3, "max_stars_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016", "max_stars_repo_licenses": [ "BSD-3-Clause" ], "max_stars_repo_name": "redfish64/autonomic-agda", "max_stars_repo_path": "test/Fail/Issue610.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": 213, "size": 600 }
module Relation.Path where open import Relation.Path.Operation	{ "alphanum_fraction": 0.8307692308, "avg_line_length": 13, "ext": "agda", "hexsha": "f86b0e4c5174faf9961411e1c8e10e92b79e64bd", "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": "3411b253b0a49a5f9c3301df175ae8ecdc563b12", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "CodaFi/HoTT-Exercises", "max_forks_repo_path": "Relation/Path.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "3411b253b0a49a5f9c3301df175ae8ecdc563b12", "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": "CodaFi/HoTT-Exercises", "max_issues_repo_path": "Relation/Path.agda", "max_line_length": 35, "max_stars_count": null, "max_stars_repo_head_hexsha": "3411b253b0a49a5f9c3301df175ae8ecdc563b12", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "CodaFi/HoTT-Exercises", "max_stars_repo_path": "Relation/Path.agda", "max_stars_repo_stars_event_max_datetime": null, "max_stars_repo_stars_event_min_datetime": null, "num_tokens": 11, "size": 65 }
open import Mockingbird.Forest using (Forest) module Mockingbird.Forest.Combination {b ℓ} (forest : Forest {b} {ℓ}) where open import Mockingbird.Forest.Combination.Base public	{ "alphanum_fraction": 0.7877094972, "avg_line_length": 29.8333333333, "ext": "agda", "hexsha": "1226b73efbbaf4811b0a37fe5186fbf747a6018e", "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": "df8bf877e60b3059532c54a247a36a3d83cd55b0", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "splintah/combinatory-logic", "max_forks_repo_path": "Mockingbird/Forest/Combination.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "df8bf877e60b3059532c54a247a36a3d83cd55b0", "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": "splintah/combinatory-logic", "max_issues_repo_path": "Mockingbird/Forest/Combination.agda", "max_line_length": 75, "max_stars_count": 1, "max_stars_repo_head_hexsha": "df8bf877e60b3059532c54a247a36a3d83cd55b0", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "splintah/combinatory-logic", "max_stars_repo_path": "Mockingbird/Forest/Combination.agda", "max_stars_repo_stars_event_max_datetime": "2022-02-28T23:44:42.000Z", "max_stars_repo_stars_event_min_datetime": "2022-02-28T23:44:42.000Z", "num_tokens": 51, "size": 179 }
{-# OPTIONS --without-K #-} module Path2Equiv where -- nothing for the standard library needed directly! open import FT open import Equivalences open import TypeEquivalences -- We now have enough to map each Pi combinator to the corresponding type equivalence path2equiv : {B₁ B₂ : FT} → (B₁ ⇛ B₂) → (⟦ B₁ ⟧ ≃ ⟦ B₂ ⟧) path2equiv unite₊⇛ = unite₊equiv path2equiv uniti₊⇛ = uniti₊equiv path2equiv swap₊⇛ = swap₊equiv path2equiv assocl₊⇛ = assocl₊equiv path2equiv assocr₊⇛ = assocr₊equiv path2equiv unite⋆⇛ = unite⋆equiv path2equiv uniti⋆⇛ = uniti⋆equiv path2equiv swap⋆⇛ = swap⋆equiv path2equiv assocl⋆⇛ = assocl⋆equiv path2equiv assocr⋆⇛ = assocr⋆equiv path2equiv distz⇛ = distzequiv path2equiv factorz⇛ = factorzequiv path2equiv dist⇛ = distequiv path2equiv factor⇛ = factorequiv path2equiv id⇛ = idequiv path2equiv (sym⇛ p) = sym≃ (path2equiv p) path2equiv (p ◎ q) = trans≃ (path2equiv p) (path2equiv q) path2equiv (p ⊕ q) = path⊎ (path2equiv p) (path2equiv q) path2equiv (p ⊗ q) = path× (path2equiv p) (path2equiv q)	{ "alphanum_fraction": 0.7159199237, "avg_line_length": 30.8529411765, "ext": "agda", "hexsha": "53a4042c426c2f34a48c0e243accf81205d141f6", "lang": "Agda", "max_forks_count": 3, "max_forks_repo_forks_event_max_datetime": "2019-09-10T09:47:13.000Z", "max_forks_repo_forks_event_min_datetime": "2016-05-29T01:56:33.000Z", "max_forks_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1", "max_forks_repo_licenses": [ "BSD-2-Clause" ], "max_forks_repo_name": "JacquesCarette/pi-dual", "max_forks_repo_path": "Univalence/OldUnivalence/Path2Equiv.agda", "max_issues_count": 4, "max_issues_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1", "max_issues_repo_issues_event_max_datetime": "2021-10-29T20:41:23.000Z", "max_issues_repo_issues_event_min_datetime": "2018-06-07T16:27:41.000Z", "max_issues_repo_licenses": [ "BSD-2-Clause" ], "max_issues_repo_name": "JacquesCarette/pi-dual", "max_issues_repo_path": "Univalence/OldUnivalence/Path2Equiv.agda", "max_line_length": 85, "max_stars_count": 14, "max_stars_repo_head_hexsha": "003835484facfde0b770bc2b3d781b42b76184c1", "max_stars_repo_licenses": [ "BSD-2-Clause" ], "max_stars_repo_name": "JacquesCarette/pi-dual", "max_stars_repo_path": "Univalence/OldUnivalence/Path2Equiv.agda", "max_stars_repo_stars_event_max_datetime": "2021-05-05T01:07:57.000Z", "max_stars_repo_stars_event_min_datetime": "2015-08-18T21:40:15.000Z", "num_tokens": 436, "size": 1049 }
------------------------------------------------------------------------ -- Recursive types and potentially infinite trees ------------------------------------------------------------------------ module RecursiveTypes.Syntax where open import Data.Nat open import Data.Fin open import Function.Base open import Data.Product open import Codata.Musical.Notation open import Relation.Nullary import Relation.Nullary.Decidable as Dec open import Relation.Binary open import Relation.Binary.PropositionalEquality import Data.Fin.Properties as FP private open module DF {n} = DecSetoid (FP.≡-decSetoid n) using () renaming (_≟_ to _≟F_) ------------------------------------------------------------------------ -- Types infixr 10 _⟶_ infix 10 μ_⟶_ -- Recursive types, parameterised on the maximum number of free -- variables. -- -- μ σ ⟶ τ stands for μX. σ ⟶ τ, where X can be free in σ and τ. The -- arrow is included to avoid nonsensical types like μX.X. Note that -- no attempt is made to ensure that the variable bound in μ_⟶_ is -- actually used. data Ty (n : ℕ) : Set where ⊥ : Ty n ⊤ : Ty n var : (x : Fin n) → Ty n _⟶_ : (τ₁ τ₂ : Ty n) → Ty n μ_⟶_ : (τ₁ τ₂ : Ty (suc n)) → Ty n -- Potentially infinite trees. data Tree (n : ℕ) : Set where ⊥ : Tree n ⊤ : Tree n var : (x : Fin n) → Tree n _⟶_ : (τ₁ τ₂ : ∞ (Tree n)) → Tree n ------------------------------------------------------------------------ -- Syntactic equality of types is decidable private drop-var : ∀ {n x y} → (Ty n ∋ var x) ≡ var y → x ≡ y drop-var refl = refl drop⟶ˡ : ∀ {n σ₁ σ₂ τ₁ τ₂} → (Ty n ∋ σ₁ ⟶ σ₂) ≡ τ₁ ⟶ τ₂ → σ₁ ≡ τ₁ drop⟶ˡ refl = refl drop⟶ʳ : ∀ {n σ₁ σ₂ τ₁ τ₂} → (Ty n ∋ σ₁ ⟶ σ₂) ≡ τ₁ ⟶ τ₂ → σ₂ ≡ τ₂ drop⟶ʳ refl = refl dropμ⟶ˡ : ∀ {n σ₁ σ₂ τ₁ τ₂} → (Ty n ∋ μ σ₁ ⟶ σ₂) ≡ μ τ₁ ⟶ τ₂ → σ₁ ≡ τ₁ dropμ⟶ˡ refl = refl dropμ⟶ʳ : ∀ {n σ₁ σ₂ τ₁ τ₂} → (Ty n ∋ μ σ₁ ⟶ σ₂) ≡ μ τ₁ ⟶ τ₂ → σ₂ ≡ τ₂ dropμ⟶ʳ refl = refl infix 4 _≡?_ _≡?_ : ∀ {n} (σ τ : Ty n) → Dec (σ ≡ τ) ⊥ ≡? ⊥ = yes refl ⊥ ≡? ⊤ = no (λ ()) ⊥ ≡? var y = no (λ ()) ⊥ ≡? τ₁ ⟶ τ₂ = no (λ ()) ⊥ ≡? μ τ₁ ⟶ τ₂ = no (λ ()) ⊤ ≡? ⊥ = no (λ ()) ⊤ ≡? ⊤ = yes refl ⊤ ≡? var y = no (λ ()) ⊤ ≡? τ₁ ⟶ τ₂ = no (λ ()) ⊤ ≡? μ τ₁ ⟶ τ₂ = no (λ ()) var x ≡? ⊥ = no (λ ()) var x ≡? ⊤ = no (λ ()) var x ≡? var y = Dec.map′ (cong var) drop-var (x ≟F y) var x ≡? τ₁ ⟶ τ₂ = no (λ ()) var x ≡? μ τ₁ ⟶ τ₂ = no (λ ()) σ₁ ⟶ σ₂ ≡? ⊥ = no (λ ()) σ₁ ⟶ σ₂ ≡? ⊤ = no (λ ()) σ₁ ⟶ σ₂ ≡? var y = no (λ ()) σ₁ ⟶ σ₂ ≡? τ₁ ⟶ τ₂ with σ₁ ≡? τ₁ \| σ₂ ≡? τ₂ σ₁ ⟶ σ₂ ≡? .σ₁ ⟶ .σ₂ \| yes refl \| yes refl = yes refl σ₁ ⟶ σ₂ ≡? τ₁ ⟶ τ₂ \| no σ₁≢τ₁ \| _ = no (σ₁≢τ₁ ∘ drop⟶ˡ) σ₁ ⟶ σ₂ ≡? τ₁ ⟶ τ₂ \| _ \| no σ₂≢τ₂ = no (σ₂≢τ₂ ∘ drop⟶ʳ) σ₁ ⟶ σ₂ ≡? μ τ₁ ⟶ τ₂ = no (λ ()) μ σ₁ ⟶ σ₂ ≡? ⊥ = no (λ ()) μ σ₁ ⟶ σ₂ ≡? ⊤ = no (λ ()) μ σ₁ ⟶ σ₂ ≡? var y = no (λ ()) μ σ₁ ⟶ σ₂ ≡? τ₁ ⟶ τ₂ = no (λ ()) μ σ₁ ⟶ σ₂ ≡? μ τ₁ ⟶ τ₂ with σ₁ ≡? τ₁ \| σ₂ ≡? τ₂ μ σ₁ ⟶ σ₂ ≡? μ .σ₁ ⟶ .σ₂ \| yes refl \| yes refl = yes refl μ σ₁ ⟶ σ₂ ≡? μ τ₁ ⟶ τ₂ \| no σ₁≢τ₁ \| _ = no (σ₁≢τ₁ ∘ dropμ⟶ˡ) μ σ₁ ⟶ σ₂ ≡? μ τ₁ ⟶ τ₂ \| _ \| no σ₂≢τ₂ = no (σ₂≢τ₂ ∘ dropμ⟶ʳ) ------------------------------------------------------------------------ -- Hypotheses -- A hypothesis is a pair of types where the first is assumed to be a -- subtype of the other. open Data.Product public using () renaming (_,_ to _≲_) Hyp : ℕ → Set Hyp n = Ty n × Ty n	{ "alphanum_fraction": 0.4336378291, "avg_line_length": 31.2773109244, "ext": "agda", "hexsha": "8c3b482416449ebe181ac36a531fdf95aad76950", "lang": "Agda", "max_forks_count": null, "max_forks_repo_forks_event_max_datetime": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_head_hexsha": "1b90445566df0d3b4ba6e31bd0bac417b4c0eb0e", "max_forks_repo_licenses": [ "MIT" ], "max_forks_repo_name": "nad/codata", "max_forks_repo_path": "RecursiveTypes/Syntax.agda", "max_issues_count": null, "max_issues_repo_head_hexsha": "1b90445566df0d3b4ba6e31bd0bac417b4c0eb0e", "max_issues_repo_issues_event_max_datetime": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_licenses": [ "MIT" ], "max_issues_repo_name": "nad/codata", "max_issues_repo_path": "RecursiveTypes/Syntax.agda", "max_line_length": 72, "max_stars_count": 1, "max_stars_repo_head_hexsha": "1b90445566df0d3b4ba6e31bd0bac417b4c0eb0e", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "nad/codata", "max_stars_repo_path": "RecursiveTypes/Syntax.agda", "max_stars_repo_stars_event_max_datetime": "2021-02-13T14:48:45.000Z", "max_stars_repo_stars_event_min_datetime": "2021-02-13T14:48:45.000Z", "num_tokens": 1523, "size": 3722 }
module _ where module M₁ where record R : Set₂ where field _A : Set₁ open R -- The following code used to be syntactically incorrect, because -- the left-hand side could be parsed either as the function r -- applied to a pattern variable, or as the copattern _A applied -- to r. Now the former interpretation is ruled out. r : R r A = Set module M₂ where record R : Set₂ where field _A : Set₁ open R data D : Set where d_A : D -- Name parts coming from constructors can be used as part of -- copatterns. r : R r A = Set module M₃ where data D₂ : Set where c : D₂ record R₂ : Set₁ where field f_c : Set open R₂ -- Name parts coming from projections can be used as part of -- constructor patterns. F : D₂ → Set₁ F c = Set	{ "alphanum_fraction": 0.6385836386, "avg_line_length": 15.75, "ext": "agda", "hexsha": "964dc98cb17f92b7fa47341841a93d6dac6d9b3e", "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/Issue3400.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/Issue3400.agda", "max_line_length": 67, "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/Issue3400.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": 251, "size": 819 }
{-# OPTIONS --without-K #-} open import HoTT hiding (_::_) module algebra.Word {i} (A : Type i) where data Word : Type i where nil : Word _::_ : A → Word → Word _inv::_ : A → Word → Word infixr 60 _::_ _inv::_ -- The following six functions prove things like if [x ∷ v ≡ y ∷ w], -- then [x ≡ y]. -- This is not as easy as it sounds, you cannot directly induct on the equality -- (because [x ∷ v] is not a general element of type word), so you have to -- extract the head, but it’s not always possible… Word= : (v w : Word) → Type i Word= nil nil = Lift ⊤ Word= nil (y :: w) = Lift ⊥ Word= nil (y inv:: w) = Lift ⊥ Word= (x :: v) nil = Lift ⊥ Word= (x :: v) (y :: w) = (x == y) × (v == w) Word= (x :: v) (y inv:: w) = Lift ⊥ Word= (x inv:: v) nil = Lift ⊥ Word= (x inv:: v) (y :: w) = Lift ⊥ Word= (x inv:: v) (y inv:: w) = (x == y) × (v == w) Word=-out : {v w : Word} (p : v == w) → Word= v w Word=-out {v = nil} idp = lift unit Word=-out {v = x :: v} idp = (idp , idp) Word=-out {v = x inv:: v} idp = (idp , idp) Word=-in : {v w : Word} → Word= v w → v == w Word=-in {nil} {nil} _ = idp Word=-in {nil} {y :: w} (lift ()) Word=-in {nil} {y inv:: w} (lift ()) Word=-in {x :: v} {nil} (lift ()) Word=-in {x :: v} {y :: w} (p , q) = ap2 _::_ p q Word=-in {x :: v} {y inv:: w} (lift ()) Word=-in {x inv:: v} {nil} (lift ()) Word=-in {x inv:: v} {y :: w} (lift ()) Word=-in {x inv:: v} {y inv:: w} (p , q) = ap2 _inv::_ p q Word-fst= : {x y : A} {v w : Word} (p : x :: v == y :: w) → x == y Word-fst= p = fst (Word=-out p) Word-snd= : {x y : A} {v w : Word} (p : x :: v == y :: w) → v == w Word-snd= p = snd (Word=-out p) Word-fst=' : {x y : A} {v w : Word} (p : x inv:: v == y inv:: w) → x == y Word-fst=' p = fst (Word=-out p) Word-snd=' : {x y : A} {v w : Word} (p : x inv:: v == y inv:: w) → v == w Word-snd=' p = snd (Word=-out p)	{ "alphanum_fraction": 0.4459980714, "avg_line_length": 35.7586206897, "ext": "agda", "hexsha": "08a8586acdaa5a6988b1bc3ea81ecb0b3ec3cde9", "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": "algebra/Word.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": "algebra/Word.agda", "max_line_length": 81, "max_stars_count": 1, "max_stars_repo_head_hexsha": "f8fa68bf753d64d7f45556ca09d0da7976709afa", "max_stars_repo_licenses": [ "MIT" ], "max_stars_repo_name": "UlrikBuchholtz/HoTT-Agda", "max_stars_repo_path": "algebra/Word.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": 831, "size": 2074 }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.