Search is not available for this dataset
text
string | meta
dict |
|---|---|
{-# OPTIONS --cubical --no-exact-split --safe #-}
module Cubical.Data.Nat.Base where
open import Cubical.Core.Primitives
open import Agda.Builtin.Nat public
using (zero; suc; _+_; _*_)
renaming (Nat to ℕ)
predℕ : ℕ → ℕ
predℕ zero = 0
predℕ (suc n) = n
caseNat : ∀ {ℓ} → {A : Type ℓ} → (a0 aS : A) → ℕ → A
caseNat a0 aS 0 = a0
caseNat a0 aS (suc n) = aS
doubleℕ : ℕ → ℕ
doubleℕ 0 = 0
doubleℕ (suc x) = suc (suc (doubleℕ x))
-- doublesℕ n m = 2^n * m
doublesℕ : ℕ → ℕ → ℕ
doublesℕ 0 m = m
doublesℕ (suc n) m = doublesℕ n (doubleℕ m)
-- iterate
iter : ∀ {ℓ} {A : Type ℓ} → ℕ → (A → A) → A → A
iter zero f z = z
iter (suc n) f z = f (iter n f z)
| {
"alphanum_fraction": 0.584962406,
"avg_line_length": 21.4516129032,
"ext": "agda",
"hexsha": "71d01c34189dba51f2508e281646f7bb47aeadc9",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cj-xu/cubical",
"max_forks_repo_path": "Cubical/Data/Nat/Base.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cj-xu/cubical",
"max_issues_repo_path": "Cubical/Data/Nat/Base.agda",
"max_line_length": 52,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cj-xu/cubical",
"max_stars_repo_path": "Cubical/Data/Nat/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 292,
"size": 665
} |
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Properties.Universe {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Typed
open import Definition.LogicalRelation
open import Definition.LogicalRelation.ShapeView
open import Definition.LogicalRelation.Irrelevance
open import Tools.Embedding
-- Helper function for reducible terms of type U for specific type derivations.
univEq′ : ∀ {l Γ A} ([U] : Γ ⊩⟨ l ⟩U) → Γ ⊩⟨ l ⟩ A ∷ U / U-intr [U] → Γ ⊩⟨ ⁰ ⟩ A
univEq′ (noemb (Uᵣ .⁰ 0<1 ⊢Γ)) (Uₜ A₁ d typeA A≡A [A]) = [A]
univEq′ (emb 0<1 x) (ιx [A]) = univEq′ x [A]
-- Reducible terms of type U are reducible types.
univEq : ∀ {l Γ A} ([U] : Γ ⊩⟨ l ⟩ U) → Γ ⊩⟨ l ⟩ A ∷ U / [U] → Γ ⊩⟨ ⁰ ⟩ A
univEq [U] [A] = univEq′ (U-elim [U])
(irrelevanceTerm [U] (U-intr (U-elim [U])) [A])
-- Helper function for reducible term equality of type U for specific type derivations.
univEqEq′ : ∀ {l l′ Γ A B} ([U] : Γ ⊩⟨ l ⟩U) ([A] : Γ ⊩⟨ l′ ⟩ A)
→ Γ ⊩⟨ l ⟩ A ≡ B ∷ U / U-intr [U]
→ Γ ⊩⟨ l′ ⟩ A ≡ B / [A]
univEqEq′ (noemb (Uᵣ .⁰ 0<1 ⊢Γ)) [A]
(Uₜ₌ A₁ B₁ d d′ typeA typeB A≡B [t] [u] [t≡u]) =
irrelevanceEq [t] [A] [t≡u]
univEqEq′ (emb 0<1 x) [A] (ιx [A≡B]) = univEqEq′ x [A] [A≡B]
-- Reducible term equality of type U is reducible type equality.
univEqEq : ∀ {l l′ Γ A B} ([U] : Γ ⊩⟨ l ⟩ U) ([A] : Γ ⊩⟨ l′ ⟩ A)
→ Γ ⊩⟨ l ⟩ A ≡ B ∷ U / [U]
→ Γ ⊩⟨ l′ ⟩ A ≡ B / [A]
univEqEq [U] [A] [A≡B] =
let [A≡B]′ = irrelevanceEqTerm [U] (U-intr (U-elim [U])) [A≡B]
in univEqEq′ (U-elim [U]) [A] [A≡B]′
| {
"alphanum_fraction": 0.5648259304,
"avg_line_length": 39.6666666667,
"ext": "agda",
"hexsha": "a7fa0f539eeeca42dc643fe03fbfc7ef0777790c",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "2251b8da423be0c6fb916f2675d7bd8537e4cd96",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "loic-p/logrel-mltt",
"max_forks_repo_path": "Definition/LogicalRelation/Properties/Universe.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "2251b8da423be0c6fb916f2675d7bd8537e4cd96",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "loic-p/logrel-mltt",
"max_issues_repo_path": "Definition/LogicalRelation/Properties/Universe.agda",
"max_line_length": 87,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "2251b8da423be0c6fb916f2675d7bd8537e4cd96",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "loic-p/logrel-mltt",
"max_stars_repo_path": "Definition/LogicalRelation/Properties/Universe.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 745,
"size": 1666
} |
module ExtInterface.Data.Product where
-- TODO: Write to Agda team about the lack of compilability of Sigma.
-- I assumed that the builtin flag would allow to compile Σ into (,)
-- but it doesn't. That's why this microfile exists
infixr 4 ⟨_,_⟩
infixr 2 _×_
data _×_ (A B : Set) : Set where
⟨_,_⟩ : A → B → A × B
{-# COMPILE GHC _×_ = data (,) ((,)) #-} -- Yeah, kinda abstract
proj₁ : ∀ {A B : Set} → A × B → A
proj₁ ⟨ x , y ⟩ = x
proj₂ : ∀ {A B : Set} → A × B → B
proj₂ ⟨ x , y ⟩ = y
map : ∀ {A B C D : Set}
→ (A → C) → (B → D) → A × B → C × D
map f g ⟨ x , y ⟩ = ⟨ f x , g y ⟩
map₁ : ∀ {A B C : Set}
→ (A → C) → A × B → C × B
map₁ f = map f (λ x → x)
map₂ : ∀ {A B D : Set}
→ (B → D) → A × B → A × D
map₂ g = map (λ x → x) g
| {
"alphanum_fraction": 0.5019920319,
"avg_line_length": 23.53125,
"ext": "agda",
"hexsha": "cf2689eddbf9adfa853513874c540784fa514162",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2020-09-20T00:36:09.000Z",
"max_forks_repo_forks_event_min_datetime": "2020-09-20T00:36:09.000Z",
"max_forks_repo_head_hexsha": "896e67a2ad21041a1c9ef5f3ad6318c67d730341",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "RPI-WCL/safety-envelopes-sentinels",
"max_forks_repo_path": "agda/ExtInterface/Data/Product.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "896e67a2ad21041a1c9ef5f3ad6318c67d730341",
"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": "RPI-WCL/safety-envelopes-sentinels",
"max_issues_repo_path": "agda/ExtInterface/Data/Product.agda",
"max_line_length": 69,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "896e67a2ad21041a1c9ef5f3ad6318c67d730341",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "RPI-WCL/safety-envelopes-sentinels",
"max_stars_repo_path": "agda/ExtInterface/Data/Product.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 309,
"size": 753
} |
module #16 where
{-
Show that addition of natural numbers is commutative: ∏(i,j:N)(i + j = j + i).
-}
open import Data.Nat
open import Relation.Binary.PropositionalEquality
open Relation.Binary.PropositionalEquality.≡-Reasoning
l-commut₀ : (n : ℕ) → n + 0 ≡ n
l-commut₀ zero = refl
l-commut₀ (suc n) = cong suc (l-commut₀ n)
suc-in-the-middle-with-you : ∀ m n → m + suc n ≡ suc (m + n)
suc-in-the-middle-with-you zero n = refl
suc-in-the-middle-with-you (suc m) n = cong suc (suc-in-the-middle-with-you m n)
+-commutative : (m n : ℕ) → m + n ≡ n + m
+-commutative zero n = sym (l-commut₀ n)
+-commutative (suc m) n =
begin
(suc m) + n
≡⟨ refl ⟩
suc (m + n)
≡⟨ cong suc (+-commutative m n) ⟩
suc (n + m)
≡⟨ sym (suc-in-the-middle-with-you n m) ⟩
n + (suc m)
∎
| {
"alphanum_fraction": 0.6069651741,
"avg_line_length": 25.935483871,
"ext": "agda",
"hexsha": "d6cefabe161d5faf1d76827b1f0d3f93f2926013",
"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": "Chapter1/#16.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": "Chapter1/#16.agda",
"max_line_length": 80,
"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": "Chapter1/#16.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 306,
"size": 804
} |
{-# OPTIONS --without-K #-}
module function.isomorphism where
open import function.isomorphism.core public
open import function.isomorphism.properties public
open import function.isomorphism.coherent public
open import function.isomorphism.lift public
open import function.isomorphism.utils public
open import function.isomorphism.univalence public
open import function.isomorphism.remove public
| {
"alphanum_fraction": 0.8488664987,
"avg_line_length": 36.0909090909,
"ext": "agda",
"hexsha": "28b07ac5be7e6d07cb2a496092d6773bb33ab08c",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2019-02-26T06:17:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-04-11T17:19:12.000Z",
"max_forks_repo_head_hexsha": "beebe176981953ab48f37de5eb74557cfc5402f4",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "HoTT/M-types",
"max_forks_repo_path": "function/isomorphism.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "beebe176981953ab48f37de5eb74557cfc5402f4",
"max_issues_repo_issues_event_max_datetime": "2015-02-11T15:20:34.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-02-11T11:14:59.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "HoTT/M-types",
"max_issues_repo_path": "function/isomorphism.agda",
"max_line_length": 50,
"max_stars_count": 27,
"max_stars_repo_head_hexsha": "beebe176981953ab48f37de5eb74557cfc5402f4",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "HoTT/M-types",
"max_stars_repo_path": "function/isomorphism.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-09T07:26:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-04-14T15:47:03.000Z",
"num_tokens": 78,
"size": 397
} |
{-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Library.Action where
open import Light.Level using (Level ; Setω)
open import Light.Library.Data.Unit as Unit using (Unit)
open import Light.Library.Data.Natural as Natural using (ℕ)
open import Light.Variable.Sets
open import Light.Variable.Levels
open import Light.Package using (Package)
record Dependencies : Setω where
field ⦃ unit‐package ⦄ : Package record { Unit }
field ⦃ natural‐package ⦄ : Package record { Natural }
record Library (dependencies : Dependencies) : Setω where
field
main‐ℓ : Level
Action : Set aℓ → Set aℓ
pure : 𝕒 → Action 𝕒
_>>=_ : Action 𝕒 → (𝕒 → Action 𝕓) → Action 𝕓
_>>_ : Action 𝕒 → Action 𝕓 → Action 𝕓
log : 𝕒 → Action Unit
Main : Set main‐ℓ
run : Action Unit → Main
prompt : Action ℕ
alert : 𝕒 → Action Unit
open Library ⦃ ... ⦄ public
| {
"alphanum_fraction": 0.623880597,
"avg_line_length": 34.6551724138,
"ext": "agda",
"hexsha": "43d93abc59bc66541e29e5e099089e0fe565b159",
"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": "44b1c724f2de95d3a9effe87ca36ef9eca8b4756",
"max_forks_repo_licenses": [
"0BSD"
],
"max_forks_repo_name": "Zambonifofex/lightlib",
"max_forks_repo_path": "Light/Library/Action.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "44b1c724f2de95d3a9effe87ca36ef9eca8b4756",
"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": "Zambonifofex/lightlib",
"max_issues_repo_path": "Light/Library/Action.agda",
"max_line_length": 79,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "44b1c724f2de95d3a9effe87ca36ef9eca8b4756",
"max_stars_repo_licenses": [
"0BSD"
],
"max_stars_repo_name": "zamfofex/lightlib",
"max_stars_repo_path": "Light/Library/Action.agda",
"max_stars_repo_stars_event_max_datetime": "2019-12-20T21:33:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-12-20T21:33:05.000Z",
"num_tokens": 272,
"size": 1005
} |
module Issue858 where
module _ (A B : Set) (recompute : .B → .{{A}} → B) where
_$_ : .(A → B) → .A → B
f $ x with .{f} | .(f x) | .{{x}}
... | y = recompute y
module _ (A B : Set) (recompute : ..B → ..{{A}} → B) where
_$'_ : ..(A → B) → ..A → B
f $' x with ..{f} | ..(f x) | ..{{x}}
... | y = recompute y
| {
"alphanum_fraction": 0.4080996885,
"avg_line_length": 22.9285714286,
"ext": "agda",
"hexsha": "d66cc54339d2676f0e1c26f52f9431be042bbc70",
"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": "cc026a6a97a3e517bb94bafa9d49233b067c7559",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "cagix/agda",
"max_forks_repo_path": "test/Succeed/Issue858.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "cc026a6a97a3e517bb94bafa9d49233b067c7559",
"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-2-Clause"
],
"max_issues_repo_name": "cagix/agda",
"max_issues_repo_path": "test/Succeed/Issue858.agda",
"max_line_length": 58,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "cc026a6a97a3e517bb94bafa9d49233b067c7559",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "cagix/agda",
"max_stars_repo_path": "test/Succeed/Issue858.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": 144,
"size": 321
} |
{-# OPTIONS --universe-polymorphism #-}
module AutoMisc where
-- prelude
postulate
Level : Set
lzero : Level
lsuc : (i : Level) → Level
{-# BUILTIN LEVEL Level #-}
{-# BUILTIN LEVELZERO lzero #-}
{-# BUILTIN LEVELSUC lsuc #-}
data _≡_ {a} {A : Set a} (x : A) : A → Set where
refl : x ≡ x
trans : ∀ {a} {A : Set a} → {x y z : A} → x ≡ y → y ≡ z → x ≡ z
trans refl refl = refl
sym : ∀ {a} {A : Set a} → {x y : A} → x ≡ y → y ≡ x
sym refl = refl
cong : ∀ {a b} {A : Set a} {B : Set b}
(f : A → B) {x y} → x ≡ y → f x ≡ f y
cong f refl = refl
data _IsRelatedTo_ {a : Level} {Carrier : Set a} (x y : Carrier) : Set a where
relTo : (x∼y : x ≡ y) → x IsRelatedTo y
begin_ : {a : Level} {Carrier : Set a} → {x y : Carrier} → x IsRelatedTo y → x ≡ y
begin relTo x∼y = x∼y
_∎ : {a : Level} {Carrier : Set a} → (x : Carrier) → x IsRelatedTo x
_∎ _ = relTo refl
_≡⟨_⟩_ : {a : Level} {Carrier : Set a} → (x : Carrier) {y z : Carrier} → x ≡ y → y IsRelatedTo z → x IsRelatedTo z
_ ≡⟨ x∼y ⟩ relTo y∼z = relTo (trans x∼y y∼z)
data ℕ : Set where
zero : ℕ
suc : (n : ℕ) → ℕ
_+_ : ℕ → ℕ → ℕ
zero + n = n
suc m + n = suc (m + n)
data ⊥ : Set where
¬ : Set → Set
¬ A = A → ⊥
data Π (A : Set) (F : A → Set) : Set where
fun : ((a : A) → F a) → Π A F
data Σ (A : Set) (F : A → Set) : Set where
ΣI : (a : A) → (F a) → Σ A F
data Fin : ℕ → Set where
zero : ∀ {n} → Fin (suc n)
suc : ∀ {n} → Fin n → Fin (suc n)
data List (X : Set) : Set where
[] : List X
_∷_ : X → List X → List X
_++_ : {X : Set} → List X → List X → List X
[] ++ ys = ys
(x ∷ xs) ++ ys = x ∷ (xs ++ ys)
data Vec (X : Set) : ℕ → Set where
[] : Vec X zero
_∷_ : ∀ {n} → X → Vec X n → Vec X (suc n)
module AdditionCommutative where
lemma : ∀ n m → (n + suc m) ≡ suc (n + m)
lemma n m = {!!}
lemma' : ∀ n m → (n + suc m) ≡ suc (n + m)
lemma' zero m = refl
lemma' (suc n) m = cong suc (lemma' n m)
addcommut : ∀ n m → (n + m) ≡ (m + n)
addcommut n m = {!!}
module Drink where
postulate RAA : (A : Set) → (¬ A → ⊥) → A
drink : (A : Set) → (a : A)
→ (Drink : A → Set) → Σ A (λ x → (Drink x) → Π A Drink)
drink A a Drink = {!!}
module VecMap where
map : {X Y : Set} → {n : ℕ} → (X → Y) → Vec X n → Vec Y n
map f xs = {!!}
module Disproving where
p : {X : Set} → (xs ys : List X) → (xs ++ ys) ≡ (ys ++ xs)
p = {!!}
| {
"alphanum_fraction": 0.4892086331,
"avg_line_length": 21.6788990826,
"ext": "agda",
"hexsha": "30a21a6b7dc9943d0426a6f68c00798b400e1e10",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "20596e9dd9867166a64470dd24ea68925ff380ce",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "np/agda-git-experiment",
"max_forks_repo_path": "test/interaction/AutoMisc.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "20596e9dd9867166a64470dd24ea68925ff380ce",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "np/agda-git-experiment",
"max_issues_repo_path": "test/interaction/AutoMisc.agda",
"max_line_length": 114,
"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/interaction/AutoMisc.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": 1012,
"size": 2363
} |
module UnSized.SelfRef where
open import Data.Unit.Base
open import Data.Product
open import Data.String.Base
open import Data.Sum using (_⊎_) renaming (inj₁ to inl; inj₂ to inr)
open import Size
--open import SimpleCell
open import SizedIO.Object
open import SizedIO.IOObject
open import SizedIO.ConsoleObject
-- open import PrimTypeHelpersSmall
open import UnSizedIO.Base hiding (main)
open import UnSizedIO.Console hiding (main)
open import NativeIO
--open import SimpleCell
-- Object Alpha
data AlphaMethod A : Set where
print : AlphaMethod A
set : A → AlphaMethod A
m1 : AlphaMethod A
m2 : AlphaMethod A
AlphaResponses : {A : Set} (c : AlphaMethod A) → Set
AlphaResponses _ = ⊤
alphaI : (A : Set) → Interface
Method (alphaI A) = AlphaMethod A
Result (alphaI A) m = AlphaResponses m
alphaC : (i : Size) → Set
alphaC i = ConsoleObject i (alphaI String)
--
-- Self Referential: method 'm1' calls method 'm2'
--
{-
-- {-# NON_TERMINATING #-}
alphaO : ∀{i} (s : String) → alphaC i
method (alphaO s) print =
exec (putStrLn s) >>
return (_ , alphaO s)
method (alphaO s) (set x) =
return (_ , alphaO x)
-- force (method (alphaO s) m1) = exec (putStrLn s) λ _ →
-- method (alphaO s) m2 >>= λ{ (_ , c₀) →
-- return (_ , c₀) }
method (alphaO s) m1 =
exec1 (putStrLn s) >>
method (alphaO s) m2 >>= λ{ (_ , c₀) →
return (_ , c₀) }
method (alphaO s) m2 =
return (_ , alphaO (s ++ "->m2"))
program : String → IOConsole ∞ Unit
program arg =
let c₀ = alphaO ("start̄\n====\n\n") in
method c₀ m1 >>= λ{ (_ , c₁) → --- ===> m1 called, but m2 prints out text
method c₁ print >>= λ{ (_ , c₂) →
exec1 (putStrLn "\n\n====\nend") }}
main : NativeIO Unit
main = translateIOConsole (program "")
-}
| {
"alphanum_fraction": 0.6452164009,
"avg_line_length": 23.7297297297,
"ext": "agda",
"hexsha": "653d7e7310d0441ce74c8c3a8d1fe7e0de373f40",
"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/UnSized/SelfRef.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/UnSized/SelfRef.agda",
"max_line_length": 78,
"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/UnSized/SelfRef.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": 576,
"size": 1756
} |
{-# OPTIONS --without-K #-}
module HoTT.Identity.Coproduct where
open import HoTT.Base
open import HoTT.Equivalence
open variables
private variable x y : A + B
_=+_ : {A : 𝒰 i} {B : 𝒰 j} (x y : A + B) → 𝒰 (i ⊔ j)
_=+_ {j = j} (inl a₁) (inl a₂) = Lift {j} (a₁ == a₂)
_=+_ (inl _) (inr _) = 𝟎
_=+_ (inr _) (inl _) = 𝟎
_=+_ {i} (inr b₁) (inr b₂) = Lift {i} (b₁ == b₂)
=+-equiv : (x == y) ≃ x =+ y
=+-equiv = f , qinv→isequiv (g , η , ε)
where
f : x == y → x =+ y
f {x = inl a} refl = lift refl
f {x = inr a} refl = lift refl
g : x =+ y → x == y
g {x = inl _} {inl _} (lift refl) = refl
g {x = inl _} {inr _} ()
g {x = inr _} {inl _} ()
g {x = inr _} {inr _} (lift refl) = refl
η : {x y : A + B} → g {x = x} {y} ∘ f ~ id
η {y = inl _} refl = refl
η {y = inr _} refl = refl
ε : f {x = x} {y} ∘ g ~ id
ε {x = inl _} {inl _} (lift refl) = refl
ε {x = inl _} {inr _} ()
ε {x = inr _} {inl _} ()
ε {x = inr _} {inr _} (lift refl) = refl
=+-elim : x == y → x =+ y
=+-elim = pr₁ =+-equiv
=+-intro : x =+ y → x == y
=+-intro = Iso.g (eqv→iso =+-equiv)
| {
"alphanum_fraction": 0.4699907664,
"avg_line_length": 24.6136363636,
"ext": "agda",
"hexsha": "f804fd3bd194bd5819f1fe6e338efa6a4741d735",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508",
"max_forks_repo_licenses": [
"0BSD"
],
"max_forks_repo_name": "michaelforney/hott",
"max_forks_repo_path": "HoTT/Identity/Coproduct.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"0BSD"
],
"max_issues_repo_name": "michaelforney/hott",
"max_issues_repo_path": "HoTT/Identity/Coproduct.agda",
"max_line_length": 52,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "ef4d9fbb9cc0352657f1a6d0d3534d4c8a6fd508",
"max_stars_repo_licenses": [
"0BSD"
],
"max_stars_repo_name": "michaelforney/hott",
"max_stars_repo_path": "HoTT/Identity/Coproduct.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 529,
"size": 1083
} |
{-# OPTIONS --safe #-}
module Cubical.HITs.SequentialColimit.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat
private
variable
ℓ : Level
record Sequence (ℓ : Level) : Type (ℓ-suc ℓ) where
field
space : ℕ → Type ℓ
map : {n : ℕ} → space n → space (1 + n)
open Sequence
data Lim→ (X : Sequence ℓ) : Type ℓ where
inl : {n : ℕ} → X .space n → Lim→ X
push : {n : ℕ}(x : X .space n) → inl x ≡ inl (X .map x)
| {
"alphanum_fraction": 0.6192560175,
"avg_line_length": 21.7619047619,
"ext": "agda",
"hexsha": "bb1427f06baf14d046d65462e3024a523746914b",
"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/HITs/SequentialColimit/Base.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/HITs/SequentialColimit/Base.agda",
"max_line_length": 57,
"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/HITs/SequentialColimit/Base.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": 163,
"size": 457
} |
open import Oscar.Prelude
open import Oscar.Class.IsPrecategory
open import Oscar.Class.Reflexivity
open import Oscar.Class.Transleftidentity
open import Oscar.Class.Transrightidentity
open import Oscar.Class.Transitivity
module Oscar.Class.IsCategory where
module _
{𝔬} {𝔒 : Ø 𝔬}
{𝔯} (_∼_ : 𝔒 → 𝔒 → Ø 𝔯)
{ℓ} (_∼̇_ : ∀ {x y} → x ∼ y → x ∼ y → Ø ℓ) (let infix 4 _∼̇_ ; _∼̇_ = _∼̇_)
(ε : Reflexivity.type _∼_)
(_↦_ : Transitivity.type _∼_)
where
record IsCategory : Ø 𝔬 ∙̂ 𝔯 ∙̂ ℓ where
constructor ∁
field
⦃ `IsPrecategory ⦄ : IsPrecategory _∼_ _∼̇_ _↦_
⦃ `𝓣ransleftidentity ⦄ : Transleftidentity.class _∼_ _∼̇_ ε _↦_
⦃ `𝓣ransrightidentity ⦄ : Transrightidentity.class _∼_ _∼̇_ ε _↦_
| {
"alphanum_fraction": 0.6593103448,
"avg_line_length": 30.2083333333,
"ext": "agda",
"hexsha": "bdc45f47821a701077facaf536f6fecb846d97c9",
"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-3/src/Oscar/Class/IsCategory.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-3/src/Oscar/Class/IsCategory.agda",
"max_line_length": 77,
"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-3/src/Oscar/Class/IsCategory.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 308,
"size": 725
} |
module logic where
open import Level
open import Relation.Nullary
open import Relation.Binary hiding (_⇔_ )
open import Data.Empty
data One {n : Level } : Set n where
OneObj : One
data Two : Set where
i0 : Two
i1 : Two
data Bool : Set where
true : Bool
false : Bool
record _∧_ {n m : Level} (A : Set n) ( B : Set m ) : Set (n ⊔ m) where
constructor ⟪_,_⟫
field
proj1 : A
proj2 : B
data _∨_ {n m : Level} (A : Set n) ( B : Set m ) : Set (n ⊔ m) where
case1 : A → A ∨ B
case2 : B → A ∨ B
_⇔_ : {n m : Level } → ( A : Set n ) ( B : Set m ) → Set (n ⊔ m)
_⇔_ A B = ( A → B ) ∧ ( B → A )
contra-position : {n m : Level } {A : Set n} {B : Set m} → (A → B) → ¬ B → ¬ A
contra-position {n} {m} {A} {B} f ¬b a = ¬b ( f a )
double-neg : {n : Level } {A : Set n} → A → ¬ ¬ A
double-neg A notnot = notnot A
double-neg2 : {n : Level } {A : Set n} → ¬ ¬ ¬ A → ¬ A
double-neg2 notnot A = notnot ( double-neg A )
de-morgan : {n : Level } {A B : Set n} → A ∧ B → ¬ ( (¬ A ) ∨ (¬ B ) )
de-morgan {n} {A} {B} and (case1 ¬A) = ⊥-elim ( ¬A ( _∧_.proj1 and ))
de-morgan {n} {A} {B} and (case2 ¬B) = ⊥-elim ( ¬B ( _∧_.proj2 and ))
dont-or : {n m : Level} {A : Set n} { B : Set m } → A ∨ B → ¬ A → B
dont-or {A} {B} (case1 a) ¬A = ⊥-elim ( ¬A a )
dont-or {A} {B} (case2 b) ¬A = b
dont-orb : {n m : Level} {A : Set n} { B : Set m } → A ∨ B → ¬ B → A
dont-orb {A} {B} (case2 b) ¬B = ⊥-elim ( ¬B b )
dont-orb {A} {B} (case1 a) ¬B = a
infixr 130 _∧_
infixr 140 _∨_
infixr 150 _⇔_
| {
"alphanum_fraction": 0.497707924,
"avg_line_length": 26.3275862069,
"ext": "agda",
"hexsha": "e9ec323257c93bf764d953b2d5db6678e54e1362",
"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": "031f1ea3a3037cd51eb022dbfb5c75b037bf8aa0",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "shinji-kono/zf-in-agda",
"max_forks_repo_path": "src/logic.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "031f1ea3a3037cd51eb022dbfb5c75b037bf8aa0",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "shinji-kono/zf-in-agda",
"max_issues_repo_path": "src/logic.agda",
"max_line_length": 78,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "031f1ea3a3037cd51eb022dbfb5c75b037bf8aa0",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "shinji-kono/zf-in-agda",
"max_stars_repo_path": "src/logic.agda",
"max_stars_repo_stars_event_max_datetime": "2021-01-10T13:27:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-10-02T13:46:23.000Z",
"num_tokens": 687,
"size": 1527
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Heterogeneous N-ary Relations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Relation.Nary where
------------------------------------------------------------------------
-- Concrete examples can be found in README.Nary. This file's comments
-- are more focused on the implementation details and the motivations
-- behind the design decisions.
------------------------------------------------------------------------
open import Level using (Level; _⊔_; Lift)
open import Data.Unit.Base
open import Data.Bool.Base using (true; false)
open import Data.Empty
open import Data.Nat.Base using (zero; suc)
open import Data.Product as Prod using (_×_; _,_)
open import Data.Product.Nary.NonDependent
open import Data.Sum.Base using (_⊎_)
open import Function using (_$_; _∘′_)
open import Function.Nary.NonDependent
open import Relation.Nullary using (¬_; Dec; yes; no; _because_)
import Relation.Nullary.Decidable as Dec
open import Relation.Nullary.Product using (_×-dec_)
import Relation.Unary as Unary
open import Relation.Binary.PropositionalEquality using (_≡_; cong; subst)
private
variable
r : Level
R : Set r
------------------------------------------------------------------------
-- Generic type constructors
-- `Relation.Unary` provides users with a wealth of combinators to work
-- with indexed sets. We can generalise these to n-ary relations.
-- The crucial thing to notice here is that because we are explicitly
-- considering that the input function should be a `Set`-ended `Arrows`,
-- all the other parameters are inferrable. This allows us to make the
-- number arguments (`n`) implicit.
------------------------------------------------------------------------
------------------------------------------------------------------------
-- Quantifiers
-- If we already know how to quantify over one variable, we can easily
-- describe how to quantify over `n` variables by induction over said `n`.
quantₙ : (∀ {i l} {I : Set i} → (I → Set l) → Set (i ⊔ l)) →
∀ n {ls} {as : Sets n ls} →
Arrows n as (Set r) → Set (r ⊔ (⨆ n ls))
quantₙ Q zero f = f
quantₙ Q (suc n) f = Q (λ x → quantₙ Q n (f x))
infix 5 ∃⟨_⟩ Π[_] ∀[_]
-- existential quantifier
∃⟨_⟩ : ∀ {n ls r} {as : Sets n ls} → as ⇉ Set r → Set (r ⊔ (⨆ n ls))
∃⟨_⟩ = quantₙ Unary.Satisfiable _
-- explicit universal quantifiers
Π[_] : ∀ {n ls r} {as : Sets n ls} → as ⇉ Set r → Set (r ⊔ (⨆ n ls))
Π[_] = quantₙ Unary.Universal _
-- implicit universal quantifiers
∀[_] : ∀ {n ls r} {as : Sets n ls} → as ⇉ Set r → Set (r ⊔ (⨆ n ls))
∀[_] = quantₙ Unary.IUniversal _
-- ≟-mapₙ : ∀ n. (con : A₁ → ⋯ → Aₙ → R) →
-- Injectiveₙ n con →
-- ∀ a₁₁ a₁₂ ⋯ aₙ₁ aₙ₂ →
-- Dec (a₁₁ ≡ a₁₂) → ⋯ → Dec (aₙ₁ ≡ aₙ₂) →
-- Dec (con a₁₁ ⋯ aₙ₁ ≡ con a₁₂ ⋯ aₙ₂)
≟-mapₙ : ∀ n {ls} {as : Sets n ls} (con : Arrows n as R) → Injectiveₙ n con →
∀ {l r} → Arrows n (Dec <$> Equalₙ n l r) (Dec (uncurryₙ n con l ≡ uncurryₙ n con r))
≟-mapₙ n con con-inj =
curryₙ n λ a?s → let as? = Product-dec n a?s in
Dec.map′ (cong (uncurryₙ n con) ∘′ fromEqualₙ n) con-inj as?
------------------------------------------------------------------------
-- Substitution
module _ {n r ls} {as : Sets n ls} (P : as ⇉ Set r) where
-- Substitutionₙ : ∀ n. ∀ a₁₁ a₁₂ ⋯ aₙ₁ aₙ₂ →
-- a₁₁ ≡ a₁₂ → ⋯ → aₙ₁ ≡ aₙ₂ →
-- P a₁₁ ⋯ aₙ₁ → P a₁₂ ⋯ aₙ₂
Substitutionₙ : Set (r ⊔ (⨆ n ls))
Substitutionₙ = ∀ {l r} → Equalₙ n l r ⇉ (uncurryₙ n P l → uncurryₙ n P r)
substₙ : Substitutionₙ
substₙ = curryₙ n (subst (uncurryₙ n P) ∘′ fromEqualₙ n)
------------------------------------------------------------------------
-- Pointwise liftings of k-ary operators
-- Rather than having multiple ad-hoc lifting functions for various arities
-- we have a fully generic liftₙ functional which lifts a k-ary operator
-- to work with k n-ary functions whose respective codomains match the domains
-- of the operator.
-- The type of liftₙ is fairly unreadable. Here it is written with ellipsis:
-- liftₙ : ∀ k n. (B₁ → ⋯ → Bₖ → R) →
-- (A₁ → ⋯ → Aₙ → B₁) →
-- ⋮
-- (A₁ → ⋯ → Aₙ → B₁) →
-- (A₁ → ⋯ → Aₙ → R)
liftₙ : ∀ k n {ls rs} {as : Sets n ls} {bs : Sets k rs} →
Arrows k bs R → Arrows k (smap _ (Arrows n as) k bs) (Arrows n as R)
liftₙ k n op = curry⊤ₙ k λ fs →
curry⊤ₙ n λ vs →
uncurry⊤ₙ k op $
palg _ _ k (λ f → uncurry⊤ₙ n f vs) fs where
-- The bulk of the work happens in this auxiliary definition:
palg : ∀ f (F : ∀ {l} → Set l → Set (f l)) n {ls} {as : Sets n ls} →
(∀ {l} {r : Set l} → F r → r) → Product⊤ n (smap f F n as) → Product⊤ n as
palg f F zero alg ps = _
palg f F (suc n) alg (p , ps) = alg p , palg f F n alg ps
-- implication
infixr 6 _⇒_
_⇒_ : ∀ {n} {ls r s} {as : Sets n ls} →
as ⇉ Set r → as ⇉ Set s → as ⇉ Set (r ⊔ s)
_⇒_ = liftₙ 2 _ (λ A B → A → B)
-- conjunction
infixr 7 _∩_
_∩_ : ∀ {n} {ls r s} {as : Sets n ls} →
as ⇉ Set r → as ⇉ Set s → as ⇉ Set (r ⊔ s)
_∩_ = liftₙ 2 _ _×_
-- disjunction
infixr 8 _∪_
_∪_ : ∀ {n} {ls r s} {as : Sets n ls} →
as ⇉ Set r → as ⇉ Set s → as ⇉ Set (r ⊔ s)
_∪_ = liftₙ 2 _ _⊎_
-- negation
∁ : ∀ {n ls r} {as : Sets n ls} → as ⇉ Set r → as ⇉ Set r
∁ = liftₙ 1 _ ¬_
apply⊤ₙ : ∀ {n ls r} {as : Sets n ls} {R : as ⇉ Set r} →
Π[ R ] → (vs : Product⊤ n as) → uncurry⊤ₙ n R vs
apply⊤ₙ {zero} prf vs = prf
apply⊤ₙ {suc n} prf (v , vs) = apply⊤ₙ (prf v) vs
applyₙ : ∀ {n ls r} {as : Sets n ls} {R : as ⇉ Set r} →
Π[ R ] → (vs : Product n as) → uncurry⊤ₙ n R (toProduct⊤ n vs)
applyₙ {n} prf vs = apply⊤ₙ prf (toProduct⊤ n vs)
iapply⊤ₙ : ∀ {n ls r} {as : Sets n ls} {R : as ⇉ Set r} →
∀[ R ] → {vs : Product⊤ n as} → uncurry⊤ₙ n R vs
iapply⊤ₙ {zero} prf = prf
iapply⊤ₙ {suc n} prf = iapply⊤ₙ {n} prf
iapplyₙ : ∀ {n ls r} {as : Sets n ls} {R : as ⇉ Set r} →
∀[ R ] → {vs : Product n as} → uncurry⊤ₙ n R (toProduct⊤ n vs)
iapplyₙ {n} prf = iapply⊤ₙ {n} prf
------------------------------------------------------------------------
-- Properties of N-ary relations
-- Decidability
Decidable : ∀ {n ls r} {as : Sets n ls} → as ⇉ Set r → Set (r ⊔ ⨆ n ls)
Decidable R = Π[ mapₙ _ Dec R ]
-- erasure
⌊_⌋ : ∀ {n ls r} {as : Sets n ls} {R : as ⇉ Set r} → Decidable R → as ⇉ Set r
⌊_⌋ {zero} R? = Lift _ (Dec.True R?)
⌊_⌋ {suc n} R? a = ⌊ R? a ⌋
-- equivalence between R and its erasure
fromWitness : ∀ {n ls r} {as : Sets n ls} (R : as ⇉ Set r) (R? : Decidable R) →
∀[ ⌊ R? ⌋ ⇒ R ]
fromWitness {zero} R R? with R?
... | yes r = λ _ → r
... | false because _ = λ ()
fromWitness {suc n} R R? = fromWitness (R _) (R? _)
toWitness : ∀ {n ls r} {as : Sets n ls} (R : as ⇉ Set r) (R? : Decidable R) →
∀[ R ⇒ ⌊ R? ⌋ ]
toWitness {zero} R R? with R?
... | true because _ = _
... | no ¬r = ⊥-elim ∘′ ¬r
toWitness {suc n} R R? = toWitness (R _) (R? _)
| {
"alphanum_fraction": 0.5088108783,
"avg_line_length": 34.4832535885,
"ext": "agda",
"hexsha": "c451f508f0c20d38d6d83f1f46148f50922053bd",
"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/Nary.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/Nary.agda",
"max_line_length": 94,
"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/Nary.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": 2613,
"size": 7207
} |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Relation.Nullary.DecidableEq where
open import Cubical.Relation.Nullary.Properties
using (Dec→Stable; Discrete→isSet) public
| {
"alphanum_fraction": 0.7731958763,
"avg_line_length": 32.3333333333,
"ext": "agda",
"hexsha": "6d194a1677d9d10991011389c8aedeaef58c44a0",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-22T02:02:01.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-22T02:02:01.000Z",
"max_forks_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "dan-iel-lee/cubical",
"max_forks_repo_path": "Cubical/Relation/Nullary/DecidableEq.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/Relation/Nullary/DecidableEq.agda",
"max_line_length": 50,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "dan-iel-lee/cubical",
"max_stars_repo_path": "Cubical/Relation/Nullary/DecidableEq.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 52,
"size": 194
} |
{-# OPTIONS --erased-cubical --safe #-}
module Util where
open import Cubical.Core.Everything using (_≡_; Level; Type; Σ; _,_; fst; snd; _≃_; ~_)
open import Cubical.Foundations.Prelude using (refl; sym; _∙_; cong; transport; subst; funExt; transp; I; i0; i1)
--open import Cubical.Foundations.Function using (_∘_)
open import Cubical.Foundations.Univalence using (ua)
open import Cubical.Foundations.Isomorphism using (iso; Iso; isoToPath; section; retract; isoToEquiv)
open import Agda.Primitive using (Level)
open import Data.Fin using (Fin; #_; toℕ; inject; fromℕ; fromℕ<; inject₁) renaming (zero to fz; suc to fsuc)
open import Data.Bool using (Bool; true; false; if_then_else_)
open import Data.Integer using (ℤ; +_; -[1+_]; _-_; ∣_∣; -_)
open import Data.List using (List; concat; replicate; []; _∷_; _∷ʳ_; map; _++_; reverse)
open import Data.Maybe using (Maybe; just; nothing)
open import Data.Nat using (ℕ; zero; suc; _+_; _*_; _<ᵇ_; _≤ᵇ_; _≡ᵇ_; _<?_; _≟_; _∸_; _<_; s≤s; z≤n; _⊓_)
open import Data.Nat.DivMod using (_mod_)
open import Data.Nat.Properties using (≤-step; ≤-trans; ≤-refl)
open import Data.Product using (_×_; _,_)
open import Data.Vec using (Vec; _∷_; []; zip; last) renaming (concat to cat; replicate to rep; map to vmap; _∷ʳ_ to _v∷ʳ_)
open import Relation.Nullary using (yes; no; ¬_)
open import Relation.Nullary.Decidable using (False)
open import Relation.Unary using (Pred; Decidable)
infixr 9 _∘_
_∘_ : {ℓ : Level}{A : Type ℓ}{B : A → Type ℓ}{C : (a : A) → B a → Type ℓ}
(g : {a : A} → (b : B a) → C a b) → (f : (a : A) → B a) → (a : A) → C a (f a)
g ∘ f = λ x → g (f x)
{-# INLINE _∘_ #-}
repeat : {ℓ : Level} {A : Type ℓ} → (n : ℕ) → List A → List A
repeat n = concat ∘ replicate n
repeatV : {ℓ : Level} {A : Type ℓ} {k : ℕ} → (n : ℕ) → Vec A k → Vec A (n * k)
repeatV n = cat ∘ rep {n = n}
-- return index of first element that satisfies predicate or last element if none do
findIndex : {a ℓ : Level} {A : Type a} {n : ℕ} {P : Pred A ℓ} → Decidable P → Vec A (suc n) → Fin (suc n)
findIndex _ (x ∷ []) = # 0
findIndex P (x ∷ y ∷ ys) with P x
... | yes _ = # 0
... | no _ = fsuc (findIndex P (y ∷ ys))
-- Returns a list of all adjacent pairs in the original list.
pairs : {ℓ : Level} {A : Type ℓ} → List A → List (A × A)
pairs [] = []
pairs (x ∷ []) = []
pairs (x ∷ y ∷ xs) = (x , y) ∷ pairs (y ∷ xs)
-- Returns a list of all pairs in the original list.
allPairs : {ℓ : Level} {A : Type ℓ} → List A → List (A × A)
allPairs [] = []
allPairs (x ∷ xs) = map (x ,_) xs ++ allPairs xs
-- Returns a singleton list of the pair of the first and last element if the list has at least 2 elements,
-- or the empty list otherwise.
firstLast : {ℓ : Level} {A : Type ℓ} → List A → List (A × A)
firstLast [] = []
firstLast (x ∷ xs) with reverse xs
... | [] = []
... | y ∷ ys = (x , y) ∷ []
-- Returns a list of all adjacent pairs in the original list, prepended by the pair of the first and last elements.
◯pairs : {ℓ : Level} {A : Type ℓ} → List A → List (A × A)
◯pairs xs = firstLast xs ++ pairs xs
-- Returns a list of the first element paired with all later elements, in order.
firstPairs : {ℓ : Level} {A : Type ℓ} → List A → List (A × A)
firstPairs [] = []
firstPairs (x ∷ xs) = map (x ,_) xs
-- Basic Boolean Filter and Elem
filter : {ℓ : Level} {A : Type ℓ} → (A → Bool) → List A → List A
filter f [] = []
filter f (x ∷ xs) = if f x then x ∷ filter f xs else filter f xs
infix 4 _∈_via_
_∈_via_ : {ℓ : Level} {A : Type ℓ} → A → List A → (A → A → Bool) → Bool
x ∈ [] via f = false
x ∈ y ∷ ys via f = if f x y then true else x ∈ ys via f
concatMaybe : {ℓ : Level} {A : Type ℓ} → List (Maybe A) → List A
concatMaybe [] = []
concatMaybe (nothing ∷ xs) = concatMaybe xs
concatMaybe (just x ∷ xs) = x ∷ concatMaybe xs
listMin : {ℓ : Level} {A : Type ℓ} → (A → ℕ) → List A → Maybe A
listMin f [] = nothing
listMin f (x ∷ xs) with listMin f xs
... | nothing = just x
... | just y = if f x <ᵇ f y then just x else just y
fins : (k : ℕ) → Vec (Fin k) k
fins zero = []
fins (suc k) = fz ∷ vmap fsuc (fins k)
fins' : (n : ℕ) → (k : Fin n) → Vec (Fin n) (toℕ k)
fins' n k = vmap inject (fins (toℕ k))
finSuc : {n : ℕ} → Fin (suc n) → Fin (suc n)
finSuc {n} m with suc (toℕ m) <? suc n
... | yes x = fromℕ< x
... | no _ = fz
_+N_ : {n : ℕ} → Fin (suc n) → ℕ → Fin (suc n)
a +N zero = a
a +N suc b = finSuc a +N b
∣-∣helper : (n : ℕ) → ℕ → ℕ → ℕ
∣-∣helper n a b with a ≤ᵇ b
... | true = (b ∸ a) ⊓ ((n + a) ∸ b)
... | false = (a ∸ b) ⊓ ((n + b) ∸ a)
⟨_⟩∣_-_∣ : (n : ℕ) → Fin n → Fin n → ℕ
⟨_⟩∣_-_∣ n a b = ∣-∣helper n (toℕ a) (toℕ b)
n∸k<n : (n k : ℕ) → (suc n) ∸ (suc k) < suc n
n∸k<n zero zero = s≤s z≤n
n∸k<n (suc n) zero = s≤s (n∸k<n n zero)
n∸k<n zero (suc k) = s≤s z≤n
n∸k<n (suc n) (suc k) = ≤-trans (n∸k<n n k) (≤-step ≤-refl)
opposite' : ∀ {n} → Fin n → Fin n
opposite' {suc n} fz = fz
opposite' {suc n} (fsuc k) = fromℕ< (n∸k<n n (toℕ k))
-- opposite "i" = "n - i" (i.e. the additive inverse).
opposite : ∀ {n} → Fin n → Fin n
opposite {suc n} fz = fz
opposite {suc n} (fsuc fz) = fromℕ n
opposite {suc n} (fsuc (fsuc i)) = inject₁ (opposite (fsuc i))
_modℕ_ : (dividend : ℤ) (divisor : ℕ) {≢0 : False (divisor ≟ 0)} → Fin divisor
((+ n) modℕ d) {d≠0} = (n mod d) {d≠0}
(-[1+ n ] modℕ d) {d≠0} = opposite ((suc n mod d) {d≠0})
zipWithIndex : {ℓ : Level} {A : Type ℓ} {k : ℕ} → Vec A k → Vec (Fin k × A) k
zipWithIndex {k = k} = zip (fins k)
iter : {ℓ : Level} {A : Type ℓ} → (A → A) → ℕ → A → List A
iter f zero x = x ∷ []
iter f (suc n) x = x ∷ iter f n (f x)
rotateLeft : {ℓ : Level} {A : Type ℓ} → List A → List A
rotateLeft [] = []
rotateLeft (x ∷ xs) = xs ∷ʳ x
rotateRight : {ℓ : Level} {A : Type ℓ} → List A → List A
rotateRight = reverse ∘ rotateLeft ∘ reverse
vrotateLeft : {ℓ : Level} {A : Type ℓ} {k : ℕ} → Vec A k → Vec A k
vrotateLeft {k = zero} [] = []
vrotateLeft {k = suc k} (x ∷ xs) = xs v∷ʳ x
vrotateRight : {ℓ : Level} {A : Type ℓ} {k : ℕ} → Vec A k → Vec A k
vrotateRight {k = zero} [] = []
vrotateRight {k = suc k} xs@(_ ∷ ys) = last xs ∷ ys
| {
"alphanum_fraction": 0.5595978937,
"avg_line_length": 38.6851851852,
"ext": "agda",
"hexsha": "2ea437b386146d14964e82ee16325f72116b996f",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2020-11-10T04:04:40.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-01-12T17:02:36.000Z",
"max_forks_repo_head_hexsha": "04896c61b603d46011b7d718fcb47dd756e66021",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "halfaya/MusicTools",
"max_forks_repo_path": "agda/Util.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "04896c61b603d46011b7d718fcb47dd756e66021",
"max_issues_repo_issues_event_max_datetime": "2020-11-17T00:58:55.000Z",
"max_issues_repo_issues_event_min_datetime": "2020-11-13T01:26:20.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "halfaya/MusicTools",
"max_issues_repo_path": "agda/Util.agda",
"max_line_length": 135,
"max_stars_count": 28,
"max_stars_repo_head_hexsha": "04896c61b603d46011b7d718fcb47dd756e66021",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "halfaya/MusicTools",
"max_stars_repo_path": "agda/Util.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-04T18:04:07.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-04-21T09:08:52.000Z",
"num_tokens": 2499,
"size": 6267
} |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Susp.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Data.Bool
open import Cubical.HITs.Join
open import Cubical.HITs.Susp.Base
open Iso
Susp-iso-joinBool : ∀ {ℓ} {A : Type ℓ} → Iso (Susp A) (join A Bool)
fun Susp-iso-joinBool north = inr true
fun Susp-iso-joinBool south = inr false
fun Susp-iso-joinBool (merid a i) = (sym (push a true) ∙ push a false) i
inv Susp-iso-joinBool (inr true ) = north
inv Susp-iso-joinBool (inr false) = south
inv Susp-iso-joinBool (inl _) = north
inv Susp-iso-joinBool (push a true i) = north
inv Susp-iso-joinBool (push a false i) = merid a i
rightInv Susp-iso-joinBool (inr true ) = refl
rightInv Susp-iso-joinBool (inr false) = refl
rightInv Susp-iso-joinBool (inl a) = sym (push a true)
rightInv Susp-iso-joinBool (push a true i) j = push a true (i ∨ ~ j)
rightInv Susp-iso-joinBool (push a false i) j
= hcomp (λ k → λ { (i = i0) → push a true (~ j)
; (i = i1) → push a false k
; (j = i1) → push a false (i ∧ k) })
(push a true (~ i ∧ ~ j))
leftInv Susp-iso-joinBool north = refl
leftInv Susp-iso-joinBool south = refl
leftInv (Susp-iso-joinBool {A = A}) (merid a i) j
= hcomp (λ k → λ { (i = i0) → transp (λ _ → Susp A) (k ∨ j) north
; (i = i1) → transp (λ _ → Susp A) (k ∨ j) (merid a k)
; (j = i1) → merid a (i ∧ k) })
(transp (λ _ → Susp A) j north)
Susp≃joinBool : ∀ {ℓ} {A : Type ℓ} → Susp A ≃ join A Bool
Susp≃joinBool = isoToEquiv Susp-iso-joinBool
Susp≡joinBool : ∀ {ℓ} {A : Type ℓ} → Susp A ≡ join A Bool
Susp≡joinBool = isoToPath Susp-iso-joinBool
congSuspEquiv : ∀ {ℓ} {A B : Type ℓ} → A ≃ B → Susp A ≃ Susp B
congSuspEquiv {ℓ} {A} {B} h = isoToEquiv isom
where isom : Iso (Susp A) (Susp B)
Iso.fun isom north = north
Iso.fun isom south = south
Iso.fun isom (merid a i) = merid (fst h a) i
Iso.inv isom north = north
Iso.inv isom south = south
Iso.inv isom (merid a i) = merid (invEq h a) i
Iso.rightInv isom north = refl
Iso.rightInv isom south = refl
Iso.rightInv isom (merid a i) j = merid (retEq h a j) i
Iso.leftInv isom north = refl
Iso.leftInv isom south = refl
Iso.leftInv isom (merid a i) j = merid (secEq h a j) i
suspToPropRec : ∀ {ℓ ℓ'} {A : Type ℓ} {B : Susp A → Type ℓ'} (a : A)
→ ((x : Susp A) → isProp (B x))
→ B north
→ (x : Susp A) → B x
suspToPropRec a isProp Bnorth north = Bnorth
suspToPropRec {B = B} a isProp Bnorth south = subst B (merid a) Bnorth
suspToPropRec {B = B} a isProp Bnorth (merid a₁ i) =
isOfHLevel→isOfHLevelDep 1 isProp Bnorth (subst B (merid a) Bnorth) (merid a₁) i
suspToPropRec2 : ∀ {ℓ ℓ'} {A : Type ℓ} {B : Susp A → Susp A → Type ℓ'} (a : A)
→ ((x y : Susp A) → isProp (B x y))
→ B north north
→ (x y : Susp A) → B x y
suspToPropRec2 a isProp Bnorth =
suspToPropRec a (λ x → isOfHLevelΠ 1 λ y → isProp x y)
(suspToPropRec a (λ x → isProp north x) Bnorth)
| {
"alphanum_fraction": 0.6,
"avg_line_length": 41.835443038,
"ext": "agda",
"hexsha": "85fe61cd9688941cfcad74dd99ebec2afe8f2f24",
"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": "f6771617374bfe65a7043d00731fed5a673aa729",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "knrafto/cubical",
"max_forks_repo_path": "Cubical/HITs/Susp/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "f6771617374bfe65a7043d00731fed5a673aa729",
"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": "knrafto/cubical",
"max_issues_repo_path": "Cubical/HITs/Susp/Properties.agda",
"max_line_length": 82,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "f6771617374bfe65a7043d00731fed5a673aa729",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "knrafto/cubical",
"max_stars_repo_path": "Cubical/HITs/Susp/Properties.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1192,
"size": 3305
} |
{-# OPTIONS --without-K #-}
module container.m.from-nat.bisimulation where
open import level
open import sum
open import equality
open import function
open import container.core
open import container.m.coalgebra as MC hiding (IsMor ; _⇒_)
open import container.m.from-nat.coalgebra hiding (X)
open import hott.level
module Def {la lb lc} {C : Container la lb lc} (𝓧 : Coalg C (lb ⊔ lc)) where
open Container C
open Σ 𝓧 renaming (proj₁ to X ; proj₂ to γ)
open MC C using (IsMor ; _⇒_)
-- Σ-closure of an indexed binary relation
Σ₂[_] : (∀ {i} → X i → X i → Set (lb ⊔ lc)) → I → Set _
Σ₂[ _∼_ ] i = Σ (X i) λ x → Σ (X i) λ x′ → x ∼ x′
-- projections
module _ {_∼_ : ∀ {i} → X i → X i → Set _} (i : I) where
Σ₂-proj₁ : Σ₂[ _∼_ ] i → X i
Σ₂-proj₁ = proj₁
Σ₂-proj₂ : Σ₂[ _∼_ ] i → X i
Σ₂-proj₂ = proj₁ ∘' proj₂
Σ₂-proj₃ : (r : Σ₂[ _∼_ ] i) → _∼_ (Σ₂-proj₁ r) (Σ₂-proj₂ r)
Σ₂-proj₃ = proj₂ ∘' proj₂
-- Definition 16 in Ahrens, Capriotti and Spadotti (arXiv:1504.02949v1 [cs.LO])
-- bisimulation definition
record Bisim (_∼_ : ∀ {i} → X i → X i → Set _): Set(lb ⊔ lc ⊔ lsuc la) where
field
α : Σ₂[ _∼_ ] →ⁱ F Σ₂[ _∼_ ]
π₁-Mor : IsMor (_ , α) 𝓧 Σ₂-proj₁
π₂-Mor : IsMor (_ , α) 𝓧 Σ₂-proj₂
𝓑 : Coalg C _
𝓑 = _ , α
π₁ : 𝓑 ⇒ 𝓧
π₁ = _ , π₁-Mor
π₂ : 𝓑 ⇒ 𝓧
π₂ = _ , π₂-Mor
-- Lemma 17 in Ahrens, Capriotti and Spadotti (arXiv:1504.02949v1 [cs.LO])
Δ : Bisim (λ {i} → _≡_)
Δ = record { α = α ; π₁-Mor = π₁-Mor ; π₂-Mor = π₂-Mor }
where α : Σ₂[ _≡_ ] →ⁱ F Σ₂[ _≡_ ]
α i (x , ._ , refl) = proj₁ (γ _ x)
, λ b → (proj₂ (γ _ x) b) , (_ , refl)
π₁-Mor : IsMor (_ , α) 𝓧 _
π₁-Mor = funextⁱ helper
where helper : (i : I) → (p : Σ₂[ _≡_ ] i) → _
helper i (m , ._ , refl) = refl
π₂-Mor : IsMor (_ , α) 𝓧 _
π₂-Mor = funextⁱ helper
where helper : (i : I) → (p : Σ₂[ _≡_ ] i) → _
helper i (m , ._ , refl) = refl
--------------------------------------------------------------------------------
-- coinduction proof principle
module _ {la lb lc} {C : Container la lb lc} where
open Container C
open MC C using (IsMor ; _⇒_)
private
𝓜 : Coalg C (lb ⊔ lc)
𝓜 = 𝓛 C
unfold : ∀ (𝓧 : Coalg C (lb ⊔ lc)) → 𝓧 ⇒ 𝓜
unfold 𝓧 = proj₁ $ lim-terminal C 𝓧
unfold-universal = λ {ℓ} (𝓧 : Coalg C ℓ) → proj₂ (lim-terminal C 𝓧)
open Σ 𝓜 renaming (proj₁ to M ; proj₂ to out) ; open Def 𝓜
module _ {_∼_ : ∀ {i} → M i → M i → Set (lb ⊔ lc)} (B : Bisim _∼_) where
-- Theorem 18 in Ahrens, Capriotti and Spadotti (arXiv:1504.02949v1 [cs.LO])
-- coinduction proof principle
cpp : ∀ {i} {m m′ : M i} → m ∼ m′ → m ≡ m′
cpp {i} p = funext-invⁱ (proj₁ $ apΣ π₁=π₂) i (_ , _ , p)
where open Bisim B
abstract
π₁=π₂ : π₁ ≡ π₂
π₁=π₂ = (sym $ unfold-universal 𝓑 π₁) · unfold-universal 𝓑 π₂
-- In particular, provided that the bisimulation _∼_ is reflexive, we have:
module _ (∼-refl : ∀ {i} {m : M i} → m ∼ m) where
cpp′ : ∀ {i} {m m′ : M i} → m ∼ m′ → m ≡ m′
cpp′ {i} p = cpp p · sym (cpp ∼-refl)
cpp′-inv : ∀ {i} {m m′ : M i} → m ≡ m′ → m ∼ m′
cpp′-inv refl = ∼-refl
cpp′-id : ∀ {i} {m : M i} → cpp′ ∼-refl ≡ refl {x = m}
cpp′-id = left-inverse $ cpp ∼-refl
cpp′-retraction : ∀ {i} {m m′ : M i} (p : m ≡ m′) → cpp′ (cpp′-inv p) ≡ p
cpp′-retraction refl = left-inverse $ cpp ∼-refl
| {
"alphanum_fraction": 0.5053672316,
"avg_line_length": 31.8918918919,
"ext": "agda",
"hexsha": "e0b5c227c5fee71b250ee41868acc9cd27a77ded",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2019-02-26T06:17:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-04-11T17:19:12.000Z",
"max_forks_repo_head_hexsha": "beebe176981953ab48f37de5eb74557cfc5402f4",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "HoTT/M-types",
"max_forks_repo_path": "container/m/from-nat/bisimulation.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "beebe176981953ab48f37de5eb74557cfc5402f4",
"max_issues_repo_issues_event_max_datetime": "2015-02-11T15:20:34.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-02-11T11:14:59.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "HoTT/M-types",
"max_issues_repo_path": "container/m/from-nat/bisimulation.agda",
"max_line_length": 81,
"max_stars_count": 27,
"max_stars_repo_head_hexsha": "beebe176981953ab48f37de5eb74557cfc5402f4",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "HoTT/M-types",
"max_stars_repo_path": "container/m/from-nat/bisimulation.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-09T07:26:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-04-14T15:47:03.000Z",
"num_tokens": 1495,
"size": 3540
} |
{-# OPTIONS --without-K #-}
module M-types.Base.Core where
open import Agda.Primitive public using (Level) renaming
(
lzero to ℓ-zero ;
lsuc to ℓ-suc ;
_⊔_ to ℓ-max
)
variable
ℓ ℓ₀ ℓ₁ ℓ₂ : Level
Ty : (ℓ : Level) → Set (ℓ-suc ℓ)
Ty ℓ = Set ℓ
| {
"alphanum_fraction": 0.4953560372,
"avg_line_length": 17,
"ext": "agda",
"hexsha": "2264bf341c01cdbea16439a39a0dfe442543fbc4",
"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": "5b70f4b3dc3e50365ad7a3a80b0cd14efbfa4369",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "DDOtten/M-types",
"max_forks_repo_path": "Base/Core.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "5b70f4b3dc3e50365ad7a3a80b0cd14efbfa4369",
"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": "DDOtten/M-types",
"max_issues_repo_path": "Base/Core.agda",
"max_line_length": 60,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "5b70f4b3dc3e50365ad7a3a80b0cd14efbfa4369",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "DDOtten/M-types",
"max_stars_repo_path": "Base/Core.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 106,
"size": 323
} |
module _ where
-- Ulf's example of why removing abstract may
-- cause a proof that used to work to now fail
-- Agda mailing list, 16 May 2018
open import Agda.Builtin.Nat
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
module WithAbstract where
abstract
f : Nat → Nat
f zero = zero
f (suc n) = suc (f n)
lem : ∀ n → f n ≡ n
lem zero = refl
lem (suc n) rewrite lem n = refl
thm : ∀ m n → f (suc m) + n ≡ suc (m + n)
thm m n rewrite lem (suc m) = refl
-- Works.
thm′ : ∀ m n → f (suc m) + n ≡ suc (m + n)
thm′ m n = {!!}
{- Hole 0
Goal: f (suc m) + n ≡ suc (m + n)
————————————————————————————————————————————————————————————
n : Nat
m : Nat
-}
module WithoutAbstract where
f : Nat → Nat
f zero = zero
f (suc n) = suc (f n)
lem : ∀ n → f n ≡ n
lem zero = refl
lem (suc n) rewrite lem n = refl
thm : ∀ m n → f (suc m) + n ≡ suc (m + n)
thm m n rewrite lem (suc m) = {! refl!}
-- Fails since rewrite doesn't trigger:
-- lem (suc m) : suc (f m) ≡ suc m
-- goal : suc (f m + n) ≡ suc (m + n)
-- NB: The problem is with the expansion of `f`,
-- not with the expansion of the lemma
thm′ : ∀ m n → f (suc m) + n ≡ suc (m + n)
thm′ m n = {!!}
{- Holes 1 and 2
Goal: suc (f m + n) ≡ suc (m + n)
————————————————————————————————————————————————————————————
n : Nat
m : Nat
-}
| {
"alphanum_fraction": 0.4895758447,
"avg_line_length": 21.4,
"ext": "agda",
"hexsha": "705e54143ab0ba4da67b3f8ac626417ab7da42c5",
"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/Ulf.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/Ulf.agda",
"max_line_length": 60,
"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/Ulf.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": 507,
"size": 1391
} |
postulate
A : Set
module _ where
{-# POLARITY A #-}
| {
"alphanum_fraction": 0.5862068966,
"avg_line_length": 8.2857142857,
"ext": "agda",
"hexsha": "d0a310a8728484d30e011797aee29f0d32742061",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "pthariensflame/agda",
"max_forks_repo_path": "test/Fail/Polarity-pragma-out-of-scope.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "pthariensflame/agda",
"max_issues_repo_path": "test/Fail/Polarity-pragma-out-of-scope.agda",
"max_line_length": 20,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "pthariensflame/agda",
"max_stars_repo_path": "test/Fail/Polarity-pragma-out-of-scope.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": 20,
"size": 58
} |
module UniDB.Subst where
open import UniDB.Subst.Core public
open import UniDB.Subst.Pair public
open import UniDB.Subst.Inst public
| {
"alphanum_fraction": 0.8222222222,
"avg_line_length": 19.2857142857,
"ext": "agda",
"hexsha": "5a1e4c7cdc16d5bdef0dd1b63c1c2c792df2be06",
"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/Subst.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/Subst.agda",
"max_line_length": 35,
"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/Subst.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 36,
"size": 135
} |
{-# OPTIONS --without-K --rewriting --allow-unsolved-metas #-}
open import HoTT renaming (pt to pt⊙)
open import homotopy.DisjointlyPointedSet
open import lib.types.Nat
open import lib.types.Vec
module simplicial.Base where
-- HELPERS
combinations : ℕ → List ℕ -> List (List ℕ)
combinations 0 _ = nil :: nil
combinations _ nil = nil
combinations (S n) (x :: xs) = (map (λ ys → x :: ys) (combinations (n) xs)) ++ (combinations (S n) xs)
standardSimplex : ℕ → List ℕ
standardSimplex O = nil
standardSimplex (S x) = (S x) :: (standardSimplex x)
-- UGLY HELPER FUNCTIONS -- TO BE REPLACED WITH STANDARD FUNCTIONS LATER ON
bfilter : {A : Type₀} → ((a : A) → Bool) → List A → List A
bfilter f nil = nil
bfilter f (a :: l) with f a
... | inl _ = a :: (bfilter f l)
... | inr _ = bfilter f l
ℕin : ℕ → List ℕ → Bool
ℕin x nil = inr unit
ℕin x (y :: ys) with ℕ-has-dec-eq x y
... | inl x₁ = inl unit
... | inr x₁ = inr unit
_lsubset_ : List ℕ → List ℕ → Bool
nil lsubset ys = inl unit
(x :: xs) lsubset ys with ℕin x ys
... | inl _ = xs lsubset ys
... | inr _ = inr unit
-- TYPES FOR SIMPLICES
-- 'Simplices' saves a collection of simplices, grouped by their dimension.
-- Note that we do not specify the dimensions of individual simplices, since
-- otherwise we could not simply save all simplices in a single vector
Simplex = List ℕ
Simplices : ℕ → Type₀
Simplices dim = (Vec (List Simplex) dim)
is-closed : {dim : ℕ} → (Simplices dim) → Type₀
record SC (dim : ℕ) : Type₀ where
constructor complex
field
simplices : Simplices dim
closed : is-closed simplices
simplices : {dim : ℕ} → SC dim → Simplices dim
simplices (complex simplices _) = simplices
faces : Simplex → List Simplex
faces s = concat (map (λ l → combinations l s) (standardSimplex (ℕ-pred (length s))))
-- removes grouping of simplices by dimension and puts all simplices in single list
compress : {dim : ℕ} → Simplices dim → List Simplex
compress {dim} [] = nil
compress {dim} (xs ∷ xss) = xs ++ compress xss
bodies : {dim : ℕ} → (SC dim) → Simplex → List Simplex
bodies (complex ss _) s = bfilter (λ o → (s lsubset o)) (compress ss)
-- inverse of compress function
unfold : {dim : ℕ} → List Simplex → Simplices dim
unfold {dim} ss = unfold' {dim} ss (emptyss dim)
where
emptyss : (dim : ℕ) → Simplices dim
emptyss 0 = []
emptyss (S n) = nil ∷ (emptyss n)
unfold' : {dim : ℕ} → List Simplex → Simplices dim → Simplices dim
unfold' {dim} nil sc = sc
unfold' {dim} (x :: ss) sc = insert (faces x) sc
where
insert : {dim : ℕ} → List Simplex → Simplices dim → Simplices dim
insert nil sc = sc
insert (s :: ss) sc = insertS s sc
where
insertS : {dim : ℕ} → Simplex → Simplices dim → Simplices dim
insertS s sc = updateAt ((length s) , {!!}) (λ l → s :: l) sc
is-closed {dim} ss = All (λ s → All (λ f → f ∈ ssc) (faces s)) ssc
where ssc = compress ss
-- takes facet description of SC and generates their face closure
SCgenerator : (dim : ℕ) → List Simplex → SC dim
SC.simplices (SCgenerator dim ss) = unfold $ concat(concat (map(λ simplex → map (λ l → combinations l simplex) (standardSimplex (length simplex))) ss))
SC.closed (SCgenerator dim ss) = {!!}
-- EXAMPLES
sc-unit : SC 2
SC.simplices sc-unit = ((1 :: nil) :: (2 :: nil) :: nil) ∷ ((1 :: 2 :: nil) :: nil) ∷ []
SC.closed sc-unit = nil :: (nil :: (((here idp) :: ((there (here idp)) :: nil)) :: nil))
sc-circle : SC 2
SC.simplices sc-circle =
((1 :: nil) :: (2 :: nil) :: (3 :: nil) :: nil) ∷
((1 :: 2 :: nil) :: (1 :: 3 :: nil) :: (2 :: 3 :: nil) :: nil) ∷ []
SC.closed sc-circle = nil :: (nil :: (nil :: (((here idp) :: ((there (here idp)) :: nil)) :: (((here idp) :: ((there (there (here idp))) :: nil)) :: ((there (here idp) :: (there (there (here idp)) :: nil)) :: nil)))))
-- sc-circle-equiv-cw-circle : CWSphere 1 ≃ CWSphere 1
-- sc-circle-equiv-cw-circle = {!!}
sc-sphere : SC 3
sc-sphere = SCgenerator 3 ((1 :: 2 :: 3 :: nil) :: (1 :: 3 :: 4 :: nil) :: (2 :: 3 :: 4 :: nil) :: (1 :: 3 :: 4 :: nil) :: nil)
sc-unit-gen : SC 2
sc-unit-gen = SCgenerator 2 ((1 :: 2 :: nil) :: nil)
-- sc-unit≃sc-unit-gen : sc-unit ≃ sc-unit-gen
-- sc-unit≃sc-unit-gen = ?
| {
"alphanum_fraction": 0.6119580753,
"avg_line_length": 33.8548387097,
"ext": "agda",
"hexsha": "40dc64538203a48e9383a9b15b469fe4feba2b7c",
"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": "01bbd8841f9b9b25666b91e65b196d8f472b9978",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "maxdore/hott-morse",
"max_forks_repo_path": "theorems/simplicial/Base.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "01bbd8841f9b9b25666b91e65b196d8f472b9978",
"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": "maxdore/hott-morse",
"max_issues_repo_path": "theorems/simplicial/Base.agda",
"max_line_length": 217,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "01bbd8841f9b9b25666b91e65b196d8f472b9978",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "maxdore/hott-morse",
"max_stars_repo_path": "theorems/simplicial/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1414,
"size": 4198
} |
-- If we try to naively extend the Kripke structure used for NbE of STLC,
-- we find that it is sound, but not complete.
--
-- The definition of semantic objects, which represent terms in normal form,
-- is not big enough to represent neutral terms of the coproduct types.
-- The problem is visible in the definition of `reflect`.
module STLC2.Kovacs.Normalisation.SoundNotComplete where
open import STLC2.Kovacs.NormalForm public
--------------------------------------------------------------------------------
-- (Tyᴺ)
infix 3 _⊩_
_⊩_ : 𝒞 → 𝒯 → Set
Γ ⊩ ⎵ = Γ ⊢ⁿᶠ ⎵
Γ ⊩ A ⇒ B = ∀ {Γ′} → (η : Γ′ ⊇ Γ) (a : Γ′ ⊩ A)
→ Γ′ ⊩ B
Γ ⊩ A ⩕ B = Γ ⊩ A × Γ ⊩ B
Γ ⊩ ⫪ = ⊤
Γ ⊩ ⫫ = ⊥
Γ ⊩ A ⩖ B = Γ ⊩ A ⊎ Γ ⊩ B
-- (Conᴺ ; ∙ ; _,_)
infix 3 _⊩⋆_
data _⊩⋆_ : 𝒞 → 𝒞 → Set
where
∅ : ∀ {Γ} → Γ ⊩⋆ ∅
_,_ : ∀ {Γ Ξ A} → (ρ : Γ ⊩⋆ Ξ) (a : Γ ⊩ A)
→ Γ ⊩⋆ Ξ , A
--------------------------------------------------------------------------------
-- (Tyᴺₑ)
acc : ∀ {A Γ Γ′} → Γ′ ⊇ Γ → Γ ⊩ A → Γ′ ⊩ A
acc {⎵} η M = renⁿᶠ η M
acc {A ⇒ B} η f = λ η′ a → f (η ○ η′) a
acc {A ⩕ B} η s = acc η (proj₁ s) , acc η (proj₂ s)
acc {⫪} η s = tt
acc {⫫} η s = elim⊥ s
acc {A ⩖ B} η s = elim⊎ s (λ a → inj₁ (acc η a))
(λ b → inj₂ (acc η b))
-- (Conᴺₑ)
-- NOTE: _⬖_ = acc⋆
_⬖_ : ∀ {Γ Γ′ Ξ} → Γ ⊩⋆ Ξ → Γ′ ⊇ Γ → Γ′ ⊩⋆ Ξ
∅ ⬖ η = ∅
(ρ , a) ⬖ η = ρ ⬖ η , acc η a
--------------------------------------------------------------------------------
-- (∈ᴺ)
getᵥ : ∀ {Γ Ξ A} → Γ ⊩⋆ Ξ → Ξ ∋ A → Γ ⊩ A
getᵥ (ρ , a) zero = a
getᵥ (ρ , a) (suc i) = getᵥ ρ i
-- (Tmᴺ)
eval : ∀ {Γ Ξ A} → Γ ⊩⋆ Ξ → Ξ ⊢ A → Γ ⊩ A
eval ρ (𝓋 i) = getᵥ ρ i
eval ρ (ƛ M) = λ η a → eval (ρ ⬖ η , a) M
eval ρ (M ∙ N) = eval ρ M idₑ (eval ρ N)
eval ρ (M , N) = eval ρ M , eval ρ N
eval ρ (π₁ M) = proj₁ (eval ρ M)
eval ρ (π₂ M) = proj₂ (eval ρ M)
eval ρ τ = tt
eval ρ (φ M) = elim⊥ (eval ρ M)
eval ρ (ι₁ M) = inj₁ (eval ρ M)
eval ρ (ι₂ M) = inj₂ (eval ρ M)
eval ρ (M ⁇ N₁ ∥ N₂) = elim⊎ (eval ρ M) (λ M₁ → eval (ρ , M₁) N₁)
(λ M₂ → eval (ρ , M₂) N₂)
-- mutual
-- -- (qᴺ)
-- reify : ∀ {A Γ} → Γ ⊩ A → Γ ⊢ⁿᶠ A
-- reify {⎵} M = M
-- reify {A ⇒ B} f = ƛ (reify (f (wkₑ idₑ) (reflect 0)))
-- reify {A ⩕ B} s = reify (proj₁ s) , reify (proj₂ s)
-- reify {⫪} s = τ
-- reify {⫫} s = elim⊥ s
-- reify {A ⩖ B} s = elim⊎ s (λ a → ι₁ (reify a))
-- (λ b → ι₂ (reify b))
-- -- (uᴺ)
-- reflect : ∀ {A Γ} → Γ ⊢ⁿᵉ A → Γ ⊩ A
-- reflect {⎵} M = ne M
-- reflect {A ⇒ B} M = λ η a → reflect (renⁿᵉ η M ∙ reify a)
-- reflect {A ⩕ B} M = reflect (π₁ M) , reflect (π₂ M)
-- reflect {⫪} M = tt
-- reflect {⫫} M = {!!}
-- reflect {A ⩖ B} M = {!!}
-- -- (uᶜᴺ)
-- idᵥ : ∀ {Γ} → Γ ⊩⋆ Γ
-- idᵥ {∅} = ∅
-- idᵥ {Γ , A} = idᵥ ⬖ wkₑ idₑ , reflect 0
-- -- (nf)
-- nf : ∀ {Γ A} → Γ ⊢ A → Γ ⊢ⁿᶠ A
-- nf M = reify (eval idᵥ M)
--------------------------------------------------------------------------------
| {
"alphanum_fraction": 0.3756765361,
"avg_line_length": 26.175,
"ext": "agda",
"hexsha": "0279557be71874e731586ad52e25ffdfa8d90900",
"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": "bd626509948fbf8503ec2e31c1852e1ac6edcc79",
"max_forks_repo_licenses": [
"X11"
],
"max_forks_repo_name": "mietek/coquand-kovacs",
"max_forks_repo_path": "src/STLC2/Kovacs/Normalisation/SoundNotComplete.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "bd626509948fbf8503ec2e31c1852e1ac6edcc79",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"X11"
],
"max_issues_repo_name": "mietek/coquand-kovacs",
"max_issues_repo_path": "src/STLC2/Kovacs/Normalisation/SoundNotComplete.agda",
"max_line_length": 80,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "bd626509948fbf8503ec2e31c1852e1ac6edcc79",
"max_stars_repo_licenses": [
"X11"
],
"max_stars_repo_name": "mietek/coquand-kovacs",
"max_stars_repo_path": "src/STLC2/Kovacs/Normalisation/SoundNotComplete.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1490,
"size": 3141
} |
{-# OPTIONS --without-K --rewriting #-}
module Base where
{-
With the HoTT-Agda library, the following import can be used instead:
open import HoTT using
(Type; lmax; lsucc;
_==_; idp; !;
ap; apd;
Square; ids; vid-square; hid-square; SquareOver; ↓-ap-in; apd-square;
app=; λ=; app=-β;
transport;
ℕ; O; S; ℕ-reader;
_×_; _,_; fst; snd;
_∘_; ap-∘; ap-!;
PathOver; ↓-cst-in; apd=cst-in; ap-idf; ap-cst; square-symmetry; uncurry; ap-square;
Cube; idc; ap-cube;
is-contr) public
-}
open import Agda.Primitive public using (lzero)
renaming (Level to ULevel; lsuc to lsucc; _⊔_ to lmax)
Type : (i : ULevel) → Set (lsucc i)
Type i = Set i
Type₀ : Set (lsucc lzero)
Type₀ = Type lzero
infix 30 _==_
data _==_ {i} {A : Type i} (a : A) : A → Type i where
idp : a == a
PathOver : ∀ {i j} {A : Type i} (B : A → Type j)
{x y : A} (p : x == y) (u : B x) (v : B y) → Type j
PathOver B idp u v = (u == v)
infix 30 PathOver
syntax PathOver B p u v =
u == v [ B ↓ p ]
ap : ∀ {i j} {A : Type i} {B : Type j} (f : A → B) {x y : A}
→ (x == y → f x == f y)
ap f idp = idp
apd : ∀ {i j} {A : Type i} {B : A → Type j} (f : (a : A) → B a) {x y : A}
→ (p : x == y) → f x == f y [ B ↓ p ]
apd f idp = idp
transport : ∀ {i j} {A : Type i} (B : A → Type j) {x y : A} (p : x == y)
→ (B x → B y)
transport B idp u = u
infixr 60 _,_
record Σ {i j} (A : Type i) (B : A → Type j) : Type (lmax i j) where
constructor _,_
field
fst : A
snd : B fst
open Σ public
_×_ : ∀ {i j} (A : Type i) (B : Type j) → Type (lmax i j)
A × B = Σ A (λ _ → B)
data ℕ : Type lzero where
O : ℕ
S : (n : ℕ) → ℕ
Nat = ℕ
{-# BUILTIN NATURAL ℕ #-}
infixr 80 _∘_
_∘_ : ∀ {i j k} {A : Type i} {B : A → Type j} {C : (a : A) → (B a → Type k)}
→ (g : {a : A} → (x : B a) → (C a x)) → (f : (x : A) → B x) → (x : A) → C x (f x)
g ∘ f = λ x → g (f x)
uncurry : ∀ {i j k} {A : Type i} {B : A → Type j} {C : (x : A) → B x → Type k}
→ (∀ x y → C x y) → (∀ s → C (fst s) (snd s))
uncurry f (x , y) = f x y
record FromNat {i} (A : Type i) : Type (lsucc i) where
field
in-range : ℕ → Type i
read : ∀ n → ⦃ _ : in-range n ⦄ → A
open FromNat ⦃...⦄ public using () renaming (read to from-nat)
{-# BUILTIN FROMNAT from-nat #-}
record ⊤ : Type lzero where
instance constructor unit
Unit = ⊤
instance
ℕ-reader : FromNat ℕ
FromNat.in-range ℕ-reader _ = ⊤
FromNat.read ℕ-reader n = n
! : ∀ {i} {A : Type i} {x y : A} → x == y → y == x
! idp = idp
data Square {i} {A : Type i} {a₀₀ : A} : {a₀₁ a₁₀ a₁₁ : A}
→ a₀₀ == a₀₁ → a₀₀ == a₁₀ → a₀₁ == a₁₁ → a₁₀ == a₁₁ → Type i
where
ids : Square idp idp idp idp
hid-square : ∀ {i} {A : Type i} {a₀₀ a₀₁ : A} {p : a₀₀ == a₀₁}
→ Square p idp idp p
hid-square {p = idp} = ids
vid-square : ∀ {i} {A : Type i} {a₀₀ a₁₀ : A} {p : a₀₀ == a₁₀}
→ Square idp p p idp
vid-square {p = idp} = ids
ap-square : ∀ {i j} {A : Type i} {B : Type j} (f : A → B)
{a₀₀ a₀₁ a₁₀ a₁₁ : A}
{p₀₋ : a₀₀ == a₀₁} {p₋₀ : a₀₀ == a₁₀} {p₋₁ : a₀₁ == a₁₁} {p₁₋ : a₁₀ == a₁₁}
→ Square p₀₋ p₋₀ p₋₁ p₁₋
→ Square (ap f p₀₋) (ap f p₋₀) (ap f p₋₁) (ap f p₁₋)
ap-square f ids = ids
SquareOver : ∀ {i j} {A : Type i} (B : A → Type j) {a₀₀ a₀₁ a₁₀ a₁₁ : A}
{p₀₋ : a₀₀ == a₀₁} {p₋₀ : a₀₀ == a₁₀} {p₋₁ : a₀₁ == a₁₁} {p₁₋ : a₁₀ == a₁₁}
(sq : Square p₀₋ p₋₀ p₋₁ p₁₋)
{b₀₀ : B a₀₀} {b₀₁ : B a₀₁} {b₁₀ : B a₁₀} {b₁₁ : B a₁₁}
(q₀₋ : b₀₀ == b₀₁ [ B ↓ p₀₋ ]) (q₋₀ : b₀₀ == b₁₀ [ B ↓ p₋₀ ])
(q₋₁ : b₀₁ == b₁₁ [ B ↓ p₋₁ ]) (q₁₋ : b₁₀ == b₁₁ [ B ↓ p₁₋ ])
→ Type j
SquareOver B ids = Square
apd-square : ∀ {i j} {A : Type i} {B : A → Type j} (f : (x : A) → B x)
{a₀₀ a₀₁ a₁₀ a₁₁ : A}
{p₀₋ : a₀₀ == a₀₁} {p₋₀ : a₀₀ == a₁₀} {p₋₁ : a₀₁ == a₁₁} {p₁₋ : a₁₀ == a₁₁}
(sq : Square p₀₋ p₋₀ p₋₁ p₁₋)
→ SquareOver B sq (apd f p₀₋) (apd f p₋₀) (apd f p₋₁) (apd f p₁₋)
apd-square f ids = ids
square-symmetry : ∀ {i} {A : Type i} {a₀₀ a₀₁ a₁₀ a₁₁ : A}
{p₀₋ : a₀₀ == a₀₁} {p₋₀ : a₀₀ == a₁₀} {p₋₁ : a₀₁ == a₁₁} {p₁₋ : a₁₀ == a₁₁}
→ Square p₀₋ p₋₀ p₋₁ p₁₋ → Square p₋₀ p₀₋ p₁₋ p₋₁
square-symmetry ids = ids
module _ {i j k} {A : Type i} {B : Type j} (C : B → Type k) (f : A → B) where
↓-ap-in : {x y : A} {p : x == y} {u : C (f x)} {v : C (f y)}
→ u == v [ C ∘ f ↓ p ]
→ u == v [ C ↓ ap f p ]
↓-ap-in {p = idp} idp = idp
-- We postulate function extensionality
module _ {i j} {A : Type i} {P : A → Type j} {f g : (x : A) → P x} where
app= : (p : f == g) (x : A) → f x == g x
app= p x = ap (λ u → u x) p
postulate
λ= : (h : (x : A) → f x == g x) → f == g
app=-β : (h : (x : A) → f x == g x) (x : A) → app= (λ= h) x == h x
ap-∘ : ∀ {i j k} {A : Type i} {B : Type j} {C : Type k} (g : B → C) (f : A → B)
{x y : A} (p : x == y) → ap (g ∘ f) p == ap g (ap f p)
ap-∘ f g idp = idp
ap-cst : ∀ {i j} {A : Type i} {B : Type j} (b : B) {x y : A} (p : x == y)
→ ap (λ _ → b) p == idp
ap-cst b idp = idp
ap-idf : ∀ {i} {A : Type i} {u v : A} (p : u == v) → ap (λ x → x) p == p
ap-idf idp = idp
module _ {i j} {A : Type i} {B : Type j} (f : A → B) where
ap-! : {x y : A} (p : x == y)
→ ap f (! p) == ! (ap f p)
ap-! idp = idp
module _ {i j} {A : Type i} {B : Type j} where
↓-cst-in : {x y : A} {p : x == y} {u v : B}
→ u == v
→ u == v [ (λ _ → B) ↓ p ]
↓-cst-in {p = idp} q = q
{- Used for defining the recursor from the eliminator for 1-HIT -}
apd=cst-in : ∀ {i j} {A : Type i} {B : Type j} {f : A → B}
{a a' : A} {p : a == a'} {q : f a == f a'}
→ apd f p == ↓-cst-in q → ap f p == q
apd=cst-in {p = idp} x = x
data Cube {i} {A : Type i} {a₀₀₀ : A} :
{a₀₁₀ a₁₀₀ a₁₁₀ a₀₀₁ a₀₁₁ a₁₀₁ a₁₁₁ : A}
{p₀₋₀ : a₀₀₀ == a₀₁₀} {p₋₀₀ : a₀₀₀ == a₁₀₀}
{p₋₁₀ : a₀₁₀ == a₁₁₀} {p₁₋₀ : a₁₀₀ == a₁₁₀}
(sq₋₋₀ : Square p₀₋₀ p₋₀₀ p₋₁₀ p₁₋₀) -- left
{p₀₋₁ : a₀₀₁ == a₀₁₁} {p₋₀₁ : a₀₀₁ == a₁₀₁}
{p₋₁₁ : a₀₁₁ == a₁₁₁} {p₁₋₁ : a₁₀₁ == a₁₁₁}
(sq₋₋₁ : Square p₀₋₁ p₋₀₁ p₋₁₁ p₁₋₁) -- right
{p₀₀₋ : a₀₀₀ == a₀₀₁} {p₀₁₋ : a₀₁₀ == a₀₁₁}
{p₁₀₋ : a₁₀₀ == a₁₀₁} {p₁₁₋ : a₁₁₀ == a₁₁₁}
(sq₀₋₋ : Square p₀₋₀ p₀₀₋ p₀₁₋ p₀₋₁) -- back
(sq₋₀₋ : Square p₋₀₀ p₀₀₋ p₁₀₋ p₋₀₁) -- top
(sq₋₁₋ : Square p₋₁₀ p₀₁₋ p₁₁₋ p₋₁₁) -- bottom
(sq₁₋₋ : Square p₁₋₀ p₁₀₋ p₁₁₋ p₁₋₁) -- front
→ Type i
where
idc : Cube ids ids ids ids ids ids
ap-cube : ∀ {i j} {A : Type i} {B : Type j} (f : A → B)
{a₀₀₀ a₀₁₀ a₁₀₀ a₁₁₀ a₀₀₁ a₀₁₁ a₁₀₁ a₁₁₁ : A}
{p₀₋₀ : a₀₀₀ == a₀₁₀} {p₋₀₀ : a₀₀₀ == a₁₀₀}
{p₋₁₀ : a₀₁₀ == a₁₁₀} {p₁₋₀ : a₁₀₀ == a₁₁₀}
{sq₋₋₀ : Square p₀₋₀ p₋₀₀ p₋₁₀ p₁₋₀} -- left
{p₀₋₁ : a₀₀₁ == a₀₁₁} {p₋₀₁ : a₀₀₁ == a₁₀₁}
{p₋₁₁ : a₀₁₁ == a₁₁₁} {p₁₋₁ : a₁₀₁ == a₁₁₁}
{sq₋₋₁ : Square p₀₋₁ p₋₀₁ p₋₁₁ p₁₋₁} -- right
{p₀₀₋ : a₀₀₀ == a₀₀₁} {p₀₁₋ : a₀₁₀ == a₀₁₁}
{p₁₀₋ : a₁₀₀ == a₁₀₁} {p₁₁₋ : a₁₁₀ == a₁₁₁}
{sq₀₋₋ : Square p₀₋₀ p₀₀₋ p₀₁₋ p₀₋₁} -- back
{sq₋₀₋ : Square p₋₀₀ p₀₀₋ p₁₀₋ p₋₀₁} -- top
{sq₋₁₋ : Square p₋₁₀ p₀₁₋ p₁₁₋ p₋₁₁} -- bottom
{sq₁₋₋ : Square p₁₋₀ p₁₀₋ p₁₁₋ p₁₋₁} -- front
→ Cube sq₋₋₀ sq₋₋₁ sq₀₋₋ sq₋₀₋ sq₋₁₋ sq₁₋₋
→ Cube (ap-square f sq₋₋₀) (ap-square f sq₋₋₁) (ap-square f sq₀₋₋)
(ap-square f sq₋₀₋) (ap-square f sq₋₁₋) (ap-square f sq₁₋₋)
ap-cube f idc = idc
| {
"alphanum_fraction": 0.4858311011,
"avg_line_length": 29.8025210084,
"ext": "agda",
"hexsha": "3e54989c09bb0f652bd00d9188d7d4ab14e53037",
"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": "89fbc29473d2d1ed1a45c3c0e56288cdcf77050b",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "guillaumebrunerie/JamesConstruction",
"max_forks_repo_path": "Base.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "89fbc29473d2d1ed1a45c3c0e56288cdcf77050b",
"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": "guillaumebrunerie/JamesConstruction",
"max_issues_repo_path": "Base.agda",
"max_line_length": 87,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "89fbc29473d2d1ed1a45c3c0e56288cdcf77050b",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "guillaumebrunerie/JamesConstruction",
"max_stars_repo_path": "Base.agda",
"max_stars_repo_stars_event_max_datetime": "2018-11-16T22:10:16.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-12-07T04:34:52.000Z",
"num_tokens": 3790,
"size": 7093
} |
module Type.Category.IntensionalFunctionsCategory.HomFunctor where
import Functional as Fn
open import Function.Proofs
open import Logic.Predicate
import Lvl
open import Relator.Equals
open import Relator.Equals.Proofs
import Relator.Equals.Proofs.Equiv
open import Structure.Category
open import Structure.Category.Dual
open import Structure.Category.Functor
open import Structure.Function
open import Structure.Operator
open import Structure.Relator.Properties
open import Syntax.Function
open import Syntax.Transitivity
open import Type.Category.IntensionalFunctionsCategory
open import Type
private variable ℓ ℓₒ ℓₘ ℓₑ : Lvl.Level
module _
{Obj : Type{ℓₒ}}
{_⟶_ : Obj → Obj → Type{ℓₘ}}
(C : Category(_⟶_))
where
open Category(C)
covariantHomFunctor : Obj → (intro(C) →ᶠᵘⁿᶜᵗᵒʳ typeIntensionalFnCategoryObject{ℓₘ})
∃.witness (covariantHomFunctor x) y = (x ⟶ y)
Functor.map (∃.proof (covariantHomFunctor _)) = (_∘_)
Function.congruence (Functor.map-function (∃.proof (covariantHomFunctor _))) = congruence₁(_∘_)
Functor.op-preserving (∃.proof (covariantHomFunctor x)) {f = f} {g = g} =
(h ↦ (f ∘ g) ∘ h) 🝖[ _≡_ ]-[ {!!} ] -- TODO: Requires func. ext?
(h ↦ f ∘ (g ∘ h)) 🝖[ _≡_ ]-[]
(f ∘_) Fn.∘ (g ∘_) 🝖-end
Functor.id-preserving (∃.proof (covariantHomFunctor x)) = {!!}
{-
contravariantHomFunctor : Object → (dual(C) →ᶠᵘⁿᶜᵗᵒʳ typeIntensionalFnCategoryObject{ℓₘ})
∃.witness (contravariantHomFunctor x) y = (y ⟶ x)
Functor.map (∃.proof (contravariantHomFunctor _)) = Fn.swap(_∘_)
Function.congruence (Functor.map-function (∃.proof (contravariantHomFunctor x))) x₁ = {!!}
_⊜_.proof (Functor.op-preserving (∃.proof (contravariantHomFunctor x))) {x₁} = {!!}
_⊜_.proof (Functor.id-preserving (∃.proof (contravariantHomFunctor x))) {x₁} = {!!}
-}
| {
"alphanum_fraction": 0.7101769912,
"avg_line_length": 37.6666666667,
"ext": "agda",
"hexsha": "a1b3d9a6ad9b2d7139a81cbe9ccffa24979ddb07",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Lolirofle/stuff-in-agda",
"max_forks_repo_path": "Type/Category/IntensionalFunctionsCategory/HomFunctor.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "Type/Category/IntensionalFunctionsCategory/HomFunctor.agda",
"max_line_length": 97,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Lolirofle/stuff-in-agda",
"max_stars_repo_path": "Type/Category/IntensionalFunctionsCategory/HomFunctor.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": 636,
"size": 1808
} |
{-# OPTIONS --without-K #-}
module Util where
open import Agda.Primitive using (Level)
open import Data.Fin using (Fin; #_) renaming (suc to fsuc)
open import Data.Bool using (Bool; true; false; if_then_else_)
open import Data.List using (List; concat; replicate; []; _∷_)
open import Data.Maybe using (Maybe; just; nothing)
open import Data.Nat using (ℕ; suc; _*_; _<ᵇ_)
open import Data.Product using (_×_; _,_)
open import Data.Vec using (Vec; _∷_; []) renaming (concat to cat; replicate to rep)
open import Function using (_∘_)
open import Relation.Nullary using (yes; no; ¬_)
open import Relation.Unary using (Pred; Decidable)
repeat : {ℓ : Level} {A : Set ℓ} → (n : ℕ) → List A → List A
repeat n = concat ∘ replicate n
repeatV : {ℓ : Level} {A : Set ℓ} {k : ℕ} → (n : ℕ) → Vec A k → Vec A (n * k)
repeatV n = cat ∘ rep {n = n}
-- return index of first element that satisfies predicate or last element if none do
findIndex : {a ℓ : Level} {A : Set a} {n : ℕ} {P : Pred A ℓ} → Decidable P → Vec A (suc n) → Fin (suc n)
findIndex _ (x ∷ []) = # 0
findIndex P (x ∷ y ∷ ys) with P x
... | yes _ = # 0
... | no _ = fsuc (findIndex P (y ∷ ys))
-- Returns a list of all adjacent pairs in the original list.
pairs : {ℓ : Level} {A : Set ℓ} → List A → List (A × A)
pairs [] = []
pairs (x ∷ []) = []
pairs (x ∷ y ∷ xs) = (x , y) ∷ pairs (y ∷ xs)
-- Basic Boolean Filter and Elem
filter : {ℓ : Level} {A : Set ℓ} → (A → Bool) → List A → List A
filter f [] = []
filter f (x ∷ xs) = if f x then x ∷ filter f xs else filter f xs
infix 4 _∈_via_
_∈_via_ : {ℓ : Level} {A : Set ℓ} → A → List A → (A → A → Bool) → Bool
x ∈ [] via f = false
x ∈ y ∷ ys via f = if f x y then true else x ∈ ys via f
concatMaybe : {ℓ : Level} {A : Set ℓ} → List (Maybe A) → List A
concatMaybe [] = []
concatMaybe (nothing ∷ xs) = concatMaybe xs
concatMaybe (just x ∷ xs) = x ∷ concatMaybe xs
listMin : {ℓ : Level} {A : Set ℓ} → (A → ℕ) → List A → Maybe A
listMin f [] = nothing
listMin f (x ∷ xs) with listMin f xs
... | nothing = just x
... | just y = if f x <ᵇ f y then just x else just y
| {
"alphanum_fraction": 0.5705908886,
"avg_line_length": 38.8947368421,
"ext": "agda",
"hexsha": "76dfa3cb1a5e09cbc3d139c4dacf4d3c0036a8d2",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2020-11-10T04:04:40.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-01-12T17:02:36.000Z",
"max_forks_repo_head_hexsha": "04896c61b603d46011b7d718fcb47dd756e66021",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "halfaya/MusicTools",
"max_forks_repo_path": "doc/icfp20/code/Util.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "04896c61b603d46011b7d718fcb47dd756e66021",
"max_issues_repo_issues_event_max_datetime": "2020-11-17T00:58:55.000Z",
"max_issues_repo_issues_event_min_datetime": "2020-11-13T01:26:20.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "halfaya/MusicTools",
"max_issues_repo_path": "doc/icfp20/code/Util.agda",
"max_line_length": 104,
"max_stars_count": 28,
"max_stars_repo_head_hexsha": "04896c61b603d46011b7d718fcb47dd756e66021",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "halfaya/MusicTools",
"max_stars_repo_path": "doc/icfp20/code/Util.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-04T18:04:07.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-04-21T09:08:52.000Z",
"num_tokens": 755,
"size": 2217
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Homomorphism proofs for negation over polynomials
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Tactic.RingSolver.Core.Polynomial.Parameters
module Tactic.RingSolver.Core.Polynomial.Homomorphism.Negation
{r₁ r₂ r₃ r₄}
(homo : Homomorphism r₁ r₂ r₃ r₄)
where
open import Data.Product using (_,_)
open import Data.Vec using (Vec)
open import Data.Nat using (_<′_)
open import Data.Nat.Induction
open import Function
open Homomorphism homo
open import Tactic.RingSolver.Core.Polynomial.Homomorphism.Lemmas homo
open import Tactic.RingSolver.Core.Polynomial.Reasoning to
open import Tactic.RingSolver.Core.Polynomial.Base from
open import Tactic.RingSolver.Core.Polynomial.Semantics homo
⊟-step-hom : ∀ {n} (a : Acc _<′_ n) → (xs : Poly n) → ∀ ρ → ⟦ ⊟-step a xs ⟧ ρ ≈ - (⟦ xs ⟧ ρ)
⊟-step-hom (acc _ ) (Κ x ⊐ i≤n) ρ = -‿homo x
⊟-step-hom (acc wf) (⅀ xs ⊐ i≤n) ρ′ =
let (ρ , ρs) = drop-1 i≤n ρ′
neg-zero =
begin
0#
≈⟨ sym (zeroʳ _) ⟩
- 0# * 0#
≈⟨ -‿*-distribˡ 0# 0# ⟩
- (0# * 0#)
≈⟨ -‿cong (zeroˡ 0#) ⟩
- 0#
∎
in
begin
⟦ poly-map (⊟-step (wf _ i≤n)) xs ⊐↓ i≤n ⟧ ρ′
≈⟨ ⊐↓-hom (poly-map (⊟-step (wf _ i≤n)) xs) i≤n ρ′ ⟩
⅀?⟦ poly-map (⊟-step (wf _ i≤n)) xs ⟧ (ρ , ρs)
≈⟨ poly-mapR ρ ρs (⊟-step (wf _ i≤n)) -_ (-‿cong) (λ x y → *-comm x (- y) ⟨ trans ⟩ -‿*-distribˡ y x ⟨ trans ⟩ -‿cong (*-comm _ _)) (λ x y → sym (-‿+-comm x y)) (flip (⊟-step-hom (wf _ i≤n)) ρs) (sym neg-zero ) xs ⟩
- ⅀⟦ xs ⟧ (ρ , ρs)
∎
⊟-hom : ∀ {n}
→ (xs : Poly n)
→ (Ρ : Vec Carrier n)
→ ⟦ ⊟ xs ⟧ Ρ ≈ - ⟦ xs ⟧ Ρ
⊟-hom = ⊟-step-hom (<′-wellFounded _)
| {
"alphanum_fraction": 0.507741591,
"avg_line_length": 32.8596491228,
"ext": "agda",
"hexsha": "f179f9b677298d3f85747235dca9ad4eee927723",
"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/Tactic/RingSolver/Core/Polynomial/Homomorphism/Negation.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/Tactic/RingSolver/Core/Polynomial/Homomorphism/Negation.agda",
"max_line_length": 217,
"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/Tactic/RingSolver/Core/Polynomial/Homomorphism/Negation.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": 764,
"size": 1873
} |
------------------------------------------------------------------------
-- Some simple substitution combinators
------------------------------------------------------------------------
-- Given a term type which supports weakening and transformation of
-- variables to terms various substitutions are defined and various
-- lemmas proved.
open import Data.Universe.Indexed
module deBruijn.Substitution.Function.Simple
{i u e} {Uni : IndexedUniverse i u e} where
import deBruijn.Context; open deBruijn.Context Uni
open import deBruijn.Substitution.Function.Basics
open import deBruijn.Substitution.Function.Map
open import Function as F using (_$_)
open import Level using (_⊔_)
open import Relation.Binary.PropositionalEquality as P using (_≡_)
open P.≡-Reasoning
-- Simple substitutions.
record Simple {t} (T : Term-like t) : Set (i ⊔ u ⊔ e ⊔ t) where
open Term-like T
field
-- Weakens terms.
weaken : ∀ {Γ} {σ : Type Γ} → [ T ⟶ T ] ŵk[ σ ]
-- A synonym.
weaken[_] : ∀ {Γ} (σ : Type Γ) → [ T ⟶ T ] ŵk[ σ ]
weaken[_] _ = weaken
field
-- Takes variables to terms.
var : [ Var ⟶⁼ T ]
-- A property relating weaken and var.
weaken-var : ∀ {Γ σ τ} (x : Γ ∋ τ) →
weaken[ σ ] · (var · x) ≅-⊢ var · suc[ σ ] x
-- Weakens substitutions.
wk-subst : ∀ {Γ Δ σ} {ρ̂ : Γ ⇨̂ Δ} → Sub T ρ̂ → Sub T (ρ̂ ∘̂ ŵk[ σ ])
wk-subst ρ = map weaken ρ
wk-subst[_] : ∀ {Γ Δ} σ {ρ̂ : Γ ⇨̂ Δ} → Sub T ρ̂ → Sub T (ρ̂ ∘̂ ŵk[ σ ])
wk-subst[ _ ] = wk-subst
-- N-ary weakening of substitutions.
wk-subst⁺ : ∀ {Γ Δ} Δ⁺ {ρ̂ : Γ ⇨̂ Δ} → Sub T ρ̂ → Sub T (ρ̂ ∘̂ ŵk⁺ Δ⁺)
wk-subst⁺ ε ρ = ρ
wk-subst⁺ (Δ⁺ ▻ σ) ρ = wk-subst (wk-subst⁺ Δ⁺ ρ)
wk-subst₊ : ∀ {Γ Δ} Δ₊ {ρ̂ : Γ ⇨̂ Δ} → Sub T ρ̂ → Sub T (ρ̂ ∘̂ ŵk₊ Δ₊)
wk-subst₊ ε ρ = ρ
wk-subst₊ (σ ◅ Δ₊) ρ = wk-subst₊ Δ₊ (wk-subst ρ)
-- Lifting.
infixl 10 _↑_
infix 10 _↑
_↑_ : ∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} → Sub T ρ̂ → ∀ σ → Sub T (ρ̂ ↑̂ σ)
ρ ↑ _ =
P.subst (Sub T)
(≅-⇨̂-⇒-≡ $ ▻̂-cong P.refl P.refl
(P.sym $ corresponds var zero))
(wk-subst ρ ▻⇨ var · zero)
_↑ : ∀ {Γ Δ σ} {ρ̂ : Γ ⇨̂ Δ} → Sub T ρ̂ → Sub T (ρ̂ ↑̂ σ)
ρ ↑ = ρ ↑ _
-- N-ary lifting.
infixl 10 _↑⁺_ _↑₊_
_↑⁺_ : ∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} → Sub T ρ̂ → ∀ Γ⁺ → Sub T (ρ̂ ↑̂⁺ Γ⁺)
ρ ↑⁺ ε = ρ
ρ ↑⁺ (Γ⁺ ▻ σ) = (ρ ↑⁺ Γ⁺) ↑
_↑₊_ : ∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} → Sub T ρ̂ → ∀ Γ₊ → Sub T (ρ̂ ↑̂₊ Γ₊)
ρ ↑₊ ε = ρ
ρ ↑₊ (σ ◅ Γ₊) = ρ ↑ ↑₊ Γ₊
-- The identity substitution.
id[_] : ∀ Γ → Sub T îd[ Γ ]
id[ ε ] = ε⇨
id[ Γ ▻ σ ] = id[ Γ ] ↑
id : ∀ {Γ} → Sub T îd[ Γ ]
id = id[ _ ]
-- N-ary weakening.
wk⁺ : ∀ {Γ} (Γ⁺ : Ctxt⁺ Γ) → Sub T (ŵk⁺ Γ⁺)
wk⁺ ε = id
wk⁺ (Γ⁺ ▻ σ) = wk-subst (wk⁺ Γ⁺)
wk₊ : ∀ {Γ} (Γ₊ : Ctxt₊ Γ) → Sub T (ŵk₊ Γ₊)
wk₊ Γ₊ = wk-subst₊ Γ₊ id
-- Weakening.
wk[_] : ∀ {Γ} (σ : Type Γ) → Sub T ŵk[ σ ]
wk[ σ ] = wk⁺ (ε ▻ σ)
wk : ∀ {Γ} {σ : Type Γ} → Sub T ŵk[ σ ]
wk = wk[ _ ]
private
-- Three possible definitions of wk coincide definitionally.
coincide₁ : ∀ {Γ} {σ : Type Γ} → wk⁺ (ε ▻ σ) ≡ wk₊ (σ ◅ ε)
coincide₁ = P.refl
coincide₂ : ∀ {Γ} {σ : Type Γ} → wk⁺ (ε ▻ σ) ≡ wk-subst id
coincide₂ = P.refl
-- A substitution which only replaces the first variable.
sub : ∀ {Γ σ} (t : Γ ⊢ σ) → Sub T (ŝub ⟦ t ⟧)
sub t = id ▻⇨ t
abstract
-- Unfolding lemma for _↑.
unfold-↑ : ∀ {Γ Δ σ} {ρ̂ : Γ ⇨̂ Δ} (ρ : Sub T ρ̂) →
ρ ↑ σ ≅-⇨ wk-subst[ σ / ρ ] ρ ▻⇨[ σ ] var · zero
unfold-↑ _ =
drop-subst-Sub F.id
(≅-⇨̂-⇒-≡ $ ▻̂-cong P.refl P.refl (P.sym $ corresponds var zero))
-- Some congruence lemmas.
weaken-cong : ∀ {Γ₁ σ₁ τ₁} {t₁ : Γ₁ ⊢ τ₁}
{Γ₂ σ₂ τ₂} {t₂ : Γ₂ ⊢ τ₂} →
σ₁ ≅-Type σ₂ → t₁ ≅-⊢ t₂ →
weaken[ σ₁ ] · t₁ ≅-⊢ weaken[ σ₂ ] · t₂
weaken-cong P.refl P.refl = P.refl
var-cong : ∀ {Γ₁ σ₁} {x₁ : Γ₁ ∋ σ₁}
{Γ₂ σ₂} {x₂ : Γ₂ ∋ σ₂} →
x₁ ≅-∋ x₂ → var · x₁ ≅-⊢ var · x₂
var-cong P.refl = P.refl
wk-subst-cong : ∀ {Γ₁ Δ₁ σ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} {ρ₁ : Sub T ρ̂₁}
{Γ₂ Δ₂ σ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} {ρ₂ : Sub T ρ̂₂} →
σ₁ ≅-Type σ₂ → ρ₁ ≅-⇨ ρ₂ →
wk-subst[ σ₁ ] ρ₁ ≅-⇨ wk-subst[ σ₂ ] ρ₂
wk-subst-cong {ρ₁ = _ , _} {ρ₂ = ._ , _} P.refl [ P.refl ] =
[ P.refl ]
abstract
wk-subst⁺-cong : ∀ {Γ₁ Δ₁ Γ⁺₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} {ρ₁ : Sub T ρ̂₁}
{Γ₂ Δ₂ Γ⁺₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} {ρ₂ : Sub T ρ̂₂} →
Γ⁺₁ ≅-Ctxt⁺ Γ⁺₂ → ρ₁ ≅-⇨ ρ₂ →
wk-subst⁺ Γ⁺₁ ρ₁ ≅-⇨ wk-subst⁺ Γ⁺₂ ρ₂
wk-subst⁺-cong {Γ⁺₁ = ε} {ρ₁ = _ , _} {ρ₂ = ._ , _} P.refl [ P.refl ] =
[ P.refl ]
wk-subst⁺-cong {Γ⁺₁ = Γ⁺₁ ▻ σ} P.refl ρ₁≅ρ₂ =
wk-subst-cong (P.refl {x = [ σ ]})
(wk-subst⁺-cong (P.refl {x = [ Γ⁺₁ ]}) ρ₁≅ρ₂)
wk-subst₊-cong : ∀ {Γ₁ Δ₁ Γ₊₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} {ρ₁ : Sub T ρ̂₁}
{Γ₂ Δ₂ Γ₊₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} {ρ₂ : Sub T ρ̂₂} →
Γ₊₁ ≅-Ctxt₊ Γ₊₂ → ρ₁ ≅-⇨ ρ₂ →
wk-subst₊ Γ₊₁ ρ₁ ≅-⇨ wk-subst₊ Γ₊₂ ρ₂
wk-subst₊-cong {Γ₊₁ = ε} {ρ₁ = _ , _} {ρ₂ = ._ , _} P.refl [ P.refl ] =
[ P.refl ]
wk-subst₊-cong {Γ₊₁ = σ ◅ Γ₊₁} P.refl ρ₁≅ρ₂ =
wk-subst₊-cong (P.refl {x = [ Γ₊₁ ]}) (wk-subst-cong P.refl ρ₁≅ρ₂)
↑-cong : ∀ {Γ₁ Δ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} {ρ₁ : Sub T ρ̂₁} {σ₁}
{Γ₂ Δ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} {ρ₂ : Sub T ρ̂₂} {σ₂} →
ρ₁ ≅-⇨ ρ₂ → σ₁ ≅-Type σ₂ → ρ₁ ↑ σ₁ ≅-⇨ ρ₂ ↑ σ₂
↑-cong {ρ₁ = ρ₁} {σ₁} {ρ₂ = ρ₂} {σ₂} ρ₁≅ρ₂ σ₁≅σ₂ =
let lemma = /-cong σ₁≅σ₂ ρ₁≅ρ₂ in
ρ₁ ↑ σ₁ ≅-⟶⟨ unfold-↑ ρ₁ ⟩
wk-subst ρ₁ ▻⇨ var · zero[ σ₁ / ρ₁ ] ≅-⟶⟨ ▻⇨-cong σ₁≅σ₂ (wk-subst-cong lemma ρ₁≅ρ₂) (var-cong (zero-cong lemma)) ⟩
wk-subst ρ₂ ▻⇨ var · zero[ σ₂ / ρ₂ ] ≅-⟶⟨ sym-⟶ $ unfold-↑ ρ₂ ⟩
ρ₂ ↑ σ₂ ∎-⟶
↑⁺-cong : ∀ {Γ₁ Δ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} {ρ₁ : Sub T ρ̂₁} {Γ⁺₁}
{Γ₂ Δ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} {ρ₂ : Sub T ρ̂₂} {Γ⁺₂} →
ρ₁ ≅-⇨ ρ₂ → Γ⁺₁ ≅-Ctxt⁺ Γ⁺₂ → ρ₁ ↑⁺ Γ⁺₁ ≅-⇨ ρ₂ ↑⁺ Γ⁺₂
↑⁺-cong {ρ₁ = _ , _} {Γ⁺₁ = ε} {ρ₂ = ._ , _} [ P.refl ] P.refl =
[ P.refl ]
↑⁺-cong {Γ⁺₁ = Γ⁺ ▻ σ} ρ₁≅ρ₂ P.refl =
↑-cong (↑⁺-cong ρ₁≅ρ₂ (P.refl {x = [ Γ⁺ ]})) P.refl
↑₊-cong : ∀ {Γ₁ Δ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} {ρ₁ : Sub T ρ̂₁} {Γ₊₁}
{Γ₂ Δ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} {ρ₂ : Sub T ρ̂₂} {Γ₊₂} →
ρ₁ ≅-⇨ ρ₂ → Γ₊₁ ≅-Ctxt₊ Γ₊₂ → ρ₁ ↑₊ Γ₊₁ ≅-⇨ ρ₂ ↑₊ Γ₊₂
↑₊-cong {ρ₁ = _ , _} {Γ₊₁ = ε} {ρ₂ = ._ , _} [ P.refl ] P.refl =
[ P.refl ]
↑₊-cong {Γ₊₁ = σ ◅ Γ₊} ρ₁≅ρ₂ P.refl =
↑₊-cong (↑-cong ρ₁≅ρ₂ P.refl) (P.refl {x = [ Γ₊ ]})
id-cong : ∀ {Γ₁ Γ₂} → Γ₁ ≅-Ctxt Γ₂ → id[ Γ₁ ] ≅-⇨ id[ Γ₂ ]
id-cong P.refl = [ P.refl ]
wk⁺-cong : ∀ {Γ₁} {Γ⁺₁ : Ctxt⁺ Γ₁} {Γ₂} {Γ⁺₂ : Ctxt⁺ Γ₂} →
Γ⁺₁ ≅-Ctxt⁺ Γ⁺₂ → wk⁺ Γ⁺₁ ≅-⇨ wk⁺ Γ⁺₂
wk⁺-cong P.refl = [ P.refl ]
wk₊-cong : ∀ {Γ₁} {Γ₊₁ : Ctxt₊ Γ₁} {Γ₂} {Γ₊₂ : Ctxt₊ Γ₂} →
Γ₊₁ ≅-Ctxt₊ Γ₊₂ → wk₊ Γ₊₁ ≅-⇨ wk₊ Γ₊₂
wk₊-cong P.refl = [ P.refl ]
wk-cong : ∀ {Γ₁} {σ₁ : Type Γ₁} {Γ₂} {σ₂ : Type Γ₂} →
σ₁ ≅-Type σ₂ → wk[ σ₁ ] ≅-⇨ wk[ σ₂ ]
wk-cong P.refl = [ P.refl ]
sub-cong : ∀ {Γ₁ σ₁} {t₁ : Γ₁ ⊢ σ₁} {Γ₂ σ₂} {t₂ : Γ₂ ⊢ σ₂} →
t₁ ≅-⊢ t₂ → sub t₁ ≅-⇨ sub t₂
sub-cong P.refl = [ P.refl ]
abstract
-- Some lemmas relating variables to lifting.
/∋-↑ : ∀ {Γ Δ σ τ} {ρ̂ : Γ ⇨̂ Δ} (x : Γ ▻ σ ∋ τ) (ρ : Sub T ρ̂) →
x /∋ ρ ↑ ≅-⊢ x /∋ (wk-subst[ σ / ρ ] ρ ▻⇨ var · zero)
/∋-↑ x ρ = /∋-cong (P.refl {x = [ x ]}) (unfold-↑ ρ)
zero-/∋-↑ : ∀ {Γ Δ} σ {ρ̂ : Γ ⇨̂ Δ} (ρ : Sub T ρ̂) →
zero[ σ ] /∋ ρ ↑ ≅-⊢ var · zero[ σ / ρ ]
zero-/∋-↑ σ ρ = begin
[ zero[ σ ] /∋ ρ ↑ ] ≡⟨ /∋-↑ zero[ σ ] ρ ⟩
[ zero[ σ ] /∋ (wk-subst ρ ▻⇨ var · zero) ] ≡⟨ P.refl ⟩
[ var · zero ] ∎
suc-/∋-↑ : ∀ {Γ Δ τ} σ {ρ̂ : Γ ⇨̂ Δ} (x : Γ ∋ τ) (ρ : Sub T ρ̂) →
suc[ σ ] x /∋ ρ ↑ ≅-⊢ x /∋ wk-subst[ σ / ρ ] ρ
suc-/∋-↑ σ x ρ = begin
[ suc[ σ ] x /∋ ρ ↑ ] ≡⟨ /∋-↑ (suc[ σ ] x) ρ ⟩
[ suc[ σ ] x /∋ (wk-subst ρ ▻⇨ var · zero) ] ≡⟨ P.refl ⟩
[ x /∋ wk-subst ρ ] ∎
-- One can weaken either before or after looking up a variable.
-- (Note that this lemma holds definitionally, unlike the
-- corresponding lemma in deBruijn.Substitution.Data.Simple.)
/∋-wk-subst : ∀ {Γ Δ σ τ} {ρ̂ : Γ ⇨̂ Δ} (x : Γ ∋ τ) (ρ : Sub T ρ̂) →
x /∋ wk-subst[ σ ] ρ ≅-⊢ weaken[ σ ] · (x /∋ ρ)
/∋-wk-subst x ρ = P.refl
abstract
-- A corollary.
/∋-wk-subst-var :
∀ {Γ Δ σ τ} {ρ̂ : Γ ⇨̂ Δ}
(ρ : Sub T ρ̂) (x : Γ ∋ τ) (y : Δ ∋ τ / ρ) →
x /∋ ρ ≅-⊢ var · y →
x /∋ wk-subst[ σ ] ρ ≅-⊢ var · suc[ σ ] y
/∋-wk-subst-var ρ x y hyp = begin
[ x /∋ wk-subst ρ ] ≡⟨ P.refl ⟩
[ weaken · (x /∋ ρ) ] ≡⟨ weaken-cong P.refl hyp ⟩
[ weaken · (var · y) ] ≡⟨ weaken-var y ⟩
[ var · suc y ] ∎
-- The identity substitution has no effect.
/-id : ∀ {Γ} (σ : Type Γ) → σ / id ≅-Type σ
/-id σ = P.refl
/⁺-id : ∀ {Γ} (Γ⁺ : Ctxt⁺ Γ) → Γ⁺ /⁺ id ≅-Ctxt⁺ Γ⁺
/⁺-id Γ⁺ = begin
[ Γ⁺ /⁺ id ] ≡⟨ P.refl ⟩
[ Γ⁺ /̂⁺ îd ] ≡⟨ /̂⁺-îd Γ⁺ ⟩
[ Γ⁺ ] ∎
/₊-id : ∀ {Γ} (Γ₊ : Ctxt₊ Γ) → Γ₊ /₊ id ≅-Ctxt₊ Γ₊
/₊-id Γ₊ = begin
[ Γ₊ /₊ id ] ≡⟨ P.refl ⟩
[ Γ₊ /̂₊ îd ] ≡⟨ /̂₊-îd Γ₊ ⟩
[ Γ₊ ] ∎
mutual
/∋-id : ∀ {Γ σ} (x : Γ ∋ σ) → x /∋ id ≅-⊢ var · x
/∋-id {Γ = ε} ()
/∋-id {Γ = Γ ▻ σ} x = begin
[ x /∋ id ↑ ] ≡⟨ /∋-↑ x id ⟩
[ x /∋ (wk ▻⇨ var · zero) ] ≡⟨ lemma x ⟩
[ var · x ] ∎
where
lemma : ∀ {τ} (x : Γ ▻ σ ∋ τ) →
x /∋ (wk[ σ ] ▻⇨ var · zero) ≅-⊢ var · x
lemma zero = P.refl
lemma (suc x) = /∋-wk x
-- Weakening a variable is equivalent to incrementing it.
/∋-wk : ∀ {Γ σ τ} (x : Γ ∋ τ) →
x /∋ wk[ σ ] ≅-⊢ var · suc[ σ ] x
/∋-wk x = /∋-wk-subst-var id x x (/∋-id x)
-- The n-ary lifting of the identity substitution is the identity
-- substitution.
id-↑⁺ : ∀ {Γ} (Γ⁺ : Ctxt⁺ Γ) → id ↑⁺ Γ⁺ ≅-⇨ id[ Γ ++⁺ Γ⁺ ]
id-↑⁺ ε = id ∎-⟶
id-↑⁺ (Γ⁺ ▻ σ) =
(id ↑⁺ Γ⁺) ↑ ≅-⟶⟨ ↑-cong (id-↑⁺ Γ⁺) P.refl ⟩
id ↑ ∎-⟶
id-↑₊ : ∀ {Γ} (Γ₊ : Ctxt₊ Γ) → id ↑₊ Γ₊ ≅-⇨ id[ Γ ++₊ Γ₊ ]
id-↑₊ ε = id ∎-⟶
id-↑₊ (σ ◅ Γ₊) =
id ↑ ↑₊ Γ₊ ≅-⟶⟨ [ P.refl ] ⟩
id ↑₊ Γ₊ ≅-⟶⟨ id-↑₊ Γ₊ ⟩
id ∎-⟶
-- The identity substitution has no effect even if lifted.
/∋-id-↑⁺ : ∀ {Γ} Γ⁺ {σ} (x : Γ ++⁺ Γ⁺ ∋ σ) →
x /∋ id ↑⁺ Γ⁺ ≅-⊢ var · x
/∋-id-↑⁺ Γ⁺ x = begin
[ x /∋ id ↑⁺ Γ⁺ ] ≡⟨ /∋-cong (P.refl {x = [ x ]}) (id-↑⁺ Γ⁺) ⟩
[ x /∋ id ] ≡⟨ /∋-id x ⟩
[ var · x ] ∎
/∋-id-↑₊ : ∀ {Γ} Γ₊ {σ} (x : Γ ++₊ Γ₊ ∋ σ) →
x /∋ id ↑₊ Γ₊ ≅-⊢ var · x
/∋-id-↑₊ Γ₊ x = begin
[ x /∋ id ↑₊ Γ₊ ] ≡⟨ /∋-cong (P.refl {x = [ x ]}) (id-↑₊ Γ₊) ⟩
[ x /∋ id ] ≡⟨ /∋-id x ⟩
[ var · x ] ∎
-- If ρ is morally a renaming, then "deep application" of ρ to a
-- variable is still a variable.
/∋-↑⁺ : ∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ}
(ρ : Sub T ρ̂) (f : [ Var ⟶ Var ] ρ̂) →
(∀ {σ} (x : Γ ∋ σ) → x /∋ ρ ≅-⊢ var · (f · x)) →
∀ Γ⁺ {σ} (x : Γ ++⁺ Γ⁺ ∋ σ) →
x /∋ ρ ↑⁺ Γ⁺ ≅-⊢ var · (lift f Γ⁺ · x)
/∋-↑⁺ ρ f hyp ε x = hyp x
/∋-↑⁺ ρ f hyp (Γ⁺ ▻ σ) zero = begin
[ zero[ σ ] /∋ (ρ ↑⁺ Γ⁺) ↑ ] ≡⟨ zero-/∋-↑ σ (ρ ↑⁺ Γ⁺) ⟩
[ var · zero ] ∎
/∋-↑⁺ ρ f hyp (Γ⁺ ▻ σ) (suc x) = begin
[ suc[ σ ] x /∋ (ρ ↑⁺ Γ⁺) ↑ ] ≡⟨ suc-/∋-↑ σ x (ρ ↑⁺ Γ⁺) ⟩
[ x /∋ wk-subst (ρ ↑⁺ Γ⁺) ] ≡⟨ P.refl ⟩
[ weaken · (x /∋ ρ ↑⁺ Γ⁺) ] ≡⟨ weaken-cong P.refl (/∋-↑⁺ ρ f hyp Γ⁺ x) ⟩
[ weaken · (var · (lift f Γ⁺ · x)) ] ≡⟨ weaken-var (lift f Γ⁺ · x) ⟩
[ var · suc (lift f Γ⁺ · x) ] ∎
-- "Deep weakening" of a variable can be expressed without
-- reference to the weaken function.
/∋-wk-↑⁺ : ∀ {Γ σ} Γ⁺ {τ} (x : Γ ++⁺ Γ⁺ ∋ τ) →
x /∋ wk[ σ ] ↑⁺ Γ⁺ ≅-⊢
var · (lift weaken∋[ σ ] Γ⁺ · x)
/∋-wk-↑⁺ = /∋-↑⁺ wk weaken∋ /∋-wk
/∋-wk-↑⁺-↑⁺ : ∀ {Γ σ} Γ⁺ Γ⁺⁺ {τ} (x : Γ ++⁺ Γ⁺ ++⁺ Γ⁺⁺ ∋ τ) →
x /∋ wk[ σ ] ↑⁺ Γ⁺ ↑⁺ Γ⁺⁺ ≅-⊢
var · (lift (lift weaken∋[ σ ] Γ⁺) Γ⁺⁺ · x)
/∋-wk-↑⁺-↑⁺ Γ⁺ = /∋-↑⁺ (wk ↑⁺ Γ⁺) (lift weaken∋ Γ⁺) (/∋-wk-↑⁺ Γ⁺)
-- Two n-ary liftings can be merged into one.
↑⁺-⁺++⁺ : ∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} (ρ : Sub T ρ̂) Γ⁺ Γ⁺⁺ →
ρ ↑⁺ (Γ⁺ ⁺++⁺ Γ⁺⁺) ≅-⇨ ρ ↑⁺ Γ⁺ ↑⁺ Γ⁺⁺
↑⁺-⁺++⁺ ρ Γ⁺ ε = ρ ↑⁺ Γ⁺ ∎-⟶
↑⁺-⁺++⁺ ρ Γ⁺ (Γ⁺⁺ ▻ σ) =
(ρ ↑⁺ (Γ⁺ ⁺++⁺ Γ⁺⁺)) ↑ ≅-⟶⟨ ↑-cong (↑⁺-⁺++⁺ ρ Γ⁺ Γ⁺⁺)
(drop-subst-Type F.id (++⁺-++⁺ Γ⁺ Γ⁺⁺)) ⟩
(ρ ↑⁺ Γ⁺ ↑⁺ Γ⁺⁺) ↑ ∎-⟶
↑₊-₊++₊ : ∀ {Γ Δ} {ρ̂ : Γ ⇨̂ Δ} (ρ : Sub T ρ̂) Γ₊ Γ₊₊ →
ρ ↑₊ (Γ₊ ₊++₊ Γ₊₊) ≅-⇨ ρ ↑₊ Γ₊ ↑₊ Γ₊₊
↑₊-₊++₊ ρ ε Γ₊₊ = ρ ↑₊ Γ₊₊ ∎-⟶
↑₊-₊++₊ ρ (σ ◅ Γ₊) Γ₊₊ =
ρ ↑ ↑₊ (Γ₊ ₊++₊ Γ₊₊) ≅-⟶⟨ ↑₊-₊++₊ (ρ ↑) Γ₊ Γ₊₊ ⟩
ρ ↑ ↑₊ Γ₊ ↑₊ Γ₊₊ ∎-⟶
| {
"alphanum_fraction": 0.3755872045,
"avg_line_length": 34.2117346939,
"ext": "agda",
"hexsha": "7063e8db22b5117d7797426a504784a47e243cba",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/dependently-typed-syntax",
"max_forks_repo_path": "deBruijn/Substitution/Function/Simple.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/dependently-typed-syntax",
"max_issues_repo_path": "deBruijn/Substitution/Function/Simple.agda",
"max_line_length": 121,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/dependently-typed-syntax",
"max_stars_repo_path": "deBruijn/Substitution/Function/Simple.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": 7244,
"size": 13411
} |
{-
This second-order equational theory was created from the following second-order syntax description:
syntax Empty | E
type
𝟘 : 0-ary
term
abort : 𝟘 -> α
theory
(𝟘η) e : 𝟘 c : α |> abort(e) = c
-}
module Empty.Equality where
open import SOAS.Common
open import SOAS.Context
open import SOAS.Variable
open import SOAS.Families.Core
open import SOAS.Families.Build
open import SOAS.ContextMaps.Inductive
open import Empty.Signature
open import Empty.Syntax
open import SOAS.Metatheory.SecondOrder.Metasubstitution E:Syn
open import SOAS.Metatheory.SecondOrder.Equality E:Syn
private
variable
α β γ τ : ET
Γ Δ Π : Ctx
infix 1 _▹_⊢_≋ₐ_
-- Axioms of equality
data _▹_⊢_≋ₐ_ : ∀ 𝔐 Γ {α} → (𝔐 ▷ E) α Γ → (𝔐 ▷ E) α Γ → Set where
𝟘η : ⁅ 𝟘 ⁆ ⁅ α ⁆̣ ▹ ∅ ⊢ abort 𝔞 ≋ₐ 𝔟
open EqLogic _▹_⊢_≋ₐ_
open ≋-Reasoning
| {
"alphanum_fraction": 0.6987951807,
"avg_line_length": 18.8636363636,
"ext": "agda",
"hexsha": "9fd12be90dd68e3bc9011c301ba9de752b0be98f",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2022-01-24T12:49:17.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-09T20:39:59.000Z",
"max_forks_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "JoeyEremondi/agda-soas",
"max_forks_repo_path": "out/Empty/Equality.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_issues_repo_issues_event_max_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "JoeyEremondi/agda-soas",
"max_issues_repo_path": "out/Empty/Equality.agda",
"max_line_length": 99,
"max_stars_count": 39,
"max_stars_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "JoeyEremondi/agda-soas",
"max_stars_repo_path": "out/Empty/Equality.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": 331,
"size": 830
} |
{-# OPTIONS --guardedness-preserving-type-constructors #-}
module Issue602 where
infixl 6 _⊔_
postulate
Level : Set
zero : Level
suc : Level → Level
_⊔_ : Level → Level → Level
{-# BUILTIN LEVEL Level #-}
{-# BUILTIN LEVELZERO zero #-}
{-# BUILTIN LEVELSUC suc #-}
{-# BUILTIN LEVELMAX _⊔_ #-}
infix 1000 ♯_
postulate
∞ : ∀ {a} (A : Set a) → Set a
♯_ : ∀ {a} {A : Set a} → A → ∞ A
♭ : ∀ {a} {A : Set a} → ∞ A → A
{-# BUILTIN INFINITY ∞ #-}
{-# BUILTIN SHARP ♯_ #-}
{-# BUILTIN FLAT ♭ #-}
data CoNat : Set0 where
z : CoNat
s : ∞ CoNat → CoNat
record A : Set2 where
field
f : Set1
record B (a : ∞ A) : Set1 where
field
f : A.f (♭ a)
postulate
a : A
e : CoNat → A
e z = a
e (s n) = record
{ f = B (♯ e (♭ n))
} | {
"alphanum_fraction": 0.5211267606,
"avg_line_length": 16.6170212766,
"ext": "agda",
"hexsha": "83141bf59c0c7c5dd3bee739c97740ae1ff5afec",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "20596e9dd9867166a64470dd24ea68925ff380ce",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "np/agda-git-experiment",
"max_forks_repo_path": "test/succeed/Issue602.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "20596e9dd9867166a64470dd24ea68925ff380ce",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "np/agda-git-experiment",
"max_issues_repo_path": "test/succeed/Issue602.agda",
"max_line_length": 58,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "20596e9dd9867166a64470dd24ea68925ff380ce",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "np/agda-git-experiment",
"max_stars_repo_path": "test/succeed/Issue602.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": 316,
"size": 781
} |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Functor.Bifunctor
module Categories.Diagram.End {o ℓ e o′ ℓ′ e′} {C : Category o ℓ e} {D : Category o′ ℓ′ e′}
(F : Bifunctor (Category.op C) C D) where
private
module D = Category D
open D
open HomReasoning
open Equiv
variable
A B : Obj
f g : A ⇒ B
open import Level
open import Categories.Diagram.Wedge F
open import Categories.NaturalTransformation.Dinatural
record End : Set (levelOfTerm F) where
field
wedge : Wedge
module wedge = Wedge wedge
open wedge public
open Wedge
field
factor : (W : Wedge) → E W ⇒ wedge.E
universal : ∀ {W : Wedge} {A} → wedge.dinatural.α A ∘ factor W ≈ dinatural.α W A
unique : ∀ {W : Wedge} {g : E W ⇒ wedge.E} → (∀ {A} → wedge.dinatural.α A ∘ g ≈ dinatural.α W A) → factor W ≈ g
η-id : factor wedge ≈ D.id
η-id = unique identityʳ
unique′ :(∀ {A} → wedge.dinatural.α A ∘ f ≈ wedge.dinatural.α A ∘ g) → f ≈ g
unique′ {f = f} {g = g} eq = ⟺ (unique {W = Wedge-∘ wedge f} refl) ○ unique (⟺ eq)
| {
"alphanum_fraction": 0.6269621422,
"avg_line_length": 26.4146341463,
"ext": "agda",
"hexsha": "f7d88222d322f71e27ad75e51ca8a4dc6479b717",
"lang": "Agda",
"max_forks_count": 64,
"max_forks_repo_forks_event_max_datetime": "2022-03-14T02:00:59.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-06-02T16:58:15.000Z",
"max_forks_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Code-distancing/agda-categories",
"max_forks_repo_path": "src/Categories/Diagram/End.agda",
"max_issues_count": 236,
"max_issues_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_issues_repo_issues_event_max_datetime": "2022-03-28T14:31:43.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-06-01T14:53:54.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Code-distancing/agda-categories",
"max_issues_repo_path": "src/Categories/Diagram/End.agda",
"max_line_length": 118,
"max_stars_count": 279,
"max_stars_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Trebor-Huang/agda-categories",
"max_stars_repo_path": "src/Categories/Diagram/End.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-22T00:40:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-06-01T14:36:40.000Z",
"num_tokens": 392,
"size": 1083
} |
{-# OPTIONS --without-K --safe #-}
-- A "canonical" presentation of limits in Setoid.
--
-- These limits are obviously isomorphic to those created by
-- the Completeness proof, but are far less unweildy to work with.
-- This isomorphism is witnessed by Categories.Diagram.Pullback.up-to-iso
module Categories.Category.Instance.Properties.Setoids.Limits.Canonical where
open import Level
open import Data.Product using (_,_; _×_; map; zip; proj₁; proj₂; <_,_>)
open import Function.Equality as SΠ renaming (id to ⟶-id)
open import Relation.Binary.Bundles using (Setoid)
import Relation.Binary.Reasoning.Setoid as SR
open import Categories.Category.Instance.Setoids
open import Categories.Diagram.Pullback
open Setoid renaming (_≈_ to [_][_≈_])
--------------------------------------------------------------------------------
-- Pullbacks
record FiberProduct {o ℓ} {X Y Z : Setoid o ℓ} (f : X ⟶ Z) (g : Y ⟶ Z) : Set (o ⊔ ℓ) where
constructor mk-×
field
elem₁ : Carrier X
elem₂ : Carrier Y
commute : [ Z ][ f ⟨$⟩ elem₁ ≈ g ⟨$⟩ elem₂ ]
open FiberProduct
FP-≈ : ∀ {o ℓ} {X Y Z : Setoid o ℓ} {f : X ⟶ Z} {g : Y ⟶ Z} → (fb₁ fb₂ : FiberProduct f g) → Set ℓ
FP-≈ {X = X} {Y} p q = [ X ][ elem₁ p ≈ elem₁ q ] × [ Y ][ elem₂ p ≈ elem₂ q ]
pullback : ∀ (o ℓ : Level) {X Y Z : Setoid (o ⊔ ℓ) ℓ} → (f : X ⟶ Z) → (g : Y ⟶ Z) → Pullback (Setoids (o ⊔ ℓ) ℓ) f g
pullback _ _ {X = X} {Y = Y} {Z = Z} f g = record
{ P = record
{ Carrier = FiberProduct f g
; _≈_ = FP-≈
; isEquivalence = record
{ refl = X.refl , Y.refl
; sym = map X.sym Y.sym
; trans = zip X.trans Y.trans
}
}
; p₁ = record { _⟨$⟩_ = elem₁ ; cong = proj₁ }
; p₂ = record { _⟨$⟩_ = elem₂ ; cong = proj₂ }
; isPullback = record
{ commute = λ {p} {q} (eq₁ , eq₂) → trans Z (cong f eq₁) (commute q)
; universal = λ {A} {h₁} {h₂} eq → record
{ _⟨$⟩_ = λ a → record
{ elem₁ = h₁ ⟨$⟩ a
; elem₂ = h₂ ⟨$⟩ a
; commute = eq (refl A)
}
; cong = < cong h₁ , cong h₂ >
}
; unique = λ eq₁ eq₂ x≈y → eq₁ x≈y , eq₂ x≈y
; p₁∘universal≈h₁ = λ {_} {h₁} {_} eq → cong h₁ eq
; p₂∘universal≈h₂ = λ {_} {_} {h₂} eq → cong h₂ eq
}
}
where
module X = Setoid X
module Y = Setoid Y
| {
"alphanum_fraction": 0.5479808945,
"avg_line_length": 33.8676470588,
"ext": "agda",
"hexsha": "f04c9ef236ebabfaa140c59a341f9c2c1f706451",
"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": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Code-distancing/agda-categories",
"max_forks_repo_path": "src/Categories/Category/Instance/Properties/Setoids/Limits/Canonical.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"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": "Code-distancing/agda-categories",
"max_issues_repo_path": "src/Categories/Category/Instance/Properties/Setoids/Limits/Canonical.agda",
"max_line_length": 116,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Trebor-Huang/agda-categories",
"max_stars_repo_path": "src/Categories/Category/Instance/Properties/Setoids/Limits/Canonical.agda",
"max_stars_repo_stars_event_max_datetime": "2019-05-22T03:54:24.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-05-21T17:07:19.000Z",
"num_tokens": 815,
"size": 2303
} |
module Scratch (FunctionName : Set) where
open import Oscar.Data.Fin using (Fin; zero; suc; thick?)
open import Data.Nat using (ℕ; suc; zero)
open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong₂; cong; sym; trans)
open import Function using (_∘_; flip)
open import Relation.Nullary using (¬_; Dec; yes; no)
open import Data.Product using (∃; _,_; _×_)
open import Data.Empty using (⊥-elim)
open import Data.Vec using (Vec; []; _∷_)
data Term (n : ℕ) : Set where
i : (x : Fin n) -> Term n
leaf : Term n
_fork_ : (s t : Term n) -> Term n
function : FunctionName → ∀ {f} → Vec (Term n) f → Term n
Term-function-inj-FunctionName : ∀ {fn₁ fn₂} {n N₁ N₂} {ts₁ : Vec (Term n) N₁} {ts₂ : Vec (Term n) N₂} → Term.function fn₁ ts₁ ≡ Term.function fn₂ ts₂ → fn₁ ≡ fn₂
Term-function-inj-FunctionName refl = refl
Term-function-inj-VecSize : ∀ {fn₁ fn₂} {n N₁ N₂} {ts₁ : Vec (Term n) N₁} {ts₂ : Vec (Term n) N₂} → Term.function fn₁ ts₁ ≡ Term.function fn₂ ts₂ → N₁ ≡ N₂
Term-function-inj-VecSize refl = refl
Term-function-inj-Vector : ∀ {fn₁ fn₂} {n N} {ts₁ : Vec (Term n) N} {ts₂ : Vec (Term n) N} → Term.function fn₁ ts₁ ≡ Term.function fn₂ ts₂ → ts₁ ≡ ts₂
Term-function-inj-Vector refl = refl
Term-fork-inj-left : ∀ {n} {l₁ r₁ l₂ r₂ : Term n} → l₁ fork r₁ ≡ l₂ fork r₂ → l₁ ≡ l₂
Term-fork-inj-left refl = refl
Term-fork-inj-right : ∀ {n} {l₁ r₁ l₂ r₂ : Term n} → l₁ fork r₁ ≡ l₂ fork r₂ → r₁ ≡ r₂
Term-fork-inj-right refl = refl
open import Relation.Binary.HeterogeneousEquality using (_≅_; refl)
Term-function-inj-HetVector : ∀ {fn₁ fn₂} {n N₁ N₂} {ts₁ : Vec (Term n) N₁} {ts₂ : Vec (Term n) N₂} → Term.function fn₁ ts₁ ≡ Term.function fn₂ ts₂ → ts₁ ≅ ts₂
Term-function-inj-HetVector refl = refl
_~>_ : (m n : ℕ) -> Set
m ~> n = Fin m -> Term n
▹ : ∀ {m n} -> (r : Fin m -> Fin n) -> Fin m -> Term n
▹ r = i ∘ r
record Substitution (T : ℕ → Set) : Set where
field
_◃_ : ∀ {m n} -> (f : m ~> n) -> T m -> T n
open Substitution ⦃ … ⦄ public
{-# DISPLAY Substitution._◃_ _ = _◃_ #-}
mutual
instance SubstitutionTerm : Substitution Term
Substitution._◃_ SubstitutionTerm = _◃′_ where
_◃′_ : ∀ {m n} -> (f : m ~> n) -> Term m -> Term n
f ◃′ i x = f x
f ◃′ leaf = leaf
f ◃′ (s fork t) = (f ◃ s) fork (f ◃ t)
f ◃′ (function fn ts) = function fn (f ◃ ts)
instance SubstitutionVecTerm : ∀ {N} → Substitution (flip Vec N ∘ Term )
Substitution._◃_ (SubstitutionVecTerm {N}) = _◃′_ where
_◃′_ : ∀ {m n} -> (f : m ~> n) -> Vec (Term m) N -> Vec (Term n) N
f ◃′ [] = []
f ◃′ (t ∷ ts) = f ◃ t ∷ f ◃ ts
_≐_ : {m n : ℕ} -> (Fin m -> Term n) -> (Fin m -> Term n) -> Set
f ≐ g = ∀ x -> f x ≡ g x
record SubstitutionExtensionality (T : ℕ → Set) ⦃ _ : Substitution T ⦄ : Set₁ where
field
◃ext : ∀ {m n} {f g : Fin m -> Term n} -> f ≐ g -> (t : T m) -> f ◃ t ≡ g ◃ t
open SubstitutionExtensionality ⦃ … ⦄ public
mutual
instance SubstitutionExtensionalityTerm : SubstitutionExtensionality Term
SubstitutionExtensionality.◃ext SubstitutionExtensionalityTerm = ◃ext′ where
◃ext′ : ∀ {m n} {f g : Fin m -> Term n} -> f ≐ g -> ∀ t -> f ◃ t ≡ g ◃ t
◃ext′ p (i x) = p x
◃ext′ p leaf = refl
◃ext′ p (s fork t) = cong₂ _fork_ (◃ext p s) (◃ext p t)
◃ext′ p (function fn ts) = cong (function fn) (◃ext p ts)
instance SubstitutionExtensionalityVecTerm : ∀ {N} → SubstitutionExtensionality (flip Vec N ∘ Term)
SubstitutionExtensionality.◃ext (SubstitutionExtensionalityVecTerm {N}) = λ x → ◃ext′ x where
◃ext′ : ∀ {m n} {f g : Fin m -> Term n} -> f ≐ g -> ∀ {N} (t : Vec (Term m) N) -> f ◃ t ≡ g ◃ t
◃ext′ p [] = refl
◃ext′ p (t ∷ ts) = cong₂ _∷_ (◃ext p t) (◃ext p ts)
_◇_ : ∀ {l m n : ℕ } -> (f : Fin m -> Term n) (g : Fin l -> Term m) -> Fin l -> Term n
f ◇ g = (f ◃_) ∘ g
≐-cong : ∀ {m n o} {f : m ~> n} {g} (h : _ ~> o) -> f ≐ g -> (h ◇ f) ≐ (h ◇ g)
≐-cong h f≐g t = cong (h ◃_) (f≐g t)
≐-sym : ∀ {m n} {f : m ~> n} {g} -> f ≐ g -> g ≐ f
≐-sym f≐g = sym ∘ f≐g
module Sub where
record Fact1 (T : ℕ → Set) ⦃ _ : Substitution T ⦄ : Set where
field
fact1 : ∀ {n} -> (t : T n) -> i ◃ t ≡ t
open Fact1 ⦃ … ⦄ public
mutual
instance Fact1Term : Fact1 Term
Fact1.fact1 Fact1Term (i x) = refl
Fact1.fact1 Fact1Term leaf = refl
Fact1.fact1 Fact1Term (s fork t) = cong₂ _fork_ (fact1 s) (fact1 t)
Fact1.fact1 Fact1Term (function fn ts) = cong (function fn) (fact1 ts)
instance Fact1TermVec : ∀ {N} → Fact1 (flip Vec N ∘ Term)
Fact1.fact1 Fact1TermVec [] = refl
Fact1.fact1 Fact1TermVec (t ∷ ts) = cong₂ _∷_ (fact1 t) (fact1 ts)
record Fact2 (T : ℕ → Set) ⦃ _ : Substitution T ⦄ : Set where
field
-- ⦃ s ⦄ : Substitution T
fact2 : ∀ {l m n} -> {f : Fin m -> Term n} {g : _} (t : T l) → (f ◇ g) ◃ t ≡ f ◃ (g ◃ t)
open Fact2 ⦃ … ⦄ public
mutual
instance Fact2Term : Fact2 Term
-- Fact2.s Fact2Term = SubstitutionTerm
Fact2.fact2 Fact2Term (i x) = refl
Fact2.fact2 Fact2Term leaf = refl
Fact2.fact2 Fact2Term (s fork t) = cong₂ _fork_ (fact2 s) (fact2 t)
Fact2.fact2 Fact2Term {f = f} {g = g} (function fn ts) = cong (function fn) (fact2 {f = f} {g = g} ts) -- fact2 ts
instance Fact2TermVec : ∀ {N} → Fact2 (flip Vec N ∘ Term)
-- Fact2.s Fact2TermVec = SubstitutionVecTerm
Fact2.fact2 Fact2TermVec [] = refl
Fact2.fact2 Fact2TermVec (t ∷ ts) = cong₂ _∷_ (fact2 t) (fact2 ts)
fact3 : ∀ {l m n} (f : Fin m -> Term n) (r : Fin l -> Fin m) -> (f ◇ (▹ r)) ≡ (f ∘ r)
fact3 f r = refl
◃ext' : ∀ {m n o} {f : Fin m -> Term n}{g : Fin m -> Term o}{h} -> f ≐ (h ◇ g) -> ∀ (t : Term _) -> f ◃ t ≡ h ◃ (g ◃ t)
◃ext' p t = trans (◃ext p t) (Sub.fact2 t)
open import Data.Maybe using (Maybe; nothing; just; functor; maybe′)
open import Category.Monad
import Level
open RawMonad (Data.Maybe.monad {Level.zero})
record Check (T : ℕ → Set) : Set where
field
check : ∀{n} (x : Fin (suc n)) (t : T (suc n)) -> Maybe (T n)
open Check ⦃ … ⦄ public
_<*>_ = _⊛_
mutual
instance CheckTerm : Check Term
Check.check CheckTerm x (i y) = i <$> thick? x y
Check.check CheckTerm x leaf = just leaf
Check.check CheckTerm x (s fork t) = _fork_ <$> check x s ⊛ check x t
Check.check CheckTerm x (function fn ts) = ⦇ (function fn) (check x ts) ⦈
instance CheckTermVec : ∀ {N} → Check (flip Vec N ∘ Term)
Check.check CheckTermVec x [] = just []
Check.check CheckTermVec x (t ∷ ts) = ⦇ check x t ∷ check x ts ⦈
_for_ : ∀ {n} (t' : Term n) (x : Fin (suc n)) -> Fin (suc n) -> Term n
(t' for x) y = maybe′ i t' (thick? x y)
data AList : ℕ -> ℕ -> Set where
anil : ∀ {n} -> AList n n
_asnoc_/_ : ∀ {m n} (σ : AList m n) (t' : Term m) (x : Fin (suc m))
-> AList (suc m) n
sub : ∀ {m n} (σ : AList m n) -> Fin m -> Term n
sub anil = i
sub (σ asnoc t' / x) = sub σ ◇ (t' for x)
_++_ : ∀ {l m n} (ρ : AList m n) (σ : AList l m) -> AList l n
ρ ++ anil = ρ
ρ ++ (σ asnoc t' / x) = (ρ ++ σ) asnoc t' / x
++-assoc : ∀ {l m n o} (ρ : AList l m) (σ : AList n _) (τ : AList o _) -> ρ ++ (σ ++ τ) ≡ (ρ ++ σ) ++ τ
++-assoc ρ σ anil = refl
++-assoc ρ σ (τ asnoc t / x) = cong (λ s -> s asnoc t / x) (++-assoc ρ σ τ)
module SubList where
anil-id-l : ∀ {m n} (σ : AList m n) -> anil ++ σ ≡ σ
anil-id-l anil = refl
anil-id-l (σ asnoc t' / x) = cong (λ σ -> σ asnoc t' / x) (anil-id-l σ)
fact1 : ∀ {l m n} (ρ : AList m n) (σ : AList l m) -> sub (ρ ++ σ) ≐ (sub ρ ◇ sub σ)
fact1 ρ anil v = refl
fact1 {suc l} {m} {n} r (s asnoc t' / x) v = trans hyp-on-terms ◃-assoc
where
t = (t' for x) v
hyp-on-terms = ◃ext (fact1 r s) t
◃-assoc = Sub.fact2 t
_∃asnoc_/_ : ∀ {m} (a : ∃ (AList m)) (t' : Term m) (x : Fin (suc m))
-> ∃ (AList (suc m))
(n , σ) ∃asnoc t' / x = n , σ asnoc t' / x
flexFlex : ∀ {m} (x y : Fin m) -> ∃ (AList m)
flexFlex {suc m} x y with thick? x y
... | just y' = m , anil asnoc i y' / x
... | nothing = suc m , anil
flexFlex {zero} () _
flexRigid : ∀ {m} (x : Fin m) (t : Term m) -> Maybe (∃(AList m))
flexRigid {suc m} x t with check x t
... | just t' = just (m , anil asnoc t' / x)
... | nothing = nothing
flexRigid {zero} () _
-- module Scratch where
-- open import Prelude
-- open import Agda.Builtin.Size
-- open import Tactic.Nat
-- postulate
-- Domain : Set
-- record Interpretation : Set where
-- field
-- V : Nat → Domain
-- F : (arity name : Nat) → Vec Domain arity → Domain
-- P : (arity name : Nat) → Vec Domain arity → Bool
-- data Term {i : Size} : Set where
-- variable : Nat → Term
-- function : (arity name : Nat) → {j : Size< i} → Vec (Term {j}) arity → Term {i}
-- interpretTerm : Interpretation → {i : Size} → Term {i} → Domain
-- interpretTerm I (variable v) = Interpretation.V I v
-- interpretTerm I (function arity name {j} domA) = Interpretation.F I arity name (interpretTerm I <$> domA)
-- data Formula : Set where
-- atomic : (arity name : Nat) → Vec Term arity → Formula
-- logical : Formula →
-- Formula →
-- Formula
-- quantified : Nat → Formula → Formula
-- infix 40 _⊗_
-- _⊗_ : Formula → Formula → Formula
-- _⊗_ a b = logical a b
-- ~ : Formula → Formula
-- ~ a = logical a a
-- infix 50 _⊃_
-- _⊃_ : Formula → Formula → Formula
-- _⊃_ p q = ~ (~ p ⊗ q)
-- data Literal : Formula → Set where
-- Latomic : (arity name : Nat) → (terms : Vec Term arity) → Literal (atomic arity name terms)
-- logical : (arity name : Nat) → (terms : Vec Term arity) → Literal (logical (atomic arity name terms) (atomic arity name terms))
-- record Sequent : Set where
-- constructor _⊢_
-- field
-- premises : List Formula
-- conclusion : Formula
-- data _∈_ {A : Set} (a : A) : List A → Set where
-- here : (as : List A) → a ∈ (a ∷ as)
-- there : (x : A) (as : List A) → a ∈ (x ∷ as)
-- record SimpleNDProblem (s : Sequent) : Set where
-- field
-- simpleConclusion : Literal (Sequent.conclusion s)
-- simplePremises : ∀ p → p ∈ Sequent.premises s → Literal p
-- record _≞_/_ (I : Interpretation) (I₀ : Interpretation) (v₀ : Nat) : Set where
-- field
-- lawV : (v : Nat) → (v ≡ v₀ → ⊥) → Interpretation.V I v ≡ Interpretation.V I₀ v
-- lawF : (arity name : Nat) → (domA : Vec Domain arity) → Interpretation.F I arity name domA ≡ Interpretation.F I₀ arity name domA
-- lawP : (arity name : Nat) → (domA : Vec Domain arity) → Interpretation.P I arity name domA ≡ Interpretation.P I₀ arity name domA
-- record Satisfaction (A : Set) : Set₁ where
-- field
-- _⊨_ : Interpretation → A → Set
-- postulate _⊨?_ : (I : Interpretation) → (φ : A) → Dec (I ⊨ φ)
-- _⊭_ : Interpretation → A → Set
-- I ⊭ x = I ⊨ x → ⊥
-- open Satisfaction ⦃ … ⦄
-- instance
-- SatisfactionFormula : Satisfaction Formula
-- Satisfaction._⊨_ SatisfactionFormula = _⊨ᴹ_ where
-- _⊨ᴹ_ : Interpretation → Formula → Set
-- _⊨ᴹ_ I₀ (quantified v₀ φ) = (I : Interpretation) → I ≞ I₀ / v₀ → I ⊨ᴹ φ
-- _⊨ᴹ_ I₀ (atomic arity name domA) = Interpretation.P I₀ arity name (interpretTerm I₀ <$> domA) ≡ true
-- _⊨ᴹ_ I₀ (logical φ₁ φ₂) = (I₀ ⊨ᴹ φ₁ → ⊥) × (I₀ ⊨ᴹ φ₂ → ⊥)
-- {-# DISPLAY _⊨ᴹ_ I f = I ⊨ f #-}
-- record Validity (A : Set) : Set₁ where
-- field
-- ⊨_ : A → Set
-- ⊭_ : A → Set
-- ⊭ x = ⊨ x → ⊥
-- open Validity ⦃ … ⦄
-- instance
-- ValidityFormula : Validity Formula
-- Validity.⊨_ ValidityFormula φ = (I : Interpretation) → I ⊨ φ
-- instance
-- SatisfactionSequent : Satisfaction Sequent
-- Satisfaction._⊨_ SatisfactionSequent I (premises ⊢ conclusion) = (_ : (premise : Formula) → premise ∈ premises → I ⊨ premise) → I ⊨ conclusion
-- ValiditySequent : Validity Sequent
-- Validity.⊨_ ValiditySequent sequent = (I : Interpretation) → I ⊨ sequent
-- negationElimination : (I : Interpretation) (φ : Formula) → I ⊨ (φ ⊗ φ) ⊗ (φ ⊗ φ) → I ⊨ φ
-- negationElimination I φ (x , y) with I ⊨? φ
-- negationElimination I φ (x₁ , y) | yes x = x
-- negationElimination I φ (x₁ , y) | no x = ⊥-elim (x₁ (x , x))
-- -- logical (logical (logical p p) q) (logical (logical p p) q)
-- conditionalization : (I : Interpretation) (p q : Formula) → I ⊨ q → I ⊨ ((p ∷ []) ⊢ p ⊃ q)
-- conditionalization I p q ⊨q -⊨p = let ⊨p = -⊨p p (here []) in (λ { (x , ~q) → ~q ⊨q}) , (λ { (x , y) → y ⊨q})
-- modusPonens : (I : Interpretation) (p q : Formula) → I ⊨ p → I ⊨ ((p ⊗ p) ⊗ q) ⊗ ((p ⊗ p) ⊗ q) → I ⊨ q
-- modusPonens I p q P (~[~p&~p&~q] , ~[~p&~p&~q]²) with I ⊨? q
-- modusPonens I p q P (~[~p&~p&~q] , ~[~p&~p&~q]²) | yes x = x
-- modusPonens I p q P (~[~p&~p&~q] , ~[~p&~p&~q]²) | no x = ⊥-elim (~[~p&~p&~q] ((λ { (x₁ , y) → y P}) , (λ x₁ → x x₁)))
-- theorem1a : (s : Sequent) → SimpleNDProblem s → ⊨ s → Either (Sequent.conclusion s ∈ Sequent.premises s) (Σ _ λ q → q ∈ Sequent.premises s × ~ q ∈ Sequent.premises s)
-- theorem1a ([] ⊢ atomic arity name x) record { simpleConclusion = (Latomic .arity .name .x) ; simplePremises = simplePremises } x₂ = {!!}
-- theorem1a ((x₁ ∷ premises) ⊢ atomic arity name x) record { simpleConclusion = (Latomic .arity .name .x) ; simplePremises = simplePremises } x₂ = {!!}
-- theorem1a (premises ⊢ logical .(atomic arity name terms) .(atomic arity name terms)) record { simpleConclusion = (logical arity name terms) ; simplePremises = simplePremises } x₁ = {!!}
-- theorem1a (premises ⊢ quantified x conclusion) record { simpleConclusion = () ; simplePremises = simplePremises } x₂
-- theorem1b : (s : Sequent) → SimpleNDProblem s → Either (Sequent.conclusion s ∈ Sequent.premises s) (Σ _ λ q → q ∈ Sequent.premises s × ~ q ∈ Sequent.premises s) → ⊨ s
-- theorem1b s x (left x₁) I x₂ = x₂ (Sequent.conclusion s) x₁
-- theorem1b s x (right (x₁ , x₂ , y)) I x₃ = let ~q = x₃ (~ x₁) y in let q = x₃ x₁ x₂ in ⊥-elim (fst ~q q)
-- {-
-- p ≡ q
-- p -> q & q -> p
-- (~p v q) & (~q v p)
-- ~(p & ~q) & ~(q & ~p)
-- ~(~~p & ~q) & ~(~~q & ~p)
-- bicondit elim is just simplification
-- modus ponens
-- p , (p ⊗ (q ⊗ q)) ⊗ (p ⊗ (q ⊗ q)) --> q
-- ~(~p & q)
-- p or ~q
-- p -> q
-- ~p v q
-- ~(p & ~q)
-- ~(p & ~q) & ~(p & ~q)
-- ~(~~p & ~q) & ~(~~p & ~q)
-- (~~p & ~q) ⊗ (~~p & ~q)
-- (~p ⊗ q) ⊗ (~p ⊗ q)
-- ((p ⊗ p) ⊗ q) ⊗ ((p ⊗ p) ⊗ q)
-- -}
-- {-
-- conditionalization p -> q from q, with discharge p
-- (p ∷ [] ⊢ q) ⊨ (∅ ⊢ q)
-- -}
-- --data ReasonerState : List Sequent → List Sequent → Set
-- {-
-- p <-> q
-- p -> q and q -> p
-- ~p v q and ~q or p
-- ~(p and ~q) and ~(q and ~p)
-- (p and ~q) ⊗ (q and ~p)
-- ((p ⊗ p) ⊗ q) ⊗ ((q ⊗ q) ⊗ p)
-- p -> q
-- ~p v q
-- ~(p and ~q)
-- ~(p and ~q) and ~(p and ~q)
-- ((p ⊗ p) ⊗ q) ⊗ ((p ⊗ p) ⊗ q)
-- but this is just simplification
-- p , p -> q ⊢ q
-- p , ((p ⊗ p) ⊗ q) ⊗ ((p ⊗ p) ⊗ q) ⊢ q
-- p , q <-- p & q
-- p <-- ~~p
-- p <-- (p ⊗ p) ⊗ (p ⊗ p)
-- -}
-- -- PorNotP : (I : Interpretation) (P : Formula) → I ⊨ (logical (logical P (logical P P)) (logical P (logical P P)))
-- -- PorNotP I P = (λ { (x , y) → y (x , x)}) , (λ { (x , y) → y (x , x)})
-- -- IFTHEN : Formula → Formula → Formula
-- -- IFTHEN P Q = logical (logical (logical P P) Q) (logical (logical P P) Q)
-- -- EXISTS : Nat → Formula → Formula
-- -- EXISTS n φ = (logical (quantified n (logical φ φ)) (quantified n (logical φ φ)))
-- -- F : Nat → Formula
-- -- F n = atomic 1 0 (variable n ∷ [])
-- -- Fa : Formula
-- -- Fa = F 0
-- -- ∃xFx : Formula
-- -- ∃xFx = EXISTS 1 (F 1)
-- -- IfFaThenExistsFa : (I : Interpretation) → I ⊨ (IFTHEN Fa ∃xFx)
-- -- IfFaThenExistsFa I = (λ { (I⊭~Fa , I⊭∃xFx) → I⊭~Fa ((λ x → I⊭∃xFx ((λ x₁ → fst (x₁ {!!} {!!}) {!!}) , (λ x₁ → {!!}))) , {!!})}) , (λ { (x , y) → {!!}})
-- -- NotPAndNotNotP : (I : Interpretation) (P : Formula) → I ⊨ (logical P (logical P P))
-- -- NotPAndNotNotP = {!!}
-- -- -- Valid : Formula → Set₁
-- -- -- Valid φ = (I : Interpretation) → I Satisfies φ
-- -- -- -- data SkolemFormula {ι : Size} (α : Alphabet) : Set where
-- -- -- -- atomic : Predication α → SkolemFormula α
-- -- -- -- logical : {ι¹ : Size< ι} → SkolemFormula {ι¹} α → {ι² : Size< ι} → SkolemFormula {ι²} α → SkolemFormula {ι} α
-- -- -- -- record Alphabet₊ᵥ (α : Alphabet) : Set where
-- -- -- -- constructor α₊ᵥ⟨_⟩
-- -- -- -- field
-- -- -- -- alphabet : Alphabet
-- -- -- -- .one-variable-is-added : (number ∘ variables $ alphabet) ≡ suc (number ∘ variables $ α)
-- -- -- -- .there-are-no-functions-of-maximal-arity : number (functions alphabet) zero ≡ zero
-- -- -- -- .shifted-function-matches : ∀ {ytira₀ ytira₁} → finToNat ytira₁ ≡ finToNat ytira₀ → number (functions alphabet) (suc ytira₁) ≡ number (functions α) ytira₀
-- -- -- -- open Alphabet₊ᵥ
-- -- -- -- record Alphabet₊ₛ (α : Alphabet) : Set where
-- -- -- -- constructor α₊ₛ⟨_⟩
-- -- -- -- field
-- -- -- -- alphabet : Alphabet
-- -- -- -- open Alphabet₊ₛ
-- -- -- -- {-
-- -- -- -- toSkolemFormula
-- -- -- -- ∀x(F x v₀ v₁) ⟿ F v₀ v₁ v₂
-- -- -- -- ∃x(F x v₀ v₁) ⟿ F (s₀͍₂ v₀ v₁) v₀ v₁
-- -- -- -- ∀x(F x (s₀͍₂ v₀ v₁) v₁) ⟿ F v₀ (s₀͍₂ v₁ v₂) v₂
-- -- -- -- ∃x(F x (s₀͍₂ v₀ v₁) v₁) ⟿ F (s₀͍₂ v₀ v₁) (s₁͍₂ v₁ v₂) v₂
-- -- -- -- F v₀ ⊗ G v₀ ⟿ F v₀ ⊗ G v₀
-- -- -- -- ∀x(F x v₀ v₁) ⊗ ∀x(G x (s₀͍₂ x v₁) v₁) ⟿ F v₀ v₂ v₃ ⊗ G v₁ (s₀͍₂ v₀ v₃) v₃
-- -- -- -- ∀x(F x v₀ v₁) ⊗ ∃x(G x (s₀͍₂ x v₁) v₁) ⟿ F v₀ v₁ v₂ ⊗ G (s₀͍₁ v₂) (s₁͍₂ (s₀͍₂ v₂) v₂) v₂
-- -- -- -- Φ₀ = ∃x(G x (s₀͍₂ x v₁) v₁) has alphabet of 2 variables, skolem functions: 0, 0, 1
-- -- -- -- this is existential {α₊ₛ} Φ₁, where
-- -- -- -- Φ₁ = G (s₀͍₂ v₀ v₁) (s₁͍₂ (s₀͍₂ v₀ v₁)) v₁
-- -- -- -- α₊ₛ = ⟨ 2 , 0 ∷ 0 ∷ 2 ∷ [] ⟩
-- -- -- -- maybe Φ₋₁ = ∀y∃x(G x (s₀͍₂ x v₀) v₀)
-- -- -- -- and Φ₋₂ = ∀z∀y∃x(G x (s₀͍₂ x z) z), finally having no free variables, but nevertheless having skolem functions! these are user-defined functions, so this notion of Alphabet is somehow wrong. we have also left out constants (i.e. user-defined skolem-functions of arity 0)
-- -- -- -- Instead, take the alphabet as defining
-- -- -- -- a stack of free variables
-- -- -- -- a matrix (triangle?) of skolem functions
-- -- -- -- Let's try to reverse Φ₁ from a Skolem to a 1st-order formula. Is there a unique way to do it?
-- -- -- -- Φ₀' = ∀x(G (s₀͍₂ x v₀) (s₁͍₂ (s₀͍₂ x v₀)) v₀
-- -- -- -- Nope!
-- -- -- -- toSkolemFormula of
-- -- -- -- -}
-- -- -- -- -- toSkolemFormula (logical Φ₁ Φ₂) ⟿
-- -- -- -- -- let α' , φ₁ = toSkolemFormula Φ₁
-- -- -- -- -- Φ₂' = transcodeToAugmentedAlphabet Φ₂ α'
-- -- -- -- -- α'' , φ₂' = toSkolemFormula Φ₂'
-- -- -- -- -- φ₁' = transcodeToAugmentedAlphabet φ₁ α''
-- -- -- -- {-
-- -- -- -- given Δv = #varibles α' - #variables α
-- -- -- -- for every variable v in α, v in Φ, v stays the same in Φ'
-- -- -- -- for the added variable v⁺ in α₊ - α, v⁺ in Φ, v⁺ ⟿ v⁺ + Δv in transcode (universal {α₊} Φ)
-- -- -- -- α'₊ = α' + 1 variable
-- -- -- -- -}
-- -- -- -- -- record AddVariable (A : Alphabet → Set) : Set where
-- -- -- -- -- field
-- -- -- -- -- addVariableToAlphabet : {α : Alphabet} → A α → {α₊ : Alphabet} → Alphabet₊ᵥ α₊ → A α₊
-- -- -- -- -- instance
-- -- -- -- -- AddVariableFirstOrderFormula : AddVariable FirstOrderFormula
-- -- -- -- -- AddVariableFirstOrderFormula = {!!}
-- -- -- -- -- #variables = number ∘ variables
-- -- -- -- -- #functions_ofArity_ : Alphabet → Nat → Nat
-- -- -- -- -- #functions α⟨ V⟨ #variables ⟩ , S⟨ #functions ⟩ ⟩ ofArity arity = if′ lessNat arity (suc #variables) then #functions (natToFin arity) else 0
-- -- -- -- -- record _⊇_ (α' α : Alphabet) : Set where
-- -- -- -- -- field
-- -- -- -- -- at-least-as-many-variables : #variables α' ≥ #variables α
-- -- -- -- -- at-least-as-many-functions : ∀ {arity} → arity < #variables α → #functions α' ofArity arity ≥ #functions α ofArity arity
-- -- -- -- -- record AddAlphabet (α-top α-bottom : Alphabet) : Set where
-- -- -- -- -- field
-- -- -- -- -- alphabet : Alphabet
-- -- -- -- -- record Transcodeable (A : Alphabet → Set) : Set where
-- -- -- -- -- field
-- -- -- -- -- transcode : {α' α : Alphabet} → ⦃ _ : α' ⊇ α ⦄ → A α → A α'
-- -- -- -- -- open Transcodeable ⦃ … ⦄
-- -- -- -- -- record TransferAlphabet {α' α : Alphabet} (α'⊇α : α' ⊇ α) (α₊ : Alphabet₊ᵥ α) (Φ : FirstOrderFormula (alphabet α₊)) : Set where
-- -- -- -- -- field
-- -- -- -- -- alphabet : Alphabet
-- -- -- -- -- firstOrderFormula : FirstOrderFormula alphabet
-- -- -- -- -- instance
-- -- -- -- -- TranscodeablePredication : Transcodeable Predication
-- -- -- -- -- TranscodeablePredication = {!!}
-- -- -- -- -- TranscodeableAlphabet+Variable : Transcodeable Alphabet₊ᵥ
-- -- -- -- -- TranscodeableAlphabet+Variable = {!!}
-- -- -- -- -- TranscodeableSkolemFormula : Transcodeable SkolemFormula
-- -- -- -- -- TranscodeableSkolemFormula = {!!}
-- -- -- -- -- TranscodeableFirstOrderFormula : Transcodeable FirstOrderFormula
-- -- -- -- -- Transcodeable.transcode TranscodeableFirstOrderFormula (atomic p) = atomic (transcode p)
-- -- -- -- -- Transcodeable.transcode TranscodeableFirstOrderFormula (logical Φ₁ Φ₂) = logical (transcode Φ₁) (transcode Φ₂)
-- -- -- -- -- Transcodeable.transcode TranscodeableFirstOrderFormula {α'} {α} ⦃ α'⊇α ⦄ (universal {α₊} Φ) = {!!} -- universal {_} {_} {transcode α₊} (transcode Φ)
-- -- -- -- -- Transcodeable.transcode TranscodeableFirstOrderFormula (existential Φ) = {!!}
-- -- -- -- -- --(α' α : Alphabet) (α'⊇α : α' ⊇ α) (α₊ : Alphabet+Variable α) (Φ : FirstOrderFormula (alphabet α₊)) → Σ _ λ (α''' : Alphabet) → FirstOrderFormula α'''
-- -- -- -- -- --FirstOrderFormula (alphabet α₊)
-- -- -- -- -- {-
-- -- -- -- -- -}
-- -- -- -- -- -- --transcodeIntoAugmentedAlphabet :
-- -- -- -- -- -- --toSkolemFormula : {α : Alphabet} → FirstOrderFormula α → Σ _ λ (α¹ : AugmentedAlphabet α) → SkolemFormula (alphabet α¹)
-- -- -- -- -- -- --record IsEquivalentFormulas {α₀ : Alphabet} (φ₀ : SkolemFormula α₀) {α₁ : Alphabet} (Φ₁ : FirstOrderFormula α₁) : Set where
-- -- -- -- -- -- -- field
-- -- -- -- -- -- -- .atomicCase : {p : Predication α₀} → φ₀ ≡ atomic p → Φ₁ ≡ atomic p
-- -- -- -- -- -- -- --
-- -- -- -- -- -- -- -- record Alphabet+Alphabet (α₀ α₁ α₂ : Alphabet) : Set where
-- -- -- -- -- -- -- -- field
-- -- -- -- -- -- -- -- alphabet :
-- -- -- -- -- -- -- -- ∀xφ₁(x) ⊗ φ₂ ⟿ ∀x(φ₁ ⊗ φ₂)
-- -- -- -- -- -- -- -- hasQuantifiers : FirstOrderFormula α → Bool
-- -- -- -- -- -- -- --record Skolemization {α : Alphabet} (φ : FirstOrderFormula α) : Set where
-- -- -- -- -- -- -- -- field
-- -- -- -- -- -- -- -- alphabet : Alphabet
-- -- -- -- -- -- -- -- skolemization : SkolemFormula alphabet
-- -- -- -- -- -- -- record _IsAugmentationOf_ (α₁ α₀ : Alphabet) : Set where
-- -- -- -- -- -- -- record AugmentedAlphabet (α : Alphabet) : Set where
-- -- -- -- -- -- -- constructor ⟨_⟩
-- -- -- -- -- -- -- field
-- -- -- -- -- -- -- alphabet : Alphabet
-- -- -- -- -- -- -- ..laws : alphabet ≡ α
-- -- -- -- -- -- -- open AugmentedAlphabet
-- -- -- -- -- -- -- trivialAugmentation : (α : Alphabet) → AugmentedAlphabet α
-- -- -- -- -- -- -- trivialAugmentation = {!!}
-- -- -- -- -- -- -- record DisjointRelativeUnion {α : Alphabet} (α¹ α² : AugmentedAlphabet α) : Set where
-- -- -- -- -- -- -- constructor ⟨_⟩
-- -- -- -- -- -- -- field
-- -- -- -- -- -- -- augmentation : AugmentedAlphabet α
-- -- -- -- -- -- -- .laws : {!!}
-- -- -- -- -- -- -- open DisjointRelativeUnion
-- -- -- -- -- -- -- disjointRelativeUnion : {α : Alphabet} → (α¹ α² : AugmentedAlphabet α) → DisjointRelativeUnion α¹ α²
-- -- -- -- -- -- -- disjointRelativeUnion = {!!}
-- -- -- -- -- -- -- -- inAugmentedAlphabet : {α : Alphabet} → (α¹ : AugmentedAlphabet α) → SkolemFormula α → SkolemFormula (alphabet α¹)
-- -- -- -- -- -- -- -- inAugmentedAlphabet = {!!}
-- -- -- -- -- -- -- -- toSkolemFormula : {α : Alphabet} → FirstOrderFormula α → Σ _ λ (α¹ : AugmentedAlphabet α) → SkolemFormula (alphabet α¹)
-- -- -- -- -- -- -- -- toSkolemFormula {α₀} (atomic 𝑃) = trivialAugmentation α₀ , atomic 𝑃
-- -- -- -- -- -- -- -- toSkolemFormula {α₀} (logical φ₁ φ₂) with toSkolemFormula φ₁ | toSkolemFormula φ₂
-- -- -- -- -- -- -- -- toSkolemFormula {α₀} (logical φ₁ φ₂) | α¹ , Φ₁ | α² , Φ₂ = augmentation (disjointRelativeUnion α¹ α²) , logical {!inAugmentedAlphabet (augmentation (disjointRelativeUnion α¹ α²)) Φ₁!} {!Φ₂!}
-- -- -- -- -- -- -- -- toSkolemFormula {α₀} (universal x) = {!!}
-- -- -- -- -- -- -- -- toSkolemFormula {α₀} (existential x) = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- toNQFormula : ∀ {alphabet₀} → QFormula alphabet₀ → Σ _ λ alphabet₁ → NQFormula alphabet₁
-- -- -- -- -- -- -- -- -- -- -- -- -- -- toNQFormula {alphabet₀} (atomic name terms) = alphabet₀ , atomic name terms
-- -- -- -- -- -- -- -- -- -- -- -- -- -- toNQFormula {alphabet₀} (logical formula₁ formula₂) with toNQFormula formula₁ | toNQFormula formula₂
-- -- -- -- -- -- -- -- -- -- -- -- -- -- ... | alphabet₁ , nqFormula₁ | alphabet₂ , nqFormula₂ = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- toNQFormula {alphabet₀} (universal formula) = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- toNQFormula {alphabet₀} (existential formula) = {!!}
-- -- -- -- -- -- -- -- -- -- -- --VariableName = Fin ∘ |v|
-- -- -- -- -- -- -- -- -- -- -- --FunctionArity = Fin ∘ suc ∘ size
-- -- -- -- -- -- -- -- -- -- -- --FunctionName = λ alphabet ytira → Fin (|f| alphabet ytira)
-- -- -- -- -- -- -- -- -- -- -- -- record Alphabet : Set where
-- -- -- -- -- -- -- -- -- -- -- -- constructor ⟨_,_⟩
-- -- -- -- -- -- -- -- -- -- -- -- field
-- -- -- -- -- -- -- -- -- -- -- -- |v| : Nat -- number of variables
-- -- -- -- -- -- -- -- -- -- -- -- |f| : Fin (suc |v|) → Nat -- number of functions of each arity, |v| through 0
-- -- -- -- -- -- -- -- -- -- -- -- open Alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- VariableName = Fin ∘ |v|
-- -- -- -- -- -- -- -- -- -- -- -- -- FunctionArity = Fin ∘ suc ∘ |v|
-- -- -- -- -- -- -- -- -- -- -- -- -- FunctionName = λ alphabet ytira → Fin (|f| alphabet ytira)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- data Term {i : Size} (alphabet : Alphabet) : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- variable : VariableName alphabet → Term alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- function : ∀ {arity : FunctionArity alphabet} →
-- -- -- -- -- -- -- -- -- -- -- -- -- -- FunctionName alphabet (natToFin (|v| alphabet) - arity) →
-- -- -- -- -- -- -- -- -- -- -- -- -- -- ∀ {j : Size< i} → Vec (Term {j} alphabet) (finToNat arity) →
-- -- -- -- -- -- -- -- -- -- -- -- -- -- Term {i} alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- PredicateArity = Nat
-- -- -- -- -- -- -- -- -- -- -- -- -- -- PredicateName = Nat
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- a zeroth-order formula? (i.e. no quantifiers)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- data NQFormula {i : Size} (alphabet : Alphabet) : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- atomic : PredicateName → ∀ {arity} → Vec (Term alphabet) arity → NQFormula alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- logical : {j : Size< i} → NQFormula {j} alphabet → {k : Size< i} → NQFormula {k} alphabet → NQFormula {i} alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- record AugmentedByVariable (alphabet₀ alphabet₁ : Alphabet) : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- field
-- -- -- -- -- -- -- -- -- -- -- -- -- -- one-variable-is-added : |v| alphabet₁ ≡ suc (|v| alphabet₀)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- function-domain-is-zero-at-new-variable : |f| alphabet₁ zero ≡ 0
-- -- -- -- -- -- -- -- -- -- -- -- -- -- shifted-function-matches : ∀ {ytira₀ ytira₁} → finToNat ytira₁ ≡ finToNat ytira₀ → |f| alphabet₁ (suc ytira₁) ≡ |f| alphabet₀ ytira₀
-- -- -- -- -- -- -- -- -- -- -- -- -- -- record AugmentVariables (alphabet₀ : Alphabet) : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- field
-- -- -- -- -- -- -- -- -- -- -- -- -- -- alphabet₁ : Alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentation : AugmentedByVariable alphabet₀ alphabet₁
-- -- -- -- -- -- -- -- -- -- -- -- -- -- open AugmentVariables
-- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentVariables : (alphabet : Alphabet) → AugmentVariables alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentVariables ⟨ |v| , |f| ⟩ =
-- -- -- -- -- -- -- -- -- -- -- -- -- -- record
-- -- -- -- -- -- -- -- -- -- -- -- -- -- { alphabet₁ = ⟨ suc |v| , (λ { zero → zero ; (suc ytira) → |f| ytira}) ⟩
-- -- -- -- -- -- -- -- -- -- -- -- -- -- ; augmentation =
-- -- -- -- -- -- -- -- -- -- -- -- -- -- record
-- -- -- -- -- -- -- -- -- -- -- -- -- -- { one-variable-is-added = refl
-- -- -- -- -- -- -- -- -- -- -- -- -- -- ; function-domain-is-zero-at-new-variable = refl
-- -- -- -- -- -- -- -- -- -- -- -- -- -- ; shifted-function-matches = cong |f| ∘ finToNat-inj } }
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- |f|₀ = |f|₀ + 1
-- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentFunctions : Alphabet → Alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentFunctions ⟨ |v| , |f| ⟩ = ⟨ |v| , (λ { zero → suc (|f| zero) ; (suc ytira) → |f| (suc ytira) }) ⟩
-- -- -- -- -- -- -- -- -- -- -- -- -- -- data QFormula {i : Size} (alphabet : Alphabet) : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- atomic : PredicateName → ∀ {arity} → Vec (Term alphabet) arity → QFormula alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- logical : {j : Size< i} → QFormula {j} alphabet → {k : Size< i} → QFormula {k} alphabet → QFormula {i} alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- universal : QFormula (alphabet₁ (augmentVariables alphabet)) → QFormula alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- existential : QFormula (augmentFunctions alphabet) → QFormula alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- record Assignment (alphabet : Alphabet) : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- constructor ⟨_,_⟩
-- -- -- -- -- -- -- -- -- -- -- -- -- -- field
-- -- -- -- -- -- -- -- -- -- -- -- -- -- μ : VariableName alphabet → Domain
-- -- -- -- -- -- -- -- -- -- -- -- -- -- 𝑓 : ∀ {arity} → FunctionName alphabet arity → Vec Domain (finToNat arity) → Domain
-- -- -- -- -- -- -- -- -- -- -- -- -- -- evaluateTerm : ∀ {i alphabet} → Assignment alphabet → Term {i} alphabet → Domain
-- -- -- -- -- -- -- -- -- -- -- -- -- -- evaluateTerm ⟨ μ , _ ⟩ (variable x) = μ x
-- -- -- -- -- -- -- -- -- -- -- -- -- -- evaluateTerm 𝑎@(⟨ μ , 𝑓 ⟩) (function f x) = 𝑓 f (evaluateTerm 𝑎 <$> x)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- record Interpretation (alphabet : Alphabet) : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- constructor ⟨_,_⟩
-- -- -- -- -- -- -- -- -- -- -- -- -- -- open Assignment
-- -- -- -- -- -- -- -- -- -- -- -- -- -- field
-- -- -- -- -- -- -- -- -- -- -- -- -- -- 𝑎 : Assignment alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- 𝑃 : PredicateName → ∀ {arity} → Vec Domain arity → Bool
-- -- -- -- -- -- -- -- -- -- -- -- -- -- evaluateNQFormula : ∀ {i alphabet} → Interpretation alphabet → NQFormula {i} alphabet → Bool
-- -- -- -- -- -- -- -- -- -- -- -- -- -- evaluateNQFormula ⟨ 𝑎 , 𝑃 ⟩ (atomic name terms) = 𝑃 name $ evaluateTerm 𝑎 <$> terms
-- -- -- -- -- -- -- -- -- -- -- -- -- -- evaluateNQFormula I (logical formula₁ formula₂) = not (evaluateNQFormula I formula₁) && not (evaluateNQFormula I formula₂)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- toNQFormula : ∀ {alphabet₀} → QFormula alphabet₀ → Σ _ λ alphabet₁ → NQFormula alphabet₁
-- -- -- -- -- -- -- -- -- -- -- -- -- -- toNQFormula {alphabet₀} (atomic name terms) = alphabet₀ , atomic name terms
-- -- -- -- -- -- -- -- -- -- -- -- -- -- toNQFormula {alphabet₀} (logical formula₁ formula₂) with toNQFormula formula₁ | toNQFormula formula₂
-- -- -- -- -- -- -- -- -- -- -- -- -- -- ... | alphabet₁ , nqFormula₁ | alphabet₂ , nqFormula₂ = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- toNQFormula {alphabet₀} (universal formula) = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- toNQFormula {alphabet₀} (existential formula) = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- record IsADisjointUnionOfNQFormulas
-- -- -- -- -- -- -- -- -- -- -- -- -- -- {alphabet₁ alphabet₂ alphabet₁₊₂ : Alphabet}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- (formula₁ : NQFormula alphabet₁)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- (formula₂ : NQFormula alphabet₂)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- (formula₁₊₂ : NQFormula alphabet₁₊₂)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- field
-- -- -- -- -- -- -- -- -- -- -- -- -- -- alphabet-size : |v| alphabet₁₊₂ ≡ |v| alphabet₁ + |v| alphabet₂
-- -- -- -- -- -- -- -- -- -- -- -- -- -- --|f| alphabet₁₊₂ ytira
-- -- -- -- -- -- -- -- -- -- -- -- -- -- ----record AlphabetSummed (alphabet₀ alphabet₁ : Alphabet)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- --
-- -- -- -- -- -- -- -- -- -- -- -- -- -- --addAlphabets : Alphabet → Alphabet → Alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- --addAlphabets ⟨ |v|₁ , |f|₁ ⟩ ⟨ |v|₂ , |f|₂ ⟩ = ⟨ (|v|₁ + |v|₂) , (λ x → if′ finToNat x ≤? |v|₁ && finToNat x ≤? |v|₂ then {!!} else {!!}) ⟩
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- sup : ∀ {alphabet₁} → Formula alphabet₁ → ∀ {alphabet₂} → Formula alphabet₂ → Σ _ λ alphabet₁₊₂ → Formula alphabet₁₊₂ × Formula alphabet₁₊₂
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- sup {⟨ |v|₁ , |a|₁ , |f|₁ ⟩} φ₁ {⟨ |v|₂ , |a|₂ , |f|₂ ⟩} φ₂ = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- pnf : ∀ {alphabet} → Formula alphabet → Σ _ λ alphabet+ → Formula₀ alphabet+
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- pnf = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- {-
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --universal (P 0) = ∀ x → P x
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- (∀ x ∃ y (P x y)) ∨ (∀ x ∃ y (P x y))
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- P x₀ (s₀͍₁ x₀) ∨ P x₁ (s₁͍₁ x₁)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- extended|f| : (arity : Arity) → Vec ℕ (suc |a|) → Vec ℕ (++arity (max arity |a|))
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- extended|f| = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- add a variable to the alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentVariables : Alphabet → Alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentVariables = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- increaseTabulationAtN : ∀ {n} → Fin n → (Fin n → Nat) → Fin n → Nat
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- increaseTabulationAtN = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- {-
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- record AugmentedFunctions {|a| : Arity} (arity : Arity) (|f| : Vec ℕ (++arity |a|)) : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- field
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- maxA : ℕ
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- maxA-law : max arity |a| ≡ maxA
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ++|f| : Vec ℕ maxA
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- f-law : increaseTabulationAt arity (indexVec |f|)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- {-
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- define
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- a ⊗ b ≡ False a and False b
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- now, we can define
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ¬a = a ⊗ a ≡ False a and False a
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- a ∨ b = ¬(a ⊗ b) ≡ False (False a and False b) and False (False a and False b)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- a ∧ b = ¬(¬a ∨ ¬b) = ¬(¬(¬a ⊗ ¬b)) = ¬a ⊗ ¬b = False (False a and False a) and False (False b and False b)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- a → b = ¬a ∨ b = (a ⊗ a) ∨ b = ¬((a ⊗ a) ⊗ b) = ((a ⊗ a) ⊗ b) ⊗ ((a ⊗ a) ⊗ b)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- conversion to prenex
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ∀xF ⊗ G ⟿ ∃x(F ⊗ wk(G))
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ∃xF ⊗ G ⟿ ∀x(F ⊗ wk(G))
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- F ⊗ ∀xG ⟿ ∃x(wk(F) ⊗ G)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- F ⊗ ∃xG ⟿ ∀x(wk(F) ⊗ G)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ========================
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- (a ⊗ ∀xB) ⊗ c ⟿ ∃x(wk(a) ⊗ B) ⊗ c ⟿ ∀x((wk(a) ⊗ B) ⊗ wk(c))
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentF : (arity : Arity) → ∀ {|a| : Arity} → Vec ℕ (++arity |a|) → Vec ℕ (++arity (max arity |a|))
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentF arity {|a|} |f|
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- with decBool (lessNat |a| arity)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentF arity {|a|} |f| | yes x with compare arity |a|
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentF arity {.(suc (k + arity))} |f| | yes x | less (diff k refl) = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentF arity {.arity} |f| | yes x | equal refl with lessNat arity arity
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentF arity {.arity} |f| | yes x | equal refl | false = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentF zero {.zero} |f| | yes true | equal refl | true = {!!} ∷ []
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentF (suc arity) {.(suc arity)} |f| | yes true | equal refl | true = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentF arity {|a|} |f| | yes x | greater gt = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentF arity {|a|} |f| | no x with decBool (lessNat arity |a|)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentF arity {|a|} |f| | no x₁ | yes x = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentF arity {|a|} |f| | no x₁ | no x = {!!}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- = case arity <? |a| of λ { false → {!!} ; true → {!!} }
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- add a function of a given arity to the alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentFunctions : Arity → Alphabet → Alphabet
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- augmentFunctions arity ⟨ |v| , |a| , |f| ⟩ = ⟨ |v| , max arity |a| , augmentF arity |f| ⟩
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- record Alphabet : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- data DomainSignifier : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- free : Nat → DomainSignifier
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- data PartiallyAppliedFunction : Nat → Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- constant : PartiallyAppliedFunction 0
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- function : ∀ {n} → PartiallyAppliedFunction 0 → PartiallyAppliedFunction (suc n)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- Term = PartiallyAppliedFunction 0
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- data PartialyAppliedPredicate : Nat → Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- statement : PartialyAppliedPredicate 0
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- partial : ∀
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- record Language : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- field
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- Name = String
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- record Function : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- field
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- name : Name
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- number-of-arguments : Nat
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- Vec
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- data Function : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- data Term : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- function : Function →
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- data Sentence : Set where
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- predication : Name →
-- -- -- -- {-
-- -- -- -- record Variables : Set where
-- -- -- -- constructor V⟨_⟩
-- -- -- -- field
-- -- -- -- number : Nat
-- -- -- -- open Variables
-- -- -- -- record Functions (υ : Variables) : Set where
-- -- -- -- constructor S⟨_⟩
-- -- -- -- field
-- -- -- -- number : Fin (suc (number υ)) → Nat
-- -- -- -- open Functions
-- -- -- -- record Alphabet : Set where
-- -- -- -- constructor α⟨_,_⟩
-- -- -- -- field
-- -- -- -- variables : Variables
-- -- -- -- functions : Functions variables
-- -- -- -- open Alphabet
-- -- -- -- record Variable (α : Alphabet) : Set where
-- -- -- -- constructor v⟨_⟩
-- -- -- -- field
-- -- -- -- name : Fin (number (variables α))
-- -- -- -- open Variable
-- -- -- -- record Function (α : Alphabet) : Set where
-- -- -- -- constructor s⟨_,_⟩
-- -- -- -- field
-- -- -- -- arity : Fin ∘ suc ∘ number ∘ variables $ α
-- -- -- -- name : Fin $ number (functions α) arity
-- -- -- -- open Function
-- -- -- -- data Term (𝑽 : Nat) : Set where
-- -- -- -- variable : Fin 𝑽 → Term 𝑽
-- -- -- -- function : (𝑓 : Function α) → {ι₋₁ : Size< ι₀} → Vec (Term {ι₋₁} α) (finToNat (arity 𝑓)) →
-- -- -- -- Term {ι₀} α
-- -- -- -- record Predication (alphabet : Alphabet) : Set where
-- -- -- -- constructor P⟨_,_,_⟩
-- -- -- -- field
-- -- -- -- name : Nat
-- -- -- -- arity : Nat
-- -- -- -- terms : Vec (Term alphabet) arity
-- -- -- -- open Predication
-- -- -- -- -}
| {
"alphanum_fraction": 0.456325517,
"avg_line_length": 46.0704070407,
"ext": "agda",
"hexsha": "43e2cce1959f58466f875120ba1400038d6c6627",
"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/Scratch.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/Scratch.agda",
"max_line_length": 286,
"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/Scratch.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 15243,
"size": 41878
} |
{-# OPTIONS --without-K --safe #-}
module Data.Binary.Operations.Semantics where
open import Data.Nat as ℕ using (ℕ; suc; zero)
open import Data.Binary.Definitions
open import Data.Binary.Operations.Unary
import Data.List as List
2* : ℕ → ℕ
2* x = x ℕ.+ x
{-# INLINE 2* #-}
_∷⇓_ : Bit → ℕ → ℕ
O ∷⇓ xs = 2* xs
I ∷⇓ xs = suc (2* xs)
{-# INLINE _∷⇓_ #-}
⟦_⇓⟧⁺ : 𝔹⁺ → ℕ
⟦_⇓⟧⁺ = List.foldr _∷⇓_ 1
{-# INLINE ⟦_⇓⟧⁺ #-}
⟦_⇓⟧ : 𝔹 → ℕ
⟦ 0ᵇ ⇓⟧ = 0
⟦ 0< xs ⇓⟧ = ⟦ xs ⇓⟧⁺
⟦_⇑⟧ : ℕ → 𝔹
⟦ zero ⇑⟧ = 0ᵇ
⟦ suc n ⇑⟧ = inc ⟦ n ⇑⟧
| {
"alphanum_fraction": 0.527938343,
"avg_line_length": 17.3,
"ext": "agda",
"hexsha": "66ef27e5d8b382a8dab401d6bf6f796e23ab647d",
"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": "92af4d620febd47a9791d466d747278dc4a417aa",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "oisdk/agda-binary",
"max_forks_repo_path": "Data/Binary/Operations/Semantics.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "92af4d620febd47a9791d466d747278dc4a417aa",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "oisdk/agda-binary",
"max_issues_repo_path": "Data/Binary/Operations/Semantics.agda",
"max_line_length": 46,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "92af4d620febd47a9791d466d747278dc4a417aa",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "oisdk/agda-binary",
"max_stars_repo_path": "Data/Binary/Operations/Semantics.agda",
"max_stars_repo_stars_event_max_datetime": "2019-03-21T21:30:10.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-03-21T21:30:10.000Z",
"num_tokens": 284,
"size": 519
} |
module Support.Nat where
open import Support
data _<_ : (n m : ℕ) → Set where
Z<Sn : {n : ℕ} → zero < suc n
raise< : {n m : ℕ} (n<m : n < m) → suc n < suc m
infix 5 _>_
_>_ : (m n : ℕ) → Set
_>_ = flip _<_
infixr 7 _+_
_+_ : (n m : ℕ) → ℕ
zero + m = m
suc n + m = suc (n + m)
infixr 9 _*_
_*_ : (n m : ℕ) → ℕ
zero * m = zero
(suc n) * m = m + n * m
+-is-nondecreasingʳ : ∀ (n m : ℕ) → n < suc (n + m)
+-is-nondecreasingʳ zero m = Z<Sn
+-is-nondecreasingʳ (suc y) m = raise< (+-is-nondecreasingʳ y m)
+-idˡ : ∀ a → 0 + a ≣ a
+-idˡ a = ≣-refl
+-idʳ : ∀ a → a + 0 ≣ a
+-idʳ zero = ≣-refl
+-idʳ (suc y) = ≣-cong suc (+-idʳ y)
+-assocˡ : ∀ a b c → (a + b) + c ≣ a + (b + c)
+-assocˡ zero b c = ≣-refl
+-assocˡ (suc a) b c = ≣-cong suc (+-assocˡ a b c)
+-assocʳ : ∀ a b c → a + (b + c) ≣ (a + b) + c
+-assocʳ zero b c = ≣-refl
+-assocʳ (suc a) b c = ≣-cong suc (+-assocʳ a b c)
+-sucˡ : ∀ a b → suc a + b ≣ suc (a + b)
+-sucˡ a b = ≣-refl
+-sucʳ : ∀ a b → a + suc b ≣ suc (a + b)
+-sucʳ zero b = ≣-refl
+-sucʳ (suc y) b = ≣-cong suc (+-sucʳ y b)
+-comm : ∀ a b → a + b ≣ b + a
+-comm a zero = +-idʳ a
+-comm a (suc y) = ≣-trans (≣-cong suc (+-comm a y)) (+-sucʳ a y)
*-killˡ : ∀ a → 0 * a ≣ 0
*-killˡ a = ≣-refl
*-killʳ : ∀ a → a * 0 ≣ 0
*-killʳ zero = ≣-refl
*-killʳ (suc y) = *-killʳ y
*-idˡ : ∀ a → 1 * a ≣ a
*-idˡ a = +-idʳ a
*-idʳ : ∀ a → a * 1 ≣ a
*-idʳ zero = ≣-refl
*-idʳ (suc y) = ≣-cong suc (*-idʳ y)
*-dist-+ˡ : ∀ a b c → a * (b + c) ≣ a * b + a * c
*-dist-+ˡ zero b c = ≣-refl
*-dist-+ˡ (suc y) b c =
begin
(b + c) + y * (b + c)
≈⟨ ≣-cong (_+_ (b + c)) (*-dist-+ˡ y b c) ⟩
(b + c) + y * b + y * c
≈⟨ +-assocʳ (b + c) (y * b) (y * c) ⟩
((b + c) + y * b) + y * c
≈⟨ ≣-cong (λ x → (x + y * b) + y * c) (+-comm b c) ⟩
((c + b) + y * b) + y * c
≈⟨ ≣-cong (λ x → x + y * c) (+-assocˡ c b (y * b)) ⟩
(c + b + y * b) + y * c
≈⟨ ≣-cong (λ x → x + y * c) (+-comm c (b + y * b)) ⟩
((b + y * b) + c) + y * c
≈⟨ +-assocˡ (b + y * b) c (y * c) ⟩
(b + y * b) + c + y * c
∎
where open ≣-reasoning ℕ
*-dist-+ʳ : ∀ a b c → (a + b) * c ≣ a * c + b * c
*-dist-+ʳ zero b c = ≣-refl
*-dist-+ʳ (suc y) b c = ≣-trans (+-assocʳ c (y * c) (b * c)) (≣-cong (_+_ c) (*-dist-+ʳ y b c))
*-assocˡ : ∀ a b c → (a * b) * c ≣ a * (b * c)
*-assocˡ zero b c = ≣-refl
*-assocˡ (suc y) b c = ≣-trans (≣-cong (_+_ (b * c)) (*-assocˡ y b c))
(*-dist-+ʳ b (y * b) c)
*-assocʳ : ∀ a b c → (a * b) * c ≣ a * (b * c)
*-assocʳ zero b c = ≣-refl
*-assocʳ (suc y) b c = ≣-trans (≣-cong (_+_ (b * c)) (*-assocʳ y b c))
(*-dist-+ʳ b (y * b) c)
*-sucˡ : ∀ a b → (suc a) * b ≣ b + a * b
*-sucˡ a b = ≣-refl
*-sucʳ : ∀ a b → a * (suc b) ≣ a + a * b
*-sucʳ zero b = ≣-refl
*-sucʳ (suc y) b = ≣-cong suc (
begin
b + y * suc b
≈⟨ ≣-cong (_+_ b) (*-sucʳ y b) ⟩
b + y + y * b
≈⟨ +-assocʳ b y (y * b) ⟩
(b + y) + y * b
≈⟨ ≣-cong (λ x → x + y * b) (+-comm b y) ⟩
(y + b) + y * b
≈⟨ +-assocˡ y b (y * b) ⟩
y + b + y * b
∎)
where open ≣-reasoning ℕ
*-comm : ∀ a b → a * b ≣ b * a
*-comm a zero = *-killʳ a
*-comm a (suc y) =
begin
a * suc y
≈⟨ *-sucʳ a y ⟩
a + a * y
≈⟨ ≣-cong (_+_ a) (*-comm a y) ⟩
a + y * a
∎
where open ≣-reasoning ℕ
<-irref : ∀ {n} → ¬ (n < n)
<-irref (raise< n<m) = <-irref n<m
<-trans : ∀ {l m n} → (l < m) → (m < n) → (l < n)
<-trans Z<Sn (raise< n<m) = Z<Sn
<-trans (raise< n<m) (raise< n<m') = raise< (<-trans n<m n<m')
<-trans-assoc : ∀ {a b c d} → {a<b : a < b} {b<c : b < c} {c<d : c < d} → <-trans a<b (<-trans b<c c<d) ≣ <-trans (<-trans a<b b<c) c<d
<-trans-assoc {a<b = Z<Sn} {raise< b<c} {raise< c<d} = ≣-refl
<-trans-assoc {a<b = raise< a<b} {raise< b<c} {raise< c<d} = ≣-cong raise< <-trans-assoc
<-unsucʳ : ∀ {m n} → m < suc n → Either (m ≣ n) (m < n)
<-unsucʳ (Z<Sn {zero}) = inl ≣-refl
<-unsucʳ (Z<Sn {suc y}) = inr Z<Sn
<-unsucʳ (raise< {n} {zero} ())
<-unsucʳ (raise< {n} {suc y} n<m) = (≣-cong suc +++ raise<) (<-unsucʳ n<m)
<-unsucˡ : ∀ {m n} → suc m < n → m < n
<-unsucˡ (raise< {zero} Z<Pn) = Z<Sn
<-unsucˡ (raise< {suc y} Sy<Pn) = raise< (<-unsucˡ Sy<Pn)
<-sucˡ : ∀ {m n} → m < n → Either (suc m ≣ n) (suc m < n)
<-sucˡ (Z<Sn {zero}) = inl ≣-refl
<-sucˡ (Z<Sn {suc y}) = inr (raise< Z<Sn)
<-sucˡ (raise< n<m) = (≣-cong suc +++ raise<) (<-sucˡ n<m)
<-sucʳ : ∀ {m n} → m < n → m < suc n
<-sucʳ Z<Sn = Z<Sn
<-sucʳ (raise< Pm<Pn) = raise< (<-sucʳ Pm<Pn)
| {
"alphanum_fraction": 0.4273236282,
"avg_line_length": 27.90625,
"ext": "agda",
"hexsha": "5e27c1cf31daf5f4fd836b950e4ea82fe44ac6c3",
"lang": "Agda",
"max_forks_count": 23,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T13:50:56.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-02-05T13:03:09.000Z",
"max_forks_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "p-pavel/categories",
"max_forks_repo_path": "Categories/Support/Nat.agda",
"max_issues_count": 19,
"max_issues_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2",
"max_issues_repo_issues_event_max_datetime": "2019-08-09T16:31:40.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-05-23T06:47:10.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "p-pavel/categories",
"max_issues_repo_path": "Categories/Support/Nat.agda",
"max_line_length": 135,
"max_stars_count": 98,
"max_stars_repo_head_hexsha": "36f4181d751e2ecb54db219911d8c69afe8ba892",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "copumpkin/categories",
"max_stars_repo_path": "Categories/Support/Nat.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-08T05:20:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-04-15T14:57:33.000Z",
"num_tokens": 2389,
"size": 4465
} |
module _ where
A : Set₁
A = Set | {
"alphanum_fraction": 0.6363636364,
"avg_line_length": 6.6,
"ext": "agda",
"hexsha": "ffe52768d3c5a55ca5b792ad74b76df18e404850",
"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/AnonymousModule.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/AnonymousModule.agda",
"max_line_length": 14,
"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/succeed/AnonymousModule.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": 13,
"size": 33
} |
------------------------------------------------------------------------------
-- Conat properties
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module FOTC.Data.Conat.PropertiesI where
open import FOTC.Base
open import FOTC.Data.Conat
open import FOTC.Data.Nat
------------------------------------------------------------------------------
-- Because a greatest post-fixed point is a fixed-point, then the
-- Conat predicate is also a pre-fixed point of the functional NatF,
-- i.e.
--
-- NatF Conat ≤ Conat (see FOTC.Data.Conat.Type).
Conat-in : ∀ {n} →
n ≡ zero ∨ (∃[ n' ] n ≡ succ₁ n' ∧ Conat n') →
Conat n
Conat-in h = Conat-coind A h' h
where
A : D → Set
A n = n ≡ zero ∨ (∃[ n' ] n ≡ succ₁ n' ∧ Conat n')
h' : ∀ {n} → A n → n ≡ zero ∨ (∃[ n' ] n ≡ succ₁ n' ∧ A n')
h' (inj₁ n≡0) = inj₁ n≡0
h' (inj₂ (n' , prf , Cn')) = inj₂ (n' , prf , Conat-out Cn')
0-Conat : Conat zero
0-Conat = Conat-coind A h refl
where
A : D → Set
A n = n ≡ zero
h : ∀ {n} → A n → n ≡ zero ∨ (∃[ n' ] n ≡ succ₁ n' ∧ A n')
h An = inj₁ An
-- Adapted from (Sander 1992, p. 57).
∞-Conat : Conat ∞
∞-Conat = Conat-coind A h refl
where
A : D → Set
A n = n ≡ ∞
h : ∀ {n} → A n → n ≡ zero ∨ (∃[ n' ] n ≡ succ₁ n' ∧ A n')
h An = inj₂ (∞ , trans An ∞-eq , refl)
N→Conat : ∀ {n} → N n → Conat n
N→Conat Nn = Conat-coind N h Nn
where
h : ∀ {m} → N m → m ≡ zero ∨ (∃[ m' ] m ≡ succ₁ m' ∧ N m')
h nzero = inj₁ refl
h (nsucc {m} Nm) = inj₂ (m , refl , Nm)
-- A different proof.
N→Conat' : ∀ {n} → N n → Conat n
N→Conat' nzero = Conat-in (inj₁ refl)
N→Conat' (nsucc {n} Nn) = Conat-in (inj₂ (n , refl , (N→Conat' Nn)))
------------------------------------------------------------------------------
-- References
--
-- Sander, Herbert P. (1992). A Logic of Functional Programs with an
-- Application to Concurrency. PhD thesis. Department of Computer
-- Sciences: Chalmers University of Technology and University of
-- Gothenburg.
| {
"alphanum_fraction": 0.4677858439,
"avg_line_length": 30.6111111111,
"ext": "agda",
"hexsha": "626095314d67c0391e13f02ea9d7850e052cb893",
"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/Conat/PropertiesI.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/Conat/PropertiesI.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/Conat/PropertiesI.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": 745,
"size": 2204
} |
module Everything where
-- The development can almost entirely be type-checked using --safe,
-- We mark modules that use the TERMINATING pragma with (**)
-- And one module that uses --rewriting with (*).
-- These are the only modules that Agda does not accept ass --safe.
-- # First we summarize the library we use by Rouvoet et al '20, CPP.
--
-- Our work contributes various improvements to the library.
-- In particular, its generalization relations whose underlying
-- equivalence is not propositional equality.
-- But also various additions to the parts of the library
-- mentioned below.
-- Core defines what a proof-relevant ternary relation (Rel₃).
import Relation.Ternary.Core
-- Structures defines type classes for ternary relations.
-- A PRSA is a commutative monoid and should implement:
-- - IsPartialMonoid <: IsPartialSemigroup
-- - IsCommutative
import Relation.Ternary.Structures
-- The overloaded syntax of separation logic comes from:
import Relation.Ternary.Structures.Syntax
-- Resource aware versions of data types that we use are defined generically
-- in Relation.Ternary.Data:
import Relation.Ternary.Data.Bigstar -- 'Star' in figure 5 of the paper
import Relation.Ternary.Data.Bigplus -- 'Plus'
import Relation.Ternary.Data.ReflexiveTransitive -- 'IStar'
-- The computational structures from the library that we use in the paper
import Relation.Ternary.Functor
import Relation.Ternary.Monad
-- # We make the following additions to the library, that we describe in the paper.
-- A generic PRSA for list separation modulo permutations.
-- It is generic in the sense that it is parameterized in a PRSA on its elements.
-- We prove that it is a PRSA, with various additional properties that are
-- crucial for the model construction in the paper.
import Relation.Ternary.Construct.Bag
import Relation.Ternary.Construct.Bag.Properties
-- A generic PRSA Exchange, that generalizes the interface composition relation.
import Relation.Ternary.Construct.Exchange
-- Its construction is generic in 2 PRSAs that obey some properties.
-- These properties are formalized as type-classes on ternary relations
import Relation.Ternary.Structures.Positive
import Relation.Ternary.Structures.Crosssplit
-- We added the writer monad construction described in the paper.
import Relation.Ternary.Monad.Writer
-- # We then formalize the typed language CF, and typed bytecode,
-- and implement the typed compilation backend.
-- The model:
-- The bag separation implements the 'disjoint' and the 'overlapping' context
-- separation from the paper, depending on how you instantiate it.
-- The instantiation is done in the JVM model construction.
-- Here we also instantiate Exchange to obtain interface composition.
import JVM.Model
-- Syntax of bytecode
import JVM.Types
import JVM.Syntax.Instructions
import JVM.Syntax.Bytecode
-- The Compiler monad
import JVM.Compiler.Monad
-- The source language
import CF.Types
import CF.Syntax -- co-contextual
import CF.Syntax.Hoisted -- co-contextual without local variable introductions
import CF.Syntax.DeBruijn -- contextual
import CF.Transform.Hoist -- hoisting local variable declarations (**)
import CF.Transform.UnCo -- contextualizing (**)
import CF.Transform.Compile.Expressions -- compiling expressions
import CF.Transform.Compile.Statements -- compiling statements
import CF.Transform.Compile.ToJVM -- typeclass for type translation
import JVM.Transform.Noooops -- bytecode optimization that removes nops
import JVM.Transform.Assemble -- bytecode translation to absolute jumps (*)
import JVM.Printer -- printer for co-contextual bytecode to Jasmin (not verified) (**)
-- Example compilations.
-- These can be run by first compiling them using `make examples`.
-- The output will be in _build/bin/
import CF.Examples.Ex1 -- (*,**)
import CF.Examples.Ex2 -- (*,**)
| {
"alphanum_fraction": 0.7572472901,
"avg_line_length": 39.2772277228,
"ext": "agda",
"hexsha": "71333049403e7d545336413ada72d976aa575b2a",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-12-28T17:37:15.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-12-28T17:37:15.000Z",
"max_forks_repo_head_hexsha": "c84bc6b834295ac140ff30bfc8e55228efbf6d2a",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "ajrouvoet/jvm.agda",
"max_forks_repo_path": "src/Everything.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c84bc6b834295ac140ff30bfc8e55228efbf6d2a",
"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": "ajrouvoet/jvm.agda",
"max_issues_repo_path": "src/Everything.agda",
"max_line_length": 107,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "c84bc6b834295ac140ff30bfc8e55228efbf6d2a",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "ajrouvoet/jvm.agda",
"max_stars_repo_path": "src/Everything.agda",
"max_stars_repo_stars_event_max_datetime": "2021-02-28T21:49:08.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-10-07T14:07:17.000Z",
"num_tokens": 843,
"size": 3967
} |
{-# OPTIONS --cubical --safe #-}
module Data.Fin.Injective where
open import Prelude
open import Data.Fin.Base
open import Data.Fin.Properties using (discreteFin)
open import Data.Nat
open import Data.Nat.Properties using (+-comm)
open import Function.Injective
private
variable n m : ℕ
infix 4 _≢ᶠ_ _≡ᶠ_
_≢ᶠ_ _≡ᶠ_ : Fin n → Fin n → Type _
n ≢ᶠ m = T (not (discreteFin n m .does))
n ≡ᶠ m = T (discreteFin n m .does)
_F↣_ : ℕ → ℕ → Type
n F↣ m = Σ[ f ⦂ (Fin n → Fin m) ] × ∀ {x y} → x ≢ᶠ y → f x ≢ᶠ f y
shift : (x y : Fin (suc n)) → x ≢ᶠ y → Fin n
shift f0 (fs y) x≢y = y
shift {suc _} (fs x) f0 x≢y = f0
shift {suc _} (fs x) (fs y) x≢y = fs (shift x y x≢y)
shift-inj : ∀ (x y z : Fin (suc n)) x≢y x≢z → y ≢ᶠ z → shift x y x≢y ≢ᶠ shift x z x≢z
shift-inj f0 (fs y) (fs z) x≢y x≢z x+y≢x+z = x+y≢x+z
shift-inj {suc _} (fs x) f0 (fs z) x≢y x≢z x+y≢x+z = tt
shift-inj {suc _} (fs x) (fs y) f0 x≢y x≢z x+y≢x+z = tt
shift-inj {suc _} (fs x) (fs y) (fs z) x≢y x≢z x+y≢x+z = shift-inj x y z x≢y x≢z x+y≢x+z
shrink : suc n F↣ suc m → n F↣ m
shrink (f , inj) .fst x = shift (f f0) (f (fs x)) (inj tt)
shrink (f , inj) .snd p = shift-inj (f f0) (f (fs _)) (f (fs _)) (inj tt) (inj tt) (inj p)
¬plus-inj : ∀ n m → ¬ (suc (n + m) F↣ m)
¬plus-inj zero zero (f , _) = f f0
¬plus-inj zero (suc m) inj = ¬plus-inj zero m (shrink inj)
¬plus-inj (suc n) m (f , p) = ¬plus-inj n m (f ∘ fs , p)
toFin-inj : (Fin n ↣ Fin m) → n F↣ m
toFin-inj f .fst = f .fst
toFin-inj (f , inj) .snd {x} {y} x≢ᶠy with discreteFin x y | discreteFin (f x) (f y)
... | no ¬p | yes p = ¬p (inj _ _ p)
... | no _ | no _ = tt
n≢sn+m : ∀ n m → Fin n ≢ Fin (suc (n + m))
n≢sn+m n m n≡m =
¬plus-inj m n
(toFin-inj
(subst
(_↣ Fin n)
(n≡m ; cong (Fin ∘ suc) (+-comm n m))
refl-↣))
Fin-inj : Injective Fin
Fin-inj n m eq with compare n m
... | equal _ = refl
... | less n k = ⊥-elim (n≢sn+m n k eq)
... | greater m k = ⊥-elim (n≢sn+m m k (sym eq))
| {
"alphanum_fraction": 0.517961165,
"avg_line_length": 30.7462686567,
"ext": "agda",
"hexsha": "185d655b7b1eb4502d0e472ebd03d6acb0a0b82d",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "oisdk/agda-playground",
"max_forks_repo_path": "Data/Fin/Injective.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "oisdk/agda-playground",
"max_issues_repo_path": "Data/Fin/Injective.agda",
"max_line_length": 92,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "oisdk/agda-playground",
"max_stars_repo_path": "Data/Fin/Injective.agda",
"max_stars_repo_stars_event_max_datetime": "2021-11-16T08:11:34.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-09-11T17:45:41.000Z",
"num_tokens": 996,
"size": 2060
} |
module _ where
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
postulate
C : Set → Set
record R (F : Nat → Set) : Set where
field
n : Nat
⦃ iC ⦄ : C (F n)
postulate
T : Nat → Set
instance
iCT5 : C (T 5)
module _ (n m : Nat) where
foo : n ≡ suc m → Nat → Set
foo refl p = Nat
where
bar : R T
R.n bar = 5
| {
"alphanum_fraction": 0.5659340659,
"avg_line_length": 14,
"ext": "agda",
"hexsha": "909e72e20f4b4edd67f0358bf757a9555260ea68",
"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/Issue2911.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/Issue2911.agda",
"max_line_length": 36,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue2911.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": 140,
"size": 364
} |
module Text.Greek.SBLGNT.Jas where
open import Data.List
open import Text.Greek.Bible
open import Text.Greek.Script
open import Text.Greek.Script.Unicode
ΙΑΚΩΒΟΥ : List (Word)
ΙΑΚΩΒΟΥ =
word (Ἰ ∷ ά ∷ κ ∷ ω ∷ β ∷ ο ∷ ς ∷ []) "Jas.1.1"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "Jas.1.1"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.1"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "Jas.1.1"
∷ word (Ἰ ∷ η ∷ σ ∷ ο ∷ ῦ ∷ []) "Jas.1.1"
∷ word (Χ ∷ ρ ∷ ι ∷ σ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.1.1"
∷ word (δ ∷ ο ∷ ῦ ∷ ∙λ ∷ ο ∷ ς ∷ []) "Jas.1.1"
∷ word (τ ∷ α ∷ ῖ ∷ ς ∷ []) "Jas.1.1"
∷ word (δ ∷ ώ ∷ δ ∷ ε ∷ κ ∷ α ∷ []) "Jas.1.1"
∷ word (φ ∷ υ ∷ ∙λ ∷ α ∷ ῖ ∷ ς ∷ []) "Jas.1.1"
∷ word (τ ∷ α ∷ ῖ ∷ ς ∷ []) "Jas.1.1"
∷ word (ἐ ∷ ν ∷ []) "Jas.1.1"
∷ word (τ ∷ ῇ ∷ []) "Jas.1.1"
∷ word (δ ∷ ι ∷ α ∷ σ ∷ π ∷ ο ∷ ρ ∷ ᾷ ∷ []) "Jas.1.1"
∷ word (χ ∷ α ∷ ί ∷ ρ ∷ ε ∷ ι ∷ ν ∷ []) "Jas.1.1"
∷ word (Π ∷ ᾶ ∷ σ ∷ α ∷ ν ∷ []) "Jas.1.2"
∷ word (χ ∷ α ∷ ρ ∷ ὰ ∷ ν ∷ []) "Jas.1.2"
∷ word (ἡ ∷ γ ∷ ή ∷ σ ∷ α ∷ σ ∷ θ ∷ ε ∷ []) "Jas.1.2"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.1.2"
∷ word (μ ∷ ο ∷ υ ∷ []) "Jas.1.2"
∷ word (ὅ ∷ τ ∷ α ∷ ν ∷ []) "Jas.1.2"
∷ word (π ∷ ε ∷ ι ∷ ρ ∷ α ∷ σ ∷ μ ∷ ο ∷ ῖ ∷ ς ∷ []) "Jas.1.2"
∷ word (π ∷ ε ∷ ρ ∷ ι ∷ π ∷ έ ∷ σ ∷ η ∷ τ ∷ ε ∷ []) "Jas.1.2"
∷ word (π ∷ ο ∷ ι ∷ κ ∷ ί ∷ ∙λ ∷ ο ∷ ι ∷ ς ∷ []) "Jas.1.2"
∷ word (γ ∷ ι ∷ ν ∷ ώ ∷ σ ∷ κ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "Jas.1.3"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.1.3"
∷ word (τ ∷ ὸ ∷ []) "Jas.1.3"
∷ word (δ ∷ ο ∷ κ ∷ ί ∷ μ ∷ ι ∷ ο ∷ ν ∷ []) "Jas.1.3"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.1.3"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.1.3"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ε ∷ ω ∷ ς ∷ []) "Jas.1.3"
∷ word (κ ∷ α ∷ τ ∷ ε ∷ ρ ∷ γ ∷ ά ∷ ζ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.1.3"
∷ word (ὑ ∷ π ∷ ο ∷ μ ∷ ο ∷ ν ∷ ή ∷ ν ∷ []) "Jas.1.3"
∷ word (ἡ ∷ []) "Jas.1.4"
∷ word (δ ∷ ὲ ∷ []) "Jas.1.4"
∷ word (ὑ ∷ π ∷ ο ∷ μ ∷ ο ∷ ν ∷ ὴ ∷ []) "Jas.1.4"
∷ word (ἔ ∷ ρ ∷ γ ∷ ο ∷ ν ∷ []) "Jas.1.4"
∷ word (τ ∷ έ ∷ ∙λ ∷ ε ∷ ι ∷ ο ∷ ν ∷ []) "Jas.1.4"
∷ word (ἐ ∷ χ ∷ έ ∷ τ ∷ ω ∷ []) "Jas.1.4"
∷ word (ἵ ∷ ν ∷ α ∷ []) "Jas.1.4"
∷ word (ἦ ∷ τ ∷ ε ∷ []) "Jas.1.4"
∷ word (τ ∷ έ ∷ ∙λ ∷ ε ∷ ι ∷ ο ∷ ι ∷ []) "Jas.1.4"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.4"
∷ word (ὁ ∷ ∙λ ∷ ό ∷ κ ∷ ∙λ ∷ η ∷ ρ ∷ ο ∷ ι ∷ []) "Jas.1.4"
∷ word (ἐ ∷ ν ∷ []) "Jas.1.4"
∷ word (μ ∷ η ∷ δ ∷ ε ∷ ν ∷ ὶ ∷ []) "Jas.1.4"
∷ word (∙λ ∷ ε ∷ ι ∷ π ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "Jas.1.4"
∷ word (Ε ∷ ἰ ∷ []) "Jas.1.5"
∷ word (δ ∷ έ ∷ []) "Jas.1.5"
∷ word (τ ∷ ι ∷ ς ∷ []) "Jas.1.5"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.1.5"
∷ word (∙λ ∷ ε ∷ ί ∷ π ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.1.5"
∷ word (σ ∷ ο ∷ φ ∷ ί ∷ α ∷ ς ∷ []) "Jas.1.5"
∷ word (α ∷ ἰ ∷ τ ∷ ε ∷ ί ∷ τ ∷ ω ∷ []) "Jas.1.5"
∷ word (π ∷ α ∷ ρ ∷ ὰ ∷ []) "Jas.1.5"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.1.5"
∷ word (δ ∷ ι ∷ δ ∷ ό ∷ ν ∷ τ ∷ ο ∷ ς ∷ []) "Jas.1.5"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "Jas.1.5"
∷ word (π ∷ ᾶ ∷ σ ∷ ι ∷ ν ∷ []) "Jas.1.5"
∷ word (ἁ ∷ π ∷ ∙λ ∷ ῶ ∷ ς ∷ []) "Jas.1.5"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.5"
∷ word (μ ∷ ὴ ∷ []) "Jas.1.5"
∷ word (ὀ ∷ ν ∷ ε ∷ ι ∷ δ ∷ ί ∷ ζ ∷ ο ∷ ν ∷ τ ∷ ο ∷ ς ∷ []) "Jas.1.5"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.5"
∷ word (δ ∷ ο ∷ θ ∷ ή ∷ σ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.1.5"
∷ word (α ∷ ὐ ∷ τ ∷ ῷ ∷ []) "Jas.1.5"
∷ word (α ∷ ἰ ∷ τ ∷ ε ∷ ί ∷ τ ∷ ω ∷ []) "Jas.1.6"
∷ word (δ ∷ ὲ ∷ []) "Jas.1.6"
∷ word (ἐ ∷ ν ∷ []) "Jas.1.6"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ε ∷ ι ∷ []) "Jas.1.6"
∷ word (μ ∷ η ∷ δ ∷ ὲ ∷ ν ∷ []) "Jas.1.6"
∷ word (δ ∷ ι ∷ α ∷ κ ∷ ρ ∷ ι ∷ ν ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ς ∷ []) "Jas.1.6"
∷ word (ὁ ∷ []) "Jas.1.6"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.1.6"
∷ word (δ ∷ ι ∷ α ∷ κ ∷ ρ ∷ ι ∷ ν ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ς ∷ []) "Jas.1.6"
∷ word (ἔ ∷ ο ∷ ι ∷ κ ∷ ε ∷ ν ∷ []) "Jas.1.6"
∷ word (κ ∷ ∙λ ∷ ύ ∷ δ ∷ ω ∷ ν ∷ ι ∷ []) "Jas.1.6"
∷ word (θ ∷ α ∷ ∙λ ∷ ά ∷ σ ∷ σ ∷ η ∷ ς ∷ []) "Jas.1.6"
∷ word (ἀ ∷ ν ∷ ε ∷ μ ∷ ι ∷ ζ ∷ ο ∷ μ ∷ έ ∷ ν ∷ ῳ ∷ []) "Jas.1.6"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.6"
∷ word (ῥ ∷ ι ∷ π ∷ ι ∷ ζ ∷ ο ∷ μ ∷ έ ∷ ν ∷ ῳ ∷ []) "Jas.1.6"
∷ word (μ ∷ ὴ ∷ []) "Jas.1.7"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.1.7"
∷ word (ο ∷ ἰ ∷ έ ∷ σ ∷ θ ∷ ω ∷ []) "Jas.1.7"
∷ word (ὁ ∷ []) "Jas.1.7"
∷ word (ἄ ∷ ν ∷ θ ∷ ρ ∷ ω ∷ π ∷ ο ∷ ς ∷ []) "Jas.1.7"
∷ word (ἐ ∷ κ ∷ ε ∷ ῖ ∷ ν ∷ ο ∷ ς ∷ []) "Jas.1.7"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.1.7"
∷ word (∙λ ∷ ή ∷ μ ∷ ψ ∷ ε ∷ τ ∷ α ∷ ί ∷ []) "Jas.1.7"
∷ word (τ ∷ ι ∷ []) "Jas.1.7"
∷ word (π ∷ α ∷ ρ ∷ ὰ ∷ []) "Jas.1.7"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.1.7"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "Jas.1.7"
∷ word (ἀ ∷ ν ∷ ὴ ∷ ρ ∷ []) "Jas.1.8"
∷ word (δ ∷ ί ∷ ψ ∷ υ ∷ χ ∷ ο ∷ ς ∷ []) "Jas.1.8"
∷ word (ἀ ∷ κ ∷ α ∷ τ ∷ ά ∷ σ ∷ τ ∷ α ∷ τ ∷ ο ∷ ς ∷ []) "Jas.1.8"
∷ word (ἐ ∷ ν ∷ []) "Jas.1.8"
∷ word (π ∷ ά ∷ σ ∷ α ∷ ι ∷ ς ∷ []) "Jas.1.8"
∷ word (τ ∷ α ∷ ῖ ∷ ς ∷ []) "Jas.1.8"
∷ word (ὁ ∷ δ ∷ ο ∷ ῖ ∷ ς ∷ []) "Jas.1.8"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.1.8"
∷ word (Κ ∷ α ∷ υ ∷ χ ∷ ά ∷ σ ∷ θ ∷ ω ∷ []) "Jas.1.9"
∷ word (δ ∷ ὲ ∷ []) "Jas.1.9"
∷ word (ὁ ∷ []) "Jas.1.9"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ὸ ∷ ς ∷ []) "Jas.1.9"
∷ word (ὁ ∷ []) "Jas.1.9"
∷ word (τ ∷ α ∷ π ∷ ε ∷ ι ∷ ν ∷ ὸ ∷ ς ∷ []) "Jas.1.9"
∷ word (ἐ ∷ ν ∷ []) "Jas.1.9"
∷ word (τ ∷ ῷ ∷ []) "Jas.1.9"
∷ word (ὕ ∷ ψ ∷ ε ∷ ι ∷ []) "Jas.1.9"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.1.9"
∷ word (ὁ ∷ []) "Jas.1.10"
∷ word (δ ∷ ὲ ∷ []) "Jas.1.10"
∷ word (π ∷ ∙λ ∷ ο ∷ ύ ∷ σ ∷ ι ∷ ο ∷ ς ∷ []) "Jas.1.10"
∷ word (ἐ ∷ ν ∷ []) "Jas.1.10"
∷ word (τ ∷ ῇ ∷ []) "Jas.1.10"
∷ word (τ ∷ α ∷ π ∷ ε ∷ ι ∷ ν ∷ ώ ∷ σ ∷ ε ∷ ι ∷ []) "Jas.1.10"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.1.10"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.1.10"
∷ word (ὡ ∷ ς ∷ []) "Jas.1.10"
∷ word (ἄ ∷ ν ∷ θ ∷ ο ∷ ς ∷ []) "Jas.1.10"
∷ word (χ ∷ ό ∷ ρ ∷ τ ∷ ο ∷ υ ∷ []) "Jas.1.10"
∷ word (π ∷ α ∷ ρ ∷ ε ∷ ∙λ ∷ ε ∷ ύ ∷ σ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.1.10"
∷ word (ἀ ∷ ν ∷ έ ∷ τ ∷ ε ∷ ι ∷ ∙λ ∷ ε ∷ ν ∷ []) "Jas.1.11"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.1.11"
∷ word (ὁ ∷ []) "Jas.1.11"
∷ word (ἥ ∷ ∙λ ∷ ι ∷ ο ∷ ς ∷ []) "Jas.1.11"
∷ word (σ ∷ ὺ ∷ ν ∷ []) "Jas.1.11"
∷ word (τ ∷ ῷ ∷ []) "Jas.1.11"
∷ word (κ ∷ α ∷ ύ ∷ σ ∷ ω ∷ ν ∷ ι ∷ []) "Jas.1.11"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.11"
∷ word (ἐ ∷ ξ ∷ ή ∷ ρ ∷ α ∷ ν ∷ ε ∷ ν ∷ []) "Jas.1.11"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.1.11"
∷ word (χ ∷ ό ∷ ρ ∷ τ ∷ ο ∷ ν ∷ []) "Jas.1.11"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.11"
∷ word (τ ∷ ὸ ∷ []) "Jas.1.11"
∷ word (ἄ ∷ ν ∷ θ ∷ ο ∷ ς ∷ []) "Jas.1.11"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.1.11"
∷ word (ἐ ∷ ξ ∷ έ ∷ π ∷ ε ∷ σ ∷ ε ∷ ν ∷ []) "Jas.1.11"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.11"
∷ word (ἡ ∷ []) "Jas.1.11"
∷ word (ε ∷ ὐ ∷ π ∷ ρ ∷ έ ∷ π ∷ ε ∷ ι ∷ α ∷ []) "Jas.1.11"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.1.11"
∷ word (π ∷ ρ ∷ ο ∷ σ ∷ ώ ∷ π ∷ ο ∷ υ ∷ []) "Jas.1.11"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.1.11"
∷ word (ἀ ∷ π ∷ ώ ∷ ∙λ ∷ ε ∷ τ ∷ ο ∷ []) "Jas.1.11"
∷ word (ο ∷ ὕ ∷ τ ∷ ω ∷ ς ∷ []) "Jas.1.11"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.11"
∷ word (ὁ ∷ []) "Jas.1.11"
∷ word (π ∷ ∙λ ∷ ο ∷ ύ ∷ σ ∷ ι ∷ ο ∷ ς ∷ []) "Jas.1.11"
∷ word (ἐ ∷ ν ∷ []) "Jas.1.11"
∷ word (τ ∷ α ∷ ῖ ∷ ς ∷ []) "Jas.1.11"
∷ word (π ∷ ο ∷ ρ ∷ ε ∷ ί ∷ α ∷ ι ∷ ς ∷ []) "Jas.1.11"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.1.11"
∷ word (μ ∷ α ∷ ρ ∷ α ∷ ν ∷ θ ∷ ή ∷ σ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.1.11"
∷ word (Μ ∷ α ∷ κ ∷ ά ∷ ρ ∷ ι ∷ ο ∷ ς ∷ []) "Jas.1.12"
∷ word (ἀ ∷ ν ∷ ὴ ∷ ρ ∷ []) "Jas.1.12"
∷ word (ὃ ∷ ς ∷ []) "Jas.1.12"
∷ word (ὑ ∷ π ∷ ο ∷ μ ∷ έ ∷ ν ∷ ε ∷ ι ∷ []) "Jas.1.12"
∷ word (π ∷ ε ∷ ι ∷ ρ ∷ α ∷ σ ∷ μ ∷ ό ∷ ν ∷ []) "Jas.1.12"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.1.12"
∷ word (δ ∷ ό ∷ κ ∷ ι ∷ μ ∷ ο ∷ ς ∷ []) "Jas.1.12"
∷ word (γ ∷ ε ∷ ν ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ς ∷ []) "Jas.1.12"
∷ word (∙λ ∷ ή ∷ μ ∷ ψ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.1.12"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.1.12"
∷ word (σ ∷ τ ∷ έ ∷ φ ∷ α ∷ ν ∷ ο ∷ ν ∷ []) "Jas.1.12"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.1.12"
∷ word (ζ ∷ ω ∷ ῆ ∷ ς ∷ []) "Jas.1.12"
∷ word (ὃ ∷ ν ∷ []) "Jas.1.12"
∷ word (ἐ ∷ π ∷ η ∷ γ ∷ γ ∷ ε ∷ ί ∷ ∙λ ∷ α ∷ τ ∷ ο ∷ []) "Jas.1.12"
∷ word (τ ∷ ο ∷ ῖ ∷ ς ∷ []) "Jas.1.12"
∷ word (ἀ ∷ γ ∷ α ∷ π ∷ ῶ ∷ σ ∷ ι ∷ ν ∷ []) "Jas.1.12"
∷ word (α ∷ ὐ ∷ τ ∷ ό ∷ ν ∷ []) "Jas.1.12"
∷ word (μ ∷ η ∷ δ ∷ ε ∷ ὶ ∷ ς ∷ []) "Jas.1.13"
∷ word (π ∷ ε ∷ ι ∷ ρ ∷ α ∷ ζ ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ς ∷ []) "Jas.1.13"
∷ word (∙λ ∷ ε ∷ γ ∷ έ ∷ τ ∷ ω ∷ []) "Jas.1.13"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.1.13"
∷ word (Ἀ ∷ π ∷ ὸ ∷ []) "Jas.1.13"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "Jas.1.13"
∷ word (π ∷ ε ∷ ι ∷ ρ ∷ ά ∷ ζ ∷ ο ∷ μ ∷ α ∷ ι ∷ []) "Jas.1.13"
∷ word (ὁ ∷ []) "Jas.1.13"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.1.13"
∷ word (θ ∷ ε ∷ ὸ ∷ ς ∷ []) "Jas.1.13"
∷ word (ἀ ∷ π ∷ ε ∷ ί ∷ ρ ∷ α ∷ σ ∷ τ ∷ ό ∷ ς ∷ []) "Jas.1.13"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.1.13"
∷ word (κ ∷ α ∷ κ ∷ ῶ ∷ ν ∷ []) "Jas.1.13"
∷ word (π ∷ ε ∷ ι ∷ ρ ∷ ά ∷ ζ ∷ ε ∷ ι ∷ []) "Jas.1.13"
∷ word (δ ∷ ὲ ∷ []) "Jas.1.13"
∷ word (α ∷ ὐ ∷ τ ∷ ὸ ∷ ς ∷ []) "Jas.1.13"
∷ word (ο ∷ ὐ ∷ δ ∷ έ ∷ ν ∷ α ∷ []) "Jas.1.13"
∷ word (ἕ ∷ κ ∷ α ∷ σ ∷ τ ∷ ο ∷ ς ∷ []) "Jas.1.14"
∷ word (δ ∷ ὲ ∷ []) "Jas.1.14"
∷ word (π ∷ ε ∷ ι ∷ ρ ∷ ά ∷ ζ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.1.14"
∷ word (ὑ ∷ π ∷ ὸ ∷ []) "Jas.1.14"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.1.14"
∷ word (ἰ ∷ δ ∷ ί ∷ α ∷ ς ∷ []) "Jas.1.14"
∷ word (ἐ ∷ π ∷ ι ∷ θ ∷ υ ∷ μ ∷ ί ∷ α ∷ ς ∷ []) "Jas.1.14"
∷ word (ἐ ∷ ξ ∷ ε ∷ ∙λ ∷ κ ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ς ∷ []) "Jas.1.14"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.14"
∷ word (δ ∷ ε ∷ ∙λ ∷ ε ∷ α ∷ ζ ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ς ∷ []) "Jas.1.14"
∷ word (ε ∷ ἶ ∷ τ ∷ α ∷ []) "Jas.1.15"
∷ word (ἡ ∷ []) "Jas.1.15"
∷ word (ἐ ∷ π ∷ ι ∷ θ ∷ υ ∷ μ ∷ ί ∷ α ∷ []) "Jas.1.15"
∷ word (σ ∷ υ ∷ ∙λ ∷ ∙λ ∷ α ∷ β ∷ ο ∷ ῦ ∷ σ ∷ α ∷ []) "Jas.1.15"
∷ word (τ ∷ ί ∷ κ ∷ τ ∷ ε ∷ ι ∷ []) "Jas.1.15"
∷ word (ἁ ∷ μ ∷ α ∷ ρ ∷ τ ∷ ί ∷ α ∷ ν ∷ []) "Jas.1.15"
∷ word (ἡ ∷ []) "Jas.1.15"
∷ word (δ ∷ ὲ ∷ []) "Jas.1.15"
∷ word (ἁ ∷ μ ∷ α ∷ ρ ∷ τ ∷ ί ∷ α ∷ []) "Jas.1.15"
∷ word (ἀ ∷ π ∷ ο ∷ τ ∷ ε ∷ ∙λ ∷ ε ∷ σ ∷ θ ∷ ε ∷ ῖ ∷ σ ∷ α ∷ []) "Jas.1.15"
∷ word (ἀ ∷ π ∷ ο ∷ κ ∷ ύ ∷ ε ∷ ι ∷ []) "Jas.1.15"
∷ word (θ ∷ ά ∷ ν ∷ α ∷ τ ∷ ο ∷ ν ∷ []) "Jas.1.15"
∷ word (μ ∷ ὴ ∷ []) "Jas.1.16"
∷ word (π ∷ ∙λ ∷ α ∷ ν ∷ ᾶ ∷ σ ∷ θ ∷ ε ∷ []) "Jas.1.16"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.1.16"
∷ word (μ ∷ ο ∷ υ ∷ []) "Jas.1.16"
∷ word (ἀ ∷ γ ∷ α ∷ π ∷ η ∷ τ ∷ ο ∷ ί ∷ []) "Jas.1.16"
∷ word (Π ∷ ᾶ ∷ σ ∷ α ∷ []) "Jas.1.17"
∷ word (δ ∷ ό ∷ σ ∷ ι ∷ ς ∷ []) "Jas.1.17"
∷ word (ἀ ∷ γ ∷ α ∷ θ ∷ ὴ ∷ []) "Jas.1.17"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.17"
∷ word (π ∷ ᾶ ∷ ν ∷ []) "Jas.1.17"
∷ word (δ ∷ ώ ∷ ρ ∷ η ∷ μ ∷ α ∷ []) "Jas.1.17"
∷ word (τ ∷ έ ∷ ∙λ ∷ ε ∷ ι ∷ ο ∷ ν ∷ []) "Jas.1.17"
∷ word (ἄ ∷ ν ∷ ω ∷ θ ∷ έ ∷ ν ∷ []) "Jas.1.17"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.1.17"
∷ word (κ ∷ α ∷ τ ∷ α ∷ β ∷ α ∷ ῖ ∷ ν ∷ ο ∷ ν ∷ []) "Jas.1.17"
∷ word (ἀ ∷ π ∷ ὸ ∷ []) "Jas.1.17"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.1.17"
∷ word (π ∷ α ∷ τ ∷ ρ ∷ ὸ ∷ ς ∷ []) "Jas.1.17"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "Jas.1.17"
∷ word (φ ∷ ώ ∷ τ ∷ ω ∷ ν ∷ []) "Jas.1.17"
∷ word (π ∷ α ∷ ρ ∷ []) "Jas.1.17"
∷ word (ᾧ ∷ []) "Jas.1.17"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.1.17"
∷ word (ἔ ∷ ν ∷ ι ∷ []) "Jas.1.17"
∷ word (π ∷ α ∷ ρ ∷ α ∷ ∙λ ∷ ∙λ ∷ α ∷ γ ∷ ὴ ∷ []) "Jas.1.17"
∷ word (ἢ ∷ []) "Jas.1.17"
∷ word (τ ∷ ρ ∷ ο ∷ π ∷ ῆ ∷ ς ∷ []) "Jas.1.17"
∷ word (ἀ ∷ π ∷ ο ∷ σ ∷ κ ∷ ί ∷ α ∷ σ ∷ μ ∷ α ∷ []) "Jas.1.17"
∷ word (β ∷ ο ∷ υ ∷ ∙λ ∷ η ∷ θ ∷ ε ∷ ὶ ∷ ς ∷ []) "Jas.1.18"
∷ word (ἀ ∷ π ∷ ε ∷ κ ∷ ύ ∷ η ∷ σ ∷ ε ∷ ν ∷ []) "Jas.1.18"
∷ word (ἡ ∷ μ ∷ ᾶ ∷ ς ∷ []) "Jas.1.18"
∷ word (∙λ ∷ ό ∷ γ ∷ ῳ ∷ []) "Jas.1.18"
∷ word (ἀ ∷ ∙λ ∷ η ∷ θ ∷ ε ∷ ί ∷ α ∷ ς ∷ []) "Jas.1.18"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.1.18"
∷ word (τ ∷ ὸ ∷ []) "Jas.1.18"
∷ word (ε ∷ ἶ ∷ ν ∷ α ∷ ι ∷ []) "Jas.1.18"
∷ word (ἡ ∷ μ ∷ ᾶ ∷ ς ∷ []) "Jas.1.18"
∷ word (ἀ ∷ π ∷ α ∷ ρ ∷ χ ∷ ή ∷ ν ∷ []) "Jas.1.18"
∷ word (τ ∷ ι ∷ ν ∷ α ∷ []) "Jas.1.18"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "Jas.1.18"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.1.18"
∷ word (κ ∷ τ ∷ ι ∷ σ ∷ μ ∷ ά ∷ τ ∷ ω ∷ ν ∷ []) "Jas.1.18"
∷ word (Ἴ ∷ σ ∷ τ ∷ ε ∷ []) "Jas.1.19"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.1.19"
∷ word (μ ∷ ο ∷ υ ∷ []) "Jas.1.19"
∷ word (ἀ ∷ γ ∷ α ∷ π ∷ η ∷ τ ∷ ο ∷ ί ∷ []) "Jas.1.19"
∷ word (ἔ ∷ σ ∷ τ ∷ ω ∷ []) "Jas.1.19"
∷ word (δ ∷ ὲ ∷ []) "Jas.1.19"
∷ word (π ∷ ᾶ ∷ ς ∷ []) "Jas.1.19"
∷ word (ἄ ∷ ν ∷ θ ∷ ρ ∷ ω ∷ π ∷ ο ∷ ς ∷ []) "Jas.1.19"
∷ word (τ ∷ α ∷ χ ∷ ὺ ∷ ς ∷ []) "Jas.1.19"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.1.19"
∷ word (τ ∷ ὸ ∷ []) "Jas.1.19"
∷ word (ἀ ∷ κ ∷ ο ∷ ῦ ∷ σ ∷ α ∷ ι ∷ []) "Jas.1.19"
∷ word (β ∷ ρ ∷ α ∷ δ ∷ ὺ ∷ ς ∷ []) "Jas.1.19"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.1.19"
∷ word (τ ∷ ὸ ∷ []) "Jas.1.19"
∷ word (∙λ ∷ α ∷ ∙λ ∷ ῆ ∷ σ ∷ α ∷ ι ∷ []) "Jas.1.19"
∷ word (β ∷ ρ ∷ α ∷ δ ∷ ὺ ∷ ς ∷ []) "Jas.1.19"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.1.19"
∷ word (ὀ ∷ ρ ∷ γ ∷ ή ∷ ν ∷ []) "Jas.1.19"
∷ word (ὀ ∷ ρ ∷ γ ∷ ὴ ∷ []) "Jas.1.20"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.1.20"
∷ word (ἀ ∷ ν ∷ δ ∷ ρ ∷ ὸ ∷ ς ∷ []) "Jas.1.20"
∷ word (δ ∷ ι ∷ κ ∷ α ∷ ι ∷ ο ∷ σ ∷ ύ ∷ ν ∷ η ∷ ν ∷ []) "Jas.1.20"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "Jas.1.20"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.1.20"
∷ word (ἐ ∷ ρ ∷ γ ∷ ά ∷ ζ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.1.20"
∷ word (δ ∷ ι ∷ ὸ ∷ []) "Jas.1.21"
∷ word (ἀ ∷ π ∷ ο ∷ θ ∷ έ ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "Jas.1.21"
∷ word (π ∷ ᾶ ∷ σ ∷ α ∷ ν ∷ []) "Jas.1.21"
∷ word (ῥ ∷ υ ∷ π ∷ α ∷ ρ ∷ ί ∷ α ∷ ν ∷ []) "Jas.1.21"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.21"
∷ word (π ∷ ε ∷ ρ ∷ ι ∷ σ ∷ σ ∷ ε ∷ ί ∷ α ∷ ν ∷ []) "Jas.1.21"
∷ word (κ ∷ α ∷ κ ∷ ί ∷ α ∷ ς ∷ []) "Jas.1.21"
∷ word (ἐ ∷ ν ∷ []) "Jas.1.21"
∷ word (π ∷ ρ ∷ α ∷ ΰ ∷ τ ∷ η ∷ τ ∷ ι ∷ []) "Jas.1.21"
∷ word (δ ∷ έ ∷ ξ ∷ α ∷ σ ∷ θ ∷ ε ∷ []) "Jas.1.21"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.1.21"
∷ word (ἔ ∷ μ ∷ φ ∷ υ ∷ τ ∷ ο ∷ ν ∷ []) "Jas.1.21"
∷ word (∙λ ∷ ό ∷ γ ∷ ο ∷ ν ∷ []) "Jas.1.21"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.1.21"
∷ word (δ ∷ υ ∷ ν ∷ ά ∷ μ ∷ ε ∷ ν ∷ ο ∷ ν ∷ []) "Jas.1.21"
∷ word (σ ∷ ῶ ∷ σ ∷ α ∷ ι ∷ []) "Jas.1.21"
∷ word (τ ∷ ὰ ∷ ς ∷ []) "Jas.1.21"
∷ word (ψ ∷ υ ∷ χ ∷ ὰ ∷ ς ∷ []) "Jas.1.21"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.1.21"
∷ word (Γ ∷ ί ∷ ν ∷ ε ∷ σ ∷ θ ∷ ε ∷ []) "Jas.1.22"
∷ word (δ ∷ ὲ ∷ []) "Jas.1.22"
∷ word (π ∷ ο ∷ ι ∷ η ∷ τ ∷ α ∷ ὶ ∷ []) "Jas.1.22"
∷ word (∙λ ∷ ό ∷ γ ∷ ο ∷ υ ∷ []) "Jas.1.22"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.22"
∷ word (μ ∷ ὴ ∷ []) "Jas.1.22"
∷ word (ἀ ∷ κ ∷ ρ ∷ ο ∷ α ∷ τ ∷ α ∷ ὶ ∷ []) "Jas.1.22"
∷ word (μ ∷ ό ∷ ν ∷ ο ∷ ν ∷ []) "Jas.1.22"
∷ word (π ∷ α ∷ ρ ∷ α ∷ ∙λ ∷ ο ∷ γ ∷ ι ∷ ζ ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "Jas.1.22"
∷ word (ἑ ∷ α ∷ υ ∷ τ ∷ ο ∷ ύ ∷ ς ∷ []) "Jas.1.22"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.1.23"
∷ word (ε ∷ ἴ ∷ []) "Jas.1.23"
∷ word (τ ∷ ι ∷ ς ∷ []) "Jas.1.23"
∷ word (ἀ ∷ κ ∷ ρ ∷ ο ∷ α ∷ τ ∷ ὴ ∷ ς ∷ []) "Jas.1.23"
∷ word (∙λ ∷ ό ∷ γ ∷ ο ∷ υ ∷ []) "Jas.1.23"
∷ word (ἐ ∷ σ ∷ τ ∷ ὶ ∷ ν ∷ []) "Jas.1.23"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.23"
∷ word (ο ∷ ὐ ∷ []) "Jas.1.23"
∷ word (π ∷ ο ∷ ι ∷ η ∷ τ ∷ ή ∷ ς ∷ []) "Jas.1.23"
∷ word (ο ∷ ὗ ∷ τ ∷ ο ∷ ς ∷ []) "Jas.1.23"
∷ word (ἔ ∷ ο ∷ ι ∷ κ ∷ ε ∷ ν ∷ []) "Jas.1.23"
∷ word (ἀ ∷ ν ∷ δ ∷ ρ ∷ ὶ ∷ []) "Jas.1.23"
∷ word (κ ∷ α ∷ τ ∷ α ∷ ν ∷ ο ∷ ο ∷ ῦ ∷ ν ∷ τ ∷ ι ∷ []) "Jas.1.23"
∷ word (τ ∷ ὸ ∷ []) "Jas.1.23"
∷ word (π ∷ ρ ∷ ό ∷ σ ∷ ω ∷ π ∷ ο ∷ ν ∷ []) "Jas.1.23"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.1.23"
∷ word (γ ∷ ε ∷ ν ∷ έ ∷ σ ∷ ε ∷ ω ∷ ς ∷ []) "Jas.1.23"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.1.23"
∷ word (ἐ ∷ ν ∷ []) "Jas.1.23"
∷ word (ἐ ∷ σ ∷ ό ∷ π ∷ τ ∷ ρ ∷ ῳ ∷ []) "Jas.1.23"
∷ word (κ ∷ α ∷ τ ∷ ε ∷ ν ∷ ό ∷ η ∷ σ ∷ ε ∷ ν ∷ []) "Jas.1.24"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.1.24"
∷ word (ἑ ∷ α ∷ υ ∷ τ ∷ ὸ ∷ ν ∷ []) "Jas.1.24"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.24"
∷ word (ἀ ∷ π ∷ ε ∷ ∙λ ∷ ή ∷ ∙λ ∷ υ ∷ θ ∷ ε ∷ ν ∷ []) "Jas.1.24"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.24"
∷ word (ε ∷ ὐ ∷ θ ∷ έ ∷ ω ∷ ς ∷ []) "Jas.1.24"
∷ word (ἐ ∷ π ∷ ε ∷ ∙λ ∷ ά ∷ θ ∷ ε ∷ τ ∷ ο ∷ []) "Jas.1.24"
∷ word (ὁ ∷ π ∷ ο ∷ ῖ ∷ ο ∷ ς ∷ []) "Jas.1.24"
∷ word (ἦ ∷ ν ∷ []) "Jas.1.24"
∷ word (ὁ ∷ []) "Jas.1.25"
∷ word (δ ∷ ὲ ∷ []) "Jas.1.25"
∷ word (π ∷ α ∷ ρ ∷ α ∷ κ ∷ ύ ∷ ψ ∷ α ∷ ς ∷ []) "Jas.1.25"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.1.25"
∷ word (ν ∷ ό ∷ μ ∷ ο ∷ ν ∷ []) "Jas.1.25"
∷ word (τ ∷ έ ∷ ∙λ ∷ ε ∷ ι ∷ ο ∷ ν ∷ []) "Jas.1.25"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.1.25"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.1.25"
∷ word (ἐ ∷ ∙λ ∷ ε ∷ υ ∷ θ ∷ ε ∷ ρ ∷ ί ∷ α ∷ ς ∷ []) "Jas.1.25"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.25"
∷ word (π ∷ α ∷ ρ ∷ α ∷ μ ∷ ε ∷ ί ∷ ν ∷ α ∷ ς ∷ []) "Jas.1.25"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.1.25"
∷ word (ἀ ∷ κ ∷ ρ ∷ ο ∷ α ∷ τ ∷ ὴ ∷ ς ∷ []) "Jas.1.25"
∷ word (ἐ ∷ π ∷ ι ∷ ∙λ ∷ η ∷ σ ∷ μ ∷ ο ∷ ν ∷ ῆ ∷ ς ∷ []) "Jas.1.25"
∷ word (γ ∷ ε ∷ ν ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ς ∷ []) "Jas.1.25"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ ὰ ∷ []) "Jas.1.25"
∷ word (π ∷ ο ∷ ι ∷ η ∷ τ ∷ ὴ ∷ ς ∷ []) "Jas.1.25"
∷ word (ἔ ∷ ρ ∷ γ ∷ ο ∷ υ ∷ []) "Jas.1.25"
∷ word (ο ∷ ὗ ∷ τ ∷ ο ∷ ς ∷ []) "Jas.1.25"
∷ word (μ ∷ α ∷ κ ∷ ά ∷ ρ ∷ ι ∷ ο ∷ ς ∷ []) "Jas.1.25"
∷ word (ἐ ∷ ν ∷ []) "Jas.1.25"
∷ word (τ ∷ ῇ ∷ []) "Jas.1.25"
∷ word (π ∷ ο ∷ ι ∷ ή ∷ σ ∷ ε ∷ ι ∷ []) "Jas.1.25"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.1.25"
∷ word (ἔ ∷ σ ∷ τ ∷ α ∷ ι ∷ []) "Jas.1.25"
∷ word (Ε ∷ ἴ ∷ []) "Jas.1.26"
∷ word (τ ∷ ι ∷ ς ∷ []) "Jas.1.26"
∷ word (δ ∷ ο ∷ κ ∷ ε ∷ ῖ ∷ []) "Jas.1.26"
∷ word (θ ∷ ρ ∷ η ∷ σ ∷ κ ∷ ὸ ∷ ς ∷ []) "Jas.1.26"
∷ word (ε ∷ ἶ ∷ ν ∷ α ∷ ι ∷ []) "Jas.1.26"
∷ word (μ ∷ ὴ ∷ []) "Jas.1.26"
∷ word (χ ∷ α ∷ ∙λ ∷ ι ∷ ν ∷ α ∷ γ ∷ ω ∷ γ ∷ ῶ ∷ ν ∷ []) "Jas.1.26"
∷ word (γ ∷ ∙λ ∷ ῶ ∷ σ ∷ σ ∷ α ∷ ν ∷ []) "Jas.1.26"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.1.26"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ ὰ ∷ []) "Jas.1.26"
∷ word (ἀ ∷ π ∷ α ∷ τ ∷ ῶ ∷ ν ∷ []) "Jas.1.26"
∷ word (κ ∷ α ∷ ρ ∷ δ ∷ ί ∷ α ∷ ν ∷ []) "Jas.1.26"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.1.26"
∷ word (τ ∷ ο ∷ ύ ∷ τ ∷ ο ∷ υ ∷ []) "Jas.1.26"
∷ word (μ ∷ ά ∷ τ ∷ α ∷ ι ∷ ο ∷ ς ∷ []) "Jas.1.26"
∷ word (ἡ ∷ []) "Jas.1.26"
∷ word (θ ∷ ρ ∷ η ∷ σ ∷ κ ∷ ε ∷ ί ∷ α ∷ []) "Jas.1.26"
∷ word (θ ∷ ρ ∷ η ∷ σ ∷ κ ∷ ε ∷ ί ∷ α ∷ []) "Jas.1.27"
∷ word (κ ∷ α ∷ θ ∷ α ∷ ρ ∷ ὰ ∷ []) "Jas.1.27"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.27"
∷ word (ἀ ∷ μ ∷ ί ∷ α ∷ ν ∷ τ ∷ ο ∷ ς ∷ []) "Jas.1.27"
∷ word (π ∷ α ∷ ρ ∷ ὰ ∷ []) "Jas.1.27"
∷ word (τ ∷ ῷ ∷ []) "Jas.1.27"
∷ word (θ ∷ ε ∷ ῷ ∷ []) "Jas.1.27"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.27"
∷ word (π ∷ α ∷ τ ∷ ρ ∷ ὶ ∷ []) "Jas.1.27"
∷ word (α ∷ ὕ ∷ τ ∷ η ∷ []) "Jas.1.27"
∷ word (ἐ ∷ σ ∷ τ ∷ ί ∷ ν ∷ []) "Jas.1.27"
∷ word (ἐ ∷ π ∷ ι ∷ σ ∷ κ ∷ έ ∷ π ∷ τ ∷ ε ∷ σ ∷ θ ∷ α ∷ ι ∷ []) "Jas.1.27"
∷ word (ὀ ∷ ρ ∷ φ ∷ α ∷ ν ∷ ο ∷ ὺ ∷ ς ∷ []) "Jas.1.27"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.1.27"
∷ word (χ ∷ ή ∷ ρ ∷ α ∷ ς ∷ []) "Jas.1.27"
∷ word (ἐ ∷ ν ∷ []) "Jas.1.27"
∷ word (τ ∷ ῇ ∷ []) "Jas.1.27"
∷ word (θ ∷ ∙λ ∷ ί ∷ ψ ∷ ε ∷ ι ∷ []) "Jas.1.27"
∷ word (α ∷ ὐ ∷ τ ∷ ῶ ∷ ν ∷ []) "Jas.1.27"
∷ word (ἄ ∷ σ ∷ π ∷ ι ∷ ∙λ ∷ ο ∷ ν ∷ []) "Jas.1.27"
∷ word (ἑ ∷ α ∷ υ ∷ τ ∷ ὸ ∷ ν ∷ []) "Jas.1.27"
∷ word (τ ∷ η ∷ ρ ∷ ε ∷ ῖ ∷ ν ∷ []) "Jas.1.27"
∷ word (ἀ ∷ π ∷ ὸ ∷ []) "Jas.1.27"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.1.27"
∷ word (κ ∷ ό ∷ σ ∷ μ ∷ ο ∷ υ ∷ []) "Jas.1.27"
∷ word (Ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.2.1"
∷ word (μ ∷ ο ∷ υ ∷ []) "Jas.2.1"
∷ word (μ ∷ ὴ ∷ []) "Jas.2.1"
∷ word (ἐ ∷ ν ∷ []) "Jas.2.1"
∷ word (π ∷ ρ ∷ ο ∷ σ ∷ ω ∷ π ∷ ο ∷ ∙λ ∷ η ∷ μ ∷ ψ ∷ ί ∷ α ∷ ι ∷ ς ∷ []) "Jas.2.1"
∷ word (ἔ ∷ χ ∷ ε ∷ τ ∷ ε ∷ []) "Jas.2.1"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "Jas.2.1"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.2.1"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.2.1"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "Jas.2.1"
∷ word (ἡ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.2.1"
∷ word (Ἰ ∷ η ∷ σ ∷ ο ∷ ῦ ∷ []) "Jas.2.1"
∷ word (Χ ∷ ρ ∷ ι ∷ σ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.2.1"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.2.1"
∷ word (δ ∷ ό ∷ ξ ∷ η ∷ ς ∷ []) "Jas.2.1"
∷ word (ἐ ∷ ὰ ∷ ν ∷ []) "Jas.2.2"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.2.2"
∷ word (ε ∷ ἰ ∷ σ ∷ έ ∷ ∙λ ∷ θ ∷ ῃ ∷ []) "Jas.2.2"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.2.2"
∷ word (σ ∷ υ ∷ ν ∷ α ∷ γ ∷ ω ∷ γ ∷ ὴ ∷ ν ∷ []) "Jas.2.2"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.2.2"
∷ word (ἀ ∷ ν ∷ ὴ ∷ ρ ∷ []) "Jas.2.2"
∷ word (χ ∷ ρ ∷ υ ∷ σ ∷ ο ∷ δ ∷ α ∷ κ ∷ τ ∷ ύ ∷ ∙λ ∷ ι ∷ ο ∷ ς ∷ []) "Jas.2.2"
∷ word (ἐ ∷ ν ∷ []) "Jas.2.2"
∷ word (ἐ ∷ σ ∷ θ ∷ ῆ ∷ τ ∷ ι ∷ []) "Jas.2.2"
∷ word (∙λ ∷ α ∷ μ ∷ π ∷ ρ ∷ ᾷ ∷ []) "Jas.2.2"
∷ word (ε ∷ ἰ ∷ σ ∷ έ ∷ ∙λ ∷ θ ∷ ῃ ∷ []) "Jas.2.2"
∷ word (δ ∷ ὲ ∷ []) "Jas.2.2"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.2"
∷ word (π ∷ τ ∷ ω ∷ χ ∷ ὸ ∷ ς ∷ []) "Jas.2.2"
∷ word (ἐ ∷ ν ∷ []) "Jas.2.2"
∷ word (ῥ ∷ υ ∷ π ∷ α ∷ ρ ∷ ᾷ ∷ []) "Jas.2.2"
∷ word (ἐ ∷ σ ∷ θ ∷ ῆ ∷ τ ∷ ι ∷ []) "Jas.2.2"
∷ word (ἐ ∷ π ∷ ι ∷ β ∷ ∙λ ∷ έ ∷ ψ ∷ η ∷ τ ∷ ε ∷ []) "Jas.2.3"
∷ word (δ ∷ ὲ ∷ []) "Jas.2.3"
∷ word (ἐ ∷ π ∷ ὶ ∷ []) "Jas.2.3"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.2.3"
∷ word (φ ∷ ο ∷ ρ ∷ ο ∷ ῦ ∷ ν ∷ τ ∷ α ∷ []) "Jas.2.3"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "Jas.2.3"
∷ word (ἐ ∷ σ ∷ θ ∷ ῆ ∷ τ ∷ α ∷ []) "Jas.2.3"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "Jas.2.3"
∷ word (∙λ ∷ α ∷ μ ∷ π ∷ ρ ∷ ὰ ∷ ν ∷ []) "Jas.2.3"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.3"
∷ word (ε ∷ ἴ ∷ π ∷ η ∷ τ ∷ ε ∷ []) "Jas.2.3"
∷ word (Σ ∷ ὺ ∷ []) "Jas.2.3"
∷ word (κ ∷ ά ∷ θ ∷ ο ∷ υ ∷ []) "Jas.2.3"
∷ word (ὧ ∷ δ ∷ ε ∷ []) "Jas.2.3"
∷ word (κ ∷ α ∷ ∙λ ∷ ῶ ∷ ς ∷ []) "Jas.2.3"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.3"
∷ word (τ ∷ ῷ ∷ []) "Jas.2.3"
∷ word (π ∷ τ ∷ ω ∷ χ ∷ ῷ ∷ []) "Jas.2.3"
∷ word (ε ∷ ἴ ∷ π ∷ η ∷ τ ∷ ε ∷ []) "Jas.2.3"
∷ word (Σ ∷ ὺ ∷ []) "Jas.2.3"
∷ word (σ ∷ τ ∷ ῆ ∷ θ ∷ ι ∷ []) "Jas.2.3"
∷ word (ἢ ∷ []) "Jas.2.3"
∷ word (κ ∷ ά ∷ θ ∷ ο ∷ υ ∷ []) "Jas.2.3"
∷ word (ἐ ∷ κ ∷ ε ∷ ῖ ∷ []) "Jas.2.3"
∷ word (ὑ ∷ π ∷ ὸ ∷ []) "Jas.2.3"
∷ word (τ ∷ ὸ ∷ []) "Jas.2.3"
∷ word (ὑ ∷ π ∷ ο ∷ π ∷ ό ∷ δ ∷ ι ∷ ό ∷ ν ∷ []) "Jas.2.3"
∷ word (μ ∷ ο ∷ υ ∷ []) "Jas.2.3"
∷ word (ο ∷ ὐ ∷ []) "Jas.2.4"
∷ word (δ ∷ ι ∷ ε ∷ κ ∷ ρ ∷ ί ∷ θ ∷ η ∷ τ ∷ ε ∷ []) "Jas.2.4"
∷ word (ἐ ∷ ν ∷ []) "Jas.2.4"
∷ word (ἑ ∷ α ∷ υ ∷ τ ∷ ο ∷ ῖ ∷ ς ∷ []) "Jas.2.4"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.4"
∷ word (ἐ ∷ γ ∷ έ ∷ ν ∷ ε ∷ σ ∷ θ ∷ ε ∷ []) "Jas.2.4"
∷ word (κ ∷ ρ ∷ ι ∷ τ ∷ α ∷ ὶ ∷ []) "Jas.2.4"
∷ word (δ ∷ ι ∷ α ∷ ∙λ ∷ ο ∷ γ ∷ ι ∷ σ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.2.4"
∷ word (π ∷ ο ∷ ν ∷ η ∷ ρ ∷ ῶ ∷ ν ∷ []) "Jas.2.4"
∷ word (ἀ ∷ κ ∷ ο ∷ ύ ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.2.5"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.2.5"
∷ word (μ ∷ ο ∷ υ ∷ []) "Jas.2.5"
∷ word (ἀ ∷ γ ∷ α ∷ π ∷ η ∷ τ ∷ ο ∷ ί ∷ []) "Jas.2.5"
∷ word (ο ∷ ὐ ∷ χ ∷ []) "Jas.2.5"
∷ word (ὁ ∷ []) "Jas.2.5"
∷ word (θ ∷ ε ∷ ὸ ∷ ς ∷ []) "Jas.2.5"
∷ word (ἐ ∷ ξ ∷ ε ∷ ∙λ ∷ έ ∷ ξ ∷ α ∷ τ ∷ ο ∷ []) "Jas.2.5"
∷ word (τ ∷ ο ∷ ὺ ∷ ς ∷ []) "Jas.2.5"
∷ word (π ∷ τ ∷ ω ∷ χ ∷ ο ∷ ὺ ∷ ς ∷ []) "Jas.2.5"
∷ word (τ ∷ ῷ ∷ []) "Jas.2.5"
∷ word (κ ∷ ό ∷ σ ∷ μ ∷ ῳ ∷ []) "Jas.2.5"
∷ word (π ∷ ∙λ ∷ ο ∷ υ ∷ σ ∷ ί ∷ ο ∷ υ ∷ ς ∷ []) "Jas.2.5"
∷ word (ἐ ∷ ν ∷ []) "Jas.2.5"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ε ∷ ι ∷ []) "Jas.2.5"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.5"
∷ word (κ ∷ ∙λ ∷ η ∷ ρ ∷ ο ∷ ν ∷ ό ∷ μ ∷ ο ∷ υ ∷ ς ∷ []) "Jas.2.5"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.2.5"
∷ word (β ∷ α ∷ σ ∷ ι ∷ ∙λ ∷ ε ∷ ί ∷ α ∷ ς ∷ []) "Jas.2.5"
∷ word (ἧ ∷ ς ∷ []) "Jas.2.5"
∷ word (ἐ ∷ π ∷ η ∷ γ ∷ γ ∷ ε ∷ ί ∷ ∙λ ∷ α ∷ τ ∷ ο ∷ []) "Jas.2.5"
∷ word (τ ∷ ο ∷ ῖ ∷ ς ∷ []) "Jas.2.5"
∷ word (ἀ ∷ γ ∷ α ∷ π ∷ ῶ ∷ σ ∷ ι ∷ ν ∷ []) "Jas.2.5"
∷ word (α ∷ ὐ ∷ τ ∷ ό ∷ ν ∷ []) "Jas.2.5"
∷ word (ὑ ∷ μ ∷ ε ∷ ῖ ∷ ς ∷ []) "Jas.2.6"
∷ word (δ ∷ ὲ ∷ []) "Jas.2.6"
∷ word (ἠ ∷ τ ∷ ι ∷ μ ∷ ά ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.2.6"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.2.6"
∷ word (π ∷ τ ∷ ω ∷ χ ∷ ό ∷ ν ∷ []) "Jas.2.6"
∷ word (ο ∷ ὐ ∷ χ ∷ []) "Jas.2.6"
∷ word (ο ∷ ἱ ∷ []) "Jas.2.6"
∷ word (π ∷ ∙λ ∷ ο ∷ ύ ∷ σ ∷ ι ∷ ο ∷ ι ∷ []) "Jas.2.6"
∷ word (κ ∷ α ∷ τ ∷ α ∷ δ ∷ υ ∷ ν ∷ α ∷ σ ∷ τ ∷ ε ∷ ύ ∷ ο ∷ υ ∷ σ ∷ ι ∷ ν ∷ []) "Jas.2.6"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.2.6"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.6"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ὶ ∷ []) "Jas.2.6"
∷ word (ἕ ∷ ∙λ ∷ κ ∷ ο ∷ υ ∷ σ ∷ ι ∷ ν ∷ []) "Jas.2.6"
∷ word (ὑ ∷ μ ∷ ᾶ ∷ ς ∷ []) "Jas.2.6"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.2.6"
∷ word (κ ∷ ρ ∷ ι ∷ τ ∷ ή ∷ ρ ∷ ι ∷ α ∷ []) "Jas.2.6"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.2.7"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ὶ ∷ []) "Jas.2.7"
∷ word (β ∷ ∙λ ∷ α ∷ σ ∷ φ ∷ η ∷ μ ∷ ο ∷ ῦ ∷ σ ∷ ι ∷ ν ∷ []) "Jas.2.7"
∷ word (τ ∷ ὸ ∷ []) "Jas.2.7"
∷ word (κ ∷ α ∷ ∙λ ∷ ὸ ∷ ν ∷ []) "Jas.2.7"
∷ word (ὄ ∷ ν ∷ ο ∷ μ ∷ α ∷ []) "Jas.2.7"
∷ word (τ ∷ ὸ ∷ []) "Jas.2.7"
∷ word (ἐ ∷ π ∷ ι ∷ κ ∷ ∙λ ∷ η ∷ θ ∷ ὲ ∷ ν ∷ []) "Jas.2.7"
∷ word (ἐ ∷ φ ∷ []) "Jas.2.7"
∷ word (ὑ ∷ μ ∷ ᾶ ∷ ς ∷ []) "Jas.2.7"
∷ word (Ε ∷ ἰ ∷ []) "Jas.2.8"
∷ word (μ ∷ έ ∷ ν ∷ τ ∷ ο ∷ ι ∷ []) "Jas.2.8"
∷ word (ν ∷ ό ∷ μ ∷ ο ∷ ν ∷ []) "Jas.2.8"
∷ word (τ ∷ ε ∷ ∙λ ∷ ε ∷ ῖ ∷ τ ∷ ε ∷ []) "Jas.2.8"
∷ word (β ∷ α ∷ σ ∷ ι ∷ ∙λ ∷ ι ∷ κ ∷ ὸ ∷ ν ∷ []) "Jas.2.8"
∷ word (κ ∷ α ∷ τ ∷ ὰ ∷ []) "Jas.2.8"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "Jas.2.8"
∷ word (γ ∷ ρ ∷ α ∷ φ ∷ ή ∷ ν ∷ []) "Jas.2.8"
∷ word (Ἀ ∷ γ ∷ α ∷ π ∷ ή ∷ σ ∷ ε ∷ ι ∷ ς ∷ []) "Jas.2.8"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.2.8"
∷ word (π ∷ ∙λ ∷ η ∷ σ ∷ ί ∷ ο ∷ ν ∷ []) "Jas.2.8"
∷ word (σ ∷ ο ∷ υ ∷ []) "Jas.2.8"
∷ word (ὡ ∷ ς ∷ []) "Jas.2.8"
∷ word (σ ∷ ε ∷ α ∷ υ ∷ τ ∷ ό ∷ ν ∷ []) "Jas.2.8"
∷ word (κ ∷ α ∷ ∙λ ∷ ῶ ∷ ς ∷ []) "Jas.2.8"
∷ word (π ∷ ο ∷ ι ∷ ε ∷ ῖ ∷ τ ∷ ε ∷ []) "Jas.2.8"
∷ word (ε ∷ ἰ ∷ []) "Jas.2.9"
∷ word (δ ∷ ὲ ∷ []) "Jas.2.9"
∷ word (π ∷ ρ ∷ ο ∷ σ ∷ ω ∷ π ∷ ο ∷ ∙λ ∷ η ∷ μ ∷ π ∷ τ ∷ ε ∷ ῖ ∷ τ ∷ ε ∷ []) "Jas.2.9"
∷ word (ἁ ∷ μ ∷ α ∷ ρ ∷ τ ∷ ί ∷ α ∷ ν ∷ []) "Jas.2.9"
∷ word (ἐ ∷ ρ ∷ γ ∷ ά ∷ ζ ∷ ε ∷ σ ∷ θ ∷ ε ∷ []) "Jas.2.9"
∷ word (ἐ ∷ ∙λ ∷ ε ∷ γ ∷ χ ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "Jas.2.9"
∷ word (ὑ ∷ π ∷ ὸ ∷ []) "Jas.2.9"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.2.9"
∷ word (ν ∷ ό ∷ μ ∷ ο ∷ υ ∷ []) "Jas.2.9"
∷ word (ὡ ∷ ς ∷ []) "Jas.2.9"
∷ word (π ∷ α ∷ ρ ∷ α ∷ β ∷ ά ∷ τ ∷ α ∷ ι ∷ []) "Jas.2.9"
∷ word (ὅ ∷ σ ∷ τ ∷ ι ∷ ς ∷ []) "Jas.2.10"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.2.10"
∷ word (ὅ ∷ ∙λ ∷ ο ∷ ν ∷ []) "Jas.2.10"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.2.10"
∷ word (ν ∷ ό ∷ μ ∷ ο ∷ ν ∷ []) "Jas.2.10"
∷ word (τ ∷ η ∷ ρ ∷ ή ∷ σ ∷ ῃ ∷ []) "Jas.2.10"
∷ word (π ∷ τ ∷ α ∷ ί ∷ σ ∷ ῃ ∷ []) "Jas.2.10"
∷ word (δ ∷ ὲ ∷ []) "Jas.2.10"
∷ word (ἐ ∷ ν ∷ []) "Jas.2.10"
∷ word (ἑ ∷ ν ∷ ί ∷ []) "Jas.2.10"
∷ word (γ ∷ έ ∷ γ ∷ ο ∷ ν ∷ ε ∷ ν ∷ []) "Jas.2.10"
∷ word (π ∷ ά ∷ ν ∷ τ ∷ ω ∷ ν ∷ []) "Jas.2.10"
∷ word (ἔ ∷ ν ∷ ο ∷ χ ∷ ο ∷ ς ∷ []) "Jas.2.10"
∷ word (ὁ ∷ []) "Jas.2.11"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.2.11"
∷ word (ε ∷ ἰ ∷ π ∷ ώ ∷ ν ∷ []) "Jas.2.11"
∷ word (Μ ∷ ὴ ∷ []) "Jas.2.11"
∷ word (μ ∷ ο ∷ ι ∷ χ ∷ ε ∷ ύ ∷ σ ∷ ῃ ∷ ς ∷ []) "Jas.2.11"
∷ word (ε ∷ ἶ ∷ π ∷ ε ∷ ν ∷ []) "Jas.2.11"
∷ word (κ ∷ α ∷ ί ∷ []) "Jas.2.11"
∷ word (Μ ∷ ὴ ∷ []) "Jas.2.11"
∷ word (φ ∷ ο ∷ ν ∷ ε ∷ ύ ∷ σ ∷ ῃ ∷ ς ∷ []) "Jas.2.11"
∷ word (ε ∷ ἰ ∷ []) "Jas.2.11"
∷ word (δ ∷ ὲ ∷ []) "Jas.2.11"
∷ word (ο ∷ ὐ ∷ []) "Jas.2.11"
∷ word (μ ∷ ο ∷ ι ∷ χ ∷ ε ∷ ύ ∷ ε ∷ ι ∷ ς ∷ []) "Jas.2.11"
∷ word (φ ∷ ο ∷ ν ∷ ε ∷ ύ ∷ ε ∷ ι ∷ ς ∷ []) "Jas.2.11"
∷ word (δ ∷ έ ∷ []) "Jas.2.11"
∷ word (γ ∷ έ ∷ γ ∷ ο ∷ ν ∷ α ∷ ς ∷ []) "Jas.2.11"
∷ word (π ∷ α ∷ ρ ∷ α ∷ β ∷ ά ∷ τ ∷ η ∷ ς ∷ []) "Jas.2.11"
∷ word (ν ∷ ό ∷ μ ∷ ο ∷ υ ∷ []) "Jas.2.11"
∷ word (ο ∷ ὕ ∷ τ ∷ ω ∷ ς ∷ []) "Jas.2.12"
∷ word (∙λ ∷ α ∷ ∙λ ∷ ε ∷ ῖ ∷ τ ∷ ε ∷ []) "Jas.2.12"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.12"
∷ word (ο ∷ ὕ ∷ τ ∷ ω ∷ ς ∷ []) "Jas.2.12"
∷ word (π ∷ ο ∷ ι ∷ ε ∷ ῖ ∷ τ ∷ ε ∷ []) "Jas.2.12"
∷ word (ὡ ∷ ς ∷ []) "Jas.2.12"
∷ word (δ ∷ ι ∷ ὰ ∷ []) "Jas.2.12"
∷ word (ν ∷ ό ∷ μ ∷ ο ∷ υ ∷ []) "Jas.2.12"
∷ word (ἐ ∷ ∙λ ∷ ε ∷ υ ∷ θ ∷ ε ∷ ρ ∷ ί ∷ α ∷ ς ∷ []) "Jas.2.12"
∷ word (μ ∷ έ ∷ ∙λ ∷ ∙λ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "Jas.2.12"
∷ word (κ ∷ ρ ∷ ί ∷ ν ∷ ε ∷ σ ∷ θ ∷ α ∷ ι ∷ []) "Jas.2.12"
∷ word (ἡ ∷ []) "Jas.2.13"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.2.13"
∷ word (κ ∷ ρ ∷ ί ∷ σ ∷ ι ∷ ς ∷ []) "Jas.2.13"
∷ word (ἀ ∷ ν ∷ έ ∷ ∙λ ∷ ε ∷ ο ∷ ς ∷ []) "Jas.2.13"
∷ word (τ ∷ ῷ ∷ []) "Jas.2.13"
∷ word (μ ∷ ὴ ∷ []) "Jas.2.13"
∷ word (π ∷ ο ∷ ι ∷ ή ∷ σ ∷ α ∷ ν ∷ τ ∷ ι ∷ []) "Jas.2.13"
∷ word (ἔ ∷ ∙λ ∷ ε ∷ ο ∷ ς ∷ []) "Jas.2.13"
∷ word (κ ∷ α ∷ τ ∷ α ∷ κ ∷ α ∷ υ ∷ χ ∷ ᾶ ∷ τ ∷ α ∷ ι ∷ []) "Jas.2.13"
∷ word (ἔ ∷ ∙λ ∷ ε ∷ ο ∷ ς ∷ []) "Jas.2.13"
∷ word (κ ∷ ρ ∷ ί ∷ σ ∷ ε ∷ ω ∷ ς ∷ []) "Jas.2.13"
∷ word (Τ ∷ ί ∷ []) "Jas.2.14"
∷ word (ὄ ∷ φ ∷ ε ∷ ∙λ ∷ ο ∷ ς ∷ []) "Jas.2.14"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.2.14"
∷ word (μ ∷ ο ∷ υ ∷ []) "Jas.2.14"
∷ word (ἐ ∷ ὰ ∷ ν ∷ []) "Jas.2.14"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.2.14"
∷ word (∙λ ∷ έ ∷ γ ∷ ῃ ∷ []) "Jas.2.14"
∷ word (τ ∷ ι ∷ ς ∷ []) "Jas.2.14"
∷ word (ἔ ∷ χ ∷ ε ∷ ι ∷ ν ∷ []) "Jas.2.14"
∷ word (ἔ ∷ ρ ∷ γ ∷ α ∷ []) "Jas.2.14"
∷ word (δ ∷ ὲ ∷ []) "Jas.2.14"
∷ word (μ ∷ ὴ ∷ []) "Jas.2.14"
∷ word (ἔ ∷ χ ∷ ῃ ∷ []) "Jas.2.14"
∷ word (μ ∷ ὴ ∷ []) "Jas.2.14"
∷ word (δ ∷ ύ ∷ ν ∷ α ∷ τ ∷ α ∷ ι ∷ []) "Jas.2.14"
∷ word (ἡ ∷ []) "Jas.2.14"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ι ∷ ς ∷ []) "Jas.2.14"
∷ word (σ ∷ ῶ ∷ σ ∷ α ∷ ι ∷ []) "Jas.2.14"
∷ word (α ∷ ὐ ∷ τ ∷ ό ∷ ν ∷ []) "Jas.2.14"
∷ word (ἐ ∷ ὰ ∷ ν ∷ []) "Jas.2.15"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ὸ ∷ ς ∷ []) "Jas.2.15"
∷ word (ἢ ∷ []) "Jas.2.15"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ὴ ∷ []) "Jas.2.15"
∷ word (γ ∷ υ ∷ μ ∷ ν ∷ ο ∷ ὶ ∷ []) "Jas.2.15"
∷ word (ὑ ∷ π ∷ ά ∷ ρ ∷ χ ∷ ω ∷ σ ∷ ι ∷ ν ∷ []) "Jas.2.15"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.15"
∷ word (∙λ ∷ ε ∷ ι ∷ π ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "Jas.2.15"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.2.15"
∷ word (ἐ ∷ φ ∷ η ∷ μ ∷ έ ∷ ρ ∷ ο ∷ υ ∷ []) "Jas.2.15"
∷ word (τ ∷ ρ ∷ ο ∷ φ ∷ ῆ ∷ ς ∷ []) "Jas.2.15"
∷ word (ε ∷ ἴ ∷ π ∷ ῃ ∷ []) "Jas.2.16"
∷ word (δ ∷ έ ∷ []) "Jas.2.16"
∷ word (τ ∷ ι ∷ ς ∷ []) "Jas.2.16"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῖ ∷ ς ∷ []) "Jas.2.16"
∷ word (ἐ ∷ ξ ∷ []) "Jas.2.16"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.2.16"
∷ word (Ὑ ∷ π ∷ ά ∷ γ ∷ ε ∷ τ ∷ ε ∷ []) "Jas.2.16"
∷ word (ἐ ∷ ν ∷ []) "Jas.2.16"
∷ word (ε ∷ ἰ ∷ ρ ∷ ή ∷ ν ∷ ῃ ∷ []) "Jas.2.16"
∷ word (θ ∷ ε ∷ ρ ∷ μ ∷ α ∷ ί ∷ ν ∷ ε ∷ σ ∷ θ ∷ ε ∷ []) "Jas.2.16"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.16"
∷ word (χ ∷ ο ∷ ρ ∷ τ ∷ ά ∷ ζ ∷ ε ∷ σ ∷ θ ∷ ε ∷ []) "Jas.2.16"
∷ word (μ ∷ ὴ ∷ []) "Jas.2.16"
∷ word (δ ∷ ῶ ∷ τ ∷ ε ∷ []) "Jas.2.16"
∷ word (δ ∷ ὲ ∷ []) "Jas.2.16"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῖ ∷ ς ∷ []) "Jas.2.16"
∷ word (τ ∷ ὰ ∷ []) "Jas.2.16"
∷ word (ἐ ∷ π ∷ ι ∷ τ ∷ ή ∷ δ ∷ ε ∷ ι ∷ α ∷ []) "Jas.2.16"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.2.16"
∷ word (σ ∷ ώ ∷ μ ∷ α ∷ τ ∷ ο ∷ ς ∷ []) "Jas.2.16"
∷ word (τ ∷ ί ∷ []) "Jas.2.16"
∷ word (ὄ ∷ φ ∷ ε ∷ ∙λ ∷ ο ∷ ς ∷ []) "Jas.2.16"
∷ word (ο ∷ ὕ ∷ τ ∷ ω ∷ ς ∷ []) "Jas.2.17"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.17"
∷ word (ἡ ∷ []) "Jas.2.17"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ι ∷ ς ∷ []) "Jas.2.17"
∷ word (ἐ ∷ ὰ ∷ ν ∷ []) "Jas.2.17"
∷ word (μ ∷ ὴ ∷ []) "Jas.2.17"
∷ word (ἔ ∷ χ ∷ ῃ ∷ []) "Jas.2.17"
∷ word (ἔ ∷ ρ ∷ γ ∷ α ∷ []) "Jas.2.17"
∷ word (ν ∷ ε ∷ κ ∷ ρ ∷ ά ∷ []) "Jas.2.17"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.2.17"
∷ word (κ ∷ α ∷ θ ∷ []) "Jas.2.17"
∷ word (ἑ ∷ α ∷ υ ∷ τ ∷ ή ∷ ν ∷ []) "Jas.2.17"
∷ word (Ἀ ∷ ∙λ ∷ ∙λ ∷ []) "Jas.2.18"
∷ word (ἐ ∷ ρ ∷ ε ∷ ῖ ∷ []) "Jas.2.18"
∷ word (τ ∷ ι ∷ ς ∷ []) "Jas.2.18"
∷ word (Σ ∷ ὺ ∷ []) "Jas.2.18"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.2.18"
∷ word (ἔ ∷ χ ∷ ε ∷ ι ∷ ς ∷ []) "Jas.2.18"
∷ word (κ ∷ ἀ ∷ γ ∷ ὼ ∷ []) "Jas.2.18"
∷ word (ἔ ∷ ρ ∷ γ ∷ α ∷ []) "Jas.2.18"
∷ word (ἔ ∷ χ ∷ ω ∷ []) "Jas.2.18"
∷ word (δ ∷ ε ∷ ῖ ∷ ξ ∷ ό ∷ ν ∷ []) "Jas.2.18"
∷ word (μ ∷ ο ∷ ι ∷ []) "Jas.2.18"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "Jas.2.18"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.2.18"
∷ word (σ ∷ ο ∷ υ ∷ []) "Jas.2.18"
∷ word (χ ∷ ω ∷ ρ ∷ ὶ ∷ ς ∷ []) "Jas.2.18"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "Jas.2.18"
∷ word (ἔ ∷ ρ ∷ γ ∷ ω ∷ ν ∷ []) "Jas.2.18"
∷ word (κ ∷ ἀ ∷ γ ∷ ώ ∷ []) "Jas.2.18"
∷ word (σ ∷ ο ∷ ι ∷ []) "Jas.2.18"
∷ word (δ ∷ ε ∷ ί ∷ ξ ∷ ω ∷ []) "Jas.2.18"
∷ word (ἐ ∷ κ ∷ []) "Jas.2.18"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "Jas.2.18"
∷ word (ἔ ∷ ρ ∷ γ ∷ ω ∷ ν ∷ []) "Jas.2.18"
∷ word (μ ∷ ο ∷ υ ∷ []) "Jas.2.18"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "Jas.2.18"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.2.18"
∷ word (σ ∷ ὺ ∷ []) "Jas.2.19"
∷ word (π ∷ ι ∷ σ ∷ τ ∷ ε ∷ ύ ∷ ε ∷ ι ∷ ς ∷ []) "Jas.2.19"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.2.19"
∷ word (ε ∷ ἷ ∷ ς ∷ []) "Jas.2.19"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.2.19"
∷ word (ὁ ∷ []) "Jas.2.19"
∷ word (θ ∷ ε ∷ ό ∷ ς ∷ []) "Jas.2.19"
∷ word (κ ∷ α ∷ ∙λ ∷ ῶ ∷ ς ∷ []) "Jas.2.19"
∷ word (π ∷ ο ∷ ι ∷ ε ∷ ῖ ∷ ς ∷ []) "Jas.2.19"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.19"
∷ word (τ ∷ ὰ ∷ []) "Jas.2.19"
∷ word (δ ∷ α ∷ ι ∷ μ ∷ ό ∷ ν ∷ ι ∷ α ∷ []) "Jas.2.19"
∷ word (π ∷ ι ∷ σ ∷ τ ∷ ε ∷ ύ ∷ ο ∷ υ ∷ σ ∷ ι ∷ ν ∷ []) "Jas.2.19"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.19"
∷ word (φ ∷ ρ ∷ ί ∷ σ ∷ σ ∷ ο ∷ υ ∷ σ ∷ ι ∷ ν ∷ []) "Jas.2.19"
∷ word (θ ∷ έ ∷ ∙λ ∷ ε ∷ ι ∷ ς ∷ []) "Jas.2.20"
∷ word (δ ∷ ὲ ∷ []) "Jas.2.20"
∷ word (γ ∷ ν ∷ ῶ ∷ ν ∷ α ∷ ι ∷ []) "Jas.2.20"
∷ word (ὦ ∷ []) "Jas.2.20"
∷ word (ἄ ∷ ν ∷ θ ∷ ρ ∷ ω ∷ π ∷ ε ∷ []) "Jas.2.20"
∷ word (κ ∷ ε ∷ ν ∷ έ ∷ []) "Jas.2.20"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.2.20"
∷ word (ἡ ∷ []) "Jas.2.20"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ι ∷ ς ∷ []) "Jas.2.20"
∷ word (χ ∷ ω ∷ ρ ∷ ὶ ∷ ς ∷ []) "Jas.2.20"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "Jas.2.20"
∷ word (ἔ ∷ ρ ∷ γ ∷ ω ∷ ν ∷ []) "Jas.2.20"
∷ word (ἀ ∷ ρ ∷ γ ∷ ή ∷ []) "Jas.2.20"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.2.20"
∷ word (Ἀ ∷ β ∷ ρ ∷ α ∷ ὰ ∷ μ ∷ []) "Jas.2.21"
∷ word (ὁ ∷ []) "Jas.2.21"
∷ word (π ∷ α ∷ τ ∷ ὴ ∷ ρ ∷ []) "Jas.2.21"
∷ word (ἡ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.2.21"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.2.21"
∷ word (ἐ ∷ ξ ∷ []) "Jas.2.21"
∷ word (ἔ ∷ ρ ∷ γ ∷ ω ∷ ν ∷ []) "Jas.2.21"
∷ word (ἐ ∷ δ ∷ ι ∷ κ ∷ α ∷ ι ∷ ώ ∷ θ ∷ η ∷ []) "Jas.2.21"
∷ word (ἀ ∷ ν ∷ ε ∷ ν ∷ έ ∷ γ ∷ κ ∷ α ∷ ς ∷ []) "Jas.2.21"
∷ word (Ἰ ∷ σ ∷ α ∷ ὰ ∷ κ ∷ []) "Jas.2.21"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.2.21"
∷ word (υ ∷ ἱ ∷ ὸ ∷ ν ∷ []) "Jas.2.21"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.2.21"
∷ word (ἐ ∷ π ∷ ὶ ∷ []) "Jas.2.21"
∷ word (τ ∷ ὸ ∷ []) "Jas.2.21"
∷ word (θ ∷ υ ∷ σ ∷ ι ∷ α ∷ σ ∷ τ ∷ ή ∷ ρ ∷ ι ∷ ο ∷ ν ∷ []) "Jas.2.21"
∷ word (β ∷ ∙λ ∷ έ ∷ π ∷ ε ∷ ι ∷ ς ∷ []) "Jas.2.22"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.2.22"
∷ word (ἡ ∷ []) "Jas.2.22"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ι ∷ ς ∷ []) "Jas.2.22"
∷ word (σ ∷ υ ∷ ν ∷ ή ∷ ρ ∷ γ ∷ ε ∷ ι ∷ []) "Jas.2.22"
∷ word (τ ∷ ο ∷ ῖ ∷ ς ∷ []) "Jas.2.22"
∷ word (ἔ ∷ ρ ∷ γ ∷ ο ∷ ι ∷ ς ∷ []) "Jas.2.22"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.2.22"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.22"
∷ word (ἐ ∷ κ ∷ []) "Jas.2.22"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "Jas.2.22"
∷ word (ἔ ∷ ρ ∷ γ ∷ ω ∷ ν ∷ []) "Jas.2.22"
∷ word (ἡ ∷ []) "Jas.2.22"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ι ∷ ς ∷ []) "Jas.2.22"
∷ word (ἐ ∷ τ ∷ ε ∷ ∙λ ∷ ε ∷ ι ∷ ώ ∷ θ ∷ η ∷ []) "Jas.2.22"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.23"
∷ word (ἐ ∷ π ∷ ∙λ ∷ η ∷ ρ ∷ ώ ∷ θ ∷ η ∷ []) "Jas.2.23"
∷ word (ἡ ∷ []) "Jas.2.23"
∷ word (γ ∷ ρ ∷ α ∷ φ ∷ ὴ ∷ []) "Jas.2.23"
∷ word (ἡ ∷ []) "Jas.2.23"
∷ word (∙λ ∷ έ ∷ γ ∷ ο ∷ υ ∷ σ ∷ α ∷ []) "Jas.2.23"
∷ word (Ἐ ∷ π ∷ ί ∷ σ ∷ τ ∷ ε ∷ υ ∷ σ ∷ ε ∷ ν ∷ []) "Jas.2.23"
∷ word (δ ∷ ὲ ∷ []) "Jas.2.23"
∷ word (Ἀ ∷ β ∷ ρ ∷ α ∷ ὰ ∷ μ ∷ []) "Jas.2.23"
∷ word (τ ∷ ῷ ∷ []) "Jas.2.23"
∷ word (θ ∷ ε ∷ ῷ ∷ []) "Jas.2.23"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.23"
∷ word (ἐ ∷ ∙λ ∷ ο ∷ γ ∷ ί ∷ σ ∷ θ ∷ η ∷ []) "Jas.2.23"
∷ word (α ∷ ὐ ∷ τ ∷ ῷ ∷ []) "Jas.2.23"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.2.23"
∷ word (δ ∷ ι ∷ κ ∷ α ∷ ι ∷ ο ∷ σ ∷ ύ ∷ ν ∷ η ∷ ν ∷ []) "Jas.2.23"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.23"
∷ word (φ ∷ ί ∷ ∙λ ∷ ο ∷ ς ∷ []) "Jas.2.23"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "Jas.2.23"
∷ word (ἐ ∷ κ ∷ ∙λ ∷ ή ∷ θ ∷ η ∷ []) "Jas.2.23"
∷ word (ὁ ∷ ρ ∷ ᾶ ∷ τ ∷ ε ∷ []) "Jas.2.24"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.2.24"
∷ word (ἐ ∷ ξ ∷ []) "Jas.2.24"
∷ word (ἔ ∷ ρ ∷ γ ∷ ω ∷ ν ∷ []) "Jas.2.24"
∷ word (δ ∷ ι ∷ κ ∷ α ∷ ι ∷ ο ∷ ῦ ∷ τ ∷ α ∷ ι ∷ []) "Jas.2.24"
∷ word (ἄ ∷ ν ∷ θ ∷ ρ ∷ ω ∷ π ∷ ο ∷ ς ∷ []) "Jas.2.24"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.24"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.2.24"
∷ word (ἐ ∷ κ ∷ []) "Jas.2.24"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ε ∷ ω ∷ ς ∷ []) "Jas.2.24"
∷ word (μ ∷ ό ∷ ν ∷ ο ∷ ν ∷ []) "Jas.2.24"
∷ word (ὁ ∷ μ ∷ ο ∷ ί ∷ ω ∷ ς ∷ []) "Jas.2.25"
∷ word (δ ∷ ὲ ∷ []) "Jas.2.25"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.25"
∷ word (Ῥ ∷ α ∷ ὰ ∷ β ∷ []) "Jas.2.25"
∷ word (ἡ ∷ []) "Jas.2.25"
∷ word (π ∷ ό ∷ ρ ∷ ν ∷ η ∷ []) "Jas.2.25"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.2.25"
∷ word (ἐ ∷ ξ ∷ []) "Jas.2.25"
∷ word (ἔ ∷ ρ ∷ γ ∷ ω ∷ ν ∷ []) "Jas.2.25"
∷ word (ἐ ∷ δ ∷ ι ∷ κ ∷ α ∷ ι ∷ ώ ∷ θ ∷ η ∷ []) "Jas.2.25"
∷ word (ὑ ∷ π ∷ ο ∷ δ ∷ ε ∷ ξ ∷ α ∷ μ ∷ έ ∷ ν ∷ η ∷ []) "Jas.2.25"
∷ word (τ ∷ ο ∷ ὺ ∷ ς ∷ []) "Jas.2.25"
∷ word (ἀ ∷ γ ∷ γ ∷ έ ∷ ∙λ ∷ ο ∷ υ ∷ ς ∷ []) "Jas.2.25"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.25"
∷ word (ἑ ∷ τ ∷ έ ∷ ρ ∷ ᾳ ∷ []) "Jas.2.25"
∷ word (ὁ ∷ δ ∷ ῷ ∷ []) "Jas.2.25"
∷ word (ἐ ∷ κ ∷ β ∷ α ∷ ∙λ ∷ ο ∷ ῦ ∷ σ ∷ α ∷ []) "Jas.2.25"
∷ word (ὥ ∷ σ ∷ π ∷ ε ∷ ρ ∷ []) "Jas.2.26"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.2.26"
∷ word (τ ∷ ὸ ∷ []) "Jas.2.26"
∷ word (σ ∷ ῶ ∷ μ ∷ α ∷ []) "Jas.2.26"
∷ word (χ ∷ ω ∷ ρ ∷ ὶ ∷ ς ∷ []) "Jas.2.26"
∷ word (π ∷ ν ∷ ε ∷ ύ ∷ μ ∷ α ∷ τ ∷ ο ∷ ς ∷ []) "Jas.2.26"
∷ word (ν ∷ ε ∷ κ ∷ ρ ∷ ό ∷ ν ∷ []) "Jas.2.26"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.2.26"
∷ word (ο ∷ ὕ ∷ τ ∷ ω ∷ ς ∷ []) "Jas.2.26"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.2.26"
∷ word (ἡ ∷ []) "Jas.2.26"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ι ∷ ς ∷ []) "Jas.2.26"
∷ word (χ ∷ ω ∷ ρ ∷ ὶ ∷ ς ∷ []) "Jas.2.26"
∷ word (ἔ ∷ ρ ∷ γ ∷ ω ∷ ν ∷ []) "Jas.2.26"
∷ word (ν ∷ ε ∷ κ ∷ ρ ∷ ά ∷ []) "Jas.2.26"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.2.26"
∷ word (Μ ∷ ὴ ∷ []) "Jas.3.1"
∷ word (π ∷ ο ∷ ∙λ ∷ ∙λ ∷ ο ∷ ὶ ∷ []) "Jas.3.1"
∷ word (δ ∷ ι ∷ δ ∷ ά ∷ σ ∷ κ ∷ α ∷ ∙λ ∷ ο ∷ ι ∷ []) "Jas.3.1"
∷ word (γ ∷ ί ∷ ν ∷ ε ∷ σ ∷ θ ∷ ε ∷ []) "Jas.3.1"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.3.1"
∷ word (μ ∷ ο ∷ υ ∷ []) "Jas.3.1"
∷ word (ε ∷ ἰ ∷ δ ∷ ό ∷ τ ∷ ε ∷ ς ∷ []) "Jas.3.1"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.3.1"
∷ word (μ ∷ ε ∷ ῖ ∷ ζ ∷ ο ∷ ν ∷ []) "Jas.3.1"
∷ word (κ ∷ ρ ∷ ί ∷ μ ∷ α ∷ []) "Jas.3.1"
∷ word (∙λ ∷ η ∷ μ ∷ ψ ∷ ό ∷ μ ∷ ε ∷ θ ∷ α ∷ []) "Jas.3.1"
∷ word (π ∷ ο ∷ ∙λ ∷ ∙λ ∷ ὰ ∷ []) "Jas.3.2"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.3.2"
∷ word (π ∷ τ ∷ α ∷ ί ∷ ο ∷ μ ∷ ε ∷ ν ∷ []) "Jas.3.2"
∷ word (ἅ ∷ π ∷ α ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "Jas.3.2"
∷ word (ε ∷ ἴ ∷ []) "Jas.3.2"
∷ word (τ ∷ ι ∷ ς ∷ []) "Jas.3.2"
∷ word (ἐ ∷ ν ∷ []) "Jas.3.2"
∷ word (∙λ ∷ ό ∷ γ ∷ ῳ ∷ []) "Jas.3.2"
∷ word (ο ∷ ὐ ∷ []) "Jas.3.2"
∷ word (π ∷ τ ∷ α ∷ ί ∷ ε ∷ ι ∷ []) "Jas.3.2"
∷ word (ο ∷ ὗ ∷ τ ∷ ο ∷ ς ∷ []) "Jas.3.2"
∷ word (τ ∷ έ ∷ ∙λ ∷ ε ∷ ι ∷ ο ∷ ς ∷ []) "Jas.3.2"
∷ word (ἀ ∷ ν ∷ ή ∷ ρ ∷ []) "Jas.3.2"
∷ word (δ ∷ υ ∷ ν ∷ α ∷ τ ∷ ὸ ∷ ς ∷ []) "Jas.3.2"
∷ word (χ ∷ α ∷ ∙λ ∷ ι ∷ ν ∷ α ∷ γ ∷ ω ∷ γ ∷ ῆ ∷ σ ∷ α ∷ ι ∷ []) "Jas.3.2"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.2"
∷ word (ὅ ∷ ∙λ ∷ ο ∷ ν ∷ []) "Jas.3.2"
∷ word (τ ∷ ὸ ∷ []) "Jas.3.2"
∷ word (σ ∷ ῶ ∷ μ ∷ α ∷ []) "Jas.3.2"
∷ word (ε ∷ ἰ ∷ []) "Jas.3.3"
∷ word (δ ∷ ὲ ∷ []) "Jas.3.3"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "Jas.3.3"
∷ word (ἵ ∷ π ∷ π ∷ ω ∷ ν ∷ []) "Jas.3.3"
∷ word (τ ∷ ο ∷ ὺ ∷ ς ∷ []) "Jas.3.3"
∷ word (χ ∷ α ∷ ∙λ ∷ ι ∷ ν ∷ ο ∷ ὺ ∷ ς ∷ []) "Jas.3.3"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.3.3"
∷ word (τ ∷ ὰ ∷ []) "Jas.3.3"
∷ word (σ ∷ τ ∷ ό ∷ μ ∷ α ∷ τ ∷ α ∷ []) "Jas.3.3"
∷ word (β ∷ ά ∷ ∙λ ∷ ∙λ ∷ ο ∷ μ ∷ ε ∷ ν ∷ []) "Jas.3.3"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.3.3"
∷ word (τ ∷ ὸ ∷ []) "Jas.3.3"
∷ word (π ∷ ε ∷ ί ∷ θ ∷ ε ∷ σ ∷ θ ∷ α ∷ ι ∷ []) "Jas.3.3"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ὺ ∷ ς ∷ []) "Jas.3.3"
∷ word (ἡ ∷ μ ∷ ῖ ∷ ν ∷ []) "Jas.3.3"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.3"
∷ word (ὅ ∷ ∙λ ∷ ο ∷ ν ∷ []) "Jas.3.3"
∷ word (τ ∷ ὸ ∷ []) "Jas.3.3"
∷ word (σ ∷ ῶ ∷ μ ∷ α ∷ []) "Jas.3.3"
∷ word (α ∷ ὐ ∷ τ ∷ ῶ ∷ ν ∷ []) "Jas.3.3"
∷ word (μ ∷ ε ∷ τ ∷ ά ∷ γ ∷ ο ∷ μ ∷ ε ∷ ν ∷ []) "Jas.3.3"
∷ word (ἰ ∷ δ ∷ ο ∷ ὺ ∷ []) "Jas.3.4"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.4"
∷ word (τ ∷ ὰ ∷ []) "Jas.3.4"
∷ word (π ∷ ∙λ ∷ ο ∷ ῖ ∷ α ∷ []) "Jas.3.4"
∷ word (τ ∷ η ∷ ∙λ ∷ ι ∷ κ ∷ α ∷ ῦ ∷ τ ∷ α ∷ []) "Jas.3.4"
∷ word (ὄ ∷ ν ∷ τ ∷ α ∷ []) "Jas.3.4"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.4"
∷ word (ὑ ∷ π ∷ ὸ ∷ []) "Jas.3.4"
∷ word (ἀ ∷ ν ∷ έ ∷ μ ∷ ω ∷ ν ∷ []) "Jas.3.4"
∷ word (σ ∷ κ ∷ ∙λ ∷ η ∷ ρ ∷ ῶ ∷ ν ∷ []) "Jas.3.4"
∷ word (ἐ ∷ ∙λ ∷ α ∷ υ ∷ ν ∷ ό ∷ μ ∷ ε ∷ ν ∷ α ∷ []) "Jas.3.4"
∷ word (μ ∷ ε ∷ τ ∷ ά ∷ γ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.3.4"
∷ word (ὑ ∷ π ∷ ὸ ∷ []) "Jas.3.4"
∷ word (ἐ ∷ ∙λ ∷ α ∷ χ ∷ ί ∷ σ ∷ τ ∷ ο ∷ υ ∷ []) "Jas.3.4"
∷ word (π ∷ η ∷ δ ∷ α ∷ ∙λ ∷ ί ∷ ο ∷ υ ∷ []) "Jas.3.4"
∷ word (ὅ ∷ π ∷ ο ∷ υ ∷ []) "Jas.3.4"
∷ word (ἡ ∷ []) "Jas.3.4"
∷ word (ὁ ∷ ρ ∷ μ ∷ ὴ ∷ []) "Jas.3.4"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.3.4"
∷ word (ε ∷ ὐ ∷ θ ∷ ύ ∷ ν ∷ ο ∷ ν ∷ τ ∷ ο ∷ ς ∷ []) "Jas.3.4"
∷ word (β ∷ ο ∷ ύ ∷ ∙λ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.3.4"
∷ word (ο ∷ ὕ ∷ τ ∷ ω ∷ ς ∷ []) "Jas.3.5"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.5"
∷ word (ἡ ∷ []) "Jas.3.5"
∷ word (γ ∷ ∙λ ∷ ῶ ∷ σ ∷ σ ∷ α ∷ []) "Jas.3.5"
∷ word (μ ∷ ι ∷ κ ∷ ρ ∷ ὸ ∷ ν ∷ []) "Jas.3.5"
∷ word (μ ∷ έ ∷ ∙λ ∷ ο ∷ ς ∷ []) "Jas.3.5"
∷ word (ἐ ∷ σ ∷ τ ∷ ὶ ∷ ν ∷ []) "Jas.3.5"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.5"
∷ word (μ ∷ ε ∷ γ ∷ ά ∷ ∙λ ∷ α ∷ []) "Jas.3.5"
∷ word (α ∷ ὐ ∷ χ ∷ ε ∷ ῖ ∷ []) "Jas.3.5"
∷ word (Ἰ ∷ δ ∷ ο ∷ ὺ ∷ []) "Jas.3.5"
∷ word (ἡ ∷ ∙λ ∷ ί ∷ κ ∷ ο ∷ ν ∷ []) "Jas.3.5"
∷ word (π ∷ ῦ ∷ ρ ∷ []) "Jas.3.5"
∷ word (ἡ ∷ ∙λ ∷ ί ∷ κ ∷ η ∷ ν ∷ []) "Jas.3.5"
∷ word (ὕ ∷ ∙λ ∷ η ∷ ν ∷ []) "Jas.3.5"
∷ word (ἀ ∷ ν ∷ ά ∷ π ∷ τ ∷ ε ∷ ι ∷ []) "Jas.3.5"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.6"
∷ word (ἡ ∷ []) "Jas.3.6"
∷ word (γ ∷ ∙λ ∷ ῶ ∷ σ ∷ σ ∷ α ∷ []) "Jas.3.6"
∷ word (π ∷ ῦ ∷ ρ ∷ []) "Jas.3.6"
∷ word (ὁ ∷ []) "Jas.3.6"
∷ word (κ ∷ ό ∷ σ ∷ μ ∷ ο ∷ ς ∷ []) "Jas.3.6"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.3.6"
∷ word (ἀ ∷ δ ∷ ι ∷ κ ∷ ί ∷ α ∷ ς ∷ []) "Jas.3.6"
∷ word (ἡ ∷ []) "Jas.3.6"
∷ word (γ ∷ ∙λ ∷ ῶ ∷ σ ∷ σ ∷ α ∷ []) "Jas.3.6"
∷ word (κ ∷ α ∷ θ ∷ ί ∷ σ ∷ τ ∷ α ∷ τ ∷ α ∷ ι ∷ []) "Jas.3.6"
∷ word (ἐ ∷ ν ∷ []) "Jas.3.6"
∷ word (τ ∷ ο ∷ ῖ ∷ ς ∷ []) "Jas.3.6"
∷ word (μ ∷ έ ∷ ∙λ ∷ ε ∷ σ ∷ ι ∷ ν ∷ []) "Jas.3.6"
∷ word (ἡ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.3.6"
∷ word (ἡ ∷ []) "Jas.3.6"
∷ word (σ ∷ π ∷ ι ∷ ∙λ ∷ ο ∷ ῦ ∷ σ ∷ α ∷ []) "Jas.3.6"
∷ word (ὅ ∷ ∙λ ∷ ο ∷ ν ∷ []) "Jas.3.6"
∷ word (τ ∷ ὸ ∷ []) "Jas.3.6"
∷ word (σ ∷ ῶ ∷ μ ∷ α ∷ []) "Jas.3.6"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.6"
∷ word (φ ∷ ∙λ ∷ ο ∷ γ ∷ ί ∷ ζ ∷ ο ∷ υ ∷ σ ∷ α ∷ []) "Jas.3.6"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.3.6"
∷ word (τ ∷ ρ ∷ ο ∷ χ ∷ ὸ ∷ ν ∷ []) "Jas.3.6"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.3.6"
∷ word (γ ∷ ε ∷ ν ∷ έ ∷ σ ∷ ε ∷ ω ∷ ς ∷ []) "Jas.3.6"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.6"
∷ word (φ ∷ ∙λ ∷ ο ∷ γ ∷ ι ∷ ζ ∷ ο ∷ μ ∷ έ ∷ ν ∷ η ∷ []) "Jas.3.6"
∷ word (ὑ ∷ π ∷ ὸ ∷ []) "Jas.3.6"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.3.6"
∷ word (γ ∷ ε ∷ έ ∷ ν ∷ ν ∷ η ∷ ς ∷ []) "Jas.3.6"
∷ word (π ∷ ᾶ ∷ σ ∷ α ∷ []) "Jas.3.7"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.3.7"
∷ word (φ ∷ ύ ∷ σ ∷ ι ∷ ς ∷ []) "Jas.3.7"
∷ word (θ ∷ η ∷ ρ ∷ ί ∷ ω ∷ ν ∷ []) "Jas.3.7"
∷ word (τ ∷ ε ∷ []) "Jas.3.7"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.7"
∷ word (π ∷ ε ∷ τ ∷ ε ∷ ι ∷ ν ∷ ῶ ∷ ν ∷ []) "Jas.3.7"
∷ word (ἑ ∷ ρ ∷ π ∷ ε ∷ τ ∷ ῶ ∷ ν ∷ []) "Jas.3.7"
∷ word (τ ∷ ε ∷ []) "Jas.3.7"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.7"
∷ word (ἐ ∷ ν ∷ α ∷ ∙λ ∷ ί ∷ ω ∷ ν ∷ []) "Jas.3.7"
∷ word (δ ∷ α ∷ μ ∷ ά ∷ ζ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.3.7"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.7"
∷ word (δ ∷ ε ∷ δ ∷ ά ∷ μ ∷ α ∷ σ ∷ τ ∷ α ∷ ι ∷ []) "Jas.3.7"
∷ word (τ ∷ ῇ ∷ []) "Jas.3.7"
∷ word (φ ∷ ύ ∷ σ ∷ ε ∷ ι ∷ []) "Jas.3.7"
∷ word (τ ∷ ῇ ∷ []) "Jas.3.7"
∷ word (ἀ ∷ ν ∷ θ ∷ ρ ∷ ω ∷ π ∷ ί ∷ ν ∷ ῃ ∷ []) "Jas.3.7"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "Jas.3.8"
∷ word (δ ∷ ὲ ∷ []) "Jas.3.8"
∷ word (γ ∷ ∙λ ∷ ῶ ∷ σ ∷ σ ∷ α ∷ ν ∷ []) "Jas.3.8"
∷ word (ο ∷ ὐ ∷ δ ∷ ε ∷ ὶ ∷ ς ∷ []) "Jas.3.8"
∷ word (δ ∷ α ∷ μ ∷ ά ∷ σ ∷ α ∷ ι ∷ []) "Jas.3.8"
∷ word (δ ∷ ύ ∷ ν ∷ α ∷ τ ∷ α ∷ ι ∷ []) "Jas.3.8"
∷ word (ἀ ∷ ν ∷ θ ∷ ρ ∷ ώ ∷ π ∷ ω ∷ ν ∷ []) "Jas.3.8"
∷ word (ἀ ∷ κ ∷ α ∷ τ ∷ ά ∷ σ ∷ τ ∷ α ∷ τ ∷ ο ∷ ν ∷ []) "Jas.3.8"
∷ word (κ ∷ α ∷ κ ∷ ό ∷ ν ∷ []) "Jas.3.8"
∷ word (μ ∷ ε ∷ σ ∷ τ ∷ ὴ ∷ []) "Jas.3.8"
∷ word (ἰ ∷ ο ∷ ῦ ∷ []) "Jas.3.8"
∷ word (θ ∷ α ∷ ν ∷ α ∷ τ ∷ η ∷ φ ∷ ό ∷ ρ ∷ ο ∷ υ ∷ []) "Jas.3.8"
∷ word (ἐ ∷ ν ∷ []) "Jas.3.9"
∷ word (α ∷ ὐ ∷ τ ∷ ῇ ∷ []) "Jas.3.9"
∷ word (ε ∷ ὐ ∷ ∙λ ∷ ο ∷ γ ∷ ο ∷ ῦ ∷ μ ∷ ε ∷ ν ∷ []) "Jas.3.9"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.3.9"
∷ word (κ ∷ ύ ∷ ρ ∷ ι ∷ ο ∷ ν ∷ []) "Jas.3.9"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.9"
∷ word (π ∷ α ∷ τ ∷ έ ∷ ρ ∷ α ∷ []) "Jas.3.9"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.9"
∷ word (ἐ ∷ ν ∷ []) "Jas.3.9"
∷ word (α ∷ ὐ ∷ τ ∷ ῇ ∷ []) "Jas.3.9"
∷ word (κ ∷ α ∷ τ ∷ α ∷ ρ ∷ ώ ∷ μ ∷ ε ∷ θ ∷ α ∷ []) "Jas.3.9"
∷ word (τ ∷ ο ∷ ὺ ∷ ς ∷ []) "Jas.3.9"
∷ word (ἀ ∷ ν ∷ θ ∷ ρ ∷ ώ ∷ π ∷ ο ∷ υ ∷ ς ∷ []) "Jas.3.9"
∷ word (τ ∷ ο ∷ ὺ ∷ ς ∷ []) "Jas.3.9"
∷ word (κ ∷ α ∷ θ ∷ []) "Jas.3.9"
∷ word (ὁ ∷ μ ∷ ο ∷ ί ∷ ω ∷ σ ∷ ι ∷ ν ∷ []) "Jas.3.9"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "Jas.3.9"
∷ word (γ ∷ ε ∷ γ ∷ ο ∷ ν ∷ ό ∷ τ ∷ α ∷ ς ∷ []) "Jas.3.9"
∷ word (ἐ ∷ κ ∷ []) "Jas.3.10"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.3.10"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.3.10"
∷ word (σ ∷ τ ∷ ό ∷ μ ∷ α ∷ τ ∷ ο ∷ ς ∷ []) "Jas.3.10"
∷ word (ἐ ∷ ξ ∷ έ ∷ ρ ∷ χ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.3.10"
∷ word (ε ∷ ὐ ∷ ∙λ ∷ ο ∷ γ ∷ ί ∷ α ∷ []) "Jas.3.10"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.10"
∷ word (κ ∷ α ∷ τ ∷ ά ∷ ρ ∷ α ∷ []) "Jas.3.10"
∷ word (ο ∷ ὐ ∷ []) "Jas.3.10"
∷ word (χ ∷ ρ ∷ ή ∷ []) "Jas.3.10"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.3.10"
∷ word (μ ∷ ο ∷ υ ∷ []) "Jas.3.10"
∷ word (τ ∷ α ∷ ῦ ∷ τ ∷ α ∷ []) "Jas.3.10"
∷ word (ο ∷ ὕ ∷ τ ∷ ω ∷ ς ∷ []) "Jas.3.10"
∷ word (γ ∷ ί ∷ ν ∷ ε ∷ σ ∷ θ ∷ α ∷ ι ∷ []) "Jas.3.10"
∷ word (μ ∷ ή ∷ τ ∷ ι ∷ []) "Jas.3.11"
∷ word (ἡ ∷ []) "Jas.3.11"
∷ word (π ∷ η ∷ γ ∷ ὴ ∷ []) "Jas.3.11"
∷ word (ἐ ∷ κ ∷ []) "Jas.3.11"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.3.11"
∷ word (α ∷ ὐ ∷ τ ∷ ῆ ∷ ς ∷ []) "Jas.3.11"
∷ word (ὀ ∷ π ∷ ῆ ∷ ς ∷ []) "Jas.3.11"
∷ word (β ∷ ρ ∷ ύ ∷ ε ∷ ι ∷ []) "Jas.3.11"
∷ word (τ ∷ ὸ ∷ []) "Jas.3.11"
∷ word (γ ∷ ∙λ ∷ υ ∷ κ ∷ ὺ ∷ []) "Jas.3.11"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.11"
∷ word (τ ∷ ὸ ∷ []) "Jas.3.11"
∷ word (π ∷ ι ∷ κ ∷ ρ ∷ ό ∷ ν ∷ []) "Jas.3.11"
∷ word (μ ∷ ὴ ∷ []) "Jas.3.12"
∷ word (δ ∷ ύ ∷ ν ∷ α ∷ τ ∷ α ∷ ι ∷ []) "Jas.3.12"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.3.12"
∷ word (μ ∷ ο ∷ υ ∷ []) "Jas.3.12"
∷ word (σ ∷ υ ∷ κ ∷ ῆ ∷ []) "Jas.3.12"
∷ word (ἐ ∷ ∙λ ∷ α ∷ ί ∷ α ∷ ς ∷ []) "Jas.3.12"
∷ word (π ∷ ο ∷ ι ∷ ῆ ∷ σ ∷ α ∷ ι ∷ []) "Jas.3.12"
∷ word (ἢ ∷ []) "Jas.3.12"
∷ word (ἄ ∷ μ ∷ π ∷ ε ∷ ∙λ ∷ ο ∷ ς ∷ []) "Jas.3.12"
∷ word (σ ∷ ῦ ∷ κ ∷ α ∷ []) "Jas.3.12"
∷ word (ο ∷ ὔ ∷ τ ∷ ε ∷ []) "Jas.3.12"
∷ word (ἁ ∷ ∙λ ∷ υ ∷ κ ∷ ὸ ∷ ν ∷ []) "Jas.3.12"
∷ word (γ ∷ ∙λ ∷ υ ∷ κ ∷ ὺ ∷ []) "Jas.3.12"
∷ word (π ∷ ο ∷ ι ∷ ῆ ∷ σ ∷ α ∷ ι ∷ []) "Jas.3.12"
∷ word (ὕ ∷ δ ∷ ω ∷ ρ ∷ []) "Jas.3.12"
∷ word (Τ ∷ ί ∷ ς ∷ []) "Jas.3.13"
∷ word (σ ∷ ο ∷ φ ∷ ὸ ∷ ς ∷ []) "Jas.3.13"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.13"
∷ word (ἐ ∷ π ∷ ι ∷ σ ∷ τ ∷ ή ∷ μ ∷ ω ∷ ν ∷ []) "Jas.3.13"
∷ word (ἐ ∷ ν ∷ []) "Jas.3.13"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "Jas.3.13"
∷ word (δ ∷ ε ∷ ι ∷ ξ ∷ ά ∷ τ ∷ ω ∷ []) "Jas.3.13"
∷ word (ἐ ∷ κ ∷ []) "Jas.3.13"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.3.13"
∷ word (κ ∷ α ∷ ∙λ ∷ ῆ ∷ ς ∷ []) "Jas.3.13"
∷ word (ἀ ∷ ν ∷ α ∷ σ ∷ τ ∷ ρ ∷ ο ∷ φ ∷ ῆ ∷ ς ∷ []) "Jas.3.13"
∷ word (τ ∷ ὰ ∷ []) "Jas.3.13"
∷ word (ἔ ∷ ρ ∷ γ ∷ α ∷ []) "Jas.3.13"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.3.13"
∷ word (ἐ ∷ ν ∷ []) "Jas.3.13"
∷ word (π ∷ ρ ∷ α ∷ ΰ ∷ τ ∷ η ∷ τ ∷ ι ∷ []) "Jas.3.13"
∷ word (σ ∷ ο ∷ φ ∷ ί ∷ α ∷ ς ∷ []) "Jas.3.13"
∷ word (ε ∷ ἰ ∷ []) "Jas.3.14"
∷ word (δ ∷ ὲ ∷ []) "Jas.3.14"
∷ word (ζ ∷ ῆ ∷ ∙λ ∷ ο ∷ ν ∷ []) "Jas.3.14"
∷ word (π ∷ ι ∷ κ ∷ ρ ∷ ὸ ∷ ν ∷ []) "Jas.3.14"
∷ word (ἔ ∷ χ ∷ ε ∷ τ ∷ ε ∷ []) "Jas.3.14"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.14"
∷ word (ἐ ∷ ρ ∷ ι ∷ θ ∷ ε ∷ ί ∷ α ∷ ν ∷ []) "Jas.3.14"
∷ word (ἐ ∷ ν ∷ []) "Jas.3.14"
∷ word (τ ∷ ῇ ∷ []) "Jas.3.14"
∷ word (κ ∷ α ∷ ρ ∷ δ ∷ ί ∷ ᾳ ∷ []) "Jas.3.14"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.3.14"
∷ word (μ ∷ ὴ ∷ []) "Jas.3.14"
∷ word (κ ∷ α ∷ τ ∷ α ∷ κ ∷ α ∷ υ ∷ χ ∷ ᾶ ∷ σ ∷ θ ∷ ε ∷ []) "Jas.3.14"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.14"
∷ word (ψ ∷ ε ∷ ύ ∷ δ ∷ ε ∷ σ ∷ θ ∷ ε ∷ []) "Jas.3.14"
∷ word (κ ∷ α ∷ τ ∷ ὰ ∷ []) "Jas.3.14"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.3.14"
∷ word (ἀ ∷ ∙λ ∷ η ∷ θ ∷ ε ∷ ί ∷ α ∷ ς ∷ []) "Jas.3.14"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.3.15"
∷ word (ἔ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.3.15"
∷ word (α ∷ ὕ ∷ τ ∷ η ∷ []) "Jas.3.15"
∷ word (ἡ ∷ []) "Jas.3.15"
∷ word (σ ∷ ο ∷ φ ∷ ί ∷ α ∷ []) "Jas.3.15"
∷ word (ἄ ∷ ν ∷ ω ∷ θ ∷ ε ∷ ν ∷ []) "Jas.3.15"
∷ word (κ ∷ α ∷ τ ∷ ε ∷ ρ ∷ χ ∷ ο ∷ μ ∷ έ ∷ ν ∷ η ∷ []) "Jas.3.15"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ ὰ ∷ []) "Jas.3.15"
∷ word (ἐ ∷ π ∷ ί ∷ γ ∷ ε ∷ ι ∷ ο ∷ ς ∷ []) "Jas.3.15"
∷ word (ψ ∷ υ ∷ χ ∷ ι ∷ κ ∷ ή ∷ []) "Jas.3.15"
∷ word (δ ∷ α ∷ ι ∷ μ ∷ ο ∷ ν ∷ ι ∷ ώ ∷ δ ∷ η ∷ ς ∷ []) "Jas.3.15"
∷ word (ὅ ∷ π ∷ ο ∷ υ ∷ []) "Jas.3.16"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "Jas.3.16"
∷ word (ζ ∷ ῆ ∷ ∙λ ∷ ο ∷ ς ∷ []) "Jas.3.16"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.16"
∷ word (ἐ ∷ ρ ∷ ι ∷ θ ∷ ε ∷ ί ∷ α ∷ []) "Jas.3.16"
∷ word (ἐ ∷ κ ∷ ε ∷ ῖ ∷ []) "Jas.3.16"
∷ word (ἀ ∷ κ ∷ α ∷ τ ∷ α ∷ σ ∷ τ ∷ α ∷ σ ∷ ί ∷ α ∷ []) "Jas.3.16"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.16"
∷ word (π ∷ ᾶ ∷ ν ∷ []) "Jas.3.16"
∷ word (φ ∷ α ∷ ῦ ∷ ∙λ ∷ ο ∷ ν ∷ []) "Jas.3.16"
∷ word (π ∷ ρ ∷ ᾶ ∷ γ ∷ μ ∷ α ∷ []) "Jas.3.16"
∷ word (ἡ ∷ []) "Jas.3.17"
∷ word (δ ∷ ὲ ∷ []) "Jas.3.17"
∷ word (ἄ ∷ ν ∷ ω ∷ θ ∷ ε ∷ ν ∷ []) "Jas.3.17"
∷ word (σ ∷ ο ∷ φ ∷ ί ∷ α ∷ []) "Jas.3.17"
∷ word (π ∷ ρ ∷ ῶ ∷ τ ∷ ο ∷ ν ∷ []) "Jas.3.17"
∷ word (μ ∷ ὲ ∷ ν ∷ []) "Jas.3.17"
∷ word (ἁ ∷ γ ∷ ν ∷ ή ∷ []) "Jas.3.17"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.3.17"
∷ word (ἔ ∷ π ∷ ε ∷ ι ∷ τ ∷ α ∷ []) "Jas.3.17"
∷ word (ε ∷ ἰ ∷ ρ ∷ η ∷ ν ∷ ι ∷ κ ∷ ή ∷ []) "Jas.3.17"
∷ word (ἐ ∷ π ∷ ι ∷ ε ∷ ι ∷ κ ∷ ή ∷ ς ∷ []) "Jas.3.17"
∷ word (ε ∷ ὐ ∷ π ∷ ε ∷ ι ∷ θ ∷ ή ∷ ς ∷ []) "Jas.3.17"
∷ word (μ ∷ ε ∷ σ ∷ τ ∷ ὴ ∷ []) "Jas.3.17"
∷ word (ἐ ∷ ∙λ ∷ έ ∷ ο ∷ υ ∷ ς ∷ []) "Jas.3.17"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.3.17"
∷ word (κ ∷ α ∷ ρ ∷ π ∷ ῶ ∷ ν ∷ []) "Jas.3.17"
∷ word (ἀ ∷ γ ∷ α ∷ θ ∷ ῶ ∷ ν ∷ []) "Jas.3.17"
∷ word (ἀ ∷ δ ∷ ι ∷ ά ∷ κ ∷ ρ ∷ ι ∷ τ ∷ ο ∷ ς ∷ []) "Jas.3.17"
∷ word (ἀ ∷ ν ∷ υ ∷ π ∷ ό ∷ κ ∷ ρ ∷ ι ∷ τ ∷ ο ∷ ς ∷ []) "Jas.3.17"
∷ word (κ ∷ α ∷ ρ ∷ π ∷ ὸ ∷ ς ∷ []) "Jas.3.18"
∷ word (δ ∷ ὲ ∷ []) "Jas.3.18"
∷ word (δ ∷ ι ∷ κ ∷ α ∷ ι ∷ ο ∷ σ ∷ ύ ∷ ν ∷ η ∷ ς ∷ []) "Jas.3.18"
∷ word (ἐ ∷ ν ∷ []) "Jas.3.18"
∷ word (ε ∷ ἰ ∷ ρ ∷ ή ∷ ν ∷ ῃ ∷ []) "Jas.3.18"
∷ word (σ ∷ π ∷ ε ∷ ί ∷ ρ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.3.18"
∷ word (τ ∷ ο ∷ ῖ ∷ ς ∷ []) "Jas.3.18"
∷ word (π ∷ ο ∷ ι ∷ ο ∷ ῦ ∷ σ ∷ ι ∷ ν ∷ []) "Jas.3.18"
∷ word (ε ∷ ἰ ∷ ρ ∷ ή ∷ ν ∷ η ∷ ν ∷ []) "Jas.3.18"
∷ word (Π ∷ ό ∷ θ ∷ ε ∷ ν ∷ []) "Jas.4.1"
∷ word (π ∷ ό ∷ ∙λ ∷ ε ∷ μ ∷ ο ∷ ι ∷ []) "Jas.4.1"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.1"
∷ word (π ∷ ό ∷ θ ∷ ε ∷ ν ∷ []) "Jas.4.1"
∷ word (μ ∷ ά ∷ χ ∷ α ∷ ι ∷ []) "Jas.4.1"
∷ word (ἐ ∷ ν ∷ []) "Jas.4.1"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "Jas.4.1"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.4.1"
∷ word (ἐ ∷ ν ∷ τ ∷ ε ∷ ῦ ∷ θ ∷ ε ∷ ν ∷ []) "Jas.4.1"
∷ word (ἐ ∷ κ ∷ []) "Jas.4.1"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "Jas.4.1"
∷ word (ἡ ∷ δ ∷ ο ∷ ν ∷ ῶ ∷ ν ∷ []) "Jas.4.1"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.4.1"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "Jas.4.1"
∷ word (σ ∷ τ ∷ ρ ∷ α ∷ τ ∷ ε ∷ υ ∷ ο ∷ μ ∷ έ ∷ ν ∷ ω ∷ ν ∷ []) "Jas.4.1"
∷ word (ἐ ∷ ν ∷ []) "Jas.4.1"
∷ word (τ ∷ ο ∷ ῖ ∷ ς ∷ []) "Jas.4.1"
∷ word (μ ∷ έ ∷ ∙λ ∷ ε ∷ σ ∷ ι ∷ ν ∷ []) "Jas.4.1"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.4.1"
∷ word (ἐ ∷ π ∷ ι ∷ θ ∷ υ ∷ μ ∷ ε ∷ ῖ ∷ τ ∷ ε ∷ []) "Jas.4.2"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.2"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.4.2"
∷ word (ἔ ∷ χ ∷ ε ∷ τ ∷ ε ∷ []) "Jas.4.2"
∷ word (φ ∷ ο ∷ ν ∷ ε ∷ ύ ∷ ε ∷ τ ∷ ε ∷ []) "Jas.4.2"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.2"
∷ word (ζ ∷ η ∷ ∙λ ∷ ο ∷ ῦ ∷ τ ∷ ε ∷ []) "Jas.4.2"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.2"
∷ word (ο ∷ ὐ ∷ []) "Jas.4.2"
∷ word (δ ∷ ύ ∷ ν ∷ α ∷ σ ∷ θ ∷ ε ∷ []) "Jas.4.2"
∷ word (ἐ ∷ π ∷ ι ∷ τ ∷ υ ∷ χ ∷ ε ∷ ῖ ∷ ν ∷ []) "Jas.4.2"
∷ word (μ ∷ ά ∷ χ ∷ ε ∷ σ ∷ θ ∷ ε ∷ []) "Jas.4.2"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.2"
∷ word (π ∷ ο ∷ ∙λ ∷ ε ∷ μ ∷ ε ∷ ῖ ∷ τ ∷ ε ∷ []) "Jas.4.2"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.4.2"
∷ word (ἔ ∷ χ ∷ ε ∷ τ ∷ ε ∷ []) "Jas.4.2"
∷ word (δ ∷ ι ∷ ὰ ∷ []) "Jas.4.2"
∷ word (τ ∷ ὸ ∷ []) "Jas.4.2"
∷ word (μ ∷ ὴ ∷ []) "Jas.4.2"
∷ word (α ∷ ἰ ∷ τ ∷ ε ∷ ῖ ∷ σ ∷ θ ∷ α ∷ ι ∷ []) "Jas.4.2"
∷ word (ὑ ∷ μ ∷ ᾶ ∷ ς ∷ []) "Jas.4.2"
∷ word (α ∷ ἰ ∷ τ ∷ ε ∷ ῖ ∷ τ ∷ ε ∷ []) "Jas.4.3"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.3"
∷ word (ο ∷ ὐ ∷ []) "Jas.4.3"
∷ word (∙λ ∷ α ∷ μ ∷ β ∷ ά ∷ ν ∷ ε ∷ τ ∷ ε ∷ []) "Jas.4.3"
∷ word (δ ∷ ι ∷ ό ∷ τ ∷ ι ∷ []) "Jas.4.3"
∷ word (κ ∷ α ∷ κ ∷ ῶ ∷ ς ∷ []) "Jas.4.3"
∷ word (α ∷ ἰ ∷ τ ∷ ε ∷ ῖ ∷ σ ∷ θ ∷ ε ∷ []) "Jas.4.3"
∷ word (ἵ ∷ ν ∷ α ∷ []) "Jas.4.3"
∷ word (ἐ ∷ ν ∷ []) "Jas.4.3"
∷ word (τ ∷ α ∷ ῖ ∷ ς ∷ []) "Jas.4.3"
∷ word (ἡ ∷ δ ∷ ο ∷ ν ∷ α ∷ ῖ ∷ ς ∷ []) "Jas.4.3"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.4.3"
∷ word (δ ∷ α ∷ π ∷ α ∷ ν ∷ ή ∷ σ ∷ η ∷ τ ∷ ε ∷ []) "Jas.4.3"
∷ word (μ ∷ ο ∷ ι ∷ χ ∷ α ∷ ∙λ ∷ ί ∷ δ ∷ ε ∷ ς ∷ []) "Jas.4.4"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.4.4"
∷ word (ο ∷ ἴ ∷ δ ∷ α ∷ τ ∷ ε ∷ []) "Jas.4.4"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.4.4"
∷ word (ἡ ∷ []) "Jas.4.4"
∷ word (φ ∷ ι ∷ ∙λ ∷ ί ∷ α ∷ []) "Jas.4.4"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.4.4"
∷ word (κ ∷ ό ∷ σ ∷ μ ∷ ο ∷ υ ∷ []) "Jas.4.4"
∷ word (ἔ ∷ χ ∷ θ ∷ ρ ∷ α ∷ []) "Jas.4.4"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.4.4"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "Jas.4.4"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.4.4"
∷ word (ὃ ∷ ς ∷ []) "Jas.4.4"
∷ word (ἐ ∷ ὰ ∷ ν ∷ []) "Jas.4.4"
∷ word (ο ∷ ὖ ∷ ν ∷ []) "Jas.4.4"
∷ word (β ∷ ο ∷ υ ∷ ∙λ ∷ η ∷ θ ∷ ῇ ∷ []) "Jas.4.4"
∷ word (φ ∷ ί ∷ ∙λ ∷ ο ∷ ς ∷ []) "Jas.4.4"
∷ word (ε ∷ ἶ ∷ ν ∷ α ∷ ι ∷ []) "Jas.4.4"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.4.4"
∷ word (κ ∷ ό ∷ σ ∷ μ ∷ ο ∷ υ ∷ []) "Jas.4.4"
∷ word (ἐ ∷ χ ∷ θ ∷ ρ ∷ ὸ ∷ ς ∷ []) "Jas.4.4"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.4.4"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "Jas.4.4"
∷ word (κ ∷ α ∷ θ ∷ ί ∷ σ ∷ τ ∷ α ∷ τ ∷ α ∷ ι ∷ []) "Jas.4.4"
∷ word (ἢ ∷ []) "Jas.4.5"
∷ word (δ ∷ ο ∷ κ ∷ ε ∷ ῖ ∷ τ ∷ ε ∷ []) "Jas.4.5"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.4.5"
∷ word (κ ∷ ε ∷ ν ∷ ῶ ∷ ς ∷ []) "Jas.4.5"
∷ word (ἡ ∷ []) "Jas.4.5"
∷ word (γ ∷ ρ ∷ α ∷ φ ∷ ὴ ∷ []) "Jas.4.5"
∷ word (∙λ ∷ έ ∷ γ ∷ ε ∷ ι ∷ []) "Jas.4.5"
∷ word (Π ∷ ρ ∷ ὸ ∷ ς ∷ []) "Jas.4.5"
∷ word (φ ∷ θ ∷ ό ∷ ν ∷ ο ∷ ν ∷ []) "Jas.4.5"
∷ word (ἐ ∷ π ∷ ι ∷ π ∷ ο ∷ θ ∷ ε ∷ ῖ ∷ []) "Jas.4.5"
∷ word (τ ∷ ὸ ∷ []) "Jas.4.5"
∷ word (π ∷ ν ∷ ε ∷ ῦ ∷ μ ∷ α ∷ []) "Jas.4.5"
∷ word (ὃ ∷ []) "Jas.4.5"
∷ word (κ ∷ α ∷ τ ∷ ῴ ∷ κ ∷ ι ∷ σ ∷ ε ∷ ν ∷ []) "Jas.4.5"
∷ word (ἐ ∷ ν ∷ []) "Jas.4.5"
∷ word (ἡ ∷ μ ∷ ῖ ∷ ν ∷ []) "Jas.4.5"
∷ word (μ ∷ ε ∷ ί ∷ ζ ∷ ο ∷ ν ∷ α ∷ []) "Jas.4.6"
∷ word (δ ∷ ὲ ∷ []) "Jas.4.6"
∷ word (δ ∷ ί ∷ δ ∷ ω ∷ σ ∷ ι ∷ ν ∷ []) "Jas.4.6"
∷ word (χ ∷ ά ∷ ρ ∷ ι ∷ ν ∷ []) "Jas.4.6"
∷ word (δ ∷ ι ∷ ὸ ∷ []) "Jas.4.6"
∷ word (∙λ ∷ έ ∷ γ ∷ ε ∷ ι ∷ []) "Jas.4.6"
∷ word (Ὁ ∷ []) "Jas.4.6"
∷ word (θ ∷ ε ∷ ὸ ∷ ς ∷ []) "Jas.4.6"
∷ word (ὑ ∷ π ∷ ε ∷ ρ ∷ η ∷ φ ∷ ά ∷ ν ∷ ο ∷ ι ∷ ς ∷ []) "Jas.4.6"
∷ word (ἀ ∷ ν ∷ τ ∷ ι ∷ τ ∷ ά ∷ σ ∷ σ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.4.6"
∷ word (τ ∷ α ∷ π ∷ ε ∷ ι ∷ ν ∷ ο ∷ ῖ ∷ ς ∷ []) "Jas.4.6"
∷ word (δ ∷ ὲ ∷ []) "Jas.4.6"
∷ word (δ ∷ ί ∷ δ ∷ ω ∷ σ ∷ ι ∷ ν ∷ []) "Jas.4.6"
∷ word (χ ∷ ά ∷ ρ ∷ ι ∷ ν ∷ []) "Jas.4.6"
∷ word (ὑ ∷ π ∷ ο ∷ τ ∷ ά ∷ γ ∷ η ∷ τ ∷ ε ∷ []) "Jas.4.7"
∷ word (ο ∷ ὖ ∷ ν ∷ []) "Jas.4.7"
∷ word (τ ∷ ῷ ∷ []) "Jas.4.7"
∷ word (θ ∷ ε ∷ ῷ ∷ []) "Jas.4.7"
∷ word (ἀ ∷ ν ∷ τ ∷ ί ∷ σ ∷ τ ∷ η ∷ τ ∷ ε ∷ []) "Jas.4.7"
∷ word (δ ∷ ὲ ∷ []) "Jas.4.7"
∷ word (τ ∷ ῷ ∷ []) "Jas.4.7"
∷ word (δ ∷ ι ∷ α ∷ β ∷ ό ∷ ∙λ ∷ ῳ ∷ []) "Jas.4.7"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.7"
∷ word (φ ∷ ε ∷ ύ ∷ ξ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.4.7"
∷ word (ἀ ∷ φ ∷ []) "Jas.4.7"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.4.7"
∷ word (ἐ ∷ γ ∷ γ ∷ ί ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.4.8"
∷ word (τ ∷ ῷ ∷ []) "Jas.4.8"
∷ word (θ ∷ ε ∷ ῷ ∷ []) "Jas.4.8"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.8"
∷ word (ἐ ∷ γ ∷ γ ∷ ι ∷ ε ∷ ῖ ∷ []) "Jas.4.8"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "Jas.4.8"
∷ word (κ ∷ α ∷ θ ∷ α ∷ ρ ∷ ί ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.4.8"
∷ word (χ ∷ ε ∷ ῖ ∷ ρ ∷ α ∷ ς ∷ []) "Jas.4.8"
∷ word (ἁ ∷ μ ∷ α ∷ ρ ∷ τ ∷ ω ∷ ∙λ ∷ ο ∷ ί ∷ []) "Jas.4.8"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.8"
∷ word (ἁ ∷ γ ∷ ν ∷ ί ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.4.8"
∷ word (κ ∷ α ∷ ρ ∷ δ ∷ ί ∷ α ∷ ς ∷ []) "Jas.4.8"
∷ word (δ ∷ ί ∷ ψ ∷ υ ∷ χ ∷ ο ∷ ι ∷ []) "Jas.4.8"
∷ word (τ ∷ α ∷ ∙λ ∷ α ∷ ι ∷ π ∷ ω ∷ ρ ∷ ή ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.4.9"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.9"
∷ word (π ∷ ε ∷ ν ∷ θ ∷ ή ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.4.9"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.9"
∷ word (κ ∷ ∙λ ∷ α ∷ ύ ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.4.9"
∷ word (ὁ ∷ []) "Jas.4.9"
∷ word (γ ∷ έ ∷ ∙λ ∷ ω ∷ ς ∷ []) "Jas.4.9"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.4.9"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.4.9"
∷ word (π ∷ έ ∷ ν ∷ θ ∷ ο ∷ ς ∷ []) "Jas.4.9"
∷ word (μ ∷ ε ∷ τ ∷ α ∷ τ ∷ ρ ∷ α ∷ π ∷ ή ∷ τ ∷ ω ∷ []) "Jas.4.9"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.9"
∷ word (ἡ ∷ []) "Jas.4.9"
∷ word (χ ∷ α ∷ ρ ∷ ὰ ∷ []) "Jas.4.9"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.4.9"
∷ word (κ ∷ α ∷ τ ∷ ή ∷ φ ∷ ε ∷ ι ∷ α ∷ ν ∷ []) "Jas.4.9"
∷ word (τ ∷ α ∷ π ∷ ε ∷ ι ∷ ν ∷ ώ ∷ θ ∷ η ∷ τ ∷ ε ∷ []) "Jas.4.10"
∷ word (ἐ ∷ ν ∷ ώ ∷ π ∷ ι ∷ ο ∷ ν ∷ []) "Jas.4.10"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "Jas.4.10"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.10"
∷ word (ὑ ∷ ψ ∷ ώ ∷ σ ∷ ε ∷ ι ∷ []) "Jas.4.10"
∷ word (ὑ ∷ μ ∷ ᾶ ∷ ς ∷ []) "Jas.4.10"
∷ word (Μ ∷ ὴ ∷ []) "Jas.4.11"
∷ word (κ ∷ α ∷ τ ∷ α ∷ ∙λ ∷ α ∷ ∙λ ∷ ε ∷ ῖ ∷ τ ∷ ε ∷ []) "Jas.4.11"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ ή ∷ ∙λ ∷ ω ∷ ν ∷ []) "Jas.4.11"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.4.11"
∷ word (ὁ ∷ []) "Jas.4.11"
∷ word (κ ∷ α ∷ τ ∷ α ∷ ∙λ ∷ α ∷ ∙λ ∷ ῶ ∷ ν ∷ []) "Jas.4.11"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ῦ ∷ []) "Jas.4.11"
∷ word (ἢ ∷ []) "Jas.4.11"
∷ word (κ ∷ ρ ∷ ί ∷ ν ∷ ω ∷ ν ∷ []) "Jas.4.11"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.4.11"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ὸ ∷ ν ∷ []) "Jas.4.11"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.4.11"
∷ word (κ ∷ α ∷ τ ∷ α ∷ ∙λ ∷ α ∷ ∙λ ∷ ε ∷ ῖ ∷ []) "Jas.4.11"
∷ word (ν ∷ ό ∷ μ ∷ ο ∷ υ ∷ []) "Jas.4.11"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.11"
∷ word (κ ∷ ρ ∷ ί ∷ ν ∷ ε ∷ ι ∷ []) "Jas.4.11"
∷ word (ν ∷ ό ∷ μ ∷ ο ∷ ν ∷ []) "Jas.4.11"
∷ word (ε ∷ ἰ ∷ []) "Jas.4.11"
∷ word (δ ∷ ὲ ∷ []) "Jas.4.11"
∷ word (ν ∷ ό ∷ μ ∷ ο ∷ ν ∷ []) "Jas.4.11"
∷ word (κ ∷ ρ ∷ ί ∷ ν ∷ ε ∷ ι ∷ ς ∷ []) "Jas.4.11"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.4.11"
∷ word (ε ∷ ἶ ∷ []) "Jas.4.11"
∷ word (π ∷ ο ∷ ι ∷ η ∷ τ ∷ ὴ ∷ ς ∷ []) "Jas.4.11"
∷ word (ν ∷ ό ∷ μ ∷ ο ∷ υ ∷ []) "Jas.4.11"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ ὰ ∷ []) "Jas.4.11"
∷ word (κ ∷ ρ ∷ ι ∷ τ ∷ ή ∷ ς ∷ []) "Jas.4.11"
∷ word (ε ∷ ἷ ∷ ς ∷ []) "Jas.4.12"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.4.12"
∷ word (ν ∷ ο ∷ μ ∷ ο ∷ θ ∷ έ ∷ τ ∷ η ∷ ς ∷ []) "Jas.4.12"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.12"
∷ word (κ ∷ ρ ∷ ι ∷ τ ∷ ή ∷ ς ∷ []) "Jas.4.12"
∷ word (ὁ ∷ []) "Jas.4.12"
∷ word (δ ∷ υ ∷ ν ∷ ά ∷ μ ∷ ε ∷ ν ∷ ο ∷ ς ∷ []) "Jas.4.12"
∷ word (σ ∷ ῶ ∷ σ ∷ α ∷ ι ∷ []) "Jas.4.12"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.12"
∷ word (ἀ ∷ π ∷ ο ∷ ∙λ ∷ έ ∷ σ ∷ α ∷ ι ∷ []) "Jas.4.12"
∷ word (σ ∷ ὺ ∷ []) "Jas.4.12"
∷ word (δ ∷ ὲ ∷ []) "Jas.4.12"
∷ word (τ ∷ ί ∷ ς ∷ []) "Jas.4.12"
∷ word (ε ∷ ἶ ∷ []) "Jas.4.12"
∷ word (ὁ ∷ []) "Jas.4.12"
∷ word (κ ∷ ρ ∷ ί ∷ ν ∷ ω ∷ ν ∷ []) "Jas.4.12"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.4.12"
∷ word (π ∷ ∙λ ∷ η ∷ σ ∷ ί ∷ ο ∷ ν ∷ []) "Jas.4.12"
∷ word (Ἄ ∷ γ ∷ ε ∷ []) "Jas.4.13"
∷ word (ν ∷ ῦ ∷ ν ∷ []) "Jas.4.13"
∷ word (ο ∷ ἱ ∷ []) "Jas.4.13"
∷ word (∙λ ∷ έ ∷ γ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "Jas.4.13"
∷ word (Σ ∷ ή ∷ μ ∷ ε ∷ ρ ∷ ο ∷ ν ∷ []) "Jas.4.13"
∷ word (ἢ ∷ []) "Jas.4.13"
∷ word (α ∷ ὔ ∷ ρ ∷ ι ∷ ο ∷ ν ∷ []) "Jas.4.13"
∷ word (π ∷ ο ∷ ρ ∷ ε ∷ υ ∷ σ ∷ ό ∷ μ ∷ ε ∷ θ ∷ α ∷ []) "Jas.4.13"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.4.13"
∷ word (τ ∷ ή ∷ ν ∷ δ ∷ ε ∷ []) "Jas.4.13"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "Jas.4.13"
∷ word (π ∷ ό ∷ ∙λ ∷ ι ∷ ν ∷ []) "Jas.4.13"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.13"
∷ word (π ∷ ο ∷ ι ∷ ή ∷ σ ∷ ο ∷ μ ∷ ε ∷ ν ∷ []) "Jas.4.13"
∷ word (ἐ ∷ κ ∷ ε ∷ ῖ ∷ []) "Jas.4.13"
∷ word (ἐ ∷ ν ∷ ι ∷ α ∷ υ ∷ τ ∷ ὸ ∷ ν ∷ []) "Jas.4.13"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.13"
∷ word (ἐ ∷ μ ∷ π ∷ ο ∷ ρ ∷ ε ∷ υ ∷ σ ∷ ό ∷ μ ∷ ε ∷ θ ∷ α ∷ []) "Jas.4.13"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.13"
∷ word (κ ∷ ε ∷ ρ ∷ δ ∷ ή ∷ σ ∷ ο ∷ μ ∷ ε ∷ ν ∷ []) "Jas.4.13"
∷ word (ο ∷ ἵ ∷ τ ∷ ι ∷ ν ∷ ε ∷ ς ∷ []) "Jas.4.14"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.4.14"
∷ word (ἐ ∷ π ∷ ί ∷ σ ∷ τ ∷ α ∷ σ ∷ θ ∷ ε ∷ []) "Jas.4.14"
∷ word (τ ∷ ὸ ∷ []) "Jas.4.14"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.4.14"
∷ word (α ∷ ὔ ∷ ρ ∷ ι ∷ ο ∷ ν ∷ []) "Jas.4.14"
∷ word (π ∷ ο ∷ ί ∷ α ∷ []) "Jas.4.14"
∷ word (ἡ ∷ []) "Jas.4.14"
∷ word (ζ ∷ ω ∷ ὴ ∷ []) "Jas.4.14"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.4.14"
∷ word (ἀ ∷ τ ∷ μ ∷ ὶ ∷ ς ∷ []) "Jas.4.14"
∷ word (γ ∷ ά ∷ ρ ∷ []) "Jas.4.14"
∷ word (ἐ ∷ σ ∷ τ ∷ ε ∷ []) "Jas.4.14"
∷ word (ἡ ∷ []) "Jas.4.14"
∷ word (π ∷ ρ ∷ ὸ ∷ ς ∷ []) "Jas.4.14"
∷ word (ὀ ∷ ∙λ ∷ ί ∷ γ ∷ ο ∷ ν ∷ []) "Jas.4.14"
∷ word (φ ∷ α ∷ ι ∷ ν ∷ ο ∷ μ ∷ έ ∷ ν ∷ η ∷ []) "Jas.4.14"
∷ word (ἔ ∷ π ∷ ε ∷ ι ∷ τ ∷ α ∷ []) "Jas.4.14"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.14"
∷ word (ἀ ∷ φ ∷ α ∷ ν ∷ ι ∷ ζ ∷ ο ∷ μ ∷ έ ∷ ν ∷ η ∷ []) "Jas.4.14"
∷ word (ἀ ∷ ν ∷ τ ∷ ὶ ∷ []) "Jas.4.15"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.4.15"
∷ word (∙λ ∷ έ ∷ γ ∷ ε ∷ ι ∷ ν ∷ []) "Jas.4.15"
∷ word (ὑ ∷ μ ∷ ᾶ ∷ ς ∷ []) "Jas.4.15"
∷ word (Ἐ ∷ ὰ ∷ ν ∷ []) "Jas.4.15"
∷ word (ὁ ∷ []) "Jas.4.15"
∷ word (κ ∷ ύ ∷ ρ ∷ ι ∷ ο ∷ ς ∷ []) "Jas.4.15"
∷ word (θ ∷ ε ∷ ∙λ ∷ ή ∷ σ ∷ ῃ ∷ []) "Jas.4.15"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.15"
∷ word (ζ ∷ ή ∷ σ ∷ ο ∷ μ ∷ ε ∷ ν ∷ []) "Jas.4.15"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.15"
∷ word (π ∷ ο ∷ ι ∷ ή ∷ σ ∷ ο ∷ μ ∷ ε ∷ ν ∷ []) "Jas.4.15"
∷ word (τ ∷ ο ∷ ῦ ∷ τ ∷ ο ∷ []) "Jas.4.15"
∷ word (ἢ ∷ []) "Jas.4.15"
∷ word (ἐ ∷ κ ∷ ε ∷ ῖ ∷ ν ∷ ο ∷ []) "Jas.4.15"
∷ word (ν ∷ ῦ ∷ ν ∷ []) "Jas.4.16"
∷ word (δ ∷ ὲ ∷ []) "Jas.4.16"
∷ word (κ ∷ α ∷ υ ∷ χ ∷ ᾶ ∷ σ ∷ θ ∷ ε ∷ []) "Jas.4.16"
∷ word (ἐ ∷ ν ∷ []) "Jas.4.16"
∷ word (τ ∷ α ∷ ῖ ∷ ς ∷ []) "Jas.4.16"
∷ word (ἀ ∷ ∙λ ∷ α ∷ ζ ∷ ο ∷ ν ∷ ε ∷ ί ∷ α ∷ ι ∷ ς ∷ []) "Jas.4.16"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.4.16"
∷ word (π ∷ ᾶ ∷ σ ∷ α ∷ []) "Jas.4.16"
∷ word (κ ∷ α ∷ ύ ∷ χ ∷ η ∷ σ ∷ ι ∷ ς ∷ []) "Jas.4.16"
∷ word (τ ∷ ο ∷ ι ∷ α ∷ ύ ∷ τ ∷ η ∷ []) "Jas.4.16"
∷ word (π ∷ ο ∷ ν ∷ η ∷ ρ ∷ ά ∷ []) "Jas.4.16"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.4.16"
∷ word (ε ∷ ἰ ∷ δ ∷ ό ∷ τ ∷ ι ∷ []) "Jas.4.17"
∷ word (ο ∷ ὖ ∷ ν ∷ []) "Jas.4.17"
∷ word (κ ∷ α ∷ ∙λ ∷ ὸ ∷ ν ∷ []) "Jas.4.17"
∷ word (π ∷ ο ∷ ι ∷ ε ∷ ῖ ∷ ν ∷ []) "Jas.4.17"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.4.17"
∷ word (μ ∷ ὴ ∷ []) "Jas.4.17"
∷ word (π ∷ ο ∷ ι ∷ ο ∷ ῦ ∷ ν ∷ τ ∷ ι ∷ []) "Jas.4.17"
∷ word (ἁ ∷ μ ∷ α ∷ ρ ∷ τ ∷ ί ∷ α ∷ []) "Jas.4.17"
∷ word (α ∷ ὐ ∷ τ ∷ ῷ ∷ []) "Jas.4.17"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.4.17"
∷ word (Ἄ ∷ γ ∷ ε ∷ []) "Jas.5.1"
∷ word (ν ∷ ῦ ∷ ν ∷ []) "Jas.5.1"
∷ word (ο ∷ ἱ ∷ []) "Jas.5.1"
∷ word (π ∷ ∙λ ∷ ο ∷ ύ ∷ σ ∷ ι ∷ ο ∷ ι ∷ []) "Jas.5.1"
∷ word (κ ∷ ∙λ ∷ α ∷ ύ ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.5.1"
∷ word (ὀ ∷ ∙λ ∷ ο ∷ ∙λ ∷ ύ ∷ ζ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "Jas.5.1"
∷ word (ἐ ∷ π ∷ ὶ ∷ []) "Jas.5.1"
∷ word (τ ∷ α ∷ ῖ ∷ ς ∷ []) "Jas.5.1"
∷ word (τ ∷ α ∷ ∙λ ∷ α ∷ ι ∷ π ∷ ω ∷ ρ ∷ ί ∷ α ∷ ι ∷ ς ∷ []) "Jas.5.1"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.5.1"
∷ word (τ ∷ α ∷ ῖ ∷ ς ∷ []) "Jas.5.1"
∷ word (ἐ ∷ π ∷ ε ∷ ρ ∷ χ ∷ ο ∷ μ ∷ έ ∷ ν ∷ α ∷ ι ∷ ς ∷ []) "Jas.5.1"
∷ word (ὁ ∷ []) "Jas.5.2"
∷ word (π ∷ ∙λ ∷ ο ∷ ῦ ∷ τ ∷ ο ∷ ς ∷ []) "Jas.5.2"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.5.2"
∷ word (σ ∷ έ ∷ σ ∷ η ∷ π ∷ ε ∷ ν ∷ []) "Jas.5.2"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.2"
∷ word (τ ∷ ὰ ∷ []) "Jas.5.2"
∷ word (ἱ ∷ μ ∷ ά ∷ τ ∷ ι ∷ α ∷ []) "Jas.5.2"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.5.2"
∷ word (σ ∷ η ∷ τ ∷ ό ∷ β ∷ ρ ∷ ω ∷ τ ∷ α ∷ []) "Jas.5.2"
∷ word (γ ∷ έ ∷ γ ∷ ο ∷ ν ∷ ε ∷ ν ∷ []) "Jas.5.2"
∷ word (ὁ ∷ []) "Jas.5.3"
∷ word (χ ∷ ρ ∷ υ ∷ σ ∷ ὸ ∷ ς ∷ []) "Jas.5.3"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.5.3"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.3"
∷ word (ὁ ∷ []) "Jas.5.3"
∷ word (ἄ ∷ ρ ∷ γ ∷ υ ∷ ρ ∷ ο ∷ ς ∷ []) "Jas.5.3"
∷ word (κ ∷ α ∷ τ ∷ ί ∷ ω ∷ τ ∷ α ∷ ι ∷ []) "Jas.5.3"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.3"
∷ word (ὁ ∷ []) "Jas.5.3"
∷ word (ἰ ∷ ὸ ∷ ς ∷ []) "Jas.5.3"
∷ word (α ∷ ὐ ∷ τ ∷ ῶ ∷ ν ∷ []) "Jas.5.3"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.5.3"
∷ word (μ ∷ α ∷ ρ ∷ τ ∷ ύ ∷ ρ ∷ ι ∷ ο ∷ ν ∷ []) "Jas.5.3"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "Jas.5.3"
∷ word (ἔ ∷ σ ∷ τ ∷ α ∷ ι ∷ []) "Jas.5.3"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.3"
∷ word (φ ∷ ά ∷ γ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.5.3"
∷ word (τ ∷ ὰ ∷ ς ∷ []) "Jas.5.3"
∷ word (σ ∷ ά ∷ ρ ∷ κ ∷ α ∷ ς ∷ []) "Jas.5.3"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.5.3"
∷ word (ὡ ∷ ς ∷ []) "Jas.5.3"
∷ word (π ∷ ῦ ∷ ρ ∷ []) "Jas.5.3"
∷ word (ἐ ∷ θ ∷ η ∷ σ ∷ α ∷ υ ∷ ρ ∷ ί ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.5.3"
∷ word (ἐ ∷ ν ∷ []) "Jas.5.3"
∷ word (ἐ ∷ σ ∷ χ ∷ ά ∷ τ ∷ α ∷ ι ∷ ς ∷ []) "Jas.5.3"
∷ word (ἡ ∷ μ ∷ έ ∷ ρ ∷ α ∷ ι ∷ ς ∷ []) "Jas.5.3"
∷ word (ἰ ∷ δ ∷ ο ∷ ὺ ∷ []) "Jas.5.4"
∷ word (ὁ ∷ []) "Jas.5.4"
∷ word (μ ∷ ι ∷ σ ∷ θ ∷ ὸ ∷ ς ∷ []) "Jas.5.4"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "Jas.5.4"
∷ word (ἐ ∷ ρ ∷ γ ∷ α ∷ τ ∷ ῶ ∷ ν ∷ []) "Jas.5.4"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "Jas.5.4"
∷ word (ἀ ∷ μ ∷ η ∷ σ ∷ ά ∷ ν ∷ τ ∷ ω ∷ ν ∷ []) "Jas.5.4"
∷ word (τ ∷ ὰ ∷ ς ∷ []) "Jas.5.4"
∷ word (χ ∷ ώ ∷ ρ ∷ α ∷ ς ∷ []) "Jas.5.4"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.5.4"
∷ word (ὁ ∷ []) "Jas.5.4"
∷ word (ἀ ∷ φ ∷ υ ∷ σ ∷ τ ∷ ε ∷ ρ ∷ η ∷ μ ∷ έ ∷ ν ∷ ο ∷ ς ∷ []) "Jas.5.4"
∷ word (ἀ ∷ φ ∷ []) "Jas.5.4"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.5.4"
∷ word (κ ∷ ρ ∷ ά ∷ ζ ∷ ε ∷ ι ∷ []) "Jas.5.4"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.4"
∷ word (α ∷ ἱ ∷ []) "Jas.5.4"
∷ word (β ∷ ο ∷ α ∷ ὶ ∷ []) "Jas.5.4"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "Jas.5.4"
∷ word (θ ∷ ε ∷ ρ ∷ ι ∷ σ ∷ ά ∷ ν ∷ τ ∷ ω ∷ ν ∷ []) "Jas.5.4"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "Jas.5.4"
∷ word (τ ∷ ὰ ∷ []) "Jas.5.4"
∷ word (ὦ ∷ τ ∷ α ∷ []) "Jas.5.4"
∷ word (Κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "Jas.5.4"
∷ word (Σ ∷ α ∷ β ∷ α ∷ ὼ ∷ θ ∷ []) "Jas.5.4"
∷ word (ε ∷ ἰ ∷ σ ∷ ε ∷ ∙λ ∷ η ∷ ∙λ ∷ ύ ∷ θ ∷ α ∷ σ ∷ ι ∷ ν ∷ []) "Jas.5.4"
∷ word (ἐ ∷ τ ∷ ρ ∷ υ ∷ φ ∷ ή ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.5.5"
∷ word (ἐ ∷ π ∷ ὶ ∷ []) "Jas.5.5"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.5.5"
∷ word (γ ∷ ῆ ∷ ς ∷ []) "Jas.5.5"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.5"
∷ word (ἐ ∷ σ ∷ π ∷ α ∷ τ ∷ α ∷ ∙λ ∷ ή ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.5.5"
∷ word (ἐ ∷ θ ∷ ρ ∷ έ ∷ ψ ∷ α ∷ τ ∷ ε ∷ []) "Jas.5.5"
∷ word (τ ∷ ὰ ∷ ς ∷ []) "Jas.5.5"
∷ word (κ ∷ α ∷ ρ ∷ δ ∷ ί ∷ α ∷ ς ∷ []) "Jas.5.5"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.5.5"
∷ word (ἐ ∷ ν ∷ []) "Jas.5.5"
∷ word (ἡ ∷ μ ∷ έ ∷ ρ ∷ ᾳ ∷ []) "Jas.5.5"
∷ word (σ ∷ φ ∷ α ∷ γ ∷ ῆ ∷ ς ∷ []) "Jas.5.5"
∷ word (κ ∷ α ∷ τ ∷ ε ∷ δ ∷ ι ∷ κ ∷ ά ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.5.6"
∷ word (ἐ ∷ φ ∷ ο ∷ ν ∷ ε ∷ ύ ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.5.6"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.5.6"
∷ word (δ ∷ ί ∷ κ ∷ α ∷ ι ∷ ο ∷ ν ∷ []) "Jas.5.6"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.5.6"
∷ word (ἀ ∷ ν ∷ τ ∷ ι ∷ τ ∷ ά ∷ σ ∷ σ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.5.6"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "Jas.5.6"
∷ word (Μ ∷ α ∷ κ ∷ ρ ∷ ο ∷ θ ∷ υ ∷ μ ∷ ή ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.5.7"
∷ word (ο ∷ ὖ ∷ ν ∷ []) "Jas.5.7"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.5.7"
∷ word (ἕ ∷ ω ∷ ς ∷ []) "Jas.5.7"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.5.7"
∷ word (π ∷ α ∷ ρ ∷ ο ∷ υ ∷ σ ∷ ί ∷ α ∷ ς ∷ []) "Jas.5.7"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.5.7"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "Jas.5.7"
∷ word (ἰ ∷ δ ∷ ο ∷ ὺ ∷ []) "Jas.5.7"
∷ word (ὁ ∷ []) "Jas.5.7"
∷ word (γ ∷ ε ∷ ω ∷ ρ ∷ γ ∷ ὸ ∷ ς ∷ []) "Jas.5.7"
∷ word (ἐ ∷ κ ∷ δ ∷ έ ∷ χ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.5.7"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.5.7"
∷ word (τ ∷ ί ∷ μ ∷ ι ∷ ο ∷ ν ∷ []) "Jas.5.7"
∷ word (κ ∷ α ∷ ρ ∷ π ∷ ὸ ∷ ν ∷ []) "Jas.5.7"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.5.7"
∷ word (γ ∷ ῆ ∷ ς ∷ []) "Jas.5.7"
∷ word (μ ∷ α ∷ κ ∷ ρ ∷ ο ∷ θ ∷ υ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.5.7"
∷ word (ἐ ∷ π ∷ []) "Jas.5.7"
∷ word (α ∷ ὐ ∷ τ ∷ ῷ ∷ []) "Jas.5.7"
∷ word (ἕ ∷ ω ∷ ς ∷ []) "Jas.5.7"
∷ word (∙λ ∷ ά ∷ β ∷ ῃ ∷ []) "Jas.5.7"
∷ word (π ∷ ρ ∷ ό ∷ ϊ ∷ μ ∷ ο ∷ ν ∷ []) "Jas.5.7"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.7"
∷ word (ὄ ∷ ψ ∷ ι ∷ μ ∷ ο ∷ ν ∷ []) "Jas.5.7"
∷ word (μ ∷ α ∷ κ ∷ ρ ∷ ο ∷ θ ∷ υ ∷ μ ∷ ή ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.5.8"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.8"
∷ word (ὑ ∷ μ ∷ ε ∷ ῖ ∷ ς ∷ []) "Jas.5.8"
∷ word (σ ∷ τ ∷ η ∷ ρ ∷ ί ∷ ξ ∷ α ∷ τ ∷ ε ∷ []) "Jas.5.8"
∷ word (τ ∷ ὰ ∷ ς ∷ []) "Jas.5.8"
∷ word (κ ∷ α ∷ ρ ∷ δ ∷ ί ∷ α ∷ ς ∷ []) "Jas.5.8"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.5.8"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.5.8"
∷ word (ἡ ∷ []) "Jas.5.8"
∷ word (π ∷ α ∷ ρ ∷ ο ∷ υ ∷ σ ∷ ί ∷ α ∷ []) "Jas.5.8"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.5.8"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "Jas.5.8"
∷ word (ἤ ∷ γ ∷ γ ∷ ι ∷ κ ∷ ε ∷ ν ∷ []) "Jas.5.8"
∷ word (μ ∷ ὴ ∷ []) "Jas.5.9"
∷ word (σ ∷ τ ∷ ε ∷ ν ∷ ά ∷ ζ ∷ ε ∷ τ ∷ ε ∷ []) "Jas.5.9"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.5.9"
∷ word (κ ∷ α ∷ τ ∷ []) "Jas.5.9"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ ή ∷ ∙λ ∷ ω ∷ ν ∷ []) "Jas.5.9"
∷ word (ἵ ∷ ν ∷ α ∷ []) "Jas.5.9"
∷ word (μ ∷ ὴ ∷ []) "Jas.5.9"
∷ word (κ ∷ ρ ∷ ι ∷ θ ∷ ῆ ∷ τ ∷ ε ∷ []) "Jas.5.9"
∷ word (ἰ ∷ δ ∷ ο ∷ ὺ ∷ []) "Jas.5.9"
∷ word (ὁ ∷ []) "Jas.5.9"
∷ word (κ ∷ ρ ∷ ι ∷ τ ∷ ὴ ∷ ς ∷ []) "Jas.5.9"
∷ word (π ∷ ρ ∷ ὸ ∷ []) "Jas.5.9"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "Jas.5.9"
∷ word (θ ∷ υ ∷ ρ ∷ ῶ ∷ ν ∷ []) "Jas.5.9"
∷ word (ἕ ∷ σ ∷ τ ∷ η ∷ κ ∷ ε ∷ ν ∷ []) "Jas.5.9"
∷ word (ὑ ∷ π ∷ ό ∷ δ ∷ ε ∷ ι ∷ γ ∷ μ ∷ α ∷ []) "Jas.5.10"
∷ word (∙λ ∷ ά ∷ β ∷ ε ∷ τ ∷ ε ∷ []) "Jas.5.10"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.5.10"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.5.10"
∷ word (κ ∷ α ∷ κ ∷ ο ∷ π ∷ α ∷ θ ∷ ί ∷ α ∷ ς ∷ []) "Jas.5.10"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.10"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.5.10"
∷ word (μ ∷ α ∷ κ ∷ ρ ∷ ο ∷ θ ∷ υ ∷ μ ∷ ί ∷ α ∷ ς ∷ []) "Jas.5.10"
∷ word (τ ∷ ο ∷ ὺ ∷ ς ∷ []) "Jas.5.10"
∷ word (π ∷ ρ ∷ ο ∷ φ ∷ ή ∷ τ ∷ α ∷ ς ∷ []) "Jas.5.10"
∷ word (ο ∷ ἳ ∷ []) "Jas.5.10"
∷ word (ἐ ∷ ∙λ ∷ ά ∷ ∙λ ∷ η ∷ σ ∷ α ∷ ν ∷ []) "Jas.5.10"
∷ word (ἐ ∷ ν ∷ []) "Jas.5.10"
∷ word (τ ∷ ῷ ∷ []) "Jas.5.10"
∷ word (ὀ ∷ ν ∷ ό ∷ μ ∷ α ∷ τ ∷ ι ∷ []) "Jas.5.10"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "Jas.5.10"
∷ word (ἰ ∷ δ ∷ ο ∷ ὺ ∷ []) "Jas.5.11"
∷ word (μ ∷ α ∷ κ ∷ α ∷ ρ ∷ ί ∷ ζ ∷ ο ∷ μ ∷ ε ∷ ν ∷ []) "Jas.5.11"
∷ word (τ ∷ ο ∷ ὺ ∷ ς ∷ []) "Jas.5.11"
∷ word (ὑ ∷ π ∷ ο ∷ μ ∷ ε ∷ ί ∷ ν ∷ α ∷ ν ∷ τ ∷ α ∷ ς ∷ []) "Jas.5.11"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "Jas.5.11"
∷ word (ὑ ∷ π ∷ ο ∷ μ ∷ ο ∷ ν ∷ ὴ ∷ ν ∷ []) "Jas.5.11"
∷ word (Ἰ ∷ ὼ ∷ β ∷ []) "Jas.5.11"
∷ word (ἠ ∷ κ ∷ ο ∷ ύ ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "Jas.5.11"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.11"
∷ word (τ ∷ ὸ ∷ []) "Jas.5.11"
∷ word (τ ∷ έ ∷ ∙λ ∷ ο ∷ ς ∷ []) "Jas.5.11"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "Jas.5.11"
∷ word (ε ∷ ἴ ∷ δ ∷ ε ∷ τ ∷ ε ∷ []) "Jas.5.11"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.5.11"
∷ word (π ∷ ο ∷ ∙λ ∷ ύ ∷ σ ∷ π ∷ ∙λ ∷ α ∷ γ ∷ χ ∷ ν ∷ ό ∷ ς ∷ []) "Jas.5.11"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "Jas.5.11"
∷ word (ὁ ∷ []) "Jas.5.11"
∷ word (κ ∷ ύ ∷ ρ ∷ ι ∷ ο ∷ ς ∷ []) "Jas.5.11"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.11"
∷ word (ο ∷ ἰ ∷ κ ∷ τ ∷ ί ∷ ρ ∷ μ ∷ ω ∷ ν ∷ []) "Jas.5.11"
∷ word (Π ∷ ρ ∷ ὸ ∷ []) "Jas.5.12"
∷ word (π ∷ ά ∷ ν ∷ τ ∷ ω ∷ ν ∷ []) "Jas.5.12"
∷ word (δ ∷ έ ∷ []) "Jas.5.12"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.5.12"
∷ word (μ ∷ ο ∷ υ ∷ []) "Jas.5.12"
∷ word (μ ∷ ὴ ∷ []) "Jas.5.12"
∷ word (ὀ ∷ μ ∷ ν ∷ ύ ∷ ε ∷ τ ∷ ε ∷ []) "Jas.5.12"
∷ word (μ ∷ ή ∷ τ ∷ ε ∷ []) "Jas.5.12"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.5.12"
∷ word (ο ∷ ὐ ∷ ρ ∷ α ∷ ν ∷ ὸ ∷ ν ∷ []) "Jas.5.12"
∷ word (μ ∷ ή ∷ τ ∷ ε ∷ []) "Jas.5.12"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "Jas.5.12"
∷ word (γ ∷ ῆ ∷ ν ∷ []) "Jas.5.12"
∷ word (μ ∷ ή ∷ τ ∷ ε ∷ []) "Jas.5.12"
∷ word (ἄ ∷ ∙λ ∷ ∙λ ∷ ο ∷ ν ∷ []) "Jas.5.12"
∷ word (τ ∷ ι ∷ ν ∷ ὰ ∷ []) "Jas.5.12"
∷ word (ὅ ∷ ρ ∷ κ ∷ ο ∷ ν ∷ []) "Jas.5.12"
∷ word (ἤ ∷ τ ∷ ω ∷ []) "Jas.5.12"
∷ word (δ ∷ ὲ ∷ []) "Jas.5.12"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "Jas.5.12"
∷ word (τ ∷ ὸ ∷ []) "Jas.5.12"
∷ word (Ν ∷ α ∷ ὶ ∷ []) "Jas.5.12"
∷ word (ν ∷ α ∷ ὶ ∷ []) "Jas.5.12"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.12"
∷ word (τ ∷ ὸ ∷ []) "Jas.5.12"
∷ word (Ο ∷ ὒ ∷ []) "Jas.5.12"
∷ word (ο ∷ ὔ ∷ []) "Jas.5.12"
∷ word (ἵ ∷ ν ∷ α ∷ []) "Jas.5.12"
∷ word (μ ∷ ὴ ∷ []) "Jas.5.12"
∷ word (ὑ ∷ π ∷ ὸ ∷ []) "Jas.5.12"
∷ word (κ ∷ ρ ∷ ί ∷ σ ∷ ι ∷ ν ∷ []) "Jas.5.12"
∷ word (π ∷ έ ∷ σ ∷ η ∷ τ ∷ ε ∷ []) "Jas.5.12"
∷ word (Κ ∷ α ∷ κ ∷ ο ∷ π ∷ α ∷ θ ∷ ε ∷ ῖ ∷ []) "Jas.5.13"
∷ word (τ ∷ ι ∷ ς ∷ []) "Jas.5.13"
∷ word (ἐ ∷ ν ∷ []) "Jas.5.13"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "Jas.5.13"
∷ word (π ∷ ρ ∷ ο ∷ σ ∷ ε ∷ υ ∷ χ ∷ έ ∷ σ ∷ θ ∷ ω ∷ []) "Jas.5.13"
∷ word (ε ∷ ὐ ∷ θ ∷ υ ∷ μ ∷ ε ∷ ῖ ∷ []) "Jas.5.13"
∷ word (τ ∷ ι ∷ ς ∷ []) "Jas.5.13"
∷ word (ψ ∷ α ∷ ∙λ ∷ ∙λ ∷ έ ∷ τ ∷ ω ∷ []) "Jas.5.13"
∷ word (ἀ ∷ σ ∷ θ ∷ ε ∷ ν ∷ ε ∷ ῖ ∷ []) "Jas.5.14"
∷ word (τ ∷ ι ∷ ς ∷ []) "Jas.5.14"
∷ word (ἐ ∷ ν ∷ []) "Jas.5.14"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "Jas.5.14"
∷ word (π ∷ ρ ∷ ο ∷ σ ∷ κ ∷ α ∷ ∙λ ∷ ε ∷ σ ∷ ά ∷ σ ∷ θ ∷ ω ∷ []) "Jas.5.14"
∷ word (τ ∷ ο ∷ ὺ ∷ ς ∷ []) "Jas.5.14"
∷ word (π ∷ ρ ∷ ε ∷ σ ∷ β ∷ υ ∷ τ ∷ έ ∷ ρ ∷ ο ∷ υ ∷ ς ∷ []) "Jas.5.14"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.5.14"
∷ word (ἐ ∷ κ ∷ κ ∷ ∙λ ∷ η ∷ σ ∷ ί ∷ α ∷ ς ∷ []) "Jas.5.14"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.14"
∷ word (π ∷ ρ ∷ ο ∷ σ ∷ ε ∷ υ ∷ ξ ∷ ά ∷ σ ∷ θ ∷ ω ∷ σ ∷ α ∷ ν ∷ []) "Jas.5.14"
∷ word (ἐ ∷ π ∷ []) "Jas.5.14"
∷ word (α ∷ ὐ ∷ τ ∷ ὸ ∷ ν ∷ []) "Jas.5.14"
∷ word (ἀ ∷ ∙λ ∷ ε ∷ ί ∷ ψ ∷ α ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "Jas.5.14"
∷ word (α ∷ ὐ ∷ τ ∷ ὸ ∷ ν ∷ []) "Jas.5.14"
∷ word (ἐ ∷ ∙λ ∷ α ∷ ί ∷ ῳ ∷ []) "Jas.5.14"
∷ word (ἐ ∷ ν ∷ []) "Jas.5.14"
∷ word (τ ∷ ῷ ∷ []) "Jas.5.14"
∷ word (ὀ ∷ ν ∷ ό ∷ μ ∷ α ∷ τ ∷ ι ∷ []) "Jas.5.14"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.5.14"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "Jas.5.14"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.15"
∷ word (ἡ ∷ []) "Jas.5.15"
∷ word (ε ∷ ὐ ∷ χ ∷ ὴ ∷ []) "Jas.5.15"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.5.15"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ε ∷ ω ∷ ς ∷ []) "Jas.5.15"
∷ word (σ ∷ ώ ∷ σ ∷ ε ∷ ι ∷ []) "Jas.5.15"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.5.15"
∷ word (κ ∷ ά ∷ μ ∷ ν ∷ ο ∷ ν ∷ τ ∷ α ∷ []) "Jas.5.15"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.15"
∷ word (ἐ ∷ γ ∷ ε ∷ ρ ∷ ε ∷ ῖ ∷ []) "Jas.5.15"
∷ word (α ∷ ὐ ∷ τ ∷ ὸ ∷ ν ∷ []) "Jas.5.15"
∷ word (ὁ ∷ []) "Jas.5.15"
∷ word (κ ∷ ύ ∷ ρ ∷ ι ∷ ο ∷ ς ∷ []) "Jas.5.15"
∷ word (κ ∷ ἂ ∷ ν ∷ []) "Jas.5.15"
∷ word (ἁ ∷ μ ∷ α ∷ ρ ∷ τ ∷ ί ∷ α ∷ ς ∷ []) "Jas.5.15"
∷ word (ᾖ ∷ []) "Jas.5.15"
∷ word (π ∷ ε ∷ π ∷ ο ∷ ι ∷ η ∷ κ ∷ ώ ∷ ς ∷ []) "Jas.5.15"
∷ word (ἀ ∷ φ ∷ ε ∷ θ ∷ ή ∷ σ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "Jas.5.15"
∷ word (α ∷ ὐ ∷ τ ∷ ῷ ∷ []) "Jas.5.15"
∷ word (ἐ ∷ ξ ∷ ο ∷ μ ∷ ο ∷ ∙λ ∷ ο ∷ γ ∷ ε ∷ ῖ ∷ σ ∷ θ ∷ ε ∷ []) "Jas.5.16"
∷ word (ο ∷ ὖ ∷ ν ∷ []) "Jas.5.16"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ ή ∷ ∙λ ∷ ο ∷ ι ∷ ς ∷ []) "Jas.5.16"
∷ word (τ ∷ ὰ ∷ ς ∷ []) "Jas.5.16"
∷ word (ἁ ∷ μ ∷ α ∷ ρ ∷ τ ∷ ί ∷ α ∷ ς ∷ []) "Jas.5.16"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.16"
∷ word (ε ∷ ὔ ∷ χ ∷ ε ∷ σ ∷ θ ∷ ε ∷ []) "Jas.5.16"
∷ word (ὑ ∷ π ∷ ὲ ∷ ρ ∷ []) "Jas.5.16"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ ή ∷ ∙λ ∷ ω ∷ ν ∷ []) "Jas.5.16"
∷ word (ὅ ∷ π ∷ ω ∷ ς ∷ []) "Jas.5.16"
∷ word (ἰ ∷ α ∷ θ ∷ ῆ ∷ τ ∷ ε ∷ []) "Jas.5.16"
∷ word (π ∷ ο ∷ ∙λ ∷ ὺ ∷ []) "Jas.5.16"
∷ word (ἰ ∷ σ ∷ χ ∷ ύ ∷ ε ∷ ι ∷ []) "Jas.5.16"
∷ word (δ ∷ έ ∷ η ∷ σ ∷ ι ∷ ς ∷ []) "Jas.5.16"
∷ word (δ ∷ ι ∷ κ ∷ α ∷ ί ∷ ο ∷ υ ∷ []) "Jas.5.16"
∷ word (ἐ ∷ ν ∷ ε ∷ ρ ∷ γ ∷ ο ∷ υ ∷ μ ∷ έ ∷ ν ∷ η ∷ []) "Jas.5.16"
∷ word (Ἠ ∷ ∙λ ∷ ί ∷ α ∷ ς ∷ []) "Jas.5.17"
∷ word (ἄ ∷ ν ∷ θ ∷ ρ ∷ ω ∷ π ∷ ο ∷ ς ∷ []) "Jas.5.17"
∷ word (ἦ ∷ ν ∷ []) "Jas.5.17"
∷ word (ὁ ∷ μ ∷ ο ∷ ι ∷ ο ∷ π ∷ α ∷ θ ∷ ὴ ∷ ς ∷ []) "Jas.5.17"
∷ word (ἡ ∷ μ ∷ ῖ ∷ ν ∷ []) "Jas.5.17"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.17"
∷ word (π ∷ ρ ∷ ο ∷ σ ∷ ε ∷ υ ∷ χ ∷ ῇ ∷ []) "Jas.5.17"
∷ word (π ∷ ρ ∷ ο ∷ σ ∷ η ∷ ύ ∷ ξ ∷ α ∷ τ ∷ ο ∷ []) "Jas.5.17"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Jas.5.17"
∷ word (μ ∷ ὴ ∷ []) "Jas.5.17"
∷ word (β ∷ ρ ∷ έ ∷ ξ ∷ α ∷ ι ∷ []) "Jas.5.17"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.17"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "Jas.5.17"
∷ word (ἔ ∷ β ∷ ρ ∷ ε ∷ ξ ∷ ε ∷ ν ∷ []) "Jas.5.17"
∷ word (ἐ ∷ π ∷ ὶ ∷ []) "Jas.5.17"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.5.17"
∷ word (γ ∷ ῆ ∷ ς ∷ []) "Jas.5.17"
∷ word (ἐ ∷ ν ∷ ι ∷ α ∷ υ ∷ τ ∷ ο ∷ ὺ ∷ ς ∷ []) "Jas.5.17"
∷ word (τ ∷ ρ ∷ ε ∷ ῖ ∷ ς ∷ []) "Jas.5.17"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.17"
∷ word (μ ∷ ῆ ∷ ν ∷ α ∷ ς ∷ []) "Jas.5.17"
∷ word (ἕ ∷ ξ ∷ []) "Jas.5.17"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.18"
∷ word (π ∷ ά ∷ ∙λ ∷ ι ∷ ν ∷ []) "Jas.5.18"
∷ word (π ∷ ρ ∷ ο ∷ σ ∷ η ∷ ύ ∷ ξ ∷ α ∷ τ ∷ ο ∷ []) "Jas.5.18"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.18"
∷ word (ὁ ∷ []) "Jas.5.18"
∷ word (ο ∷ ὐ ∷ ρ ∷ α ∷ ν ∷ ὸ ∷ ς ∷ []) "Jas.5.18"
∷ word (ὑ ∷ ε ∷ τ ∷ ὸ ∷ ν ∷ []) "Jas.5.18"
∷ word (ἔ ∷ δ ∷ ω ∷ κ ∷ ε ∷ ν ∷ []) "Jas.5.18"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.18"
∷ word (ἡ ∷ []) "Jas.5.18"
∷ word (γ ∷ ῆ ∷ []) "Jas.5.18"
∷ word (ἐ ∷ β ∷ ∙λ ∷ ά ∷ σ ∷ τ ∷ η ∷ σ ∷ ε ∷ ν ∷ []) "Jas.5.18"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "Jas.5.18"
∷ word (κ ∷ α ∷ ρ ∷ π ∷ ὸ ∷ ν ∷ []) "Jas.5.18"
∷ word (α ∷ ὐ ∷ τ ∷ ῆ ∷ ς ∷ []) "Jas.5.18"
∷ word (Ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "Jas.5.19"
∷ word (μ ∷ ο ∷ υ ∷ []) "Jas.5.19"
∷ word (ἐ ∷ ά ∷ ν ∷ []) "Jas.5.19"
∷ word (τ ∷ ι ∷ ς ∷ []) "Jas.5.19"
∷ word (ἐ ∷ ν ∷ []) "Jas.5.19"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "Jas.5.19"
∷ word (π ∷ ∙λ ∷ α ∷ ν ∷ η ∷ θ ∷ ῇ ∷ []) "Jas.5.19"
∷ word (ἀ ∷ π ∷ ὸ ∷ []) "Jas.5.19"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "Jas.5.19"
∷ word (ἀ ∷ ∙λ ∷ η ∷ θ ∷ ε ∷ ί ∷ α ∷ ς ∷ []) "Jas.5.19"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.19"
∷ word (ἐ ∷ π ∷ ι ∷ σ ∷ τ ∷ ρ ∷ έ ∷ ψ ∷ ῃ ∷ []) "Jas.5.19"
∷ word (τ ∷ ι ∷ ς ∷ []) "Jas.5.19"
∷ word (α ∷ ὐ ∷ τ ∷ ό ∷ ν ∷ []) "Jas.5.19"
∷ word (γ ∷ ι ∷ ν ∷ ω ∷ σ ∷ κ ∷ έ ∷ τ ∷ ω ∷ []) "Jas.5.20"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "Jas.5.20"
∷ word (ὁ ∷ []) "Jas.5.20"
∷ word (ἐ ∷ π ∷ ι ∷ σ ∷ τ ∷ ρ ∷ έ ∷ ψ ∷ α ∷ ς ∷ []) "Jas.5.20"
∷ word (ἁ ∷ μ ∷ α ∷ ρ ∷ τ ∷ ω ∷ ∙λ ∷ ὸ ∷ ν ∷ []) "Jas.5.20"
∷ word (ἐ ∷ κ ∷ []) "Jas.5.20"
∷ word (π ∷ ∙λ ∷ ά ∷ ν ∷ η ∷ ς ∷ []) "Jas.5.20"
∷ word (ὁ ∷ δ ∷ ο ∷ ῦ ∷ []) "Jas.5.20"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.5.20"
∷ word (σ ∷ ώ ∷ σ ∷ ε ∷ ι ∷ []) "Jas.5.20"
∷ word (ψ ∷ υ ∷ χ ∷ ὴ ∷ ν ∷ []) "Jas.5.20"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "Jas.5.20"
∷ word (ἐ ∷ κ ∷ []) "Jas.5.20"
∷ word (θ ∷ α ∷ ν ∷ ά ∷ τ ∷ ο ∷ υ ∷ []) "Jas.5.20"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Jas.5.20"
∷ word (κ ∷ α ∷ ∙λ ∷ ύ ∷ ψ ∷ ε ∷ ι ∷ []) "Jas.5.20"
∷ word (π ∷ ∙λ ∷ ῆ ∷ θ ∷ ο ∷ ς ∷ []) "Jas.5.20"
∷ word (ἁ ∷ μ ∷ α ∷ ρ ∷ τ ∷ ι ∷ ῶ ∷ ν ∷ []) "Jas.5.20"
∷ []
| {
"alphanum_fraction": 0.3266746503,
"avg_line_length": 44.8537142857,
"ext": "agda",
"hexsha": "2df9aa5163792374483f054fc79627b5d18302be",
"lang": "Agda",
"max_forks_count": 5,
"max_forks_repo_forks_event_max_datetime": "2017-06-11T11:25:09.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-02-27T22:34:13.000Z",
"max_forks_repo_head_hexsha": "915c46c27c7f8aad5907474d8484f2685a4cd6a7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "scott-fleischman/GreekGrammar",
"max_forks_repo_path": "agda/Text/Greek/SBLGNT/Jas.agda",
"max_issues_count": 13,
"max_issues_repo_head_hexsha": "915c46c27c7f8aad5907474d8484f2685a4cd6a7",
"max_issues_repo_issues_event_max_datetime": "2020-09-07T11:58:38.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-05-28T20:04:08.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "scott-fleischman/GreekGrammar",
"max_issues_repo_path": "agda/Text/Greek/SBLGNT/Jas.agda",
"max_line_length": 91,
"max_stars_count": 44,
"max_stars_repo_head_hexsha": "915c46c27c7f8aad5907474d8484f2685a4cd6a7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "scott-fleischman/GreekGrammar",
"max_stars_repo_path": "agda/Text/Greek/SBLGNT/Jas.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-06T15:41:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-05-29T14:48:51.000Z",
"num_tokens": 57280,
"size": 78494
} |
module Logic.Equivalence where
import Logic.Relations
open Logic.Relations
record Equivalence (A : Set) : Set1 where
field
_==_ : Rel A
refl : Reflexive _==_
sym : Symmetric _==_
trans : Transitive _==_
| {
"alphanum_fraction": 0.658008658,
"avg_line_length": 16.5,
"ext": "agda",
"hexsha": "3b73efb29af6afb40f7b47e7668b6959ecf405ed",
"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/outdated-and-incorrect/AIM6/Cat/lib/Logic/Equivalence.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/outdated-and-incorrect/AIM6/Cat/lib/Logic/Equivalence.agda",
"max_line_length": 41,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "examples/outdated-and-incorrect/AIM6/Cat/lib/Logic/Equivalence.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 70,
"size": 231
} |
{-# OPTIONS --cubical --no-import-sorts #-}
module MorePropAlgebra where
open import MorePropAlgebra.Definitions public
open import MorePropAlgebra.Structures public
open import MorePropAlgebra.Bundles public
open import MorePropAlgebra.Consequences public
| {
"alphanum_fraction": 0.8346153846,
"avg_line_length": 28.8888888889,
"ext": "agda",
"hexsha": "e3d74ce5b113ad3dc8108467cf178cf06d6a7651",
"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": "10206b5c3eaef99ece5d18bf703c9e8b2371bde4",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "mchristianl/synthetic-reals",
"max_forks_repo_path": "agda/MorePropAlgebra.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "10206b5c3eaef99ece5d18bf703c9e8b2371bde4",
"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": "mchristianl/synthetic-reals",
"max_issues_repo_path": "agda/MorePropAlgebra.agda",
"max_line_length": 47,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "10206b5c3eaef99ece5d18bf703c9e8b2371bde4",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "mchristianl/synthetic-reals",
"max_stars_repo_path": "agda/MorePropAlgebra.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-19T12:15:21.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-07-31T18:15:26.000Z",
"num_tokens": 61,
"size": 260
} |
module _ where
primitive
primGlue : _
| {
"alphanum_fraction": 0.7317073171,
"avg_line_length": 8.2,
"ext": "agda",
"hexsha": "5a610d6b11dfe272c1fe079abb82d5f18815eda6",
"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/Issue2788b.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/Issue2788b.agda",
"max_line_length": 14,
"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/Issue2788b.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": 12,
"size": 41
} |
open import Relation.Binary using (Preorder)
open import Relation.Binary.PropositionalEquality
module Category.Monad.Monotone {ℓ}(pre : Preorder ℓ ℓ ℓ) where
open Preorder pre renaming (Carrier to I; _∼_ to _≤_; refl to ≤-refl)
open import Function
open import Level
open import Relation.Unary
open import Relation.Unary.Monotone pre
open import Relation.Unary.Monotone.Prefix
open import Relation.Unary.PredicateTransformer using (Pt)
open import Category.Monad.Predicate
open import Data.List
open import Data.Product
open import Data.List.All
record RawMPMonad (M : Pt I ℓ) : Set (suc ℓ) where
infixl 1 _≥=_
field
return : ∀ {P} → P ⊆ M P
_≥=_ : ∀ {P Q} → M P ⊆ ((P ↗ M Q) ⇒ M Q)
-- we get the predicate-monad bind for free
_>>=_ : ∀ {P Q} → M P ⊆ (λ i → (P ⊆ M Q) → M Q i)
c >>= f = c ≥= λ i≤j pj → f pj
-- which is only useful because we also get monadic strength for free:
infixl 10 _^_
_^_ : ∀ {P Q : Pred I ℓ}⦃ m : Monotone Q ⦄ → M P ⊆ (Q ⇒ M (P ∩ Q))
c ^ qi = c ≥= λ {j} x≤j pj → return (pj , wk x≤j qi)
ts : ∀ {P : Pred I ℓ} Q ⦃ m : Monotone Q ⦄ → M P ⊆ (Q ⇒ M (P ∩ Q))
ts _ c qi = c ^ qi
mapM : ∀ {P Q} → M P ⊆ ((P ↗ Q) ⇒ M Q)
mapM m f = m ≥= (λ w p → return (f w p))
sequenceM′ : ∀ {A : Set ℓ}{P : A → Pred I ℓ}{as} ⦃ mp : ∀ {a} → Monotone (P a) ⦄ {i k} → i ≤ k →
All (λ a → ∀≥[ M (P a) ] i) as → M (λ j → All (λ a → P a j) as) k
sequenceM′ _ [] = return []
sequenceM′ {P}⦃ mp ⦄ le (x ∷ xs) = do
px , le ← x le ^ le
pxs , px ← sequenceM′ le xs ^ px
return (px ∷ pxs)
sequenceM : ∀ {A : Set ℓ}{P : A → Pred I ℓ}{as} ⦃ mp : ∀ {a} → Monotone (P a) ⦄ {i} →
All (λ a → ∀≥[ M (P a) ] i) as → M (λ j → All (λ a → P a j) as) i
sequenceM = sequenceM′ ≤-refl
pmonad : RawPMonad {ℓ = ℓ} M
pmonad = record
{ return? = return
; _=<?_ = λ f px → px >>= f }
| {
"alphanum_fraction": 0.5519271949,
"avg_line_length": 32.7719298246,
"ext": "agda",
"hexsha": "8d582f7b0cc003cee9d5c7b5fea45f4084b6edfb",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-12-28T17:38:05.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-12-28T17:38:05.000Z",
"max_forks_repo_head_hexsha": "0c096fea1716d714db0ff204ef2a9450b7a816df",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "metaborg/mj.agda",
"max_forks_repo_path": "src/Category/Monad/Monotone.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "0c096fea1716d714db0ff204ef2a9450b7a816df",
"max_issues_repo_issues_event_max_datetime": "2020-10-14T13:41:58.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-13T13:03:47.000Z",
"max_issues_repo_licenses": [
"Apache-2.0"
],
"max_issues_repo_name": "metaborg/mj.agda",
"max_issues_repo_path": "src/Category/Monad/Monotone.agda",
"max_line_length": 98,
"max_stars_count": 10,
"max_stars_repo_head_hexsha": "0c096fea1716d714db0ff204ef2a9450b7a816df",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "metaborg/mj.agda",
"max_stars_repo_path": "src/Category/Monad/Monotone.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": 766,
"size": 1868
} |
module my-bool-test where
open import bool
open import eq
open import level
~~tt : ~ ~ tt ≡ tt
~~tt = refl
~~ff : ~ ~ ff ≡ ff
~~ff = refl
{-
~~-elim : ∀ (b : 𝔹) → ~ ~ b ≡ b
~~-elim tt = refl
~~-elim ff = refl
-}
~~-elim2 : ∀ (b : 𝔹) → ~ ~ b ≡ b
~~-elim2 tt = ~~tt
~~-elim2 ff = ~~ff
~~tt' : ~ ~ tt ≡ tt
~~tt' = refl{lzero}{𝔹}{tt}
~~ff' : ~ ~ ff ≡ ff
~~ff' = refl{lzero}{𝔹}{ff}
~~-elim : ∀ (b : 𝔹) → ~ ~ b ≡ b
~~-elim tt = refl
~~-elim ff = refl
||≡ff₁ : ∀ {b1 b2} → b1 || b2 ≡ ff → b1 ≡ ff
||≡ff₁ {ff} _ = refl{lzero}{𝔹}{ff}
||≡ff₁ {tt} ()
||≡ff₂ : ∀ {b1 b2} → b1 || b2 ≡ ff → ff ≡ b1
||≡ff₂ {ff} _ = refl{lzero}{𝔹}{ff}
||≡ff₂ {tt} p = sym p
||-cong₁ : ∀ {b1 b1' b2} → b1 ≡ b1' → b1 || b2 ≡ b1' || b2
||-cong₁{b1}{.b1}{b2} refl = refl
||-cong₂ : ∀ {b1 b2 b2'} → b2 ≡ b2' → b1 || b2 ≡ b1 || b2'
||-cong₂ p rewrite p = refl
ite-same : ∀{ℓ}{A : Set ℓ} →
∀(b : 𝔹) (x : A) →
(if b then x else x) ≡ x
ite-same tt x = refl
ite-same ff x = refl
𝔹-contra : ff ≡ tt → ∀ {P : Set} → P
𝔹-contra ()
p : ff && ff ≡ ~ tt
p = refl
| {
"alphanum_fraction": 0.4485714286,
"avg_line_length": 18.75,
"ext": "agda",
"hexsha": "04cd1a57309e0fb14cdb3499fe7b89c47c31e4ca",
"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": "my-bool-test.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": "my-bool-test.agda",
"max_line_length": 58,
"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": "my-bool-test.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 539,
"size": 1050
} |
module PatternSynonymAmbiguousParse where
data X : Set where
if_then_else_ : X -> X -> X -> X
if_then_ : X -> X -> X
x : X
pattern bad x = if x then if x then x else x
| {
"alphanum_fraction": 0.585492228,
"avg_line_length": 21.4444444444,
"ext": "agda",
"hexsha": "bc2e132443e2e3b956e98068d943077377b18734",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "masondesu/agda",
"max_forks_repo_path": "test/fail/PatternSynonymAmbiguousParse.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "masondesu/agda",
"max_issues_repo_path": "test/fail/PatternSynonymAmbiguousParse.agda",
"max_line_length": 44,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/agda-kanso",
"max_stars_repo_path": "test/fail/PatternSynonymAmbiguousParse.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": 61,
"size": 193
} |
------------------------------------------------------------------------
-- Laws related to D
------------------------------------------------------------------------
module TotalParserCombinators.Laws.Derivative where
open import Algebra
open import Codata.Musical.Notation
open import Data.List
import Data.List.Categorical as List
import Data.List.Relation.Binary.BagAndSetEquality as BSEq
open import Data.Maybe using (Maybe); open Data.Maybe.Maybe
open import Function using (_∘_; _$_)
private
module BagMonoid {k} {A : Set} =
CommutativeMonoid (BSEq.commutativeMonoid k A)
open import TotalParserCombinators.Derivative
open import TotalParserCombinators.Congruence as Eq
hiding (return; fail)
import TotalParserCombinators.Laws.AdditiveMonoid as AdditiveMonoid
open import TotalParserCombinators.Lib
open import TotalParserCombinators.Parser
-- Unfolding lemma for D applied to return⋆.
D-return⋆ : ∀ {Tok R t} (xs : List R) →
D t (return⋆ xs) ≅P fail {Tok = Tok}
D-return⋆ [] = fail ∎
D-return⋆ {t = t} (x ∷ xs) =
fail ∣ D t (return⋆ xs) ≅⟨ AdditiveMonoid.left-identity (D t (return⋆ xs)) ⟩
D t (return⋆ xs) ≅⟨ D-return⋆ xs ⟩
fail ∎
mutual
-- Unfolding lemma for D applied to _⊛_.
D-⊛ : ∀ {Tok R₁ R₂ fs xs t}
(p₁ : ∞⟨ xs ⟩Parser Tok (R₁ → R₂) (flatten fs))
(p₂ : ∞⟨ fs ⟩Parser Tok R₁ (flatten xs)) →
D t (p₁ ⊛ p₂) ≅P
D t (♭? p₁) ⊛ ♭? p₂ ∣ return⋆ (flatten fs) ⊛ D t (♭? p₂)
D-⊛ {fs = nothing} {xs = just _} {t = t} p₁ p₂ =
D t p₁ ⊛ ♭ p₂ ≅⟨ sym $ AdditiveMonoid.right-identity (D t p₁ ⊛ ♭ p₂) ⟩
D t p₁ ⊛ ♭ p₂ ∣ fail ≅⟨ (D t p₁ ⊛ ♭ p₂ ∎) ∣ sym (left-zero-⊛ (D t (♭ p₂))) ⟩
D t p₁ ⊛ ♭ p₂ ∣ fail ⊛ D t (♭ p₂) ∎
D-⊛ {fs = nothing} {xs = nothing} {t = t} p₁ p₂ =
D t (p₁ ⊛ p₂) ≅⟨ [ ◌ - ○ - ○ - ○ ] D t (♭ p₁) ∎ ⊛ (♭ p₂ ∎) ⟩
D t (♭ p₁) ⊛ ♭ p₂ ≅⟨ sym $ AdditiveMonoid.right-identity (D t (♭ p₁) ⊛ ♭ p₂) ⟩
D t (♭ p₁) ⊛ ♭ p₂ ∣ fail ≅⟨ (D t (♭ p₁) ⊛ ♭ p₂ ∎) ∣ sym (left-zero-⊛ (D t (♭ p₂))) ⟩
D t (♭ p₁) ⊛ ♭ p₂ ∣ fail ⊛ D t (♭ p₂) ∎
D-⊛ {fs = just _} {xs = just _} {t = t} p₁ p₂ =
D t (p₁ ⊛ p₂) ∎
D-⊛ {fs = just fs} {xs = nothing} {t = t} p₁ p₂ =
D t (p₁ ⊛ p₂) ≅⟨ [ ◌ - ○ - ○ - ○ ] D t (♭ p₁) ∎ ⊛ (p₂ ∎) ∣
(return⋆ fs ⊛ D t p₂ ∎) ⟩
D t (♭ p₁) ⊛ p₂ ∣ return⋆ fs ⊛ D t p₂ ∎
-- fail is a left zero of ⊛.
left-zero-⊛ : ∀ {Tok R₁ R₂ xs} (p : Parser Tok R₁ xs) →
fail ⊛ p ≅P fail {R = R₂}
left-zero-⊛ {xs = xs} p =
BagMonoid.reflexive (List.Applicative.left-zero xs) ∷ λ t → ♯ (
D t (fail ⊛ p) ≅⟨ D-⊛ fail p ⟩
fail ⊛ p ∣ fail ⊛ D t p ≅⟨ left-zero-⊛ p ∣ left-zero-⊛ (D t p) ⟩
fail ∣ fail ≅⟨ AdditiveMonoid.right-identity fail ⟩
fail ∎)
-- fail is a right zero of ⊛.
right-zero-⊛ : ∀ {Tok R₁ R₂ fs} (p : Parser Tok (R₁ → R₂) fs) →
p ⊛ fail ≅P fail
right-zero-⊛ {fs = fs} p =
BagMonoid.reflexive (List.Applicative.right-zero fs) ∷ λ t → ♯ (
D t (p ⊛ fail) ≅⟨ D-⊛ p fail ⟩
D t p ⊛ fail ∣ return⋆ fs ⊛ fail ≅⟨ right-zero-⊛ (D t p) ∣ right-zero-⊛ (return⋆ fs) ⟩
fail ∣ fail ≅⟨ AdditiveMonoid.left-identity fail ⟩
fail ∎)
-- A simplified instance of D-⊛.
D-return-⊛ : ∀ {Tok R₁ R₂ xs t}
(f : R₁ → R₂) (p : Parser Tok R₁ xs) →
D t (return f ⊛ p) ≅P return f ⊛ D t p
D-return-⊛ {t = t} f p =
D t (return f ⊛ p) ≅⟨ D-⊛ (return f) p ⟩
fail ⊛ p ∣ return⋆ [ f ] ⊛ D t p ≅⟨ left-zero-⊛ p ∣
[ ○ - ○ - ○ - ○ ] AdditiveMonoid.right-identity (return f) ⊛ (D t p ∎) ⟩
fail ∣ return f ⊛ D t p ≅⟨ AdditiveMonoid.left-identity (return f ⊛ D t p) ⟩
return f ⊛ D t p ∎
mutual
-- Unfolding lemma for D applied to _>>=_.
D->>= : ∀ {Tok R₁ R₂ xs t} {f : Maybe (R₁ → List R₂)}
(p₁ : ∞⟨ f ⟩Parser Tok R₁ (flatten xs))
(p₂ : (x : R₁) → ∞⟨ xs ⟩Parser Tok R₂ (apply f x)) →
D t (p₁ >>= p₂) ≅P
D t (♭? p₁) >>= (♭? ∘ p₂) ∣
return⋆ (flatten xs) >>= (λ x → D t (♭? (p₂ x)))
D->>= {xs = nothing} {t = t} {f = just _} p₁ p₂ =
D t p₁ >>= (♭ ∘ p₂) ≅⟨ sym $ AdditiveMonoid.right-identity (D t p₁ >>= (♭ ∘ p₂)) ⟩
D t p₁ >>= (♭ ∘ p₂) ∣ fail ≅⟨ (D t p₁ >>= (♭ ∘ p₂) ∎) ∣
sym (left-zero->>= (λ x → D t (♭ (p₂ x)))) ⟩
D t p₁ >>= (♭ ∘ p₂) ∣ fail >>= (λ x → D t (♭ (p₂ x))) ∎
D->>= {xs = just xs} {t = t} {f = just _} p₁ p₂ =
D t p₁ >>= p₂ ∣ return⋆ xs >>= (λ x → D t (p₂ x)) ∎
D->>= {xs = nothing} {t = t} {f = nothing} p₁ p₂ =
D t (p₁ >>= p₂) ≅⟨ [ ◌ - ○ - ○ - ○ ] _ ∎ >>= (λ _ → _ ∎) ⟩
D t (♭ p₁) >>= (♭ ∘ p₂) ≅⟨ sym $ AdditiveMonoid.right-identity (D t (♭ p₁) >>= (♭ ∘ p₂)) ⟩
D t (♭ p₁) >>= (♭ ∘ p₂) ∣ fail ≅⟨ (D t (♭ p₁) >>= (♭ ∘ p₂) ∎) ∣
sym (left-zero->>= (λ x → D t (♭ (p₂ x)))) ⟩
D t (♭ p₁) >>= (♭ ∘ p₂) ∣ fail >>= (λ x → D t (♭ (p₂ x))) ∎
D->>= {xs = just xs} {t = t} {f = nothing} p₁ p₂ =
D t (p₁ >>= p₂) ≅⟨ [ ◌ - ○ - ○ - ○ ] _ ∎ >>= (λ _ → _ ∎) ∣ (_ ∎) ⟩
D t (♭ p₁) >>= p₂ ∣ return⋆ xs >>= (λ x → D t (p₂ x)) ∎
-- fail is a left zero of _>>=_.
left-zero->>= : ∀ {Tok R₁ R₂} {f : R₁ → List R₂}
(p : (x : R₁) → Parser Tok R₂ (f x)) →
fail >>= p ≅P fail
left-zero->>= {f = f} p =
BagMonoid.reflexive (List.MonadProperties.left-zero f) ∷ λ t → ♯ (
D t (fail >>= p) ≅⟨ D->>= {t = t} fail p ⟩
fail >>= p ∣ fail >>= (λ x → D t (p x)) ≅⟨ left-zero->>= p ∣ left-zero->>= (λ x → D t (p x)) ⟩
fail ∣ fail ≅⟨ AdditiveMonoid.right-identity fail ⟩
fail ∎)
-- fail is a right zero of _>>=_.
right-zero->>= : ∀ {Tok R₁ R₂} {xs : List R₁}
(p : Parser Tok R₁ xs) →
p >>= (λ _ → fail) ≅P fail {Tok = Tok} {R = R₂}
right-zero->>= {xs = xs} p =
BagMonoid.reflexive (List.MonadProperties.right-zero xs) ∷ λ t → ♯ (
D t (p >>= λ _ → fail) ≅⟨ D->>= p (λ _ → fail) ⟩
D t p >>= (λ _ → fail) ∣ return⋆ xs >>= (λ _ → fail) ≅⟨ right-zero->>= (D t p) ∣ right-zero->>= (return⋆ xs) ⟩
fail ∣ fail ≅⟨ AdditiveMonoid.left-identity fail ⟩
fail ∎)
| {
"alphanum_fraction": 0.4111255976,
"avg_line_length": 47.6068965517,
"ext": "agda",
"hexsha": "b240aaf186d31ec2b44cef2a79fc8a8074b5c947",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "76774f54f466cfe943debf2da731074fe0c33644",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/parser-combinators",
"max_forks_repo_path": "TotalParserCombinators/Laws/Derivative.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "76774f54f466cfe943debf2da731074fe0c33644",
"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/parser-combinators",
"max_issues_repo_path": "TotalParserCombinators/Laws/Derivative.agda",
"max_line_length": 129,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "76774f54f466cfe943debf2da731074fe0c33644",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/parser-combinators",
"max_stars_repo_path": "TotalParserCombinators/Laws/Derivative.agda",
"max_stars_repo_stars_event_max_datetime": "2020-07-03T08:56:13.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-07-03T08:56:13.000Z",
"num_tokens": 2765,
"size": 6903
} |
------------------------------------------------------------------------------
-- Properties of streams of total natural numbers
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module FOT.FOTC.Data.Nat.Stream.PropertiesI where
open import FOT.FOTC.Data.Nat.Stream.Type
open import FOTC.Base
open import FOTC.Base.List
open import FOTC.Data.Nat.Type
------------------------------------------------------------------------------
postulate
zeros : D
zeros-eq : zeros ≡ zero ∷ zeros
zeros-StreamN : StreamN zeros
zeros-StreamN = StreamN-coind A h refl
where
A : D → Set
A xs = xs ≡ zeros
h : ∀ {ns} → A ns → ∃[ n' ] ∃[ ns' ] N n' ∧ A ns' ∧ ns ≡ n' ∷ ns'
h Ans = zero , zeros , nzero , refl , (trans Ans zeros-eq)
| {
"alphanum_fraction": 0.4552238806,
"avg_line_length": 29.3125,
"ext": "agda",
"hexsha": "881b72025bf702ccf2fa69da7e4b2aaa1957acf9",
"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/Stream/PropertiesI.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/Stream/PropertiesI.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/Stream/PropertiesI.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": 222,
"size": 938
} |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020 Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
{-# OPTIONS --allow-unsolved-metas #-}
open import LibraBFT.Prelude
open import LibraBFT.Lemmas
open import LibraBFT.Base.PKCS
open import LibraBFT.Base.Types
open import LibraBFT.Abstract.Types -- TODO-2: remove this, see comment below
open import LibraBFT.Yasm.AvailableEpochs using (AvailableEpochs) renaming (lookup'' to EC-lookup)
import LibraBFT.Yasm.AvailableEpochs as AE
open import LibraBFT.Yasm.Base
-- This module defines a model of a distributed system, parameterized by
-- SystemParameters, which establishes various application-dependent types,
-- handlers, etc. The model supports a set of peers executing handlers in
-- response to messages received; these handlers can update the peer's
-- local state and/or send additional messages. The model also enables
-- "cheat" steps, which can send arbitrary messages, except that they are
-- constrained to prevent a cheat step from introducing a new signature for
-- an "honest" public key. The module also contains some structures for
-- proving properties of executions of the modeled system.
module LibraBFT.Yasm.System (parms : SystemParameters) where
open SystemParameters parms
-- TODO-2: The System model currently depends on a specific EpochConfig
-- type, which is imported from LibraBFT-specific types. However, the
-- system model should be entirely application-independent. Therefore, we
-- should factor EpochConfig out of Yasm, and have the SystemParameters
-- include an EpochConfig type and a way to query whether a given peer is
-- a member of the represented epoch, and if so, with what associated PK.
open EpochConfig
PeerId : Set -- TODO-2: When we factor EpochConfig out of here (see
-- comment above), PeerId will be a parameter to
-- SystemParameters; for now, it's NodeId to make it
-- compatible with everything else.
PeerId = NodeId
SenderMsgPair : Set
SenderMsgPair = PeerId × Msg
SentMessages : Set
SentMessages = List SenderMsgPair
-- The model supports sending messages that contain some fields that are
-- /not/ covered by the message's signature. Therefore, given a message
-- with a verifiable signature, it is possible for a propositionally
-- different message that verifies against the same signature to have been
-- sent before, which is captured by the following definition.
record MsgWithSig∈ (pk : PK)(sig : Signature)(pool : SentMessages) : Set where
constructor mkMsgWithSig∈
field
msgWhole : Msg
msgPart : Part
msg⊆ : msgPart ⊂Msg msgWhole
msgSender : PeerId
msg∈pool : (msgSender , msgWhole) ∈ pool
msgSigned : WithVerSig pk msgPart
msgSameSig : ver-signature msgSigned ≡ sig
open MsgWithSig∈ public
postulate -- TODO-1: prove it
MsgWithSig∈? : ∀ {pk} {sig} {pool} → Dec (MsgWithSig∈ pk sig pool)
MsgWithSig∈-++ʳ : ∀{pk sig pool ms} → MsgWithSig∈ pk sig pool → MsgWithSig∈ pk sig (ms ++ pool)
MsgWithSig∈-++ʳ {ms = pre} msig = record
{ msgWhole = msgWhole msig
; msgPart = msgPart msig
; msg⊆ = msg⊆ msig
; msg∈pool = Any-++ʳ pre (msg∈pool msig)
; msgSigned = msgSigned msig
; msgSameSig = msgSameSig msig
}
MsgWithSig∈-++ˡ : ∀{pk sig pool ms} → MsgWithSig∈ pk sig ms → MsgWithSig∈ pk sig (ms ++ pool)
MsgWithSig∈-++ˡ {ms = pre} msig = record
{ msgWhole = msgWhole msig
; msgPart = msgPart msig
; msg⊆ = msg⊆ msig
; msg∈pool = Any-++ˡ (msg∈pool msig)
; msgSigned = msgSigned msig
; msgSameSig = msgSameSig msig
}
MsgWithSig∈-transp : ∀{pk sig pool pool'}
→ (mws : MsgWithSig∈ pk sig pool)
→ (msgSender mws , msgWhole mws) ∈ pool'
→ MsgWithSig∈ pk sig pool'
MsgWithSig∈-transp msig ∈pool' = record
{ msgWhole = msgWhole msig
; msgPart = msgPart msig
; msg⊆ = msg⊆ msig
; msg∈pool = ∈pool'
; msgSigned = msgSigned msig
; msgSameSig = msgSameSig msig
}
-- * Forbidding the Forging of Signatures
--
-- Whenever our reasoning must involve digital signatures, it is standard
-- to talk about EUF-CMA resistant signature schemes. Informally, this captures
-- signatures schemes that cannot be compromised by certain adversaries.
-- Formally, it means that for any probabilistic-polynomial-time adversary 𝓐,
-- and some security parameter k:
--
-- Pr[ EUF-CMA(k) ] ≤ ε(k) for ε a negigible function.
--
-- EUF-CMA is defined as:
--
-- EUF-CMA(k): | O(m):
-- L ← ∅ | σ ← Sign(sk , m)
-- (pk, sk) ← Gen(k) | L ← L ∪ { m }
-- (m , σ) ← 𝓐ᴼ(pk) | return σ
-- return (Verify(pk, m, σ) ∧ m ∉ L) |
--
-- This says that 𝓐 cannot create a message that has /not yet been signed/ and
-- forge a signature for it. The list 'L' keeps track of the messages that 𝓐
-- asked to be signed by the oracle.
--
-- Because the probability of the adversary to win the EUF-CMA(k) game
-- approaches 0 as k increases; it is reasonable to assume that winning
-- the game is /impossible/ for realistic security parameters.
--
-- EUF-CMA security is incorporated into our model by constraining messages
-- sent by a cheat step to ensure that for every verifiably signed part of
-- such a message, if there is a signature on the part, then it is either for
-- a dishonest public key (in which cases it's secret key may have been leaked),
-- or a message has been sent with the same signature before (in which case the
-- signature is simply being "replayed" from a previous message).
--
-- Dishonest (or "cheat") messages are those that are not the result of
-- a /handle/ or /init/ call, but rather are the result of a /cheat/ step.
--
-- A part of a cheat message can contain a verifiable signature only if it
-- is for a dishonest public key, or a message with the same signature has
-- been sent before (a cheater can "reuse" an honest signature sent
-- before; it just can't produce a new one). Note that this constraint
-- precludes a peer sending a message that contains a new verifiable
-- signature for an honest PK, even if the PK is the peer's own PK for
-- some epoch (implying that the peer possesses the associated secret
-- key). In other words, a peer that is honest for a given epoch (by
-- virtue of being a member of that epoch and being assigned an honest PK
-- for the epoch), cannot send a message for that epoch using a cheat
-- step.
CheatPartConstraint : SentMessages → Part → Set
CheatPartConstraint pool m = ∀{pk} → (ver : WithVerSig pk m)
→ Meta-Dishonest-PK pk
⊎ MsgWithSig∈ pk (ver-signature ver) pool
-- The only constraints on messages sent by cheat steps are that:
-- * the sender is not an honest member in the epoch of any part of the message
-- * the signature on any part of the message satisfies CheatCanSign, meaning
-- that it is not a new signature for an honest public key
CheatMsgConstraint : SentMessages → Msg → Set
CheatMsgConstraint pool m = ∀{part} → part ⊂Msg m → CheatPartConstraint pool part
-- * The System State
--
-- A system consists in a partial map from PeerId to PeerState, a pool
-- of sent messages and a number of available epochs.
record SystemState (e : ℕ) : Set₁ where
field
peerStates : Map PeerId PeerState
msgPool : SentMessages -- All messages ever sent
availEpochs : AvailableEpochs e
open SystemState public
initialState : SystemState 0
initialState = record
{ peerStates = Map-empty
; msgPool = []
; availEpochs = []
}
-- Convenience function for appending an epoch to the system state
pushEpoch : ∀{e} → EpochConfigFor e → SystemState e → SystemState (suc e)
pushEpoch 𝓔 st = record
{ peerStates = peerStates st
; msgPool = msgPool st
; availEpochs = AE.append 𝓔 (availEpochs st)
}
-- * Small Step Semantics
--
-- The small step semantics are divided into three datatypes:
--
-- i) StepPeerState executes a step through init or handle
-- ii) StepPeer executes a step through StepPeerState or cheat
-- iii) Step transitions the system state by a StepPeer or by
-- bringing a new epoch into existence
-- The pre and post states of Honest peers are related iff
data StepPeerState {e}(pid : PeerId)(𝓔s : AvailableEpochs e)(pool : SentMessages)
: Maybe PeerState → PeerState → List Msg → Set where
-- The peer receives an "initialization package"; for now, this consists
-- of the actual EpochConfig for the epoch being initialized. Later, we
-- may move to a more general scheme, enabled by assuming a function
-- 'render : InitPackage -> EpochConfig'.
step-init : ∀{ms s' out}(ix : Fin e)
→ (s' , out) ≡ init pid (AE.lookup' 𝓔s ix) ms
→ StepPeerState pid 𝓔s pool ms s' out
-- The peer processes a message in the pool
step-msg : ∀{m ms s s' out}
→ m ∈ pool
→ ms ≡ just s → (s' , out) ≡ handle pid (proj₂ m) s
→ StepPeerState pid 𝓔s pool ms s' out
-- The pre-state of the suplied PeerId is related to the post-state and list of output messages iff:
data StepPeer {e}(pre : SystemState e) : PeerId → Maybe PeerState → List Msg → Set where
-- it can be obtained by a handle or init call.
step-honest : ∀{pid st outs}
→ StepPeerState pid (availEpochs pre) (msgPool pre) (Map-lookup pid (peerStates pre)) st outs
→ StepPeer pre pid (just st) outs
-- or the peer decides to cheat. CheatMsgConstraint ensures it cannot
-- forge signatures by honest peers. Cheat steps do not modify peer
-- state: these are maintained exclusively by the implementation
-- handlers.
step-cheat : ∀{pid}
→ (fm : SentMessages → Maybe PeerState → Msg)
→ let m = fm (msgPool pre) (Map-lookup pid (peerStates pre))
in CheatMsgConstraint (msgPool pre) m
→ StepPeer pre pid (Map-lookup pid (peerStates pre)) (m ∷ [])
isCheat : ∀ {e pre pid ms outs} → StepPeer {e} pre pid ms outs → Set
isCheat (step-honest _) = ⊥
isCheat (step-cheat _ _) = Unit
-- Computes the post-sysstate for a given step-peer.
StepPeer-post : ∀{e pid st' outs}{pre : SystemState e}
→ StepPeer pre pid st' outs → SystemState e
StepPeer-post {e} {pid} {st'} {outs} {pre} _ = record pre
{ peerStates = Map-set pid st' (peerStates pre)
; msgPool = List-map (pid ,_) outs ++ msgPool pre
}
data Step : ∀{e e'} → SystemState e → SystemState e' → Set₁ where
step-epoch : ∀{e}{pre : SystemState e}
→ (𝓔 : EpochConfigFor e)
-- TODO-3: Eventually, we'll condition this step to only be
-- valid when peers on the previous epoch have agreed that 𝓔
-- is the new one. → ∃EnoughValidCommitMsgsFor pre 𝓔
→ Step pre (pushEpoch 𝓔 pre)
step-peer : ∀{e pid st' outs}{pre : SystemState e}
→ (pstep : StepPeer pre pid st' outs)
→ Step pre (StepPeer-post pstep)
postulate -- TODO-1: prove it
msgs-stable : ∀ {e e'} {pre : SystemState e} {post : SystemState e'} {m}
→ (theStep : Step pre post)
→ m ∈ msgPool pre
→ m ∈ msgPool post
postulate -- not used yet, but some proofs could probably be cleaned up using this,
-- e.g., prevVoteRnd≤-pred-step in Impl.VotesOnce
sendMessages-target : ∀ {m : SenderMsgPair} {sm : SentMessages} {ml : List SenderMsgPair}
→ ¬ (m ∈ sm)
→ m ∈ (ml ++ sm)
→ m ∈ ml
step-epoch-does-not-send : ∀ {e} (pre : SystemState e) (𝓔 : EpochConfigFor e)
→ msgPool (pushEpoch 𝓔 pre) ≡ msgPool pre
step-epoch-does-not-send _ _ = refl
-- * Reflexive-Transitive Closure
data Step* : ∀{e e'} → SystemState e → SystemState e' → Set₁ where
step-0 : ∀{e}{pre : SystemState e}
→ Step* pre pre
step-s : ∀{e e' e''}{fst : SystemState e}{pre : SystemState e'}{post : SystemState e''}
→ Step* fst pre
→ Step pre post
→ Step* fst post
ReachableSystemState : ∀{e} → SystemState e → Set₁
ReachableSystemState = Step* initialState
Step*-mono : ∀{e e'}{st : SystemState e}{st' : SystemState e'}
→ Step* st st' → e ≤ e'
Step*-mono step-0 = ≤-refl
Step*-mono (step-s tr (step-peer _)) = Step*-mono tr
Step*-mono (step-s tr (step-epoch _)) = ≤-step (Step*-mono tr)
MsgWithSig∈-Step* : ∀{e e' sig pk}{st : SystemState e}{st' : SystemState e'}
→ Step* st st'
→ MsgWithSig∈ pk sig (msgPool st)
→ MsgWithSig∈ pk sig (msgPool st')
MsgWithSig∈-Step* step-0 msig = msig
MsgWithSig∈-Step* (step-s tr (step-epoch _)) msig
= MsgWithSig∈-Step* tr msig
MsgWithSig∈-Step* (step-s tr (step-peer ps)) msig
= MsgWithSig∈-++ʳ (MsgWithSig∈-Step* tr msig)
MsgWithSig∈-Step*-part : ∀{e e' sig pk}{st : SystemState e}{st' : SystemState e'}
→ (tr : Step* st st')
→ (msig : MsgWithSig∈ pk sig (msgPool st))
→ msgPart msig ≡ msgPart (MsgWithSig∈-Step* tr msig)
MsgWithSig∈-Step*-part step-0 msig = refl
MsgWithSig∈-Step*-part (step-s tr (step-epoch _)) msig
= MsgWithSig∈-Step*-part tr msig
MsgWithSig∈-Step*-part (step-s tr (step-peer ps)) msig
= MsgWithSig∈-Step*-part tr msig
------------------------------------------
-- Type synonym to express a relation over system states;
SystemStateRel : (∀{e e'} → SystemState e → SystemState e' → Set₁) → Set₂
SystemStateRel P = ∀{e e'}{st : SystemState e}{st' : SystemState e'} → P st st' → Set₁
-- Just like Data.List.Any maps a predicate over elements to a predicate over lists,
-- Any-step maps a relation over steps to a relation over steps in a trace.
data Any-Step (P : SystemStateRel Step) : SystemStateRel Step* where
step-here : ∀{e e' e''}{fst : SystemState e}{pre : SystemState e'}{post : SystemState e''}
→ (cont : Step* fst pre)
→ {this : Step pre post}(prf : P this)
→ Any-Step P (step-s cont this)
step-there : ∀{e e' e''}{fst : SystemState e}{pre : SystemState e'}{post : SystemState e''}
→ {cont : Step* fst pre}
→ {this : Step pre post}
→ (prf : Any-Step P cont)
→ Any-Step P (step-s cont this)
Any-Step-elim
: ∀{e₀ e₁}{st₀ : SystemState e₀}{st₁ : SystemState e₁}{P : SystemStateRel Step}{Q : Set₁}
→ {r : Step* st₀ st₁}
→ (P⇒Q : ∀{d d'}{s : SystemState d}{s' : SystemState d'}{st : Step s s'}
→ P st → Step* s' st₁ → Q)
→ Any-Step P r → Q
Any-Step-elim P⇒Q (step-here cont prf)
= P⇒Q prf step-0
Any-Step-elim P⇒Q (step-there {this = this} f)
= Any-Step-elim (λ p s → P⇒Q p (step-s s this)) f
------------------------------------------
module _ (P : ∀{e} → SystemState e → Set) where
Step*-Step-fold : (∀{e}{st : SystemState e}
→ ReachableSystemState st
→ (𝓔 : EpochConfigFor e)
→ P st
→ P (pushEpoch 𝓔 st))
→ (∀{e pid st' outs}{st : SystemState e}
→ ReachableSystemState st
→ (pstep : StepPeer st pid st' outs)
→ P st
→ P (StepPeer-post pstep))
→ P initialState
→ ∀{e}{st : SystemState e}
→ (tr : ReachableSystemState st) → P st
Step*-Step-fold fe fs p₀ step-0 = p₀
Step*-Step-fold fe fs p₀ (step-s tr (step-epoch 𝓔)) = fe tr 𝓔 (Step*-Step-fold fe fs p₀ tr)
Step*-Step-fold fe fs p₀ (step-s tr (step-peer p)) = fs tr p (Step*-Step-fold fe fs p₀ tr)
| {
"alphanum_fraction": 0.6256800198,
"avg_line_length": 44.3178082192,
"ext": "agda",
"hexsha": "b9cdc47df53816a374b7060607210948025a35f8",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b7dd98dd90d98fbb934ef8cb4f3314940986790d",
"max_forks_repo_licenses": [
"UPL-1.0"
],
"max_forks_repo_name": "lisandrasilva/bft-consensus-agda-1",
"max_forks_repo_path": "LibraBFT/Yasm/System.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b7dd98dd90d98fbb934ef8cb4f3314940986790d",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"UPL-1.0"
],
"max_issues_repo_name": "lisandrasilva/bft-consensus-agda-1",
"max_issues_repo_path": "LibraBFT/Yasm/System.agda",
"max_line_length": 111,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "b7dd98dd90d98fbb934ef8cb4f3314940986790d",
"max_stars_repo_licenses": [
"UPL-1.0"
],
"max_stars_repo_name": "lisandrasilva/bft-consensus-agda-1",
"max_stars_repo_path": "LibraBFT/Yasm/System.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 4556,
"size": 16176
} |
module lists where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; sym; trans; cong)
open Eq.≡-Reasoning
open import Data.Bool using (Bool; true; false; T; _∧_; _∨_; not)
open import Data.Nat using (ℕ; zero; suc; _+_; _*_; _∸_; _≤_; s≤s; z≤n)
open import Data.Nat.Properties using
(+-assoc; +-identityˡ; +-identityʳ; *-assoc; *-identityˡ; *-identityʳ)
open import Relation.Nullary using (¬_; Dec; yes; no)
open import Data.Product using (_×_; ∃; ∃-syntax) renaming (_,_ to ⟨_,_⟩)
open import Function using (_∘_)
open import Level using (Level)
-- open import plfa.part1.Isomorphism using (_≃_; _⇔_)
-- 同型 (isomorphism)
infix 0 _≃_
record _≃_ (A B : Set) : Set where
field
to : A → B
from : B → A
from∘to : ∀ (x : A) → from (to x) ≡ x
to∘from : ∀ (y : B) → to (from y) ≡ y
-- open _≃_
-- 同値 (equivalence)
record _⇔_ (A B : Set) : Set where
field
to : A → B
from : B → A
-- Lists
-- リスト
infixr 5 _∷_
data List (A : Set) : Set where
[] : List A
_∷_ : A → List A → List A
_ : List ℕ
_ = 0 ∷ 1 ∷ 2 ∷ []
data List′ : Set → Set where
[]′ : ∀ {A : Set} → List′ A
_∷′_ : ∀ {A : Set} → A → List′ A → List′ A
_ : List ℕ
_ = _∷_ {ℕ} 0 (_∷_ {ℕ} 1 (_∷_ {ℕ} 2 ([] {ℕ})))
-- List syntax
-- リストの便利記法
pattern [_] z = z ∷ []
pattern [_,_] y z = y ∷ z ∷ []
pattern [_,_,_] x y z = x ∷ y ∷ z ∷ []
pattern [_,_,_,_] w x y z = w ∷ x ∷ y ∷ z ∷ []
pattern [_,_,_,_,_] v w x y z = v ∷ w ∷ x ∷ y ∷ z ∷ []
pattern [_,_,_,_,_,_] u v w x y z = u ∷ v ∷ w ∷ x ∷ y ∷ z ∷ []
-- Append
-- リストの結合
infixr 5 _++_
_++_ : ∀ {A : Set} → List A → List A → List A
[] ++ ys = ys
(x ∷ xs) ++ ys = x ∷ (xs ++ ys)
_ : [ 0 , 1 , 2 ] ++ [ 3 , 4 ] ≡ [ 0 , 1 , 2 , 3 , 4 ]
_ =
begin
0 ∷ 1 ∷ 2 ∷ [] ++ 3 ∷ 4 ∷ []
≡⟨⟩
0 ∷ (1 ∷ 2 ∷ [] ++ 3 ∷ 4 ∷ [])
≡⟨⟩
0 ∷ 1 ∷ (2 ∷ [] ++ 3 ∷ 4 ∷ [])
≡⟨⟩
0 ∷ 1 ∷ 2 ∷ ([] ++ 3 ∷ 4 ∷ [])
≡⟨⟩
0 ∷ 1 ∷ 2 ∷ 3 ∷ 4 ∷ []
∎
-- Reasoning about append
-- リストの結合法則
++-assoc : ∀ {A : Set} (xs ys zs : List A)
→ (xs ++ ys) ++ zs ≡ xs ++ (ys ++ zs)
++-assoc [] ys zs =
begin
([] ++ ys) ++ zs
≡⟨⟩
ys ++ zs
≡⟨⟩
[] ++ (ys ++ zs)
∎
++-assoc (x ∷ xs) ys zs =
begin
(x ∷ xs ++ ys) ++ zs
≡⟨⟩
x ∷ (xs ++ ys) ++ zs
≡⟨⟩
x ∷ ((xs ++ ys) ++ zs)
≡⟨ cong (x ∷_) (++-assoc xs ys zs) ⟩
x ∷ (xs ++ (ys ++ zs))
≡⟨⟩
x ∷ xs ++ (ys ++ zs)
∎
-- 空のリストが左単位元であることの証明
++-identityˡ : ∀ {A : Set} (xs : List A) → [] ++ xs ≡ xs
++-identityˡ xs =
begin
[] ++ xs
≡⟨⟩
xs
∎
-- 空のリストが右単位元であることの証明
++-identityʳ : ∀ {A : Set} (xs : List A) → xs ++ [] ≡ xs
++-identityʳ [] =
begin
[] ++ []
≡⟨⟩
[]
∎
++-identityʳ (x ∷ xs) =
begin
(x ∷ xs) ++ []
≡⟨⟩
x ∷ (xs ++ [])
≡⟨ cong (x ∷_) (++-identityʳ xs) ⟩
x ∷ xs
∎
-- Length
-- リスト長を返す関数
length : ∀ {A : Set} → List A → ℕ
length [] = zero
length (x ∷ xs) = suc (length xs)
_ : length [ 0 , 1 , 2 ] ≡ 3
_ =
begin
length (0 ∷ 1 ∷ 2 ∷ [])
≡⟨⟩
suc (length (1 ∷ 2 ∷ []))
≡⟨⟩
suc (suc (length (2 ∷ [])))
≡⟨⟩
suc (suc (suc (length {ℕ} [])))
≡⟨⟩
suc (suc (suc zero))
∎
-- Reasoning about length
-- lengthの分配性の証明
length-++ : ∀ {A : Set} (xs ys : List A)
→ length (xs ++ ys) ≡ length xs + length ys
length-++ {A} [] ys =
begin
length ([] ++ ys)
≡⟨⟩
length ys
≡⟨⟩
length {A} [] + length ys
∎
length-++ (x ∷ xs) ys =
begin
length ((x ∷ xs) ++ ys)
≡⟨⟩
suc (length (xs ++ ys))
≡⟨ cong suc (length-++ xs ys) ⟩
suc (length xs + length ys)
≡⟨⟩
length (x ∷ xs) + length ys
∎
-- Reverse
-- 逆順のリストを返す関数
reverse : ∀ {A : Set} → List A → List A
reverse [] = []
reverse (x ∷ xs) = reverse xs ++ [ x ]
_ : reverse [ 0 , 1 , 2 ] ≡ [ 2 , 1 , 0 ]
_ =
begin
reverse (0 ∷ 1 ∷ 2 ∷ [])
≡⟨⟩
reverse (1 ∷ 2 ∷ []) ++ [ 0 ]
≡⟨⟩
(reverse (2 ∷ []) ++ [ 1 ]) ++ [ 0 ]
≡⟨⟩
((reverse [] ++ [ 2 ]) ++ [ 1 ]) ++ [ 0 ]
≡⟨⟩
(([] ++ [ 2 ]) ++ [ 1 ]) ++ [ 0 ]
≡⟨⟩
(([] ++ 2 ∷ []) ++ 1 ∷ []) ++ 0 ∷ []
≡⟨⟩
(2 ∷ [] ++ 1 ∷ []) ++ 0 ∷ []
≡⟨⟩
2 ∷ ([] ++ 1 ∷ []) ++ 0 ∷ []
≡⟨⟩
(2 ∷ 1 ∷ []) ++ 0 ∷ []
≡⟨⟩
2 ∷ (1 ∷ [] ++ 0 ∷ [])
≡⟨⟩
2 ∷ 1 ∷ ([] ++ 0 ∷ [])
≡⟨⟩
2 ∷ 1 ∷ 0 ∷ []
≡⟨⟩
[ 2 , 1 , 0 ]
∎
-- Faster reverse
shunt : ∀ {A : Set} → List A → List A → List A
shunt [] ys = ys
shunt (x ∷ xs) ys = shunt xs (x ∷ ys)
shunt-reverse : ∀ {A : Set} (xs ys : List A)
→ shunt xs ys ≡ reverse xs ++ ys
shunt-reverse [] ys =
begin
shunt [] ys
≡⟨⟩
ys
≡⟨⟩
reverse [] ++ ys
∎
shunt-reverse (x ∷ xs) ys =
begin
shunt (x ∷ xs) ys
≡⟨⟩
shunt xs (x ∷ ys)
≡⟨ shunt-reverse xs (x ∷ ys) ⟩
reverse xs ++ (x ∷ ys)
≡⟨⟩
reverse xs ++ ([ x ] ++ ys)
≡⟨ sym (++-assoc (reverse xs) [ x ] ys) ⟩
(reverse xs ++ [ x ]) ++ ys
≡⟨⟩
reverse (x ∷ xs) ++ ys
∎
reverse′ : ∀ {A : Set} → List A → List A
reverse′ xs = shunt xs []
reverses : ∀ {A : Set} (xs : List A)
→ reverse′ xs ≡ reverse xs
reverses xs =
begin
reverse′ xs
≡⟨⟩
shunt xs []
≡⟨ shunt-reverse xs [] ⟩
reverse xs ++ []
≡⟨ ++-identityʳ (reverse xs) ⟩
reverse xs
∎
_ : reverse′ [ 0 , 1 , 2 ] ≡ [ 2 , 1 , 0 ]
_ =
begin
reverse′ (0 ∷ 1 ∷ 2 ∷ [])
≡⟨⟩
shunt (0 ∷ 1 ∷ 2 ∷ []) []
≡⟨⟩
shunt (1 ∷ 2 ∷ []) (0 ∷ [])
≡⟨⟩
shunt (2 ∷ []) (1 ∷ 0 ∷ [])
≡⟨⟩
shunt [] (2 ∷ 1 ∷ 0 ∷ [])
≡⟨⟩
2 ∷ 1 ∷ 0 ∷ []
∎
-- Map
map : ∀ {A B : Set} → (A → B) → List A → List B
map f [] = []
map f (x ∷ xs) = f x ∷ map f xs
_ : map suc [ 0 , 1 , 2 ] ≡ [ 1 , 2 , 3 ]
_ =
begin
map suc (0 ∷ 1 ∷ 2 ∷ [])
≡⟨⟩
suc 0 ∷ map suc (1 ∷ 2 ∷ [])
≡⟨⟩
suc 0 ∷ suc 1 ∷ map suc (2 ∷ [])
≡⟨⟩
suc 0 ∷ suc 1 ∷ suc 2 ∷ map suc []
≡⟨⟩
suc 0 ∷ suc 1 ∷ suc 2 ∷ []
≡⟨⟩
1 ∷ 2 ∷ 3 ∷ []
∎
sucs : List ℕ → List ℕ
sucs = map suc
_ : sucs [ 0 , 1 , 2 ] ≡ [ 1 , 2 , 3 ]
_ =
begin
sucs [ 0 , 1 , 2 ]
≡⟨⟩
map suc [ 0 , 1 , 2 ]
≡⟨⟩
[ 1 , 2 , 3 ]
∎
-- 右畳み込み
foldr : ∀ {A B : Set} → (A → B → B) → B → List A → B
foldr _⊗_ e [] = e
foldr _⊗_ e (x ∷ xs) = x ⊗ foldr _⊗_ e xs
_ : foldr _+_ 0 [ 1 , 2 , 3 , 4 ] ≡ 10
_ =
begin
foldr _+_ 0 (1 ∷ 2 ∷ 3 ∷ 4 ∷ [])
≡⟨⟩
1 + foldr _+_ 0 (2 ∷ 3 ∷ 4 ∷ [])
≡⟨⟩
1 + (2 + foldr _+_ 0 (3 ∷ 4 ∷ []))
≡⟨⟩
1 + (2 + (3 + foldr _+_ 0 (4 ∷ [])))
≡⟨⟩
1 + (2 + (3 + (4 + foldr _+_ 0 [])))
≡⟨⟩
1 + (2 + (3 + (4 + 0)))
∎
-- リストの要素の和
sum : List ℕ → ℕ
sum = foldr _+_ 0
_ : sum [ 1 , 2 , 3 , 4 ] ≡ 10
_ =
begin
sum [ 1 , 2 , 3 , 4 ]
≡⟨⟩
foldr _+_ 0 [ 1 , 2 , 3 , 4 ]
≡⟨⟩
10
∎
-- Monoids
record IsMonoid {A : Set} (_⊗_ : A → A → A) (e : A) : Set where
field
assoc : ∀ (x y z : A) → (x ⊗ y) ⊗ z ≡ x ⊗ (y ⊗ z)
identityˡ : ∀ (x : A) → e ⊗ x ≡ x
identityʳ : ∀ (x : A) → x ⊗ e ≡ x
open IsMonoid
+-monoid : IsMonoid _+_ 0
+-monoid =
record
{ assoc = +-assoc
; identityˡ = +-identityˡ
; identityʳ = +-identityʳ
}
*-monoid : IsMonoid _*_ 1
*-monoid =
record
{ assoc = *-assoc
; identityˡ = *-identityˡ
; identityʳ = *-identityʳ
}
++-monoid : ∀ {A : Set} → IsMonoid {List A} _++_ []
++-monoid =
record
{ assoc = ++-assoc
; identityˡ = ++-identityˡ
; identityʳ = ++-identityʳ
}
foldr-monoid : ∀ {A : Set} (_⊗_ : A → A → A) (e : A) → IsMonoid _⊗_ e →
∀ (xs : List A) (y : A) → foldr _⊗_ y xs ≡ foldr _⊗_ e xs ⊗ y
foldr-monoid _⊗_ e ⊗-monoid [] y =
begin
foldr _⊗_ y []
≡⟨⟩
y
≡⟨ sym (identityˡ ⊗-monoid y) ⟩
(e ⊗ y)
≡⟨⟩
foldr _⊗_ e [] ⊗ y
∎
foldr-monoid _⊗_ e ⊗-monoid (x ∷ xs) y =
begin
foldr _⊗_ y (x ∷ xs)
≡⟨⟩
x ⊗ (foldr _⊗_ y xs)
≡⟨ cong (x ⊗_) (foldr-monoid _⊗_ e ⊗-monoid xs y) ⟩
x ⊗ (foldr _⊗_ e xs ⊗ y)
≡⟨ sym (assoc ⊗-monoid x (foldr _⊗_ e xs) y) ⟩
(x ⊗ foldr _⊗_ e xs) ⊗ y
≡⟨⟩
foldr _⊗_ e (x ∷ xs) ⊗ y
∎
postulate
foldr-++ : ∀ {A : Set} (_⊗_ : A → A → A) (e : A) (xs ys : List A) →
foldr _⊗_ e (xs ++ ys) ≡ foldr _⊗_ (foldr _⊗_ e ys) xs
foldr-monoid-++ : ∀ {A : Set} (_⊗_ : A → A → A) (e : A) → IsMonoid _⊗_ e →
∀ (xs ys : List A) → foldr _⊗_ e (xs ++ ys) ≡ foldr _⊗_ e xs ⊗ foldr _⊗_ e ys
foldr-monoid-++ _⊗_ e monoid-⊗ xs ys =
begin
foldr _⊗_ e (xs ++ ys)
≡⟨ foldr-++ _⊗_ e xs ys ⟩
foldr _⊗_ (foldr _⊗_ e ys) xs
≡⟨ foldr-monoid _⊗_ e monoid-⊗ xs (foldr _⊗_ e ys) ⟩
foldr _⊗_ e xs ⊗ foldr _⊗_ e ys
∎
-- All
data All {A : Set} (P : A → Set) : List A → Set where
[] : All P []
_∷_ : ∀ {x : A} {xs : List A} → P x → All P xs → All P (x ∷ xs)
_ : All (_≤ 2) [ 0 , 1 , 2 ]
_ = z≤n ∷ s≤s z≤n ∷ s≤s (s≤s z≤n) ∷ []
-- Any
data Any {A : Set} (P : A → Set) : List A → Set where
here : ∀ {x : A} {xs : List A} → P x → Any P (x ∷ xs)
there : ∀ {x : A} {xs : List A} → Any P xs → Any P (x ∷ xs)
infix 4 _∈_ _∉_
_∈_ : ∀ {A : Set} (x : A) (xs : List A) → Set
x ∈ xs = Any (x ≡_) xs
_∉_ : ∀ {A : Set} (x : A) (xs : List A) → Set
x ∉ xs = ¬ (x ∈ xs)
_ : 0 ∈ [ 0 , 1 , 0 , 2 ]
_ = here refl
_ : 0 ∈ [ 0 , 1 , 0 , 2 ]
_ = there (there (here refl))
not-in : 3 ∉ [ 0 , 1 , 0 , 2 ]
not-in (here ())
not-in (there (here ()))
not-in (there (there (here ())))
not-in (there (there (there (here ()))))
not-in (there (there (there (there ()))))
-- All and append
All-++-⇔ : ∀ {A : Set} {P : A → Set} (xs ys : List A) →
All P (xs ++ ys) ⇔ (All P xs × All P ys)
All-++-⇔ xs ys =
record
{ to = to xs ys
; from = from xs ys
}
where
to : ∀ {A : Set} {P : A → Set} (xs ys : List A) →
All P (xs ++ ys) → (All P xs × All P ys)
to [] ys Pys = ⟨ [] , Pys ⟩
to (x ∷ xs) ys (Px ∷ Pxs++ys) with to xs ys Pxs++ys
... | ⟨ Pxs , Pys ⟩ = ⟨ Px ∷ Pxs , Pys ⟩
from : ∀ { A : Set} {P : A → Set} (xs ys : List A) →
All P xs × All P ys → All P (xs ++ ys)
from [] ys ⟨ [] , Pys ⟩ = Pys
from (x ∷ xs) ys ⟨ Px ∷ Pxs , Pys ⟩ = Px ∷ from xs ys ⟨ Pxs , Pys ⟩
-- Decidability of All
all : ∀ {A : Set} → (A → Bool) → List A → Bool
all p = foldr _∧_ true ∘ map p
Decidable : ∀ {A : Set} → (A → Set) → Set
Decidable {A} P = ∀ (x : A) → Dec (P x)
All? : ∀ {A : Set} {P : A → Set} → Decidable P → Decidable (All P)
All? P? [] = yes []
All? P? (x ∷ xs) with P? x | All? P? xs
... | yes Px | yes Pxs = yes (Px ∷ Pxs)
... | no ¬Px | _ = no λ{ (Px ∷ Pxs) → ¬Px Px }
... | _ | no ¬Pxs = no λ{ (Px ∷ Pxs) → ¬Pxs Pxs }
| {
"alphanum_fraction": 0.4205364869,
"avg_line_length": 21.0546558704,
"ext": "agda",
"hexsha": "6d578896ea690a0281b42bc8b31ff3bfec5c1174",
"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": "df7722b88a9b3dfde320a690b78c4c1ef8c7c547",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "akiomik/plfa-solutions",
"max_forks_repo_path": "part1/lists/lists.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "df7722b88a9b3dfde320a690b78c4c1ef8c7c547",
"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": "akiomik/plfa-solutions",
"max_issues_repo_path": "part1/lists/lists.agda",
"max_line_length": 79,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "df7722b88a9b3dfde320a690b78c4c1ef8c7c547",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "akiomik/plfa-solutions",
"max_stars_repo_path": "part1/lists/lists.agda",
"max_stars_repo_stars_event_max_datetime": "2020-07-07T09:42:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-07-07T09:42:22.000Z",
"num_tokens": 5242,
"size": 10401
} |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Monoidal.IntConstruction where
open import Level
open import Data.Fin
open import Data.Product
open import Categories.Category
open import Categories.Product
open import Categories.Monoidal
open import Categories.Functor hiding (id; _∘_; identityʳ; assoc)
open import Categories.Monoidal.Braided
open import Categories.Monoidal.Helpers
open import Categories.Monoidal.Braided.Helpers
open import Categories.Monoidal.Symmetric
open import Categories.NaturalIsomorphism
open import Categories.NaturalTransformation hiding (id)
open import Categories.Monoidal.Traced
------------------------------------------------------------------------------
record Polarized {o o' : Level} (A : Set o) (B : Set o') : Set (o ⊔ o') where
constructor ±
field
pos : A
neg : B
IntC : ∀ {o ℓ e}
{C : Category o ℓ e} {M : Monoidal C} {B : Braided M} {S : Symmetric B} →
(T : Traced S) → Category o ℓ e
IntC {o} {ℓ} {e} {C} {M} {B} {S} T = record {
Obj = Polarized C.Obj C.Obj
; _⇒_ = λ { (± A+ A-) (± B+ B-) → C [ F.⊗ₒ (A+ , B-) , F.⊗ₒ (B+ , A-) ]}
; _≡_ = C._≡_
; _∘_ = λ { {(± A+ A-)} {(± B+ B-)} {(± C+ C-)} g f →
T.trace { B- } {F.⊗ₒ (A+ , C-)} {F.⊗ₒ (C+ , A-)}
(ηassoc⇐ (ternary C C+ A- B-) C.∘
F.⊗ₘ (C.id , ηbraid (binary C B- A-)) C.∘
ηassoc⇒ (ternary C C+ B- A-) C.∘
F.⊗ₘ (g , C.id) C.∘
ηassoc⇐ (ternary C B+ C- A-) C.∘
F.⊗ₘ (C.id , ηbraid (binary C A- C-)) C.∘
ηassoc⇒ (ternary C B+ A- C-) C.∘
F.⊗ₘ (f , C.id) C.∘
ηassoc⇐ (ternary C A+ B- C-) C.∘
F.⊗ₘ (C.id , ηbraid (binary C C- B-)) C.∘
ηassoc⇒ (ternary C A+ C- B-))}
; id = F.⊗ₘ (C.id , C.id)
; assoc = λ { {(± A+ A-)} {(± B+ B-)} {(± C+ C-)} {(± D+ D-)} {f} {g} {h} →
{!!} }
; identityˡ = λ { {(± A+ A-)} {(± B+ B-)} {f} →
(begin
{!!}
↓⟨ {!!} ⟩
f ∎) }
; identityʳ = λ { {(± A+ A-)} {(± B+ B-)} {f} →
{!!} }
; equiv = C.equiv
; ∘-resp-≡ = λ { {(± A+ A-)} {(± B+ B-)} {(± C+ C-)} {f} {h} {g} {i} f≡h g≡i →
{!!} }
}
where
module C = Category C
open C.HomReasoning
module M = Monoidal M renaming (id to 𝟙)
module F = Functor M.⊗ renaming (F₀ to ⊗ₒ; F₁ to ⊗ₘ)
module B = Braided B
module S = Symmetric S
module T = Traced T
module NIassoc = NaturalIsomorphism M.assoc
open NaturalTransformation NIassoc.F⇒G renaming (η to ηassoc⇒)
open NaturalTransformation NIassoc.F⇐G renaming (η to ηassoc⇐)
module NIbraid = NaturalIsomorphism B.braid
open NaturalTransformation NIbraid.F⇒G renaming (η to ηbraid)
IntConstruction : ∀ {o ℓ e}
{C : Category o ℓ e} {M : Monoidal C} {B : Braided M} {S : Symmetric B} →
(T : Traced S) →
Σ[ IntC ∈ Category o ℓ e ]
Σ[ MIntC ∈ Monoidal IntC ]
Σ[ BIntC ∈ Braided MIntC ]
Σ[ SIntC ∈ Symmetric BIntC ]
Traced SIntC
IntConstruction = {!!}
| {
"alphanum_fraction": 0.5079623009,
"avg_line_length": 34.9659090909,
"ext": "agda",
"hexsha": "c4e956ba455ce626416ccfa2d23e9f82f9a8fae4",
"lang": "Agda",
"max_forks_count": 23,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T13:50:56.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-02-05T13:03:09.000Z",
"max_forks_repo_head_hexsha": "36f4181d751e2ecb54db219911d8c69afe8ba892",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "copumpkin/categories",
"max_forks_repo_path": "Categories/Monoidal/IntConstruction.agda",
"max_issues_count": 19,
"max_issues_repo_head_hexsha": "36f4181d751e2ecb54db219911d8c69afe8ba892",
"max_issues_repo_issues_event_max_datetime": "2019-08-09T16:31:40.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-05-23T06:47:10.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "copumpkin/categories",
"max_issues_repo_path": "Categories/Monoidal/IntConstruction.agda",
"max_line_length": 80,
"max_stars_count": 98,
"max_stars_repo_head_hexsha": "36f4181d751e2ecb54db219911d8c69afe8ba892",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "copumpkin/categories",
"max_stars_repo_path": "Categories/Monoidal/IntConstruction.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-08T05:20:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-04-15T14:57:33.000Z",
"num_tokens": 1180,
"size": 3077
} |
module Reright where
open import Prelude
open import Tactic.Reflection.Reright
open import Agda.Builtin.Reflection -- for better pretty-printing of error messages
-- 'reright' presents the user with changed context variabes, to mimic that done by 'rewrite'.
simple-reright-test₁ : (A B : Set) (F : Set → Set) → F A → A ≡ B → B → A
simple-reright-test₁ A B F FA A≡B b = reright A≡B $ λ (FB : F B) → b
-- the target of the reright (in this case x≡y₁) is excluded from the changed context variables
simple-reright-test₂ : {a : Level} {A : Set a} {x y : A} (x≡y₁ : x ≡ y) (x≡y₂ : x ≡ y) → y ≡ x
simple-reright-test₂ {y = y} x≡y₁ x≡y₂ = reright x≡y₁ λ (x≡y₂' : y ≡ y) → refl
-- the visibility of context variables remains the same in their changed state
simple-reright-test₃ : {a : Level} {A : Set a} {x y : A} (x≡y₁ : x ≡ y) (x≡y₂ : x ≡ y) {x≡y₃ : x ≡ y} → y ≡ x
simple-reright-test₃ {y = y} x≡y₁ x≡y₂ {x≡y₃} = reright x≡y₁ λ (x≡y₂' : y ≡ y) {x≡y₃' : y ≡ y} → refl
-- for some reason, when the first changed variable is hidden, it's impossible to bring it into scope
{- FAILS - results in unsolved metas
problematic-visibility : {a : Level} {A : Set a} {x y : A} (x≡y₁ : x ≡ y) {x≡y₃ : x ≡ y} → y ≡ x
problematic-visibility {y = y} x≡y₁ {x≡y₃} = reright x≡y₁ λ {x≡y₃' : y ≡ y} → refl
-}
module Test₁ where
postulate
Set≡Set : Set ≡ Set
A₀ : Set
A₁ : A₀ → Set
A₂ : (a₀ : A₀) → A₁ a₀ → Set
A₃ : (a₀ : A₀) → (a₁ : A₁ a₀) → A₂ a₀ a₁ → Set
B₀ : Set
B₁ : B₀ → Set
B₂ : (b₀ : B₀) → B₁ b₀ → Set
B₃ : (b₀ : B₀) → (b₁ : B₁ b₀) → B₂ b₀ b₁ → Set
A₀≡B₀ : A₀ ≡ B₀
F : Set → Set
C : (α : Level) (β : Level) → Set α → Set β
𝑨₀¹ : A₀
𝑨₀² : A₀
𝑨₀¹≡𝑨₀² : 𝑨₀¹ ≡ 𝑨₀²
𝑨₂𝑨₀²⋆ : (a₁𝑨₀² : A₁ 𝑨₀²) → A₂ 𝑨₀² a₁𝑨₀²
𝑩₀ : B₀
K₀ : A₀ → Set
test₀ : (b₀¹ b₀² : B₀) (b₀¹≡b₀² : b₀¹ ≡ b₀²) → Set
test₀ b₀¹ b₀² b₀¹≡b₀² with b₀¹≡b₀²
test₀ b₀¹ b₀² b₀¹≡b₀² | b₀¹≡b₀²-with = let b₀¹≡b₀²-let = b₀¹≡b₀²-with in reright b₀¹≡b₀²-let {!!}
test₁ : ∀ (a₀ : A₀) → a₀ ≡ a₀
test₁ a₀ = id (reright A₀≡B₀ {!!})
test₂ : A₀ → B₀
test₂ a₀ = reright A₀≡B₀ (λ b₀ → 𝑩₀)
test₃ : A₀ → B₀
test₃ a₀ = reright Set≡Set (reright A₀≡B₀ (λ b₀ → 𝑩₀))
test₄ : A₀ → B₀
test₄ a₀ = reright Set≡Set (reright A₀≡B₀ (λ b₀ → reright A₀≡B₀ {!!}))
test₅ : A₀ → B₀
test₅ a₀ = reright Set≡Set 𝑩₀
test₆ : A₀ → B₀
test₆ a₀ = reright Set≡Set $ reright A₀≡B₀ $ {!!}
test₇ : ∀ {α : Level}
(a₀ : A₀)
{β : Level}
(X Y : Set (α ⊔ β))
→ X ≡ Y
→ Y ≡ X
test₇ {α} a₀ {β} X Y X≡Y = id (reright X≡Y {!!})
test₈ : (a₁𝑨₀¹ : A₁ 𝑨₀¹) → A₂ 𝑨₀¹ a₁𝑨₀¹
test₈ a₁𝑨₀¹ = reright 𝑨₀¹≡𝑨₀² (λ a₁𝑨₀² → {!!})
test₉ : (a₀¹ : A₀) (a₀² : A₀) (a₀¹≡a₀²-1 : a₀¹ ≡ a₀²) (a₁a₀¹ : A₁ a₀¹) (X : Set) (Y : Set) (a₀¹≡a₀²-2 : a₀¹ ≡ a₀²) → F (A₂ a₀¹ a₁a₀¹) → F (A₁ a₀¹) ≡ A₂ a₀¹ a₁a₀¹
test₉ a₀¹ a₀² a₀¹≡a₀²-1 a₁a₀¹ X Y a₀¹≡a₀²-2 = reright a₀¹≡a₀²-1 {!!}
module _ (A₂⋆ : (a₀ : A₀) (a₁a₀ : A₁ a₀) → A₂ a₀ a₁a₀) where
test₁₀ : (a₀ : A₀) (a₁a₀¹ : A₁ a₀) (a₁a₀² : A₁ a₀) (a₁a₀¹≡a₁a₀² : a₁a₀¹ ≡ a₁a₀²) → A₂ a₀ a₁a₀¹
test₁₀ a₀ a₁a₀¹ a₁a₀² a₁a₀¹≡a₁a₀² = reright a₁a₀¹≡a₁a₀² {!!}
test₁₁ : (a₀¹ : A₀) (a₀² : A₀) (FA₁a₀¹≡FA₁a₀² : F (A₁ a₀¹) ≡ F (A₁ a₀²)) → F (A₁ a₀¹) → F (A₁ a₀¹) ≡ F (F (A₁ a₀¹))
test₁₁ a₀¹ a₀² FA₁a₀¹≡FA₁a₀² = reright FA₁a₀¹≡FA₁a₀² {!!}
test₁₂ : (a₀¹ : A₀) (a₀² : A₀) (FA₁a₀¹≡FA₁a₀² : F (A₁ a₀¹) ≡ F (A₁ a₀²)) → F (A₁ a₀¹) → F (A₁ a₀¹) ≡ F (F (A₁ a₀¹))
test₁₂ a₀¹ a₀² FA₁a₀¹≡FA₁a₀² FA₁a₀¹ = reright FA₁a₀¹≡FA₁a₀² {!!}
test₁₃ : (β : Level)
(a₀¹ : A₀)
(χ : Level)
(a₀² : A₀)
(CA₁a₀¹≡CA₁a₀² : C lzero (β ⊔ χ) (A₁ a₀¹) ≡ C lzero (β ⊔ χ) (A₁ a₀²)) →
C lzero (β ⊔ χ) (A₁ a₀¹)
→ Nat → Σ _ λ γ → C lzero (β ⊔ χ) (A₁ a₀¹) ≡ C γ (β ⊔ χ) (C lzero γ (A₁ a₀¹))
test₁₃ β a₀¹ χ a₀² CA₁a₀¹≡CA₁a₀² CA₁a₀¹ = reright CA₁a₀¹≡CA₁a₀² {!!}
test₁₄ : (a₀ : A₀) (FFA₁a₀≡FA₁a₀ : F (F (A₁ a₀)) ≡ F (A₁ a₀)) → F (F (F (F (A₁ a₀))))
test₁₄ a₀ FFA₁a₀≡FA₁a₀ = reright FFA₁a₀≡FA₁a₀ (reright FFA₁a₀≡FA₁a₀ (reright FFA₁a₀≡FA₁a₀ {!!}))
test₁₅ : (a₀ : A₀) (FA₁a₀≡FFA₁a₀ : F (A₁ a₀) ≡ F (F (A₁ a₀))) → F (F (A₁ a₀))
test₁₅ a₀ FA₁a₀≡FFA₁a₀ = reright FA₁a₀≡FFA₁a₀ (reright FA₁a₀≡FFA₁a₀ {!!})
test₁₆ : (l : A₀ → Level → Level)
(β : Level)
(a₀² : A₀)
(a₀¹ : A₀)
(CA₁a₀¹≡CA₁a₀² : C lzero (l a₀¹ β) (A₁ a₀¹) ≡ C lzero (l a₀¹ β) (A₁ a₀²))
→ C lzero (l a₀¹ β) (A₁ a₀¹)
→ Σ _ λ γ → C lzero (l a₀¹ β) (A₁ a₀¹) ≡ C γ (l a₀¹ β) (C lzero γ (A₁ a₀¹))
test₁₆ l β a₀² a₀¹ CA₁a₀¹≡CA₁a₀² CA₁a₀¹ = reright CA₁a₀¹≡CA₁a₀² {!!}
test₁₇ : (a₀¹ : A₀)
(a₀² : A₀)
(K₀a₀¹ : K₀ a₀¹)
(a₀¹≡a₀² : a₀¹ ≡ a₀²)
→ Set
test₁₇ a₀¹ a₀² K₀a₀¹ a₀¹≡a₀² = reright a₀¹≡a₀² {!!}
test₁₈ : (a₀¹ : A₀)
(a₀² : A₀)
(k₀a₀¹ : K₀ a₀¹)
(FK₀a₀¹ : F (K₀ a₀¹))
(K₀a₀¹≡K₀a₀² : K₀ a₀¹ ≡ K₀ a₀²)
→ F (F (K₀ a₀¹)) ≡ F (K₀ a₀²)
test₁₈ a₀¹ a₀² k₀a₀¹ FK₀a₀¹ K₀a₀¹≡K₀a₀² = reright K₀a₀¹≡K₀a₀² {!!}
test₁₉ : ∀ {a₀¹ : A₀}
{a₀² : A₀}
{a₁a₀²-1 a₁a₀²-2 a₁a₀²-3 : A₁ a₀²}
{a₁a₀²-2=a₁a₀²-3 : A₂ a₀² a₁a₀²-2 ≡ A₂ a₀² a₁a₀²-3}
(R : ∀ (a₀²' : A₀) → A₂ a₀² a₁a₀²-1 ≡ A₂ a₀² a₁a₀²-2)
(X : A₂ a₀² a₁a₀²-2 ≡ A₂ a₀² a₁a₀²-3)
{ignore : Set}
→ A₂ a₀² a₁a₀²-1 ≡ A₂ a₀² a₁a₀²-3
test₁₉ {a₀¹} {a₀²} {a₁a₀²-1} {a₁a₀²-2} {a₁a₀²-3} {a₁a₀²-2=a₁a₀²-3} R X = reright (R a₀¹) {!!}
{- FAILS (correctly, though perhaps without the most comprehensible of error messages)
test₂₀' : (f₁ : A₀) (f₂ : A₀) (A₀f₁≡A₀f₂ : A₁ f₁ ≡ A₁ f₂) (g₁ : A₁ f₁) → A₂ f₁ g₁
test₂₀' f₁ f₂ A₀f₁≡A₀f₂ g₁ rewrite A₀f₁≡A₀f₂ = {!!}
test₂₀ : (f₁ : A₀) (f₂ : A₀) (A₀f₁≡A₀f₂ : A₁ f₁ ≡ A₁ f₂) (g₁ : A₁ f₁) → A₂ f₁ g₁
test₂₀ f₁ f₂ A₀f₁≡A₀f₂ g₁ = reright A₀f₁≡A₀f₂ {!!}
-}
test₂₀ : ∀ {a b : Level} {A : Set a} {x y : A} (x≡y : x ≡ y) → Set
test₂₀ x≡y = reright x≡y {!!}
test₂₁ : ∀ {a b : Level} {A : Set a} {x y : A} (B : Set b) (x≡y : x ≡ y) → Set
test₂₁ B x≡y = reright x≡y {!!}
test₂₂ : ∀ {a : Level} {A : Set a} {B : Set} {x : B} {y : B} (x≡y : x ≡ y) → Set
test₂₂ x≡y = reright x≡y {!!}
module _ (l : Level) where
postulate P : Set
test₂₃ : (p : P)
(A : Set)
(x y : A)
(x≡y : x ≡ y)
→ Set
test₂₃ _ _ _ _ x≡y = reright x≡y ?
module Test₂ where
record Map
{K : Set}
(V : K → Set)
(Carrier : Nat → Set) {{isDecEquivalence/K : Eq K}} {{isDecEquivalence/V : (k : K) → Eq (V k)}} : Set₁ where
field
∅ : Carrier 0
_∉_ : ∀ {s} → K → Carrier s → Set
∅-is-empty : ∀ {𝑘} {∅ : Carrier 0} → 𝑘 ∉ ∅
_∈_ : ∀ {s} → K → Carrier s → Set
_∈_ k m = ¬ k ∉ m
field
get : ∀ {k : K} {s} {m : Carrier s} → k ∈ m → V k
put : ∀ {k₀ : K} (v₀ : V k₀) {s₁} {m₁ : Carrier s₁} → k₀ ∉ m₁ → Σ _ λ (m₀ : Carrier (suc s₁)) → Σ _ λ (k₀∈m₀ : k₀ ∈ m₀) → get k₀∈m₀ ≡ v₀
postulate
A : Set
V : A → Set
V = λ _ → Nat
postulate
M : Nat → Set
isDecEquivalence/A : Eq A
isDecEquivalence/V : (a : A) → Eq (V a)
postulate
m : Map V M {{isDecEquivalence/A}} {{isDecEquivalence/V}}
open Map m
test₁ : (v : Nat) (k : A)
→ (k∈putkv∅ : k ∈ (fst $ put {k₀ = k} v {m₁ = ∅} ∅-is-empty))
→ Set
test₁ v k k∈putkv∅ = let p = (put {k₀ = k} v {m₁ = ∅} ∅-is-empty) in let r = sym (snd $ snd p) in reright r {!!}
{- expected.out
?0 : b₀² ≡ b₀² → Set
?1 : (b : B₀) → b ≡ b
?2 : B₀ → B₀
?3 : B₀ → B₀
?4 : Y ≡ Y
?5 : A₂ 𝑨₀² a₁𝑨₀²
?6 : (a₁ : A₁ a₀²) → a₀² ≡ a₀² → F (A₂ a₀² a₁) → F (A₁ a₀²) ≡ A₂ a₀² a₁
?7 : A₂ a₀ a₁a₀²
?8 : F (A₁ a₀²) → F (A₁ a₀²) ≡ F (F (A₁ a₀²))
?9 : F (A₁ a₀²) → F (A₁ a₀²) ≡ F (F (A₁ a₀²))
?10 : C lzero (χ ⊔ β) (A₁ a₀²) →
Nat →
Σ Level
(λ γ → C lzero (χ ⊔ β) (A₁ a₀²) ≡ C γ (χ ⊔ β) (C lzero γ (A₁ a₀¹)))
?11 : F (A₁ a₀)
?12 : F (F (F (F (A₁ a₀))))
?13 : C lzero (l a₀¹ β) (A₁ a₀²) →
Σ Level
(λ γ →
C lzero (l a₀¹ β) (A₁ a₀²) ≡ C γ (l a₀¹ β) (C lzero γ (A₁ a₀¹)))
?14 : K₀ a₀² → Set
?15 : K₀ a₀² → F (K₀ a₀²) → F (F (K₀ a₀²)) ≡ F (K₀ a₀²)
?16 : (A₀ → A₂ a₀² a₁a₀²-2 ≡ A₂ a₀² a₁a₀²-2) →
A₂ a₀² a₁a₀²-2 ≡ A₂ a₀² a₁a₀²-3
?17 : Set
?18 : Set
?19 : Set
?20 : Set
?21 : (k ∉ fst (put (get (fst (snd (put v ∅-is-empty)))) ∅-is-empty) →
⊥) →
Set
-}
| {
"alphanum_fraction": 0.4930061912,
"avg_line_length": 36.6470588235,
"ext": "agda",
"hexsha": "16c38c4bf77ec07f0bde0a997b443e92f6f90933",
"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": "test/Reright.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": "test/Reright.agda",
"max_line_length": 165,
"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": "test/Reright.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": 4622,
"size": 8722
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Lists made up entirely of unique elements (setoid equality)
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (Rel; Setoid)
module Data.List.Relation.Unary.Unique.Setoid {a ℓ} (S : Setoid a ℓ) where
open Setoid S renaming (Carrier to A)
open import Data.List.Base
import Data.List.Relation.Unary.AllPairs as AllPairsM
open import Level using (_⊔_)
open import Relation.Unary using (Pred)
open import Relation.Nullary using (¬_)
------------------------------------------------------------------------
-- Definition
private
Distinct : Rel A ℓ
Distinct x y = ¬ (x ≈ y)
open import Data.List.Relation.Unary.AllPairs.Core Distinct
renaming (AllPairs to Unique)
public
open import Data.List.Relation.Unary.AllPairs {R = Distinct}
using (head; tail)
public
| {
"alphanum_fraction": 0.5628803245,
"avg_line_length": 26.6486486486,
"ext": "agda",
"hexsha": "8622bda3d6aa2e326f7f5d4883bc2bb294554302",
"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/List/Relation/Unary/Unique/Setoid.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/List/Relation/Unary/Unique/Setoid.agda",
"max_line_length": 74,
"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/List/Relation/Unary/Unique/Setoid.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": 208,
"size": 986
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Equality over lists using propositional equality
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
module Data.List.Relation.Binary.Equality.Propositional {a} {A : Set a} where
open import Data.List
import Data.List.Relation.Binary.Equality.Setoid as SetoidEquality
open import Relation.Binary.PropositionalEquality
------------------------------------------------------------------------
-- Publically re-export everything from setoid equality
open SetoidEquality (setoid A) public
------------------------------------------------------------------------
-- ≋ is propositional
≋⇒≡ : _≋_ ⇒ _≡_
≋⇒≡ [] = refl
≋⇒≡ (refl ∷ xs≈ys) = cong (_ ∷_) (≋⇒≡ xs≈ys)
≡⇒≋ : _≡_ ⇒ _≋_
≡⇒≋ refl = ≋-refl
| {
"alphanum_fraction": 0.4645232816,
"avg_line_length": 29.0967741935,
"ext": "agda",
"hexsha": "00882a210a3070316e5344a7dfbd4fa043d9d13a",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "omega12345/agda-mode",
"max_forks_repo_path": "test/asset/agda-stdlib-1.0/Data/List/Relation/Binary/Equality/Propositional.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "omega12345/agda-mode",
"max_issues_repo_path": "test/asset/agda-stdlib-1.0/Data/List/Relation/Binary/Equality/Propositional.agda",
"max_line_length": 77,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "omega12345/agda-mode",
"max_stars_repo_path": "test/asset/agda-stdlib-1.0/Data/List/Relation/Binary/Equality/Propositional.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 215,
"size": 902
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.List.Relation.Unary.Any.Properties directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Relation.BagAndSetEquality where
open import Data.List.Relation.Binary.BagAndSetEquality public
| {
"alphanum_fraction": 0.5035460993,
"avg_line_length": 32.5384615385,
"ext": "agda",
"hexsha": "166e4ddd5ff7800c46bf9dbe021be185afaef259",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "omega12345/agda-mode",
"max_forks_repo_path": "test/asset/agda-stdlib-1.0/Data/List/Relation/BagAndSetEquality.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/Relation/BagAndSetEquality.agda",
"max_line_length": 72,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "omega12345/agda-mode",
"max_stars_repo_path": "test/asset/agda-stdlib-1.0/Data/List/Relation/BagAndSetEquality.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 67,
"size": 423
} |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.RibbonCover
module experimental.CoverClassification2 {i} (X : Ptd i)
(A-conn : is-connected 0 (de⊙ X)) where
private
A = de⊙ X
a = pt X
open Cover
open import homotopy.CoverClassification X A-conn
{-
Universality of the covering generated by the fundamental group itself.
-}
-- FIXME What's the established terminology for this?
canonical-gset : Gset (πS 0 X) i
canonical-gset = record
{ El = a =₀ a
; El-level = Trunc-level
; gset-struct = record
{ act = _∙₀_
; unit-r = ∙₀-unit-r
; assoc = ∙₀-assoc
}
}
-- FIXME What's the established terminology for this?
canonical-cover : Cover A i
canonical-cover = gset-to-cover canonical-gset
{-
private
module CanonicalIsUniversal where
open covering canonical-covering
open gset canonical-gset
center′ : ∀ a → Σ A fiber
center′ a = (a , trace {gs = act} refl₀ refl₀)
center : τ ⟨1⟩ (Σ A fiber)
center = proj center′
private
-- An ugly lemma for this development only
trans-fiber≡cst-proj-Σ-eq : ∀ {i} (P : Set i) (Q : P → Set i)
(a : P) (c : Σ P Q) {b₁ b₂} (p : b₁ ≡ b₂) (q : a ≡ π₁ c)
(r : transport Q q b₁ ≡ π₂ c)
→ transport (λ r → (a , r) ≡₀ c) p (proj $ Σ-eq q r)
≡ proj (Σ-eq q (ap (transport Q q) (! p) ∘ r))
trans-fiber≡cst-proj-Σ-eq P Q a c refl q r = refl
abstract
path-trace-fiber : ∀ {a₂} y (p : a ≡ a₂)
→ transport fiber (! p ∘ ! y) (trace (proj y) (proj p))
≡ trace refl₀ refl₀
path-trace-fiber y refl =
transport fiber (! y) (trace (proj y) refl₀)
≡⟨ trans-trace act (! y) (proj y) refl₀ ⟩
trace (proj y) (proj $ ! y)
≡⟨ paste refl₀ (proj y) (proj $ ! y) ⟩
trace refl₀ (proj $ y ∘ ! y)
≡⟨ ap (trace refl₀ ◯ proj) $ opposite-right-inverse y ⟩∎
trace refl₀ refl₀
∎
path-trace : ∀ {a₂} y p → (a₂ , trace {act = act} y p) ≡₀ center′
path-trace {a₂} =
π₀-extend ⦃ λ y → Π-is-set λ p → π₀-is-set ((a₂ , trace y p) ≡ center′) ⦄
(λ y → π₀-extend ⦃ λ p → π₀-is-set ((a₂ , trace (proj y) p) ≡ center′) ⦄
(λ p → proj $ Σ-eq (! p ∘ ! y) (path-trace-fiber y p)))
abstract
path-paste′ : ∀ {a₂} y loop p
→ transport (λ r → (a₂ , r) ≡₀ center′) (paste (proj y) (proj loop) (proj p))
(path-trace (proj $ y ∘ loop) (proj p))
≡ path-trace (proj y) (proj $ loop ∘ p)
path-paste′ y loop refl =
transport (λ r → (a , r) ≡₀ center′) (paste (proj y) (proj loop) refl₀)
(proj $ Σ-eq (! (y ∘ loop)) (path-trace-fiber (y ∘ loop) refl))
≡⟨ trans-fiber≡cst-proj-Σ-eq A fiber a center′
(paste (proj y) (proj loop) refl₀)
(! (y ∘ loop)) (path-trace-fiber (y ∘ loop) refl) ⟩
proj (Σ-eq (! (y ∘ loop)) _)
≡⟨ ap proj $
ap2 (λ p q → Σ-eq p q)
(! (y ∘ loop)
≡⟨ opposite-concat y loop ⟩
! loop ∘ ! y
≡⟨ ap (λ x → ! x ∘ ! y) $ ! $ refl-right-unit loop ⟩∎
! (loop ∘ refl) ∘ ! y
∎)
(prop-has-all-paths (ribbon-is-set a _ _) _ _) ⟩∎
proj (Σ-eq (! (loop ∘ refl) ∘ ! y) (path-trace-fiber y (loop ∘ refl)))
∎
abstract
path-paste : ∀ {a₂} y loop p
→ transport (λ r → (a₂ , r) ≡₀ center′) (paste y loop p)
(path-trace (y ∘₀ loop) p)
≡ path-trace y (loop ∘₀ p)
path-paste {a₂} =
π₀-extend ⦃ λ y → Π-is-set λ loop → Π-is-set λ p → ≡-is-set $ π₀-is-set _ ⦄
(λ y → π₀-extend ⦃ λ loop → Π-is-set λ p → ≡-is-set $ π₀-is-set _ ⦄
(λ loop → π₀-extend ⦃ λ p → ≡-is-set $ π₀-is-set _ ⦄
(λ p → path-paste′ y loop p)))
path′ : (y : Σ A fiber) → proj {n = ⟨1⟩} y ≡ center
path′ y = τ-path-equiv-path-τ-S {n = ⟨0⟩} ☆
ribbon-rec {act = act} (π₁ y)
(λ r → (π₁ y , r) ≡₀ center′)
⦃ λ r → π₀-is-set ((π₁ y , r) ≡ center′) ⦄
path-trace
path-paste
(π₂ y)
path : (y : τ ⟨1⟩ (Σ A fiber)) → y ≡ center
path = τ-extend {n = ⟨1⟩} ⦃ λ _ → ≡-is-truncated ⟨1⟩ $ τ-is-truncated ⟨1⟩ _ ⦄ path′
canonical-covering-is-universal : is-universal canonical-covering
canonical-covering-is-universal = Universality.center , Universality.path
-- The other direction: If a covering is universal, then the fiber
-- is equivalent to the fundamental group.
module _ (cov : covering) (cov-is-universal : is-universal cov) where
open covering cov
open action (covering⇒action cov)
-- We need a point!
module GiveMeAPoint (center : fiber a) where
-- Goal: fiber a <-> fundamental group
fiber-a⇒fg : fiber a → a ≡₀ a
fiber-a⇒fg y = ap₀ π₁ $ connected-has-all-τ-paths
cov-is-universal (a , center) (a , y)
fg⇒fiber-a : a ≡₀ a → fiber a
fg⇒fiber-a = tracing cov center
fg⇒fiber-a⇒fg : ∀ p → fiber-a⇒fg (fg⇒fiber-a p) ≡ p
fg⇒fiber-a⇒fg = π₀-extend ⦃ λ _ → ≡-is-set $ π₀-is-set _ ⦄ λ p →
ap₀ π₁ (connected-has-all-τ-paths
cov-is-universal (a , center) (a , transport fiber p center))
≡⟨ ap (ap₀ π₁)
$ ! $ π₂ (connected-has-connected-paths cov-is-universal _ _)
(proj $ Σ-eq p refl) ⟩
ap₀ π₁ (proj $ Σ-eq p refl)
≡⟨ ap proj $ base-path-Σ-eq p refl ⟩∎
proj p
∎
fiber-a⇒fg⇒fiber-a : ∀ y → fg⇒fiber-a (fiber-a⇒fg y) ≡ y
fiber-a⇒fg⇒fiber-a y = π₀-extend
⦃ λ p → ≡-is-set {x = tracing cov center (ap₀ π₁ p)} {y = y}
$ fiber-is-set a ⦄
(λ p →
transport fiber (base-path p) center
≡⟨ trans-base-path p ⟩∎
y
∎)
(connected-has-all-τ-paths cov-is-universal (a , center) (a , y))
fiber-a≃fg : fiber a ≃ (a ≡₀ a)
fiber-a≃fg = fiber-a⇒fg , iso-is-eq _ fg⇒fiber-a
fg⇒fiber-a⇒fg fiber-a⇒fg⇒fiber-a
-- This is the best we can obtain, because there is no continuous
-- choice of the center.
[center] : [ fiber a ]
[center] = τ-extend-nondep
⦃ prop-is-gpd []-is-prop ⦄
(λ y → []-extend-nondep
⦃ []-is-prop ⦄
(proj ◯ λ p → transport fiber p (π₂ y))
(connected-has-all-τ-paths A⋆-is-conn (π₁ y) a))
(π₁ cov-is-universal)
-- [ isomorphism between the fiber and the fundamental group ]
-- This is the best we can obtain, because there is no continuous
-- choice of the center.
[fiber-a≃fg] : [ fiber a ≃ (a ≡₀ a) ]
[fiber-a≃fg] = []-extend-nondep ⦃ []-is-prop ⦄
(proj ◯ GiveMeAPoint.fiber-a≃fg) [center]
-}
| {
"alphanum_fraction": 0.505907781,
"avg_line_length": 36.335078534,
"ext": "agda",
"hexsha": "f0e10d3801a68e74031cb6c90a53bd21ebaacfb3",
"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/CoverClassification2.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/CoverClassification2.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/stash/CoverClassification2.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": 2457,
"size": 6940
} |
-- Andreas, 2015-02-07
postulate
X Y : Set
fix : (X → X) → X
g : Y → X → X
y : Y
P : X → Set
yes : (f : X → X) → P (f (fix f))
test : P (g y (fix (g y)))
test with g y
test | f = yes f
-- should be able to abstract (g y) twice
-- and succeed
| {
"alphanum_fraction": 0.4866920152,
"avg_line_length": 15.4705882353,
"ext": "agda",
"hexsha": "31b93ad213106ff9ec3fa3361bb4f97def23250c",
"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/WithAbstractTwiceInApplication.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/WithAbstractTwiceInApplication.agda",
"max_line_length": 41,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Succeed/WithAbstractTwiceInApplication.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": 113,
"size": 263
} |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Functor
module Categories.Diagram.Limit.Properties
{o ℓ e} {o′ ℓ′ e′} {C : Category o ℓ e} {J : Category o′ ℓ′ e′} where
open import Categories.Diagram.Cone.Properties
open import Categories.NaturalTransformation.NaturalIsomorphism using (NaturalIsomorphism; _≃_; module ≃)
open import Categories.Morphism.Reasoning C
open import Categories.Morphism C
import Categories.Category.Construction.Cones as Con
import Categories.Diagram.Limit as Lim
private
module J = Category J
module C = Category C
open C
variable
X Y Z : Obj
f g h : X ⇒ Y
open HomReasoning
-- natural isomorphisms respects limits
module _ {F G : Functor J C} (F≃G : F ≃ G) where
private
module F = Functor F
module G = Functor G
module LF = Lim F
module LG = Lim G
open NaturalIsomorphism F≃G
≃-resp-lim : LF.Limit → LG.Limit
≃-resp-lim L = record
{ terminal = record
{ ⊤ = record
{ apex = record
{ ψ = λ j → ⇒.η j ∘ proj j
; commute = λ {X Y} f → begin
G.F₁ f ∘ ⇒.η X ∘ proj X ≈⟨ pullˡ (⇒.sym-commute f) ⟩
(⇒.η Y ∘ F.F₁ f) ∘ proj X ≈⟨ pullʳ (limit-commute f) ⟩
⇒.η Y ∘ proj Y ∎
}
}
; ⊤-is-terminal = record
{ ! = λ {A} → record
{ arr = rep (nat-map-Cone F⇐G A)
; commute = λ {j} → assoc ○ ⟺ (switch-tofromˡ (record { iso = iso j }) (⟺ commute))
}
; !-unique = λ {K} f →
let module f = Con.Cone⇒ G f
in terminal.!-unique record
{ arr = f.arr
; commute = λ {j} → switch-fromtoˡ (record { iso = iso j }) (sym-assoc ○ f.commute)
}
}
}
}
where open LF.Limit L
≃⇒Cone⇒ : ∀ (Lf : LF.Limit) (Lg : LG.Limit) → Con.Cones G [ LG.Limit.limit (≃-resp-lim Lf) , LG.Limit.limit Lg ]
≃⇒Cone⇒ Lf Lg = rep-cone (LG.Limit.limit (≃-resp-lim Lf))
where open LG.Limit Lg
≃⇒lim≅ : ∀ {F G : Functor J C} (F≃G : F ≃ G) (Lf : Lim.Limit F) (Lg : Lim.Limit G) → Lim.Limit.apex Lf ≅ Lim.Limit.apex Lg
≃⇒lim≅ {F = F} {G} F≃G Lf Lg = record
{ from = arr (≃⇒Cone⇒ F≃G Lf Lg)
; to = arr (≃⇒Cone⇒ (≃.sym F≃G) Lg Lf)
; iso = record
{ isoˡ = Lf.terminal.⊤-id record
{ commute = λ {j} → begin
Lf.proj j ∘ arr (≃⇒Cone⇒ (≃.sym F≃G) Lg Lf) ∘ arr (≃⇒Cone⇒ F≃G Lf Lg) ≈⟨ pullˡ (⇒-commute (≃⇒Cone⇒ (≃.sym F≃G) Lg Lf)) ⟩
(⇐.η j ∘ Lg.proj j) ∘ arr (≃⇒Cone⇒ F≃G Lf Lg) ≈⟨ pullʳ (⇒-commute (≃⇒Cone⇒ F≃G Lf Lg)) ⟩
⇐.η j ∘ ⇒.η j ∘ Lf.proj j ≈⟨ cancelˡ (iso.isoˡ j) ⟩
Lf.proj j ∎
}
; isoʳ = Lg.terminal.⊤-id record
{ commute = λ {j} → begin
Lg.proj j ∘ arr (≃⇒Cone⇒ F≃G Lf Lg) ∘ arr (≃⇒Cone⇒ (≃.sym F≃G) Lg Lf) ≈⟨ pullˡ (⇒-commute (≃⇒Cone⇒ F≃G Lf Lg)) ⟩
(⇒.η j ∘ Lf.proj j) ∘ arr (≃⇒Cone⇒ (≃.sym F≃G) Lg Lf) ≈⟨ pullʳ (⇒-commute (≃⇒Cone⇒ (≃.sym F≃G) Lg Lf)) ⟩
⇒.η j ∘ ⇐.η j ∘ Lg.proj j ≈⟨ cancelˡ (iso.isoʳ j) ⟩
Lg.proj j ∎
}
}
}
where open Con.Cone⇒ renaming (commute to ⇒-commute)
module Lf = Lim.Limit Lf
module Lg = Lim.Limit Lg
open NaturalIsomorphism F≃G
| {
"alphanum_fraction": 0.4928284567,
"avg_line_length": 37.085106383,
"ext": "agda",
"hexsha": "bd08b28e697521b422a3c80061bede06a1e23833",
"lang": "Agda",
"max_forks_count": 64,
"max_forks_repo_forks_event_max_datetime": "2022-03-14T02:00:59.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-06-02T16:58:15.000Z",
"max_forks_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Code-distancing/agda-categories",
"max_forks_repo_path": "src/Categories/Diagram/Limit/Properties.agda",
"max_issues_count": 236,
"max_issues_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_issues_repo_issues_event_max_datetime": "2022-03-28T14:31:43.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-06-01T14:53:54.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Code-distancing/agda-categories",
"max_issues_repo_path": "src/Categories/Diagram/Limit/Properties.agda",
"max_line_length": 128,
"max_stars_count": 279,
"max_stars_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Trebor-Huang/agda-categories",
"max_stars_repo_path": "src/Categories/Diagram/Limit/Properties.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-22T00:40:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-06-01T14:36:40.000Z",
"num_tokens": 1411,
"size": 3486
} |
open import lib
open import sum
module grammar (form : Set)(_eq_ : form → form → 𝔹)(drop-form : (x y : form) → x ≡ y → x eq y ≡ tt)(rise-form : (x y : form) → x eq y ≡ tt → x ≡ y) where
infix 7 _⇒_
data production : Set where
_⇒_ : form → 𝕃 (form ⊎ char) → production
record grammar {numprods : ℕ} : Set where
constructor _,_
field
start : form
prods : 𝕍 production numprods
open grammar
splice : ℕ → 𝕃 (form ⊎ char) → form → 𝕃 (form ⊎ char) → 𝕃 (form ⊎ char)
splice x [] _ _ = []
splice 0 ((inj₁ s) :: ss) s' ss' with s eq s'
... | tt = ss' ++ ss
... | ff = (inj₁ s) :: ss
splice 0 (x :: ss) s' ss' = x :: ss
splice (suc n) (s :: ss) s' ss' = s :: splice n ss s' ss'
𝕃inj₂ : ∀{ℓ ℓ'}{B : Set ℓ}{A : Set ℓ'} → 𝕃 A → 𝕃 (B ⊎ A)
𝕃inj₂ (x :: xs) = (inj₂ x) :: 𝕃inj₂ xs
𝕃inj₂ [] = []
𝕃inj₁ : ∀{ℓ ℓ'}{B : Set ℓ}{A : Set ℓ'} → 𝕃 A → 𝕃 (A ⊎ B)
𝕃inj₁ (x :: xs) = (inj₁ x) :: 𝕃inj₁ xs
𝕃inj₁ [] = []
data derivation{numprods : ℕ} {g : grammar{numprods}} : 𝕃 (form ⊎ char) → 𝕃 char → Set where
end : {ss : 𝕃 char} → derivation (𝕃inj₂ ss) ss
step : ∀ {ss1 ss1' : 𝕃 (form ⊎ char)}{ss2 : 𝕃 char}{s : form}{ss : 𝕃 (form ⊎ char)} →
(m n : ℕ) → (p : n < numprods ≡ tt) →
nth𝕍 n p (prods g) ≡ (s ⇒ ss) →
m < length ss1 ≡ tt →
splice m ss1 s ss ≡ ss1' →
derivation {g = g} ss1' ss2 →
derivation ss1 ss2
splice-concat : ∀{l1 l2 target final : 𝕃 (form ⊎ char)}{n : ℕ}{slice : form} → splice n l1 slice target ≡ final → splice (n + (length l2)) (l2 ++ l1) slice target ≡ l2 ++ final
splice-concat{l2 = []}{n = n} pr rewrite +0 n = pr
splice-concat{l1}{x :: xs}{n = n} pr rewrite +suc n (length xs) | splice-concat{l1}{l2 = xs} pr = refl
_=form⊎char_ : (x y : form ⊎ char) → 𝔹
_=form⊎char_ = =⊎ _eq_ _=char_
form⊎char-drop : (x y : form ⊎ char) → x ≡ y → x =form⊎char y ≡ tt
form⊎char-drop = ≡⊎-to-= _eq_ _=char_ drop-form ≡char-to-=
form⊎char-rise : (x y : form ⊎ char) → x =form⊎char y ≡ tt → x ≡ y
form⊎char-rise = =⊎-to-≡ _eq_ _=char_ rise-form =char-to-≡
splice-concat2 : ∀{l1 l2 target final : 𝕃 (form ⊎ char)}{n : ℕ}{slice : form} → splice n l1 slice target ≡ final → n < length l1 ≡ tt → splice n (l1 ++ l2) slice target ≡ final ++ l2
splice-concat2{[]}{n = n} pr1 pr2 rewrite <-0 n = 𝔹-contra pr2
splice-concat2{inj₁ x :: xs}{l2}{target}{n = 0}{slice} pr1 pr2 with x eq slice
...| tt rewrite (sym pr1) | ++[] target | ++-assoc target xs l2 = refl
...| ff rewrite (sym pr1) = refl
splice-concat2{inj₂ x :: xs}{l2}{target}{n = 0}{slice} pr1 pr2 rewrite (sym pr1) = refl
splice-concat2{x :: xs}{l2}{target}{[]}{suc n} pr1 pr2 with pr1
...| ()
splice-concat2{x :: xs}{l2}{target}{f :: fs}{suc n}{slice} pr1 pr2 with =𝕃-from-≡ _=form⊎char_ form⊎char-drop pr1
...| s1 rewrite splice-concat2{xs}{l2}{target}{fs}{n}{slice} (≡𝕃-from-={l1 = splice n xs slice target}{fs} _=form⊎char_ form⊎char-rise (&&-snd{x =form⊎char f} s1)) pr2 | form⊎char-rise x f (&&-fst{x =form⊎char f} s1) = refl
length+ : ∀{ℓ}{A : Set ℓ}(l1 l2 : 𝕃 A) → length (l1 ++ l2) ≡ length l1 + length l2
length+ [] l2 = refl
length+ (x :: xs) l2 rewrite length+ xs l2 = refl
<-h1 : ∀{x y a : ℕ} → x < y ≡ tt → x + a < y + a ≡ tt
<-h1{x}{y}{0} p rewrite +0 x | +0 y = p
<-h1{x}{y}{suc n} p rewrite +suc y n | +suc x n = <-h1{x}{y}{n} p
<-h2 : ∀{a x y : ℕ} → a < x ≡ tt → a < x + y ≡ tt
<-h2{a}{x}{0} p rewrite +0 x = p
<-h2{a}{x}{suc y} p rewrite +suc x y with <-h2{a}{x}{y} p | <-suc (x + y)
...| pr1 | pr2 = <-trans{a}{x + y}{suc (x + y)} pr1 pr2
length𝕃inj₂ : ∀{ℓ ℓ'}{A : Set ℓ}{B : Set ℓ'} → (l : 𝕃 A) → length (𝕃inj₂{B = B} l) ≡ length l
length𝕃inj₂{B = B} (x :: xs) rewrite length𝕃inj₂{B = B} xs = refl
length𝕃inj₂ [] = refl
𝕃inj₂++ : ∀{ℓ ℓ'}{A : Set ℓ}{B : Set ℓ'} → (l1 l2 : 𝕃 A) → 𝕃inj₂{B = B} (l1 ++ l2) ≡ 𝕃inj₂ l1 ++ 𝕃inj₂ l2
𝕃inj₂++ [] l2 = refl
𝕃inj₂++{B = B} (x :: xs) l2 rewrite 𝕃inj₂++{B = B} xs l2 = refl
infixr 10 _deriv++_
_deriv++_ : {l2 l4 : 𝕃 char}{l1 l3 : 𝕃 (form ⊎ char)}{n : ℕ}{gr : grammar{n}} → derivation{g = gr} l1 l2 → derivation{g = gr} l3 l4 → derivation{g = gr} (l1 ++ l3) (l2 ++ l4)
_deriv++_{l2}{l4} end end rewrite sym (𝕃inj₂++{B = form} l2 l4) = end
_deriv++_{l2}{l4}{l1}{l3} f (step{ss1' = ss1'}{s = s}{ss} a b pr1 pr2 pr3 pr4 next) with <-h1{a}{length l3}{length l1} pr3
...| pr5 rewrite +comm (length l3) (length l1) | (sym (length+ l1 l3)) = step{ss1 = l1 ++ l3}{l1 ++ ss1'}{l2 ++ l4} (a + (length l1)) b pr1 pr2 pr5 (splice-concat{l3}{l1} pr4) (_deriv++_ f next)
_deriv++_{l2}{l4}{l1} (step{ss1' = ss1'}{s = s}{ss} a b pr1 pr2 pr3 pr4 next) end with <-h2{a}{length l1}{length (𝕃inj₂{B = form} l4)} pr3
...| pr5 rewrite sym (length+ l1 (𝕃inj₂ l4)) = step{ss1 = l1 ++ 𝕃inj₂ l4}{ss1' ++ 𝕃inj₂ l4}{l2 ++ l4} a b pr1 pr2 pr5 (splice-concat2{l1}{𝕃inj₂ l4} pr4 pr3) (_deriv++_ next end)
| {
"alphanum_fraction": 0.5562761506,
"avg_line_length": 47.8,
"ext": "agda",
"hexsha": "3e51abc977865c176fdb1ce13fd4faa31fceaba7",
"lang": "Agda",
"max_forks_count": 17,
"max_forks_repo_forks_event_max_datetime": "2021-11-28T20:13:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-12-03T22:38:15.000Z",
"max_forks_repo_head_hexsha": "f3f0261904577e930bd7646934f756679a6cbba6",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "rfindler/ial",
"max_forks_repo_path": "grammar.agda",
"max_issues_count": 8,
"max_issues_repo_head_hexsha": "f3f0261904577e930bd7646934f756679a6cbba6",
"max_issues_repo_issues_event_max_datetime": "2022-03-22T03:43:34.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-07-09T22:53:38.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "rfindler/ial",
"max_issues_repo_path": "grammar.agda",
"max_line_length": 224,
"max_stars_count": 29,
"max_stars_repo_head_hexsha": "f3f0261904577e930bd7646934f756679a6cbba6",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "rfindler/ial",
"max_stars_repo_path": "grammar.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-04T15:05:12.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-02-06T13:09:31.000Z",
"num_tokens": 2267,
"size": 4780
} |
module Issue203 where
open import Common.Level
-- shouldn't work
data Bad {a b} (A : Set a) : Set b where
[_] : (x : A) → Bad A
| {
"alphanum_fraction": 0.6165413534,
"avg_line_length": 14.7777777778,
"ext": "agda",
"hexsha": "a2455ccc3fd498988c87a641a2c07f393fc84b63",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Fail/Issue203.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/Issue203.agda",
"max_line_length": 40,
"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/Issue203.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 46,
"size": 133
} |
module Eq.KleeneTheory where
open import Prelude
open import T
open import Eq.Defs
open import Eq.LogicalTheory
open import Eq.KleeneTheoryEarly public
-- Harper says that Kleene equality is "evidently reflexive",
-- but this requires/implies termination!
-- We pick it directly from the consistency and reflexivity of
-- logical equivalence.
-- We could also prove it using halting, which we could prove from
-- either our HT result or from reflexivity of logical equivalence.
-- This is a bit simpler.
kleene-refl : Reflexive KleeneEq
kleene-refl {e} = ological-consistent (ological-refl e)
-- For kicks, we'll prove halting for closed nats.
nats-halt : (n : TNat) → THalts n
nats-halt n with kleene-refl {n}
... | kleeneq _ val E1 _ = halts E1 val
kleene-is-equivalence : IsEquivalence KleeneEq
kleene-is-equivalence = record { refl_ = kleene-refl
; sym_ = kleene-sym
; trans_ = kleene-trans }
| {
"alphanum_fraction": 0.7102803738,
"avg_line_length": 34.3928571429,
"ext": "agda",
"hexsha": "11eea6d8aa2728860dba0bda8b4c63d57e152ecc",
"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": "Eq/KleeneTheory.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": "Eq/KleeneTheory.agda",
"max_line_length": 67,
"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": "Eq/KleeneTheory.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": 252,
"size": 963
} |
{-# OPTIONS --without-K --safe #-}
module Dodo.Binary.Irreflexive where
-- Stdlib imports
open import Level using (Level)
open import Relation.Binary using (Rel; Irreflexive)
-- Local imports
open import Dodo.Binary.Equality
module _ {a ℓ₁ ℓ₂ ℓ₃ : Level} {A : Set a}
{≈ : Rel A ℓ₁} {P : Rel A ℓ₂} {Q : Rel A ℓ₃} where
irreflexive-⊆₂ : Irreflexive ≈ Q → P ⊆₂ Q → Irreflexive ≈ P
irreflexive-⊆₂ irreflexiveQ P⊆Q x≈y Pxy = irreflexiveQ x≈y (⊆₂-apply P⊆Q Pxy)
| {
"alphanum_fraction": 0.6737739872,
"avg_line_length": 27.5882352941,
"ext": "agda",
"hexsha": "4ce04d913569bc5dcfd7f0219a9a852a98d4ef0c",
"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/Irreflexive.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/Irreflexive.agda",
"max_line_length": 79,
"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/Irreflexive.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 195,
"size": 469
} |
-- Andreas, 2017-01-20, issue #1817 is fixed
open import Agda.Builtin.Size
open import Agda.Builtin.Nat renaming (Nat to ℕ)
-- Function
_$_ : ∀{a b}{A : Set a}{B : Set b} →(A → B) → A → B
f $ x = f x
case_of_ : ∀{a b}{A : Set a}{B : Set b} → A → (A → B) → B
case x of f = f x
-- Size
data SizeLt (i : Size) : Set where
size : (j : Size< i) → SizeLt i
getSize : ∀{i} → SizeLt i → Size
getSize (size j) = j
-- List
data List (A : Set) : Set where
[] : List A
_∷_ : (x : A) (xs : List A) → List A
for : ∀{A B} (xs : List A) (f : A → B) → List B
for [] f = []
for (x ∷ xs) f = f x ∷ for xs f
-- BT
data Var : (n : ℕ) → Set where
vz : ∀{n} → Var (suc n)
vs : ∀{n} → (x : Var n) → Var (suc n)
mutual
record BT (i : Size) (n : ℕ) : Set where
inductive; constructor Λ
field nabs : ℕ
var : Var (nabs + n)
args : List (BT' i (nabs + n))
record BT' (i : Size) (n : ℕ) : Set where
coinductive; constructor delay
field force : ∀{j : SizeLt i} → BT (getSize j) n
open BT'
-- Renaming
data Ope : (n m : ℕ) → Set where
id : ∀{n} → Ope n n
weak : ∀{n m} (ρ : Ope n m) → Ope (1 + n) m
lift : ∀{n m} (ρ : Ope n m) → Ope (1 + n) (1 + m)
lifts : ∀ k {n m} (ρ : Ope n m) → Ope (k + n) (k + m)
lifts 0 ρ = ρ
lifts (suc k) ρ = lift (lifts k ρ)
renVar : ∀{n m} (ρ : Ope n m) (x : Var m) → Var n
renVar id x = x
renVar (weak ρ) x = vs (renVar ρ x)
renVar (lift ρ) vz = vz
renVar (lift ρ) (vs x) = vs (renVar ρ x)
ren : ∀{i n m} (ρ : Ope n m) (t : BT i m) → BT i n
ren {i} ρ₀ (Λ n x ts) = Λ n (renVar ρ x) $ for ts \ t → delay
\{ {size j} → ren {j} ρ $ force t {size j} }
where ρ = lifts n ρ₀
| {
"alphanum_fraction": 0.4988081049,
"avg_line_length": 23.3055555556,
"ext": "agda",
"hexsha": "f440877afbbe460ce8bd75c3c972e30477e993d6",
"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/Issue1817.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2019-04-01T19:39:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-11-14T15:31:44.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue1817.agda",
"max_line_length": 61,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue1817.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": 740,
"size": 1678
} |
{-
This second-order equational theory was created from the following second-order syntax description:
syntax CTLC | ΛC
type
N : 0-ary
_↣_ : 2-ary | r30
¬_ : 1-ary | r30
term
app : α ↣ β α -> β | _$_ l20
lam : α.β -> α ↣ β | ƛ_ r10
throw : α ¬ α -> β
callcc : ¬ α.α -> α
theory
(ƛβ) b : α.β a : α |> app (lam(x.b[x]), a) = b[a]
(ƛη) f : α ↣ β |> lam (x. app(f, x)) = f
-}
module CTLC.Equality where
open import SOAS.Common
open import SOAS.Context
open import SOAS.Variable
open import SOAS.Families.Core
open import SOAS.Families.Build
open import SOAS.ContextMaps.Inductive
open import CTLC.Signature
open import CTLC.Syntax
open import SOAS.Metatheory.SecondOrder.Metasubstitution ΛC:Syn
open import SOAS.Metatheory.SecondOrder.Equality ΛC:Syn
private
variable
α β γ τ : ΛCT
Γ Δ Π : Ctx
infix 1 _▹_⊢_≋ₐ_
-- Axioms of equality
data _▹_⊢_≋ₐ_ : ∀ 𝔐 Γ {α} → (𝔐 ▷ ΛC) α Γ → (𝔐 ▷ ΛC) α Γ → Set where
ƛβ : ⁅ α ⊩ β ⁆ ⁅ α ⁆̣ ▹ ∅ ⊢ (ƛ 𝔞⟨ x₀ ⟩) $ 𝔟 ≋ₐ 𝔞⟨ 𝔟 ⟩
ƛη : ⁅ α ↣ β ⁆̣ ▹ ∅ ⊢ ƛ (𝔞 $ x₀) ≋ₐ 𝔞
open EqLogic _▹_⊢_≋ₐ_
open ≋-Reasoning
| {
"alphanum_fraction": 0.598559856,
"avg_line_length": 21.7843137255,
"ext": "agda",
"hexsha": "85659407efd9692d49a4cafa48281aee3bf56b63",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2022-01-24T12:49:17.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-09T20:39:59.000Z",
"max_forks_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "JoeyEremondi/agda-soas",
"max_forks_repo_path": "out/CTLC/Equality.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_issues_repo_issues_event_max_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "JoeyEremondi/agda-soas",
"max_issues_repo_path": "out/CTLC/Equality.agda",
"max_line_length": 99,
"max_stars_count": 39,
"max_stars_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "JoeyEremondi/agda-soas",
"max_stars_repo_path": "out/CTLC/Equality.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": 522,
"size": 1111
} |
{-# OPTIONS --cubical-compatible #-}
postulate
A : Set
B : A → Set
-- fine
record R₀ : Set where
field
@0 x : A
@0 y : B x
-- bad
record R : Set where
field
@0 x : A
y : B x
| {
"alphanum_fraction": 0.5124378109,
"avg_line_length": 11.1666666667,
"ext": "agda",
"hexsha": "1e9ce33a4e48ba1dc49589d8d29cd5ff99fd7789",
"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/Issue4748c.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/Issue4748c.agda",
"max_line_length": 36,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "KDr2/agda",
"max_stars_repo_path": "test/Fail/Issue4748c.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 76,
"size": 201
} |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Categories.NaturalTransformation.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism renaming (iso to iIso)
open import Cubical.Data.Sigma
open import Cubical.Categories.Category
open import Cubical.Categories.Functor.Base
open import Cubical.Categories.Functor.Properties
open import Cubical.Categories.Commutativity
open import Cubical.Categories.Morphism renaming (isIso to isIsoC)
private
variable
ℓC ℓC' ℓD ℓD' : Level
module _ {C : Precategory ℓC ℓC'} {D : Precategory ℓD ℓD'} where
-- syntax for sequencing in category D
infixl 15 _⋆ᴰ_
private
_⋆ᴰ_ : ∀ {x y z} (f : D [ x , y ]) (g : D [ y , z ]) → D [ x , z ]
f ⋆ᴰ g = f ⋆⟨ D ⟩ g
open Precategory
open Functor
-- type aliases because it gets tedious typing it out all the time
N-ob-Type : (F G : Functor C D) → Type _
N-ob-Type F G = (x : C .ob) → D [(F .F-ob x) , (G .F-ob x)]
N-hom-Type : (F G : Functor C D) → N-ob-Type F G → Type _
N-hom-Type F G ϕ = {x y : C .ob} (f : C [ x , y ]) → (F .F-hom f) ⋆ᴰ (ϕ y) ≡ (ϕ x) ⋆ᴰ (G .F-hom f)
record NatTrans (F G : Functor C D) : Type (ℓ-max (ℓ-max ℓC ℓC') ℓD') where
constructor natTrans
field
-- components of the natural transformation
N-ob : N-ob-Type F G
-- naturality condition
N-hom : N-hom-Type F G N-ob
record NatIso (F G : Functor C D): Type (ℓ-max (ℓ-max ℓC ℓC') (ℓ-max ℓD ℓD')) where
field
trans : NatTrans F G
open NatTrans trans
field
nIso : ∀ (x : C .ob) → isIsoC {C = D} (N-ob x)
open isIsoC
-- the three other commuting squares
sqRL : ∀ {x y : C .ob} {f : C [ x , y ]}
→ F ⟪ f ⟫ ≡ (N-ob x) ⋆ᴰ G ⟪ f ⟫ ⋆ᴰ (nIso y) .inv
sqRL {x} {y} {f} = invMoveR (isIso→areInv (nIso y)) (N-hom f)
sqLL : ∀ {x y : C .ob} {f : C [ x , y ]}
→ G ⟪ f ⟫ ⋆ᴰ (nIso y) .inv ≡ (nIso x) .inv ⋆ᴰ F ⟪ f ⟫
sqLL {x} {y} {f} = invMoveL (isIso→areInv (nIso x)) (sym sqRL')
where
sqRL' : F ⟪ f ⟫ ≡ (N-ob x) ⋆ᴰ ( G ⟪ f ⟫ ⋆ᴰ (nIso y) .inv )
sqRL' = sqRL ∙ (D .⋆Assoc _ _ _)
sqLR : ∀ {x y : C .ob} {f : C [ x , y ]}
→ G ⟪ f ⟫ ≡ (nIso x) .inv ⋆ᴰ F ⟪ f ⟫ ⋆ᴰ (N-ob y)
sqLR {x} {y} {f} = invMoveR (symAreInv (isIso→areInv (nIso y))) sqLL
open NatTrans
open NatIso
infix 10 NatTrans
syntax NatTrans F G = F ⇒ G
infix 9 NatIso
syntax NatIso F G = F ≅ᶜ G -- c superscript to indicate that this is in the context of categories
-- component of a natural transformation
infix 30 _⟦_⟧
_⟦_⟧ : ∀ {F G : Functor C D} → (F ⇒ G) → (x : C .ob) → D [(F .F-ob x) , (G .F-ob x)]
_⟦_⟧ = N-ob
idTrans : (F : Functor C D) → NatTrans F F
idTrans F .N-ob x = D .id (F .F-ob x)
idTrans F .N-hom f =
(F .F-hom f) ⋆ᴰ (idTrans F .N-ob _)
≡⟨ D .⋆IdR _ ⟩
F .F-hom f
≡⟨ sym (D .⋆IdL _) ⟩
(D .id (F .F-ob _)) ⋆ᴰ (F .F-hom f)
∎
syntax idTrans F = 1[ F ]
-- vertical sequencing
seqTrans : {F G H : Functor C D} (α : NatTrans F G) (β : NatTrans G H) → NatTrans F H
seqTrans α β .N-ob x = (α .N-ob x) ⋆ᴰ (β .N-ob x)
seqTrans {F} {G} {H} α β .N-hom f =
(F .F-hom f) ⋆ᴰ ((α .N-ob _) ⋆ᴰ (β .N-ob _))
≡⟨ sym (D .⋆Assoc _ _ _) ⟩
((F .F-hom f) ⋆ᴰ (α .N-ob _)) ⋆ᴰ (β .N-ob _)
≡[ i ]⟨ (α .N-hom f i) ⋆ᴰ (β .N-ob _) ⟩
((α .N-ob _) ⋆ᴰ (G .F-hom f)) ⋆ᴰ (β .N-ob _)
≡⟨ D .⋆Assoc _ _ _ ⟩
(α .N-ob _) ⋆ᴰ ((G .F-hom f) ⋆ᴰ (β .N-ob _))
≡[ i ]⟨ (α .N-ob _) ⋆ᴰ (β .N-hom f i) ⟩
(α .N-ob _) ⋆ᴰ ((β .N-ob _) ⋆ᴰ (H .F-hom f))
≡⟨ sym (D .⋆Assoc _ _ _) ⟩
((α .N-ob _) ⋆ᴰ (β .N-ob _)) ⋆ᴰ (H .F-hom f)
∎
compTrans : {F G H : Functor C D} (β : NatTrans G H) (α : NatTrans F G) → NatTrans F H
compTrans β α = seqTrans α β
infixl 8 seqTrans
syntax seqTrans α β = α ●ᵛ β
-- vertically sequence natural transformations whose
-- common functor is not definitional equal
seqTransP : {F G G' H : Functor C D} (p : G ≡ G')
→ (α : NatTrans F G) (β : NatTrans G' H)
→ NatTrans F H
seqTransP {F} {G} {G'} {H} p α β .N-ob x
-- sequence morphisms with non-judgementally equal (co)domain
= seqP {C = D} {p = Gx≡G'x} (α ⟦ x ⟧) (β ⟦ x ⟧)
where
Gx≡G'x : ∀ {x} → G ⟅ x ⟆ ≡ G' ⟅ x ⟆
Gx≡G'x {x} i = F-ob (p i) x
seqTransP {F} {G} {G'} {H} p α β .N-hom {x = x} {y} f
-- compose the two commuting squares
-- 1. α's commuting square
-- 2. β's commuting square, but extended to G since β is only G' ≡> H
= compSq {C = D} (α .N-hom f) βSq
where
-- functor equality implies equality of actions on objects and morphisms
Gx≡G'x : G ⟅ x ⟆ ≡ G' ⟅ x ⟆
Gx≡G'x i = F-ob (p i) x
Gy≡G'y : G ⟅ y ⟆ ≡ G' ⟅ y ⟆
Gy≡G'y i = F-ob (p i) y
Gf≡G'f : PathP (λ i → D [ Gx≡G'x i , Gy≡G'y i ]) (G ⟪ f ⟫) (G' ⟪ f ⟫)
Gf≡G'f i = p i ⟪ f ⟫
-- components of β extended out to Gx and Gy respectively
βx' = subst (λ a → D [ a , H ⟅ x ⟆ ]) (sym Gx≡G'x) (β ⟦ x ⟧)
βy' = subst (λ a → D [ a , H ⟅ y ⟆ ]) (sym Gy≡G'y) (β ⟦ y ⟧)
-- extensions are equal to originals
βy'≡βy : PathP (λ i → D [ Gy≡G'y i , H ⟅ y ⟆ ]) βy' (β ⟦ y ⟧)
βy'≡βy = symP (toPathP {A = λ i → D [ Gy≡G'y (~ i) , H ⟅ y ⟆ ]} refl)
βx≡βx' : PathP (λ i → D [ Gx≡G'x (~ i) , H ⟅ x ⟆ ]) (β ⟦ x ⟧) βx'
βx≡βx' = toPathP refl
-- left wall of square
left : PathP (λ i → D [ Gx≡G'x i , H ⟅ y ⟆ ]) (G ⟪ f ⟫ ⋆⟨ D ⟩ βy') (G' ⟪ f ⟫ ⋆⟨ D ⟩ β ⟦ y ⟧)
left i = Gf≡G'f i ⋆⟨ D ⟩ βy'≡βy i
-- right wall of square
right : PathP (λ i → D [ Gx≡G'x (~ i) , H ⟅ y ⟆ ]) (β ⟦ x ⟧ ⋆⟨ D ⟩ H ⟪ f ⟫) (βx' ⋆⟨ D ⟩ H ⟪ f ⟫)
right i = βx≡βx' i ⋆⟨ D ⟩ refl {x = H ⟪ f ⟫} i
-- putting it all together
βSq : G ⟪ f ⟫ ⋆⟨ D ⟩ βy' ≡ βx' ⋆⟨ D ⟩ H ⟪ f ⟫
βSq i = comp (λ k → D [ Gx≡G'x (~ k) , H ⟅ y ⟆ ])
(λ j → λ { (i = i0) → left (~ j)
; (i = i1) → right j })
(β .N-hom f i)
module _ ⦃ isCatD : isCategory D ⦄ {F G : Functor C D} {α β : NatTrans F G} where
open Precategory
open Functor
open NatTrans
makeNatTransPath : α .N-ob ≡ β .N-ob → α ≡ β
makeNatTransPath p i .N-ob = p i
makeNatTransPath p i .N-hom f = rem i
where
rem : PathP (λ i → (F .F-hom f) ⋆ᴰ (p i _) ≡ (p i _) ⋆ᴰ (G .F-hom f)) (α .N-hom f) (β .N-hom f)
rem = toPathP (isCatD .isSetHom _ _ _ _)
module _ ⦃ isCatD : isCategory D ⦄ {F F' G G' : Functor C D}
{α : NatTrans F G}
{β : NatTrans F' G'} where
open Precategory
open Functor
open NatTrans
makeNatTransPathP : ∀ (p : F ≡ F') (q : G ≡ G')
→ PathP (λ i → (x : C .ob) → D [ (p i) .F-ob x , (q i) .F-ob x ]) (α .N-ob) (β .N-ob)
→ PathP (λ i → NatTrans (p i) (q i)) α β
makeNatTransPathP p q P i .N-ob = P i
makeNatTransPathP p q P i .N-hom f = rem i
where
rem : PathP (λ i → ((p i) .F-hom f) ⋆ᴰ (P i _) ≡ (P i _) ⋆ᴰ ((q i) .F-hom f)) (α .N-hom f) (β .N-hom f)
rem = toPathP (isCatD .isSetHom _ _ _ _)
private
variable
ℓA ℓA' ℓB ℓB' : Level
module _ {B : Precategory ℓB ℓB'} {C : Precategory ℓC ℓC'} {D : Precategory ℓD ℓD'} where
open NatTrans
-- whiskering
-- αF
_∘ˡ_ : ∀ {G H : Functor C D} (α : NatTrans G H) → (F : Functor B C)
→ NatTrans (G ∘F F) (H ∘F F)
(_∘ˡ_ {G} {H} α F) .N-ob x = α ⟦ F ⟅ x ⟆ ⟧
(_∘ˡ_ {G} {H} α F) .N-hom f = (α .N-hom) _
-- Kβ
_∘ʳ_ : ∀ (K : Functor C D) → {G H : Functor B C} (β : NatTrans G H)
→ NatTrans (K ∘F G) (K ∘F H)
(_∘ʳ_ K {G} {H} β) .N-ob x = K ⟪ β ⟦ x ⟧ ⟫
(_∘ʳ_ K {G} {H} β) .N-hom f = preserveCommF {C = C} {D = D} {K} (β .N-hom f)
| {
"alphanum_fraction": 0.5008325861,
"avg_line_length": 35.0089686099,
"ext": "agda",
"hexsha": "390a0f3eb0969b3fe847979fb117510e93911d42",
"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": "5de11df25b79ee49d5c084fbbe6dfc66e4147a2e",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Edlyr/cubical",
"max_forks_repo_path": "Cubical/Categories/NaturalTransformation/Base.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "5de11df25b79ee49d5c084fbbe6dfc66e4147a2e",
"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": "Edlyr/cubical",
"max_issues_repo_path": "Cubical/Categories/NaturalTransformation/Base.agda",
"max_line_length": 111,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "5de11df25b79ee49d5c084fbbe6dfc66e4147a2e",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Edlyr/cubical",
"max_stars_repo_path": "Cubical/Categories/NaturalTransformation/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 3583,
"size": 7807
} |
{-# OPTIONS --copatterns --sized-types #-}
open import Common.Size
module Issue1038 (A : Set) where
record S (i : Size) : Set where
field
force : ∀ (j : Size< i) → A
head : ∀ i → S i → (j : Size< i) → A
head i s j = S.force s _
-- Problem was:
-- Cannot solve size constraints
-- (↑ _9 A i s j) =< (_i_8 A i s j) : Size
-- (_i_8 A i s j) =< i : Size
-- when checking the definition of head
-- Works now.
| {
"alphanum_fraction": 0.5841346154,
"avg_line_length": 19.8095238095,
"ext": "agda",
"hexsha": "bf203ccf6779c5e0bd607b2fa1d3abd3450c2411",
"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/Issue1038.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/Issue1038.agda",
"max_line_length": 42,
"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/Issue1038.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": 144,
"size": 416
} |
{-# OPTIONS --without-K --safe #-}
module Data.Binary.Conversion.Fast where
-- This module provides a conversion function from
-- nats which uses built-in functions.
-- It is dramatically faster than the normal conversion
-- even at smaller numbers.
open import Data.Binary.Definition
open import Data.Nat.DivMod
open import Data.Nat.Base
open import Data.Bool
⟦_⇑⟧⟨_⟩ : ℕ → ℕ → 𝔹
⟦ suc n ⇑⟧⟨ suc w ⟩ =
if even n
then 1ᵇ ⟦ n ÷ 2 ⇑⟧⟨ w ⟩
else 2ᵇ ⟦ n ÷ 2 ⇑⟧⟨ w ⟩
⟦ zero ⇑⟧⟨ _ ⟩ = 0ᵇ
⟦ suc _ ⇑⟧⟨ zero ⟩ = 0ᵇ -- will not happen
-- We build the output by repeatedly halving the input,
-- but we also pass in the number to reduce as we go so that
-- we satisfy the termination checker.
⟦_⇑⟧ : ℕ → 𝔹
⟦ n ⇑⟧ = ⟦ n ⇑⟧⟨ n ⟩
{-# INLINE ⟦_⇑⟧ #-}
-- Without the added argument to the recursor, the function does not
-- pass the termination checker:
-- {-# TERMINATING #-}
-- ⟦_⇑⟧″ : ℕ → 𝔹
-- ⟦ zero ⇑⟧″ = 0ᵇ
-- ⟦ suc n ⇑⟧″ =
-- if rem n 2 ℕ.≡ᴮ 0
-- then 1ᵇ ⟦ n ÷ 2 ⇑⟧″
-- else 2ᵇ ⟦ n ÷ 2 ⇑⟧″
-- The "principled" version (which uses well-founded recursion) is
-- incredibly slow. (and the following doesn't even compute, because of
-- cubical)
-- open import Data.Nat.WellFounded
-- ⟦_⇑⟧‴ : ℕ → 𝔹
-- ⟦ n ⇑⟧‴ = go n (≤-wellFounded n)
-- where
-- go : ∀ n → Acc _<_ n → 𝔹
-- go zero wf = 0ᵇ
-- go (suc n) (acc wf) =
-- if rem n 2 ℕ.≡ᴮ 0
-- then 1ᵇ go (n ÷ 2) (wf (n ÷ 2) (s≤s (div2≤ n)))
-- else 2ᵇ go (n ÷ 2) (wf (n ÷ 2) (s≤s (div2≤ n)))
| {
"alphanum_fraction": 0.5799457995,
"avg_line_length": 26.8363636364,
"ext": "agda",
"hexsha": "c9d557879f562fe346fd8f094f814f31e14037a0",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "oisdk/agda-playground",
"max_forks_repo_path": "Data/Binary/Conversion/Fast.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "oisdk/agda-playground",
"max_issues_repo_path": "Data/Binary/Conversion/Fast.agda",
"max_line_length": 71,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "oisdk/agda-playground",
"max_stars_repo_path": "Data/Binary/Conversion/Fast.agda",
"max_stars_repo_stars_event_max_datetime": "2021-11-16T08:11:34.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-09-11T17:45:41.000Z",
"num_tokens": 648,
"size": 1476
} |
module Isos.NatLike where
open import Isos.Isomorphism
open import Nats
open import Data.Product
open import Equality
open import Data.Unit
------------------------------------------------------------------------
-- internal stuffs
private
module WithList where
open import Lists
list→ℕ : List ⊤ → ℕ
list→ℕ [] = zero
list→ℕ (tt ∷ a) = suc (list→ℕ a)
ℕ→list : ℕ → List ⊤
ℕ→list zero = []
ℕ→list (suc a) = tt ∷ ℕ→list a
proofListL : ∀ n → list→ℕ (ℕ→list n) ≡ n
proofListL zero = refl
proofListL (suc n) rewrite proofListL n = refl
proofListR : ∀ n → ℕ→list (list→ℕ n) ≡ n
proofListR [] = refl
proofListR (tt ∷ l) rewrite proofListR l = refl
module WithVec where
open import Vecs
vec→ℕ′ : ∀ {n} → Vec ⊤ n → ℕ
vec→ℕ′ {n} [] = n
vec→ℕ′ {n} (tt ∷ a) = n
vec→ℕ : ∀ {n} → Vec ⊤ n → ∃ (λ m → n ≡ m)
vec→ℕ [] = zero , refl
vec→ℕ (tt ∷ a) with vec→ℕ a
... | m , refl = suc m , refl
ℕ→vec : ∀ {n} → ∃ (λ m → n ≡ m) → Vec ⊤ n
ℕ→vec (zero , refl) = []
ℕ→vec ((suc a) , refl) = tt ∷ ℕ→vec (a , refl)
proofVecL : ∀ {n} (m : ∃ (λ m → n ≡ m)) → vec→ℕ (ℕ→vec m) ≡ m
proofVecL (zero , refl) = refl
proofVecL (suc a , refl) rewrite proofVecL (a , refl) = refl
-- how to prove?
-- proofVecR : ∀ n → ℕ→vec (vec→ℕ n) ≡ n
------------------------------------------------------------------------
-- public aliases
iso-nat-list : ℕ ⇔ List ⊤
iso-nat-list = ∧-intro ℕ→list list→ℕ
iso-nat-vec : ∀ {n} → ∃ (λ m → n ≡ m) ⇔ Vec ⊤ n
iso-nat-vec = ∧-intro ℕ→vec vec→ℕ
| {
"alphanum_fraction": 0.4916344916,
"avg_line_length": 22.8529411765,
"ext": "agda",
"hexsha": "a32329232d49ba29e63e27c8fba70dc8274a00c2",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7dc0ea4782a5ff960fe31bdcb8718ce478eaddbc",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "ice1k/Theorems",
"max_forks_repo_path": "src/Isos/NatLike.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7dc0ea4782a5ff960fe31bdcb8718ce478eaddbc",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Apache-2.0"
],
"max_issues_repo_name": "ice1k/Theorems",
"max_issues_repo_path": "src/Isos/NatLike.agda",
"max_line_length": 72,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "7dc0ea4782a5ff960fe31bdcb8718ce478eaddbc",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "ice1k/Theorems",
"max_stars_repo_path": "src/Isos/NatLike.agda",
"max_stars_repo_stars_event_max_datetime": "2020-04-15T15:28:03.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-15T15:28:03.000Z",
"num_tokens": 614,
"size": 1554
} |
open import Signature
import Program
module Rewrite (Σ : Sig) (V : Set) (P : Program.Program Σ V) where
open import Terms Σ
open import Program Σ V
open import Data.Empty renaming (⊥ to ∅)
open import Data.Unit
open import Data.Product as Prod renaming (Σ to ⨿)
open import Data.Sum as Sum
open import Data.Fin
open import Relation.Nullary
open import Relation.Unary
open import Relation.Binary.PropositionalEquality using (_≡_; refl; subst)
data _⟿_ (t : T V) : T V → Set where
rew-step : (cl : dom P) (i : dom (getb P cl)) {σ : Subst V V} →
matches (geth P cl) t σ → -- (mgm t (geth P cl) σ) →
t ⟿ app σ (get (getb P cl) i)
Val : Pred (T V) _
Val t = (cl : dom P) (i : dom (getb P cl)) {σ : Subst V V} →
¬ (matches (geth P cl) t σ)
no-rewrite-on-vals : (t : T V) → Val t → (s : T V) → ¬ (t ⟿ s)
no-rewrite-on-vals t p ._ (rew-step cl i q) = p cl i q
data _↓_ (t : T V) : T V → Set where
val : Val t → t ↓ t
step : (r s : T V) → r ↓ s → t ⟿ r → t ↓ s
{- Strongly normalising terms wrt to P are either in normal form, i.e. values,
or for every clause that matches, every rewrite step must be SN.
This is an adaption of the usual (constructive) definition.
-}
data SN (t : T V) : Set where
val-sn : Val t → SN t
steps-sn : (cl : dom P) (i : dom (getb P cl)) {σ : Subst V V} →
(matches t (geth P cl) σ) →
SN (app σ (get (getb P cl) i)) →
SN t
-- | Determines whether a term t is derivable from an axiom, i.e., whether
-- there is a clause " ⇒ p" such that p matches t.
Axiom : Pred (T V) _
Axiom t = ∃₂ λ cl σ → (mgm t (geth P cl) σ) × (domEmpty (getb P cl))
-- | An inductively valid term is derivable in finitely many steps from
-- axioms.
data Valid (t : T V) : Set where
val-sn : Axiom t → Valid t
steps-sn : (cl : dom P) (i : dom (getb P cl)) {σ : Subst V V} →
(matches t (geth P cl) σ) →
Valid (app σ (get (getb P cl) i)) →
Valid t
{-
⊥ : {X : Set} → X ⊎ ⊤
⊥ = inj₂ tt
record Rew-Branch (F : T V → Set) (t : T V) : Set where
constructor prf-branch
field
clause : dom P
matcher : Subst V V
isMgm : mgm t (geth P clause) matcher
next : (i : dom (getb P clause)) →
F (app matcher (get (getb P clause) i))
-- | Set of rewrite trees starting in t that use the rules given in P.
-- If the tree is ⊥, then t cannot be rewritten by any of the rules of P.
data Rew (t : T V) : Set where
in-prf : Rew-Branch Rew t ⊎ ⊤ → Rew t
-- | Just as Rew, only that we also allow infinite rewriting sequences.
record Rew∞ (t : T V) : Set where
coinductive
field out-prf : Rew-Branch Rew∞ t ⊎ ⊤
open Rew∞
out-prf⁻¹ : ∀{t} → Rew-Branch Rew∞ t ⊎ ⊤ → Rew∞ t
out-prf (out-prf⁻¹ b) = b
-- | Finite rewriting trees are included in the set of the possibly infinite
-- ones.
χ-prf : ∀{t} → Rew t → Rew∞ t
χ-prf (in-prf (inj₁ (prf-branch c m isMgm next))) =
out-prf⁻¹ (inj₁ (prf-branch c m isMgm (λ i → χ-prf (next i))))
χ-prf (in-prf (inj₂ tt)) = out-prf⁻¹ ⊥
Rew-Step : (F : {s : T V} → Rew∞ s → Set) → {t : T V} (R : Rew∞ t) → Set
Rew-Step F R with out-prf R
Rew-Step F R | inj₁ (prf-branch clause matcher isMgm next) = {!!}
Rew-Step F R | inj₂ tt = ∅
data Path {t : T V} (R : Rew∞ t) : Set where
root : Path R
step : {!!} → Path R
-}
| {
"alphanum_fraction": 0.5879503482,
"avg_line_length": 31.4571428571,
"ext": "agda",
"hexsha": "c2f60ec3716894e5f1d403500e27bd43294481b8",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "8fc7a6cd878f37f9595124ee8dea62258da28aa4",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "hbasold/Sandbox",
"max_forks_repo_path": "LP/Rewrite.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "8fc7a6cd878f37f9595124ee8dea62258da28aa4",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "hbasold/Sandbox",
"max_issues_repo_path": "LP/Rewrite.agda",
"max_line_length": 78,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "8fc7a6cd878f37f9595124ee8dea62258da28aa4",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "hbasold/Sandbox",
"max_stars_repo_path": "LP/Rewrite.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1218,
"size": 3303
} |
module Loc (K : Set) where
open import Basics
open import Pr
open import Nom
data Loc : Set where
EL : Loc
_*_ : Loc -> K -> Loc
infixl 50 _*_
data _!_ : Loc -> K -> Set where
top : {L : Loc}{S : K} -> (L * S) ! S
pop : {L : Loc}{S T : K} -> L ! S -> (L * T) ! S
_<*_ : K -> Loc -> Loc
S <* EL = EL * S
S <* (L * T) = (S <* L) * T
max : {S : K}(L : Loc) -> (S <* L) ! S
max EL = top
max (L * T) = pop (max L)
_<_ : (S : K){L : Loc}{T : K} -> L ! T -> (S <* L) ! T
S < top = top
S < pop x = pop (S < x)
data MaxV (S : K)(L : Loc) : {T : K} -> (S <* L) ! T -> Set where
isMax : MaxV S L (max L)
isLow : {T : K}(x : L ! T) -> MaxV S L (S < x)
maxV : (S : K)(L : Loc){T : K}(x : (S <* L) ! T) -> MaxV S L x
maxV S EL top = isMax
maxV S EL (pop ())
maxV S (L * T) top = isLow top
maxV S (L * T) (pop x) with maxV S L x
maxV S (L * T) (pop .(max L)) | isMax = isMax
maxV S (L * T) (pop .(S < x)) | isLow x = isLow (pop x)
_bar_ : (L : Loc){S : K} -> L ! S -> Loc
EL bar ()
(L * S) bar top = L
(L * S) bar (pop v) = (L bar v) * S
infixl 50 _bar_
_thin_ : {L : Loc}{S T : K}(x : L ! S) -> (L bar x) ! T -> L ! T
top thin y = pop y
(pop x) thin top = top
(pop x) thin (pop y) = pop (x thin y)
data VarQV {L : Loc}{S : K}(x : L ! S) : {T : K} -> (L ! T) -> Set where
vSame : VarQV x x
vDiff : {T : K}(y : (L bar x) ! T) -> VarQV x (x thin y)
varQV : {L : Loc}{S T : K}(x : L ! S)(y : L ! T) -> VarQV x y
varQV top top = vSame
varQV top (pop y) = vDiff y
varQV (pop x) top = vDiff top
varQV (pop x) (pop y) with varQV x y
varQV (pop x) (pop .x) | vSame = vSame
varQV (pop x) (pop .(x thin y)) | vDiff y = vDiff (pop y)
| {
"alphanum_fraction": 0.478021978,
"avg_line_length": 25.59375,
"ext": "agda",
"hexsha": "5374168d28fc34b83727336bb30f653cc01ee6d9",
"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": "benchmark/Syntacticosmos/Loc.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": "benchmark/Syntacticosmos/Loc.agda",
"max_line_length": 72,
"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": "benchmark/Syntacticosmos/Loc.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": 748,
"size": 1638
} |
{-# OPTIONS --cubical #-}
module cubical where
open import Cubical.Core.Primitives
--- Sharp of a type: you can raise any term of type A to the sharp to get a term of type sharp-A
data ♯_ {ℓ : Level} (A : Type ℓ) : Type ℓ where
_↑♯ : A → ♯ A
-- do we need a duplicate of sharp-on-Types for crisp types?
-- data ♯c_ {@♭ ℓ : Level} (@♭ A : Type ℓ) : Type ℓ where
-- _↑♯c : A → ♯c A
-- having something crisply in sharp-A gets you something in a
-- the constructor is also the computation rule
_↓♯ : {@♭ ℓ : Level} {@♭ A : Type ℓ} (@♭ x : ♯ A) → A
(x ↑♯) ↓♯ = x
lower-then-upper : {@♭ ℓ : Level} {@♭ A : Type ℓ} (@♭ x : ♯ A) → (x ↓♯) ↑♯ ≡ x
lower-then-upper x = λ i → x
--- I is the interval pre-type
--- i0 : I
--- i1 : I
| {
"alphanum_fraction": 0.5714285714,
"avg_line_length": 24.5,
"ext": "agda",
"hexsha": "a6b9833bbe2bd61f171e979e3c6817ad5ec4570d",
"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": "497e720a1ddaa2ec713c060f999f4b3ee2fe5e8a",
"max_forks_repo_licenses": [
"CC0-1.0"
],
"max_forks_repo_name": "glangmead/formalization",
"max_forks_repo_path": "cohesion/Cubical.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "497e720a1ddaa2ec713c060f999f4b3ee2fe5e8a",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"CC0-1.0"
],
"max_issues_repo_name": "glangmead/formalization",
"max_issues_repo_path": "cohesion/Cubical.agda",
"max_line_length": 96,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "497e720a1ddaa2ec713c060f999f4b3ee2fe5e8a",
"max_stars_repo_licenses": [
"CC0-1.0"
],
"max_stars_repo_name": "glangmead/formalization",
"max_stars_repo_path": "cohesion/Cubical.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-13T05:51:12.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-10-06T17:39:22.000Z",
"num_tokens": 284,
"size": 735
} |
module Data.Nat.Properties where
import Prelude
import Logic.Base
import Logic.Relations
import Logic.Equivalence
import Logic.Operations as Operations
import Logic.Identity
import Logic.ChainReasoning
import Data.Nat
import Data.Bool
open Prelude
open Data.Nat
open Logic.Base
open Logic.Relations
open Logic.Identity
open Data.Bool
module Proofs where
module Ops = Operations.MonoEq {Nat} Equiv
open Ops
module Chain = Logic.ChainReasoning.Poly.Homogenous _≡_ (\x -> refl) (\x y z -> trans)
open Chain
+zero : (n : Nat) -> n + zero ≡ n
+zero zero = refl
+zero (suc n) = cong suc (+zero n)
+suc : (n m : Nat) -> n + suc m ≡ suc (n + m)
+suc zero m = refl
+suc (suc n) m = cong suc (+suc n m)
+commute : Commutative _+_
+commute x zero = +zero x
+commute x (suc y) = trans (+suc x y) (cong suc (+commute x y))
+assoc : Associative _+_
+assoc zero y z = refl
+assoc (suc x) y z = cong suc (+assoc x y z)
*zero : (n : Nat) -> n * zero ≡ zero
*zero zero = refl
*zero (suc n) = *zero n
*suc : (x y : Nat) -> x * suc y ≡ x + x * y
*suc zero y = refl
*suc (suc x) y =
chain> suc x * suc y
=== suc (y + x * suc y) by refl
=== suc (x + (y + x * y)) by cong suc
( chain> y + x * suc y
=== y + (x + x * y) by cong (_+_ y) (*suc x y)
=== (y + x) + x * y by +assoc y x (x * y)
=== (x + y) + x * y by cong (flip _+_ (x * y)) (+commute y x)
=== x + (y + x * y) by sym (+assoc x y (x * y))
)
=== suc x + suc x * y by refl
*commute : (x y : Nat) -> x * y ≡ y * x
*commute x zero = *zero x
*commute x (suc y) = trans (*suc x y) (cong (_+_ x) (*commute x y))
one* : (x : Nat) -> 1 * x ≡ x
one* x = +zero x
*one : (x : Nat) -> x * 1 ≡ x
*one x = trans (*commute x 1) (one* x)
*distrOver+L : (x y z : Nat) -> x * (y + z) ≡ x * y + x * z
*distrOver+L zero y z = refl
*distrOver+L (suc x) y z =
chain> suc x * (y + z)
=== (y + z) + x * (y + z) by refl
=== (y + z) + (x * y + x * z) by cong (_+_ (y + z)) ih
=== ((y + z) + x * y) + x * z by +assoc (y + z) (x * y) (x * z)
=== (y + (z + x * y)) + x * z by cong (flip _+_ (x * z)) (sym (+assoc y z (x * y)))
=== (y + (x * y + z)) + x * z by cong (\w -> (y + w) + x * z) (+commute z (x * y))
=== ((y + x * y) + z) + x * z by cong (flip _+_ (x * z)) (+assoc y (x * y) z)
=== (y + x * y) + (z + x * z) by sym (+assoc (y + x * y) z (x * z))
=== suc x * y + suc x * z by refl
where
ih = *distrOver+L x y z
*distrOver+R : (x y z : Nat) -> (x + y) * z ≡ x * z + y * z
*distrOver+R zero y z = refl
*distrOver+R (suc x) y z =
chain> (suc x + y) * z
=== z + (x + y) * z by refl
=== z + (x * z + y * z) by cong (_+_ z) (*distrOver+R x y z)
=== (z + x * z) + y * z by +assoc z (x * z) (y * z)
=== suc x * z + y * z by refl
*assoc : Associative _*_
*assoc zero y z = refl
*assoc (suc x) y z =
chain> suc x * (y * z)
=== y * z + x * (y * z) by refl
=== y * z + (x * y) * z by cong (_+_ (y * z)) ih
=== (y + x * y) * z by sym (*distrOver+R y (x * y) z)
=== (suc x * y) * z by refl
where
ih = *assoc x y z
≤refl : (n : Nat) -> IsTrue (n ≤ n)
≤refl zero = tt
≤refl (suc n) = ≤refl n
<implies≤ : (n m : Nat) -> IsTrue (n < m) -> IsTrue (n ≤ m)
<implies≤ zero m h = tt
<implies≤ (suc n) zero ()
<implies≤ (suc n) (suc m) h = <implies≤ n m h
n-m≤n : (n m : Nat) -> IsTrue (n - m ≤ n)
n-m≤n zero m = tt
n-m≤n (suc n) zero = ≤refl n
n-m≤n (suc n) (suc m) = <implies≤ (n - m) (suc n) (n-m≤n n m)
-- mod≤ : (n m : Nat) -> IsTrue (mod n (suc m) ≤ m)
-- mod≤ zero m = tt
-- mod≤ (suc n) m = mod≤ (n - m) m
open Proofs public
| {
"alphanum_fraction": 0.4565050038,
"avg_line_length": 30.4453125,
"ext": "agda",
"hexsha": "eb10ef93e64211f9cc4aba92920d2f8cebb7147d",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "examples/lib/Data/Nat/Properties.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "examples/lib/Data/Nat/Properties.agda",
"max_line_length": 91,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "examples/lib/Data/Nat/Properties.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": 1632,
"size": 3897
} |
module Structure.Category.NaturalTransformation.NaturalTransformations where
open import Functional using () renaming (id to idᶠⁿ)
open import Functional.Dependent using () renaming (_∘_ to _∘ᶠⁿ_)
open import Logic
open import Logic.Predicate
import Lvl
open import Structure.Category
open import Structure.Category.Functor
open import Structure.Category.NaturalTransformation
open import Structure.Categorical.Properties
open import Structure.Operator
open import Structure.Relator.Equivalence
open import Structure.Setoid
open import Syntax.Transitivity
open import Type
open CategoryObject
private variable ℓₒₗ ℓₒᵣ ℓₘₗ ℓₘᵣ ℓₑₗ ℓₑᵣ : Lvl.Level
module Raw
(catₗ : CategoryObject{ℓₒₗ}{ℓₘₗ}{ℓₑₗ})
(catᵣ : CategoryObject{ℓₒᵣ}{ℓₘᵣ}{ℓₑᵣ})
where
private variable F F₁ F₂ F₃ : Object(catₗ) → Object(catᵣ)
private instance _ = category catₗ
private instance _ = category catᵣ
open Category.ArrowNotation ⦃ … ⦄
open Category ⦃ … ⦄ hiding (identity)
idᴺᵀ : (x : Object(catₗ)) → (F(x) ⟶ F(x))
idᴺᵀ _ = id
_∘ᴺᵀ_ : ((x : Object(catₗ)) → (F₂(x) ⟶ F₃(x))) → ((x : Object(catₗ)) → (F₁(x) ⟶ F₂(x))) → ((x : Object(catₗ)) → (F₁(x) ⟶ F₃(x)))
(comp₁ ∘ᴺᵀ comp₂)(x) = comp₁(x) ∘ comp₂(x)
module _
{catₗ : CategoryObject{ℓₒₗ}{ℓₘₗ}{ℓₑₗ}}
{catᵣ : CategoryObject{ℓₒᵣ}{ℓₘᵣ}{ℓₑᵣ}}
where
private instance _ = category catₗ
private instance _ = category catᵣ
open Category ⦃ … ⦄ hiding (identity)
open Functor ⦃ … ⦄
private open module Equivᵣ {x}{y} = Equivalence (Equiv-equivalence ⦃ morphism-equiv(catᵣ){x}{y} ⦄) using ()
module _ where
open Raw(catₗ)(catᵣ)
module _ {functor@([∃]-intro F) : catₗ →ᶠᵘⁿᶜᵗᵒʳ catᵣ} where
identity : NaturalTransformation(functor)(functor)(idᴺᵀ)
NaturalTransformation.natural identity {x} {y} {f} =
id ∘ map f 🝖-[ Morphism.identityₗ(_)(id) ⦃ identityₗ ⦄ ]
map f 🝖-[ Morphism.identityᵣ(_)(id) ⦃ identityᵣ ⦄ ]-sym
map f ∘ id 🝖-end
module _ {functor₁@([∃]-intro F₁) functor₂@([∃]-intro F₂) functor₃@([∃]-intro F₃) : catₗ →ᶠᵘⁿᶜᵗᵒʳ catᵣ} where
composition : ∀{comp₁ comp₂} → NaturalTransformation(functor₂)(functor₃)(comp₁) → NaturalTransformation(functor₁)(functor₂)(comp₂) → NaturalTransformation(functor₁)(functor₃)(comp₁ ∘ᴺᵀ comp₂)
NaturalTransformation.natural (composition {comp₁} {comp₂} nat₁ nat₂) {x} {y} {f} =
(comp₁(y) ∘ comp₂(y)) ∘ map f 🝖-[ Morphism.associativity(_) ⦃ associativity ⦄ ]
comp₁(y) ∘ (comp₂(y) ∘ map f) 🝖-[ congruence₂ᵣ(_∘_)(comp₁(y)) (NaturalTransformation.natural nat₂) ]
comp₁(y) ∘ (map f ∘ comp₂(x)) 🝖-[ Morphism.associativity(_) ⦃ associativity ⦄ ]-sym
(comp₁(y) ∘ map f) ∘ comp₂(x) 🝖-[ congruence₂ₗ(_∘_)(comp₂(x)) (NaturalTransformation.natural nat₁) ]
(map f ∘ comp₁(x)) ∘ comp₂(x) 🝖-[ Morphism.associativity(_) ⦃ associativity ⦄ ]
map f ∘ (comp₁(x) ∘ comp₂(x)) 🝖-end
module Wrapped where
private variable F F₁ F₂ F₃ : catₗ →ᶠᵘⁿᶜᵗᵒʳ catᵣ
idᴺᵀ : (F →ᴺᵀ F)
idᴺᵀ = [∃]-intro (Raw.idᴺᵀ(catₗ)(catᵣ)) ⦃ identity ⦄
_∘ᴺᵀ_ : (F₂ →ᴺᵀ F₃) → (F₁ →ᴺᵀ F₂) → (F₁ →ᴺᵀ F₃)
_∘ᴺᵀ_ ([∃]-intro F ⦃ F-proof ⦄) ([∃]-intro G ⦃ G-proof ⦄) = [∃]-intro (Raw._∘ᴺᵀ_ (catₗ)(catᵣ) F G) ⦃ composition F-proof G-proof ⦄
| {
"alphanum_fraction": 0.6593304402,
"avg_line_length": 40.835443038,
"ext": "agda",
"hexsha": "57e8878bf2242dfef3e619bb93887b1f9be962a6",
"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/Category/NaturalTransformation/NaturalTransformations.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/Category/NaturalTransformation/NaturalTransformations.agda",
"max_line_length": 197,
"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/Category/NaturalTransformation/NaturalTransformations.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": 1419,
"size": 3226
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of disjoint lists (setoid equality)
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Relation.Binary.Disjoint.Setoid.Properties where
open import Data.List.Base
open import Data.List.Relation.Binary.Disjoint.Setoid
import Data.List.Relation.Unary.Any as Any
open import Data.List.Relation.Unary.All as All
open import Data.List.Relation.Unary.All.Properties using (¬Any⇒All¬)
open import Data.List.Relation.Unary.Any.Properties using (++⁻)
open import Data.Product using (_,_)
open import Data.Sum.Base using (inj₁; inj₂)
open import Relation.Binary
open import Relation.Nullary using (¬_)
------------------------------------------------------------------------
-- Relational properties
------------------------------------------------------------------------
module _ {c ℓ} (S : Setoid c ℓ) where
sym : Symmetric (Disjoint S)
sym xs#ys (v∈ys , v∈xs) = xs#ys (v∈xs , v∈ys)
------------------------------------------------------------------------
-- Relationship with other predicates
------------------------------------------------------------------------
module _ {c ℓ} (S : Setoid c ℓ) where
open Setoid S
Disjoint⇒AllAll : ∀ {xs ys} → Disjoint S xs ys →
All (λ x → All (λ y → ¬ x ≈ y) ys) xs
Disjoint⇒AllAll xs#ys = All.map (¬Any⇒All¬ _)
(All.tabulate (λ v∈xs v∈ys → xs#ys (Any.map reflexive v∈xs , v∈ys)))
------------------------------------------------------------------------
-- Introduction (⁺) and elimination (⁻) rules for list operations
------------------------------------------------------------------------
-- concat
module _ {c ℓ} (S : Setoid c ℓ) where
concat⁺ʳ : ∀ {vs xss} → All (Disjoint S vs) xss → Disjoint S vs (concat xss)
concat⁺ʳ {xss = xs ∷ xss} (vs#xs ∷ vs#xss) (v∈vs , v∈xs++concatxss)
with ++⁻ xs v∈xs++concatxss
... | inj₁ v∈xs = vs#xs (v∈vs , v∈xs)
... | inj₂ v∈xss = concat⁺ʳ vs#xss (v∈vs , v∈xss)
| {
"alphanum_fraction": 0.4789272031,
"avg_line_length": 37.2857142857,
"ext": "agda",
"hexsha": "03669299c43ea45df30f48663b2af5943d0b80f4",
"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/List/Relation/Binary/Disjoint/Setoid/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/List/Relation/Binary/Disjoint/Setoid/Properties.agda",
"max_line_length": 78,
"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/List/Relation/Binary/Disjoint/Setoid/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": 548,
"size": 2088
} |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.EilenbergMacLane
open import homotopy.EilenbergMacLaneFunctor
open import groups.ToOmega
open import cohomology.Theory
open import cohomology.SpectrumModel
module cohomology.EMModel where
module _ {i} (G : AbGroup i) where
open EMExplicit G using (⊙EM; EM-level; EM-conn; spectrum)
EM-E : (n : ℤ) → Ptd i
EM-E (pos m) = ⊙EM m
EM-E (negsucc m) = ⊙Lift ⊙Unit
EM-spectrum : (n : ℤ) → ⊙Ω (EM-E (succ n)) ⊙≃ EM-E n
EM-spectrum (pos n) = spectrum n
EM-spectrum (negsucc O) = ≃-to-⊙≃ {X = ⊙Ω (EM-E 0)}
(equiv (λ _ → _) (λ _ → idp)
(λ _ → idp) (prop-has-all-paths {{has-level-apply (EM-level 0) _ _}} _))
idp
EM-spectrum (negsucc (S n)) = ≃-to-⊙≃ {X = ⊙Ω (EM-E (negsucc n))}
(equiv (λ _ → _) (λ _ → idp)
(λ _ → idp) (prop-has-all-paths {{=-preserves-level ⟨⟩}} _))
idp
EM-Cohomology : CohomologyTheory i
EM-Cohomology = spectrum-cohomology EM-E EM-spectrum
open CohomologyTheory EM-Cohomology
EM-dimension : {n : ℤ} → n ≠ 0 → is-trivialᴳ (C n (⊙Lift ⊙S⁰))
EM-dimension {pos O} neq = ⊥-rec (neq idp)
EM-dimension {pos (S n)} _ =
contr-is-trivialᴳ (C (pos (S n)) (⊙Lift ⊙S⁰))
{{connected-at-level-is-contr
{{⟨⟩}}
{{Trunc-preserves-conn $
equiv-preserves-conn
(pre⊙∘-equiv ⊙lower-equiv ∘e ⊙Bool→-equiv-idf _ ⁻¹)
{{path-conn (connected-≤T (⟨⟩-monotone-≤ (≤-ap-S (O≤ n)))
)}}}}}}
EM-dimension {negsucc O} _ =
contr-is-trivialᴳ (C (negsucc O) (⊙Lift ⊙S⁰))
{{Trunc-preserves-level 0 (Σ-level (Π-level λ _ →
inhab-prop-is-contr idp {{has-level-apply (EM-level 0) _ _}})
(λ x → has-level-apply (has-level-apply (EM-level 0) _ _) _ _))}}
EM-dimension {negsucc (S n)} _ =
contr-is-trivialᴳ (C (negsucc (S n)) (⊙Lift ⊙S⁰))
{{Trunc-preserves-level 0 (Σ-level (Π-level λ _ →
=-preserves-level ⟨⟩) λ _ → =-preserves-level (=-preserves-level ⟨⟩))}}
EM-Ordinary : OrdinaryTheory i
EM-Ordinary = ordinary-theory EM-Cohomology EM-dimension
module _ {i} (G : AbGroup i) (H : AbGroup i) (φ : G →ᴬᴳ H) where
EM-E-fmap : ∀ (n : ℤ) → EM-E G n ⊙→ EM-E H n
EM-E-fmap (pos m) = ⊙EM-fmap G H φ m
EM-E-fmap (negsucc m) = ⊙idf _
open SpectrumModelMap (EM-E G) (EM-spectrum G) (EM-E H) (EM-spectrum H) EM-E-fmap
public renaming (C-coeff-fmap to EM-C-coeff-fmap;
CEl-coeff-fmap to EM-CEl-coeff-fmap;
⊙CEl-coeff-fmap to EM-⊙CEl-coeff-fmap)
module _ {i} (G : AbGroup i) where
private
EM-E-fmap-idhom : ∀ (n : ℤ)
→ EM-E-fmap G G (idhom (AbGroup.grp G)) n == ⊙idf _
EM-E-fmap-idhom (pos n) = ⊙EM-fmap-idhom G n
EM-E-fmap-idhom (negsucc n) = idp
private
module M = SpectrumModelMap (EM-E G) (EM-spectrum G) (EM-E G) (EM-spectrum G)
EM-C-coeff-fmap-idhom : (n : ℤ) (X : Ptd i)
→ EM-C-coeff-fmap G G (idhom (AbGroup.grp G)) n X == idhom _
EM-C-coeff-fmap-idhom n X =
ap (λ map → M.C-coeff-fmap map n X) (λ= EM-E-fmap-idhom) ∙
C-coeff-fmap-idf (EM-E G) (EM-spectrum G) n X
module _ {i} (G : AbGroup i) (H : AbGroup i) (K : AbGroup i)
(ψ : H →ᴬᴳ K) (φ : G →ᴬᴳ H) where
private
EM-E-fmap-∘ : ∀ (n : ℤ)
→ EM-E-fmap G K (ψ ∘ᴳ φ) n == EM-E-fmap H K ψ n ⊙∘ EM-E-fmap G H φ n
EM-E-fmap-∘ (pos n) = ⊙EM-fmap-∘ G H K ψ φ n
EM-E-fmap-∘ (negsucc n) = idp
private
module M = SpectrumModelMap (EM-E G) (EM-spectrum G) (EM-E K) (EM-spectrum K)
EM-C-coeff-fmap-∘ : (n : ℤ) (X : Ptd i)
→ EM-C-coeff-fmap G K (ψ ∘ᴳ φ) n X ==
EM-C-coeff-fmap H K ψ n X ∘ᴳ
EM-C-coeff-fmap G H φ n X
EM-C-coeff-fmap-∘ n X =
ap (λ map → M.C-coeff-fmap map n X) (λ= EM-E-fmap-∘) ∙
C-coeff-fmap-∘ (EM-E G) (EM-spectrum G)
(EM-E H) (EM-spectrum H)
(EM-E K) (EM-spectrum K)
(EM-E-fmap H K ψ)
(EM-E-fmap G H φ)
n X
module _ {i} (G : AbGroup i) where
open CohomologyTheory (spectrum-cohomology (EM-E G) (EM-spectrum G))
open EMExplicit
open import homotopy.SuspensionLoopSpaceInverse
private
module G = AbGroup G
⊙Ω-fmap-EM-E-fmap-inv-hom : ∀ (n : ℤ) → ⊙Ω-fmap (EM-E-fmap G G (inv-hom G) n) == ⊙Ω-!
⊙Ω-fmap-EM-E-fmap-inv-hom (negsucc n) =
contr-center $ =-preserves-level $
⊙→-level (⊙Ω (⊙Lift ⊙Unit)) (⊙Ω (⊙Lift ⊙Unit)) $
=-preserves-level $ Lift-level $ Unit-level
⊙Ω-fmap-EM-E-fmap-inv-hom (pos O) =
prop-path
(⊙→-level (⊙Ω (⊙EM G 0)) (⊙Ω (⊙EM G 0)) $
has-level-apply (EM-level G 0) (pt (⊙EM G 0)) (pt (⊙EM G 0)))
_ _
⊙Ω-fmap-EM-E-fmap-inv-hom (pos 1) = =⊙∘-out $
⊙Ω-fmap (⊙Trunc-fmap (⊙EM₁-fmap (inv-hom G))) ◃⊙idf
=⊙∘⟨ 0 & 0 & !⊙∘ $ ⊙<–-inv-l-=⊙∘ (⊙Ω-⊙Trunc-comm 0 (⊙EM₁ G.grp)) ⟩
⊙<– (⊙Ω-⊙Trunc-comm 0 (⊙EM₁ G.grp)) ◃⊙∘
⊙–> (⊙Ω-⊙Trunc-comm 0 (⊙EM₁ G.grp)) ◃⊙∘
⊙Ω-fmap (⊙Trunc-fmap (⊙EM₁-fmap (inv-hom G))) ◃⊙idf
=⊙∘⟨ 1 & 2 & ⊙–>-⊙Ω-⊙Trunc-comm-natural-=⊙∘ 0 (⊙EM₁-fmap (inv-hom G)) ⟩
⊙<– (⊙Ω-⊙Trunc-comm 0 (⊙EM₁ G.grp)) ◃⊙∘
⊙Trunc-fmap (⊙Ω-fmap (⊙EM₁-fmap (inv-hom G))) ◃⊙∘
⊙–> (⊙Ω-⊙Trunc-comm 0 (⊙EM₁ G.grp)) ◃⊙idf
=⊙∘₁⟨ 1 & 1 & ap ⊙Trunc-fmap $ ⊙Ω-fmap-⊙EM₁-neg G ⟩
⊙<– (⊙Ω-⊙Trunc-comm 0 (⊙EM₁ G.grp)) ◃⊙∘
⊙Trunc-fmap ⊙Ω-! ◃⊙∘
⊙–> (⊙Ω-⊙Trunc-comm 0 (⊙EM₁ G.grp)) ◃⊙idf
=⊙∘⟨ 1 & 2 & =⊙∘-in
{gs = ⊙–> (⊙Ω-⊙Trunc-comm 0 (⊙EM₁ G.grp)) ◃⊙∘ ⊙Ω-! ◃⊙idf} $
! $ ⊙λ=' –>-=ₜ-equiv-pres-! idp ⟩
⊙<– (⊙Ω-⊙Trunc-comm 0 (⊙EM₁ G.grp)) ◃⊙∘
⊙–> (⊙Ω-⊙Trunc-comm 0 (⊙EM₁ G.grp)) ◃⊙∘
⊙Ω-! ◃⊙idf
=⊙∘⟨ 0 & 2 & ⊙<–-inv-l-=⊙∘ (⊙Ω-⊙Trunc-comm 0 (⊙EM₁ G.grp)) ⟩
⊙Ω-! ◃⊙idf ∎⊙∘
⊙Ω-fmap-EM-E-fmap-inv-hom (pos (S (S k))) = =⊙∘-out $
⊙Ω-fmap (⊙EM-fmap G G (inv-hom G) (S (S k))) ◃⊙idf
=⊙∘₁⟨ ap ⊙Ω-fmap (⊙EM-neg=⊙Trunc-fmap-⊙Susp-flip G k) ⟩
⊙Ω-fmap (⊙Trunc-fmap (⊙Susp-flip (⊙Susp^ k (⊙EM₁ G.grp)))) ◃⊙idf
=⊙∘⟨ 0 & 0 & !⊙∘ $
⊙<–-inv-l-=⊙∘ (⊙Ω-⊙Trunc-comm ⟨ S k ⟩ (⊙Susp^ (S k) (⊙EM₁ G.grp))) ⟩
⊙<– (⊙Ω-⊙Trunc-comm ⟨ S k ⟩ (⊙Susp^ (S k) (⊙EM₁ G.grp))) ◃⊙∘
⊙–> (⊙Ω-⊙Trunc-comm ⟨ S k ⟩ (⊙Susp^ (S k) (⊙EM₁ G.grp))) ◃⊙∘
⊙Ω-fmap (⊙Trunc-fmap (⊙Susp-flip (⊙Susp^ k (⊙EM₁ G.grp)))) ◃⊙idf
=⊙∘⟨ 1 & 2 & ⊙–>-⊙Ω-⊙Trunc-comm-natural-=⊙∘ ⟨ S k ⟩
(⊙Susp-flip (⊙Susp^ k (⊙EM₁ G.grp))) ⟩
⊙<– (⊙Ω-⊙Trunc-comm ⟨ S k ⟩ (⊙Susp^ (S k) (⊙EM₁ G.grp))) ◃⊙∘
⊙Trunc-fmap (⊙Ω-fmap (⊙Susp-flip (⊙Susp^ k (⊙EM₁ G.grp)))) ◃⊙∘
⊙–> (⊙Ω-⊙Trunc-comm ⟨ S k ⟩ (⊙Susp^ (S k) (⊙EM₁ G.grp))) ◃⊙idf
=⊙∘₁⟨ 1 & 1 & ! $ ⊙Ω-!-⊙Susp-flip
(⊙Susp^ k (⊙EM₁ G.grp))
⟨ S k ⟩
(Spectrum.Trunc-fmap-σloop-is-equiv G k) ⟩
⊙<– (⊙Ω-⊙Trunc-comm ⟨ S k ⟩ (⊙Susp^ (S k) (⊙EM₁ G.grp))) ◃⊙∘
⊙Trunc-fmap ⊙Ω-! ◃⊙∘
⊙–> (⊙Ω-⊙Trunc-comm ⟨ S k ⟩ (⊙Susp^ (S k) (⊙EM₁ G.grp))) ◃⊙idf
=⊙∘⟨ 1 & 2 & =⊙∘-in
{gs = ⊙–> (⊙Ω-⊙Trunc-comm ⟨ S k ⟩ (⊙Susp^ (S k) (⊙EM₁ G.grp))) ◃⊙∘
⊙Ω-! ◃⊙idf} $
! $ ⊙λ=' –>-=ₜ-equiv-pres-! idp ⟩
⊙<– (⊙Ω-⊙Trunc-comm ⟨ S k ⟩ (⊙Susp^ (S k) (⊙EM₁ G.grp))) ◃⊙∘
⊙–> (⊙Ω-⊙Trunc-comm ⟨ S k ⟩ (⊙Susp^ (S k) (⊙EM₁ G.grp))) ◃⊙∘
⊙Ω-! ◃⊙idf
=⊙∘⟨ 0 & 2 & ⊙<–-inv-l-=⊙∘ (⊙Ω-⊙Trunc-comm ⟨ S k ⟩ (⊙Susp^ (S k) (⊙EM₁ G.grp))) ⟩
⊙Ω-! ◃⊙idf ∎⊙∘
EM-C-coeff-fmap-inv-hom : ∀ (n : ℤ) (X : Ptd i)
→ EM-C-coeff-fmap G G (inv-hom G) n X ==
inv-hom (C-abgroup n X)
EM-C-coeff-fmap-inv-hom n X =
group-hom= $ λ= $ Trunc-elim $ λ h → ap [_]₀ $
ap (_⊙∘ h) (⊙Ω-fmap-EM-E-fmap-inv-hom (succ n)) ∙
⊙λ=' (λ _ → idp) (∙-unit-r (ap ! (snd h)))
| {
"alphanum_fraction": 0.5005907838,
"avg_line_length": 39.671875,
"ext": "agda",
"hexsha": "98e37c1b29faac017cae30565c22d07c044b6b64",
"lang": "Agda",
"max_forks_count": 50,
"max_forks_repo_forks_event_max_datetime": "2022-02-14T03:03:25.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-10T01:48:08.000Z",
"max_forks_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "AntoineAllioux/HoTT-Agda",
"max_forks_repo_path": "theorems/cohomology/EMModel.agda",
"max_issues_count": 31,
"max_issues_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_issues_repo_issues_event_max_datetime": "2021-10-03T19:15:25.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-03-05T20:09:00.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "AntoineAllioux/HoTT-Agda",
"max_issues_repo_path": "theorems/cohomology/EMModel.agda",
"max_line_length": 87,
"max_stars_count": 294,
"max_stars_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "AntoineAllioux/HoTT-Agda",
"max_stars_repo_path": "theorems/cohomology/EMModel.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": 3984,
"size": 7617
} |
module BTree.Complete.Base.Properties {A : Set} where
open import BTree {A}
open import BTree.Complete.Base {A}
open import BTree.Equality {A}
open import BTree.Equality.Properties {A}
lemma-≃-⋗ : {l l' r' : BTree} → l ≃ l' → l' ⋗ r' → l ⋗ r'
lemma-≃-⋗ (≃nd x x' ≃lf ≃lf ≃lf) (⋗lf .x') = ⋗lf x
lemma-≃-⋗ (≃nd {r = r} x x' l≃r l≃l' l'≃r') (⋗nd .x' x'' r' l'' l'⋗r'') = ⋗nd x x'' r l'' (lemma-≃-⋗ l≃l' l'⋗r'')
lemma-⋗-≃ : {l r r' : BTree} → l ⋗ r → r ≃ r' → l ⋗ r'
lemma-⋗-≃ (⋗lf x) ≃lf = ⋗lf x
lemma-⋗-≃ (⋗nd {r' = r'} x x' r l' l⋗r') (≃nd {l' = l''} .x' x'' l'≃r' l'≃l'' l''≃r'') = ⋗nd x x'' r l'' (lemma-⋗-≃ l⋗r' (trans≃ (symm≃ l'≃r') (trans≃ l'≃l'' l''≃r'')))
| {
"alphanum_fraction": 0.4737631184,
"avg_line_length": 44.4666666667,
"ext": "agda",
"hexsha": "48f3b59d4562557f5246599881eb9d9d9323613b",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "bgbianchi/sorting",
"max_forks_repo_path": "agda/BTree/Complete/Base/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "bgbianchi/sorting",
"max_issues_repo_path": "agda/BTree/Complete/Base/Properties.agda",
"max_line_length": 168,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "b8d428bccbdd1b13613e8f6ead6c81a8f9298399",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "bgbianchi/sorting",
"max_stars_repo_path": "agda/BTree/Complete/Base/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": 406,
"size": 667
} |
module plfa-exercises.Practice5 where
open import Data.Nat using (ℕ; zero; suc)
open import Data.String using (String; _≟_)
open import Relation.Binary.PropositionalEquality using (_≡_; _≢_; refl; cong)
open import Relation.Nullary using (Dec; yes; no; ¬_)
open import plfa.part1.Isomorphism using (_≲_)
Id : Set
Id = String
infix 5 ƛ_⇒_ μ_⇒_
infixl 7 _·_
infix 8 `suc_
infix 9 `_
data Term : Set where
`_ : Id → Term
ƛ_⇒_ : Id → Term → Term
_·_ : Term → Term → Term
`zero : Term
`suc_ : Term → Term
case_[zero⇒_|suc_⇒_] : Term → Term → Id → Term → Term
μ_⇒_ : Id → Term → Term
--ƛ "x" ⇒ `suc `zero
one = `suc `zero
two = `suc one
plus : Term
plus = μ "+" ⇒ ƛ "m" ⇒ ƛ "n" ⇒
case ` "m"
[zero⇒ ` "n"
|suc "m" ⇒ `suc (` "+" · ` "m" · ` "n") ]
--plus · two · two
twoᶜ : Term
twoᶜ = ƛ "s" ⇒ ƛ "z" ⇒ ` "s" · (` "s" · ` "z")
plusᶜ : Term
plusᶜ = ƛ "m" ⇒ ƛ "n" ⇒ ƛ "s" ⇒ ƛ "z" ⇒
` "m" · ` "s" · (` "n" · ` "s" · ` "z")
sucᶜ : Term
sucᶜ = ƛ "n" ⇒ `suc (` "n")
----- Little detour into the same definitions but working in Agda
--plus c one two
--(λ m n s z → m s (n s z)) (λ s z → s z) (λ s z → s (s z)) suc zero
Nat : Set₁
Nat = ∀ {A : Set} → (A → A) → A → A
--my_two : ∀ {A : Set} → (A → A) → A → A
my_two : Nat
my_two = (λ s z → s (s z))
--my_four : ∀ {A : Set} → (A → A) → A → A
my_four : Nat
my_four = (λ s z → s (s (s (s z))))
--(λ m n s z → m s (n s z)) my_two my_four
--my_add : ∀ {A : Set} → ((A → A) → A → A) → ((A → A) → A → A) → (A → A) → A → A
my_add : Nat → Nat → Nat
my_add = (λ m n s z → m s (n s z))
--my_add = (λ m n s → (m s) ∘ (n s))
-- my_add my_two my_four ≡ λ s z → s (s (s (s (s (s z)))))
six : ℕ
six = my_add my_two my_four suc zero
--six = 6
--my_mul : ∀ {A : Set} → ((A → A) → A → A) → ((A → A) → A → A) → (A → A) → A → A
my_mul : Nat → Nat → Nat
my_mul = (λ m n s z → m (n s) z)
--my_mul = (λ m n s → m (n s))
--my_mul my_two my_four ≡ λ s z → s (s (s (s (s (s (s (s z)))))))
eight_true : my_mul my_two my_four suc zero ≡ 8
eight_true = refl
----- End of detour
-- Exercises
mult : Term
mult = μ "*" ⇒ ƛ "m" ⇒ ƛ "n" ⇒
case ` "m"
[zero⇒ `zero
|suc "m" ⇒ plus · (` "*" · ` "m" · ` "n") · ` "n" ]
multᶜ : Term
multᶜ = ƛ "m" ⇒ ƛ "n" ⇒ ƛ "s" ⇒ ƛ "z" ⇒
` "m" · (` "n" · ` "s") · ` "z"
--- End Exercises
data Value : Term → Set where
V-ƛ : ∀ {x N} → Value (ƛ x ⇒ N)
V-zero : Value `zero
V-suc : ∀ {V} → Value V → Value (`suc V)
-- Notice that this only works if we are working with _closed_ terms.
-- Open terms require more care
infix 9 _[_:=_]
-- Wrote them partly by myself
_[_:=_] : Term → Id → Term → Term
(` x) [ x' := V ] with x ≟ x'
... | yes _ = V
... | no _ = ` x
(ƛ x ⇒ M) [ x' := V ] with x ≟ x'
... | yes _ = ƛ x ⇒ M
... | no _ = ƛ x ⇒ (M [ x' := V ])
(M · N) [ x := V ] = (M [ x := V ]) · (N [ x := V ])
`zero [ _ := _ ] = `zero
(`suc M) [ x := V ] = `suc (M [ x := V ])
(case n [zero⇒ M |suc n' ⇒ N ]) [ x := V ] with x ≟ n'
... | yes _ = case (n [ x := V ]) [zero⇒ (M [ x := V ]) |suc n' ⇒ N ]
... | no _ = case (n [ x := V ]) [zero⇒ (M [ x := V ]) |suc n' ⇒ (N [ x := V ]) ]
(μ f ⇒ M) [ x := V ] with f ≟ x
... | yes _ = μ f ⇒ M
... | no _ = μ f ⇒ (M [ x := V ])
-- (ƛ "y" ⇒ ` "x" · (ƛ "x" ⇒ ` "x")) [ "x" := `zero ]
infix 4 _—→_
data _—→_ : Term → Term → Set where
ξ-·₁ : ∀ {L L′ M}
→ L —→ L′
-----------------
→ L · M —→ L′ · M
ξ-·₂ : ∀ {V M M′}
→ Value V
→ M —→ M′
-----------------
→ V · M —→ V · M′
β-ƛ : ∀ {x N V}
→ Value V
------------------------------
→ (ƛ x ⇒ N) · V —→ N [ x := V ]
ξ-suc : ∀ {M M′}
→ M —→ M′
------------------
→ `suc M —→ `suc M′
ξ-case : ∀ {x L L′ M N}
→ L —→ L′
-----------------------------------------------------------------
→ case L [zero⇒ M |suc x ⇒ N ] —→ case L′ [zero⇒ M |suc x ⇒ N ]
β-zero : ∀ {x M N}
----------------------------------------
→ case `zero [zero⇒ M |suc x ⇒ N ] —→ M
β-suc : ∀ {x V M N}
→ Value V
---------------------------------------------------
→ case `suc V [zero⇒ M |suc x ⇒ N ] —→ N [ x := V ]
β-μ : ∀ {x M}
------------------------------
→ μ x ⇒ M —→ M [ x := μ x ⇒ M ]
_ : (ƛ "x" ⇒ `suc (`suc (` "x"))) · (`suc `zero) —→ `suc (`suc (`suc `zero))
_ = β-ƛ (V-suc V-zero)
_ : (ƛ "x" ⇒ ` "x") · (ƛ "x" ⇒ ` "x") —→ (ƛ "x" ⇒ ` "x")
_ = β-ƛ V-ƛ
_ : (ƛ "x" ⇒ ` "x") · (ƛ "x" ⇒ ` "x") · (ƛ "x" ⇒ ` "x") —→ (ƛ "x" ⇒ ` "x") · (ƛ "x" ⇒ ` "x")
_ = ξ-·₁ (β-ƛ V-ƛ)
_ : twoᶜ · sucᶜ · `zero —→ (ƛ "z" ⇒ sucᶜ · (sucᶜ · ` "z")) · `zero
_ = ξ-·₁ (β-ƛ V-ƛ)
--- Detour
t : ∀ {A B : Set} → A → B → A
t = λ x y → x -- true
f : ∀ {A B : Set} → A → B → B
f = λ x y → y -- false
--is0 : ∀ {A : Set} → ((A → A → A → A) → (A → A → A) → A → A → A) → A → A → A
--is0 {A} = λ n → n (λ x → f {A}) (t {A})
--is0 : ∀ {A B : Set} → ((A → A → A → A) → (A → A → A) → A → A → A) → (A → A) → A → A
--is0 {A} {B} = λ n → n (λ x → f {A} {B}) (t {A} {B})
-- is0 {ℕ} (λ s z → z) -- returns true
-- is0 (λ s z → s z) -- returns false
--- End detour
infix 2 _—↠_
infix 1 begin_
infixr 2 _—→⟨_⟩_ _—→⟨⟩_
infix 3 _∎
data _—↠_ : Term → Term → Set where
_∎ : ∀ M
---------
→ M —↠ M
_—→⟨_⟩_ : ∀ L {M N}
→ L —→ M
→ M —↠ N
---------
→ L —↠ N
begin_ : ∀ {M N}
→ M —↠ N
------
→ M —↠ N
begin M—↠N = M—↠N
_—→⟨⟩_ : ∀ L {N}
→ L —↠ N
---------
→ L —↠ N
_—→⟨⟩_ l l—↠n = l—↠n
trans : ∀ {L M N}
→ L —↠ M
→ M —↠ N
→ L —↠ N
trans (m ∎) m—↠n = m—↠n
trans (l —→⟨ l—→o ⟩ o—↠m) m—↠n = l —→⟨ l—→o ⟩ (trans o—↠m m—↠n)
_ : (ƛ "x" ⇒ ` "x") · (ƛ "x" ⇒ ` "x") · (ƛ "x" ⇒ ` "x") · (ƛ "x" ⇒ ` "x") —↠ (ƛ "x" ⇒ ` "x")
_ =
begin
(ƛ "x" ⇒ ` "x") · (ƛ "x" ⇒ ` "x") · (ƛ "x" ⇒ ` "x") · (ƛ "x" ⇒ ` "x") —→⟨ ξ-·₁ (ξ-·₁ (β-ƛ V-ƛ)) ⟩
(ƛ "x" ⇒ ` "x") · (ƛ "x" ⇒ ` "x") · (ƛ "x" ⇒ ` "x") —→⟨ ξ-·₁ (β-ƛ V-ƛ) ⟩
(ƛ "x" ⇒ ` "x") · (ƛ "x" ⇒ ` "x") —→⟨ β-ƛ V-ƛ ⟩
ƛ "x" ⇒ ` "x"
∎
data _—↠′_ : Term → Term → Set where
step′ : ∀ {M N}
→ M —→ N
-------
→ M —↠′ N
refl′ : ∀ {M}
-------
→ M —↠′ M
trans′ : ∀ {L M N}
→ L —↠′ M
→ M —↠′ N
-------
→ L —↠′ N
↠≲—↠′ : ∀ t t' → (t —↠ t') ≲ (t —↠′ t')
↠≲—↠′ t t' = record {
to = to
; from = from
; from∘to = from∘to
}
where
to : ∀ {t t'} → t —↠ t' → t —↠′ t'
to (m ∎) = refl′ {m}
to (l —→⟨ l—→m ⟩ m—↠n) = trans′ {l} (step′ l—→m) (to m—↠n)
from : ∀ {t t'} → t —↠′ t' → t —↠ t'
from (step′ {m} {n} m—→n) = m —→⟨ m—→n ⟩ n ∎
from (refl′ {m}) = m ∎
from (trans′ {l} {m} {n} l—↠′m m—↠′n) =
trans (from l—↠′m) (from m—↠′n)
from∘to : ∀ {l n} (x : l —↠ n) → from (to x) ≡ x
from∘to (n ∎) = refl
from∘to (l —→⟨ l—→m ⟩ m—↠n) = cong (l —→⟨ l—→m ⟩_) (from∘to m—↠n)
--to∘from : ∀ {l n} (x : l —↠′ n) → to (from x) ≡ x
--to∘from (step′ {m} {n} m—→n) = ?
---- here lies the problem:
---- to (from (step′ m—→n)) ≡ step′ m—→n
---- is converted into:
---- trans′ (step′ m—→n) refl′ ≡ step′ m—→n
---- which cannot be true :/, both are constructors, both
---- create the same type. Lesson, always make sure your data
---- definitions make unique elements
--to∘from = ?
_ : twoᶜ · sucᶜ · `zero —↠ `suc `suc `zero
_ = begin
twoᶜ · sucᶜ · `zero —→⟨⟩ -- def
(ƛ "s" ⇒ ƛ "z" ⇒ ` "s" · (` "s" · ` "z")) · sucᶜ · `zero —→⟨ ξ-·₁ (β-ƛ V-ƛ) ⟩
(ƛ "z" ⇒ sucᶜ · (sucᶜ · ` "z")) · `zero —→⟨ β-ƛ V-zero ⟩
sucᶜ · (sucᶜ · `zero) —→⟨⟩
(ƛ "n" ⇒ `suc (` "n")) · ((ƛ "n" ⇒ `suc (` "n")) · `zero) —→⟨ ξ-·₂ V-ƛ (β-ƛ V-zero) ⟩
(ƛ "n" ⇒ `suc (` "n")) · `suc `zero —→⟨ β-ƛ (V-suc V-zero) ⟩
`suc `suc `zero ∎
oneᶜ : Term
oneᶜ = ƛ "s" ⇒ ƛ "z" ⇒ ` "s" · ` "z"
_ : plusᶜ · oneᶜ · oneᶜ · sucᶜ · `zero —↠ `suc `suc `zero
_ = begin
plusᶜ · oneᶜ · oneᶜ · sucᶜ · `zero —→⟨⟩
plusᶜ · oneᶜ · oneᶜ · sucᶜ · `zero —→⟨⟩
(ƛ "m" ⇒ ƛ "n" ⇒ ƛ "s" ⇒ ƛ "z" ⇒
` "m" · ` "s" · (` "n" · ` "s" · ` "z")) · oneᶜ · oneᶜ · sucᶜ · `zero —→⟨ ξ-·₁ (ξ-·₁ (ξ-·₁ (β-ƛ V-ƛ))) ⟩
(ƛ "n" ⇒ ƛ "s" ⇒ ƛ "z" ⇒
oneᶜ · ` "s" · (` "n" · ` "s" · ` "z")) · oneᶜ · sucᶜ · `zero —→⟨ ξ-·₁ (ξ-·₁ (β-ƛ V-ƛ)) ⟩
(ƛ "s" ⇒ ƛ "z" ⇒ oneᶜ · ` "s" · (oneᶜ · ` "s" · ` "z")) · sucᶜ · `zero —→⟨ ξ-·₁ (β-ƛ V-ƛ) ⟩
(ƛ "z" ⇒ oneᶜ · sucᶜ · (oneᶜ · sucᶜ · ` "z")) · `zero —→⟨ β-ƛ V-zero ⟩
oneᶜ · sucᶜ · (oneᶜ · sucᶜ · `zero) —→⟨⟩
(ƛ "s" ⇒ ƛ "z" ⇒ ` "s" · ` "z") · sucᶜ · (oneᶜ · sucᶜ · `zero) —→⟨ ξ-·₁ (β-ƛ V-ƛ) ⟩
(ƛ "z" ⇒ sucᶜ · ` "z") · (oneᶜ · sucᶜ · `zero) —→⟨ ξ-·₂ V-ƛ (ξ-·₁ (β-ƛ V-ƛ)) ⟩
(ƛ "z" ⇒ sucᶜ · ` "z") · ((ƛ "z" ⇒ sucᶜ · ` "z") · `zero) —→⟨ ξ-·₂ V-ƛ (β-ƛ V-zero) ⟩
(ƛ "z" ⇒ sucᶜ · ` "z") · (sucᶜ · `zero) —→⟨ ξ-·₂ V-ƛ (β-ƛ V-zero) ⟩
(ƛ "z" ⇒ sucᶜ · ` "z") · (`suc `zero) —→⟨ β-ƛ (V-suc V-zero) ⟩
sucᶜ · (`suc `zero) —→⟨ β-ƛ (V-suc V-zero) ⟩
`suc `suc `zero ∎
| {
"alphanum_fraction": 0.3450778292,
"avg_line_length": 29.2553846154,
"ext": "agda",
"hexsha": "6664ef87ab388a92121f165d9589a464778e4ace",
"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": "a432faf1b340cb379190a2f2b11b997b02d1cd8d",
"max_forks_repo_licenses": [
"CC0-1.0"
],
"max_forks_repo_name": "helq/old_code",
"max_forks_repo_path": "proglangs-learning/Agda/plfa-exercises/Practice5.agda",
"max_issues_count": 4,
"max_issues_repo_head_hexsha": "a432faf1b340cb379190a2f2b11b997b02d1cd8d",
"max_issues_repo_issues_event_max_datetime": "2021-06-07T15:39:48.000Z",
"max_issues_repo_issues_event_min_datetime": "2020-03-10T19:20:21.000Z",
"max_issues_repo_licenses": [
"CC0-1.0"
],
"max_issues_repo_name": "helq/old_code",
"max_issues_repo_path": "proglangs-learning/Agda/plfa-exercises/Practice5.agda",
"max_line_length": 113,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "a432faf1b340cb379190a2f2b11b997b02d1cd8d",
"max_stars_repo_licenses": [
"CC0-1.0"
],
"max_stars_repo_name": "helq/old_code",
"max_stars_repo_path": "proglangs-learning/Agda/plfa-exercises/Practice5.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 4655,
"size": 9508
} |
module Ag13 where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl)
open Eq.≡-Reasoning
open import Data.Nat using (ℕ; zero; suc)
open import Data.Product using (_×_) renaming (_,_ to ⟨_,_⟩)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Relation.Nullary using (¬_)
open import Relation.Nullary.Negation using ()
renaming (contradiction to ¬¬-intro)
open import Data.Unit using (⊤; tt)
open import Data.Empty using (⊥; ⊥-elim)
open import Ag09 using (_⇔_)
data Bool : Set where
true : Bool
false : Bool
T : Bool → Set
T true = ⊤
T false = ⊥
T→≡ : ∀ (b : Bool) → T b → b ≡ true
T→≡ true tt = refl
T→≡ false ()
≡→T : ∀ {b : Bool} → b ≡ true → T b
≡→T refl = tt
data Dec (A : Set) : Set where
yes : A → Dec A
no : ¬ A → Dec A
infix 4 _≤_
data _≤_ : ℕ → ℕ → Set where
z≤n : ∀ {n : ℕ}
--------
→ zero ≤ n
s≤s : ∀ {m n : ℕ}
→ m ≤ n
-------------
→ suc m ≤ suc n
¬s≤z : ∀ {m : ℕ} → ¬ (suc m ≤ zero)
¬s≤z ()
¬s≤s : ∀ {m n : ℕ} → ¬ (m ≤ n) → ¬ (suc m ≤ suc n)
¬s≤s ¬m≤n (s≤s m≤n) = ¬m≤n m≤n
_≤?_ : ∀ (m n : ℕ) → Dec (m ≤ n)
zero ≤? n = yes z≤n
suc m ≤? zero = no ¬s≤z
suc m ≤? suc n with m ≤? n
... | yes m≤n = yes (s≤s m≤n)
... | no ¬m≤n = no (¬s≤s ¬m≤n)
| {
"alphanum_fraction": 0.5003790751,
"avg_line_length": 21.2741935484,
"ext": "agda",
"hexsha": "a34c317f1a8815c1d76005a6bade258219473616",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-12-13T04:50:46.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-12-13T04:50:46.000Z",
"max_forks_repo_head_hexsha": "eb2cef0556efb9a4ce11783f8516789ea48cc344",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Brethland/LEARNING-STUFF",
"max_forks_repo_path": "Agda/Ag13.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "eb2cef0556efb9a4ce11783f8516789ea48cc344",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Brethland/LEARNING-STUFF",
"max_issues_repo_path": "Agda/Ag13.agda",
"max_line_length": 60,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "eb2cef0556efb9a4ce11783f8516789ea48cc344",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Brethland/LEARNING-STUFF",
"max_stars_repo_path": "Agda/Ag13.agda",
"max_stars_repo_stars_event_max_datetime": "2020-03-11T10:35:42.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-02-03T05:05:52.000Z",
"num_tokens": 554,
"size": 1319
} |
{-# OPTIONS --safe #-}
useful-lemma : ∀ {a} {A : Set a} → A
useful-lemma = useful-lemma
| {
"alphanum_fraction": 0.5730337079,
"avg_line_length": 17.8,
"ext": "agda",
"hexsha": "2c6dc4af44d961ae2071c0b1115d83d624753246",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "alhassy/agda",
"max_forks_repo_path": "test/Fail/Safe-flag-only-scope-checking-1.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "alhassy/agda",
"max_issues_repo_path": "test/Fail/Safe-flag-only-scope-checking-1.agda",
"max_line_length": 36,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "alhassy/agda",
"max_stars_repo_path": "test/Fail/Safe-flag-only-scope-checking-1.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": 32,
"size": 89
} |
{-# OPTIONS --without-K --copatterns --sized-types #-}
open import lib.Basics
open import lib.PathGroupoid
open import lib.types.Paths
open import lib.Funext
open import Size
{-
-- | Coinductive delay type. This is the functor νπ̂ : Set → Set arising
-- as the fixed point of π̂(H) = π ∘ ⟨Id, H⟩, where π : Set × Set → Set
-- with π(X, Y) = X.
record D (S : Set) : Set where
coinductive
field
force : S
open D
-- | Action of D on morphisms
D₁ : ∀ {X Y} → (X → Y) → D X → D Y
force (D₁ f x) = f (force x)
-- | D lifted to dependent functions
↑D₁ : ∀ {A} → (B : A → Set) → ((x : A) → B x) → (y : D A) → D (B (force y))
force (↑D₁ B f y) = f (force y)
D-intro : ∀ {H : Set → Set} → (∀ {X} → H X → X) → (∀ {X} → H X → D X)
force (D-intro f x) = f x
D-intro2 : ∀ {X S : Set} → (X → S) → X → D S
force (D-intro2 f x) = f x
postulate
-- | We'll need coinduction to prove such equalities in the future, or prove
-- it from univalence.
D-coind : ∀ {S} {x y : D S} → force x == force y → x == y
D-coind2 : ∀ {S} {x y : D S} → D (force x == force y) → x == y
D-coind2 p = D-coind (force p
-}
module _ where
private
mutual
data #D (A : Set) (P : Set) : Set where
#p : #D-aux A P → (Unit → Unit) → #D A P
data #D-aux (A : Set) (P : Set) : Set where
#now : A → #D-aux A P
#later : P → #D-aux A P
D : Set → Set → Set
D A X = #D A X
now : ∀ {A X} → A → D A X
now a = #p (#now a) _
later : ∀ {A X} → X → D A X
later x = #p (#later x) _
D₁ : ∀ {A P₁ P₂} → (P₁ → P₂) → (D A P₁ → D A P₂)
D₁ f (#p (#now a) _) = now a
D₁ f (#p (#later x) _) = later (f x)
record P {i : Size} (A : Set) : Set where
coinductive
field
#force : ∀ {j : Size< i} → D A (P {j} A)
open P
force : ∀ {A} → P A → D A (P A)
force x = #force x
P-intro : ∀ {A X : Set} → (X → D A X) → (X → P A)
P-intro {A} {X} f = P-intro'
where
P-intro' : ∀ {i} → X → P {i} A
#force (P-intro' x) {j} = D₁ (P-intro' {j}) (f x)
postulate -- HIT
weak~ : ∀{A X : Set} → (force* : X → D A X) →
(x : X) → (later x == force* x)
-- | Extra module for recursion using sized types.
-- This is convenient, as we can use the functor D in the definition, which
-- in turn simplifies proofs.
module DRec {A B : Set} {P' Y : Set}
(now* : A → D B Y)
(later* : P A → D B Y)
(force* : Y → D B Y)
(weak~* : (x : P A) → (later* x == force x))
where
f : D A P' → D B Y
f = f-aux phantom where
f-aux : Phantom weak~* → D A P' → D B Y
f-aux phantom (#p (#now a) _) = now* a
f-aux phantom (#p (#later x) _) = later* x
postulate -- HIT
weak~-β : (x : P') → ap f (weak~ force* x) == weak~* x
{-
module PElim {A X} {S : D A X → Set}
(now* : (a : A) → S (now a))
(later* : (x : X) → S (later x))
(force*₁ : (x : X) → D A X)
(force*₂ : (x : X) → S (force*₁ x))
(weak~* : (x : X) → -- (x_rec : S
(later* x == (force*₂ x) [ S ↓ (weak~ force*₁ x) ]))
where
f : (x : D A X) → S x
f = f-aux phantom
where
f-aux : Phantom weak~* → (x : D A X) → S x
f-aux phantom (#p (#now a) _) = now* a
f-aux phantom (#p (#later x) _) = later* x
-}
-- postulate -- HIT
-- weak~-β : (x : X) → apd f (weak~ force*₁ x) == weak~* x
{-
weak~-β₂ : (x : ∞P A) →
apd f (weak~ x) == weak~* x (↑D₁ S f x)
-- transport (weak~* x) g-is-D₁f (↑D₁ S f x)
weak~-β₂ = ?
-}
open DRec public renaming (f to D-rec)
{-
open PElim public
renaming (f to P-elim; g to ∞P-elim; f-homomorphism to P-elim-hom;
weak~-β to elim-weak~-β)
-}
module Bla where
⊥ : ∀ {A} → P A
⊥ = P-intro later unit
-- | Copairing of morphisms
[_,_] : ∀ {i j k} {A : Type i} {B : Type j} {C : Type k}
(l : A → C) (r : B → C) → (x : Coprod A B) → C
[ f , g ] x = match x withl f withr g
id-D : ∀ {A} → D A (P A) → D A (P A)
id-D {A} = D-rec now later force (weak~ force)
--(idf A) (idf (P A)) (λ x → force x) (weak~ (λ x → force x))
D₁-force : ∀ {A P₁ P₂} → (force* : P₁ → D A P₁) → (f : P₁ → P₂) → (x : P₁)
→ later (f x) == D₁ f (force* x)
D₁-force force* f x =
later (f x)
=⟨ idp ⟩
D₁ f (later x)
=⟨ weak~ force* x |in-ctx (D₁ f) ⟩
D₁ f (force* x)
∎
-- | Direct definition of bind
bind : ∀ {A B} → (A → P B) → (P A → P B)
bind {A} {B} f x = P-intro {X = P A ⊔ P B} [ u , v ] (inl x)
where
elim-A : A → D B (P A ⊔ P B)
elim-A a =
D-rec now
(later ∘ inr)
(D₁ inr ∘ force)
(D₁-force force inr)
(force (f a))
u : P A → D B (P A ⊔ P B)
u x = D-rec
elim-A
(later ∘ inl)
(later ∘ inl) -- this should be force ...
(λ _ → idp)
(force x)
v : P B → D B (P A ⊔ P B)
v = D₁ inr ∘ force
{-
-- | Copairing of morphisms
[_,_] : ∀ {i j k} {A : Type i} {B : Type j} {C : Type k}
(l : A → C) (r : B → C) → (x : Coprod A B) → C
[ f , g ] x = match x withl f withr g
-- | Inverse of [now, later] à la Lambek,
-- given by extending id + D ([now, later]) : A ⊔ D(A ⊔ ∞P A) → A ⊔ ∞P A.
out : ∀ {A} → P A → A ⊔ ∞P A
out {A} = P-rec inl force (λ _ → idp)
-- (inr ∘ D₁ [ now , later ]) resp-weak~
where
resp-weak~ : (x : D (A ⊔ ∞P A)) →
(inr ∘ D₁ [ now , later ]) x == force x
resp-weak~ x =
(inr ∘ D₁ [ now , later ]) x
=⟨ {!!} ⟩
inr (D₁ [ now , later ] x)
=⟨ {!!} ⟩
force x
∎
⊥' : ∀ {A} → ∞P A
⊥ : ∀ {A} → P A
⊥ = later (D-intro (λ _ → {!!}) unit)
force ⊥' = {!!} -- ⊥
-- | Action of P on morphisms
P₁ : ∀ {A B} → (A → B) → (P A → P B)
P₁ f = P-rec (now ∘ f) later weak~
-- | Unit for the monad
η : ∀ {A} → A → P A
η = now
-- | Monad multiplication
μ : ∀ {A} → P (P A) → P A
μ {A} = P-rec (idf (P A)) later weak~
-- | Direct definition of bind
bind : ∀ {A B} → (A → P B) → (P A → P B)
bind {A} {B} f = P-rec f later weak~
η-natural : ∀ {A B} → (f : A → B) →
η ∘ f == P₁ f ∘ η
η-natural f = λ=-nondep (λ x → idp)
where
n open FunextNonDep
μ-natural : ∀ {A B} → (f : A → B) →
μ ∘ P₁ (P₁ f) == P₁ f ∘ μ
μ-natural {A} f = λ=-nondep q
where
open FunextNonDep
T : P (P A) → Set
T x = μ ( P₁ (P₁ f) x) == P₁ f (μ x)
=-later : (x : ∞P (P A)) → D (T (force x)) → T (later x)
=-later x p = transport T (! (weak~ x)) (force p)
r : (x : ∞P (P A)) → (p : D (T (force x))) →
(=-later x p) == (force p) [ T ↓ (weak~ x) ]
r x p = trans-↓ T (weak~ x) (force p)
q : (x : P (P A)) → μ ( P₁ (P₁ f) x) == P₁ f (μ x)
q = P-elim {S = λ x → μ ( P₁ (P₁ f) x) == P₁ f (μ x)}
(λ a → idp) =-later r
-- | Termination predicate on P A
data _↓_ {A} (x : P A) : A → Set where
now↓ : (a : A) → now a == x → x ↓ a
later↓ : (a : A) → (u : ∞P A) → (later u == x) → (force u) ↓ a → x ↓ a
mutual
-- | Weak bisimilarity proofs
data ~proof {A} (x y : P A) : Set where
terminating : (a : A) → x ↓ a → y ↓ a → ~proof x y
-- A bit awkward, but otherwise we cannot pattern matching on ~proof
step : (u v : ∞P A) → (later u == x) → (later v == y) → force u ~ force v →
~proof x y
-- | Weak bisimilarity for P A
record _~_ {A} (x y : P A) : Set where
coinductive
field
out~ : ~proof x y
open _~_
terminate→=now : ∀{A} → (a : A) → (x : P A) → x ↓ a → now a == x
terminate→=now a x (now↓ .a na=x) = na=x
terminate→=now a x (later↓ .a u lu=x fu↓a) =
now a
=⟨ terminate→=now a (force u) fu↓a ⟩
force u
=⟨ ! (weak~ u) ⟩
later u
=⟨ lu=x ⟩
x
∎
lemma : ∀{A} → (a : A) → (x y : P A) → x ↓ a → y ↓ a → x == y
lemma a x y x↓a y↓a =
x
=⟨ ! (terminate→=now a x x↓a) ⟩
now a
=⟨ terminate→=now a y y↓a ⟩
y
∎
inr-inj : ∀ {i} {A B : Set i} →
(x y : B) → Path {i} {A ⊔ B} (inr x) (inr y) → x == y
inr-inj x .x idp = idp
later-inj : ∀ {A} → (u v : ∞P A) → later u == later v → u == v
later-inj u v p = inr-inj u v lem
where
lem : inr u == inr v
lem = transport (λ z → inr u == P-out z) {later u} {later v} p idp
-- | Weak bisimilarity implies equality for P A
~→= : ∀{A} → (x y : P A) → x ~ y → x == y
~→= {A} x y = P-elim {S = λ x' → x' ~ y → x' == y} now-= later-= weak~-= x
where
now-= : (a : A) → now a ~ y → now a == y
now-= a p = lem (out~ p)
where
lem : ~proof (now a) y → now a == y
lem (terminating b (now↓ .b nb=na) y↓b) =
now a
=⟨ ! nb=na ⟩
now b
=⟨ terminate→=now b y y↓b ⟩
y
∎
lem (terminating b (later↓ .b u () now_a↓b) y↓b)
lem (step u v () x₂ x₃)
later-= : (u : ∞P A) →
D (force u ~ y → force u == y) → later u ~ y → later u == y
later-= u p later_u~y = lem (out~ later_u~y)
where
lem : ~proof (later u) y → later u == y
lem (terminating a later_u↓a y↓a) = lemma a (later u) y later_u↓a y↓a
lem (step u' v later_u'=later_u later_v=y force_u'~force_v) =
later u
=⟨ weak~ u ⟩
force u
=⟨ force p force_u~y ⟩
y ∎
where
force_u'=force_u : force u' == force u
force_u'=force_u =
force u'
=⟨ later-inj u' u later_u'=later_u |in-ctx force ⟩
force u
∎
y=force_v : y == force v
y=force_v =
y
=⟨ ! later_v=y ⟩
later v
=⟨ weak~ v ⟩
force v
∎
force_u~y : force u ~ y
force_u~y = transport
(λ z → z ~ y)
force_u'=force_u
(transport! (λ z → force u' ~ z) y=force_v force_u'~force_v)
weak~-= : (u : ∞P A) (p : D (force u ~ y → force u == y)) →
(later-= u p)
== (force p) [ (λ x' → x' ~ y → x' == y) ↓ (weak~ u) ]
weak~-= u p = {!!}
-}
| {
"alphanum_fraction": 0.4415778464,
"avg_line_length": 27.5796703297,
"ext": "agda",
"hexsha": "2fff73fe5f79b867e2128c46d647d3673a55f7e1",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "8fc7a6cd878f37f9595124ee8dea62258da28aa4",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "hbasold/Sandbox",
"max_forks_repo_path": "TypeTheory/HoTT/Partiality2.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "8fc7a6cd878f37f9595124ee8dea62258da28aa4",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "hbasold/Sandbox",
"max_issues_repo_path": "TypeTheory/HoTT/Partiality2.agda",
"max_line_length": 79,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "8fc7a6cd878f37f9595124ee8dea62258da28aa4",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "hbasold/Sandbox",
"max_stars_repo_path": "TypeTheory/HoTT/Partiality2.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 4087,
"size": 10039
} |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Group where
open import Cubical.Algebra.Group.Base public
open import Cubical.Algebra.Group.Properties public
open import Cubical.Algebra.Group.Morphism public
open import Cubical.Algebra.Group.MorphismProperties public
open import Cubical.Algebra.Group.Algebra public
open import Cubical.Algebra.Group.Action public
-- open import Cubical.Algebra.Group.Higher public
-- open import Cubical.Algebra.Group.EilenbergMacLane1 public
open import Cubical.Algebra.Group.Semidirect public
open import Cubical.Algebra.Group.Notation public
| {
"alphanum_fraction": 0.8319604613,
"avg_line_length": 43.3571428571,
"ext": "agda",
"hexsha": "b9450a4eebb74e77b1c5cfb2bcf419d80ad25b24",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "c345dc0c49d3950dc57f53ca5f7099bb53a4dc3a",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Schippmunk/cubical",
"max_forks_repo_path": "Cubical/Algebra/Group.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c345dc0c49d3950dc57f53ca5f7099bb53a4dc3a",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Schippmunk/cubical",
"max_issues_repo_path": "Cubical/Algebra/Group.agda",
"max_line_length": 61,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "c345dc0c49d3950dc57f53ca5f7099bb53a4dc3a",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Schippmunk/cubical",
"max_stars_repo_path": "Cubical/Algebra/Group.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 138,
"size": 607
} |
{-# OPTIONS --without-K #-}
module Sigma {a b} {A : Set a} {B : A → Set b} where
open import Equivalence
open import Types
-- Projections for the positive sigma.
π₁′ : (p : Σ′ A B) → A
π₁′ p = split (λ _ → A) (λ a _ → a) p
π₂′ : (p : Σ′ A B) → B (π₁′ p)
π₂′ p = split (λ p → B (π₁′ p)) (λ _ b → b) p
-- Induction principle for the negative sigma.
split′ : ∀ {p} (P : Σ A B → Set p)
(f : (a : A) (b : B a) → P (a , b)) → ∀ z → P z
split′ P f p = f (π₁ p) (π₂ p)
Σ→Σ′ : Σ A B → Σ′ A B
Σ→Σ′ p = π₁ p , π₂ p
Σ′→Σ : Σ′ A B → Σ A B
Σ′→Σ = split _ _,_
Σ≃Σ′ : Σ A B ≃ Σ′ A B
Σ≃Σ′
= Σ→Σ′
, (Σ′→Σ , split
(λ p → Σ→Σ′ (Σ′→Σ p) ≡ p)
(λ _ _ → refl))
, (Σ′→Σ , λ _ → refl)
| {
"alphanum_fraction": 0.4620991254,
"avg_line_length": 21.4375,
"ext": "agda",
"hexsha": "6703383638fb6100788a370a5a1bf396a17a2eeb",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7730385adfdbdda38ee8b124be3cdeebb7312c65",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "vituscze/HoTT-lectures",
"max_forks_repo_path": "src/Sigma.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7730385adfdbdda38ee8b124be3cdeebb7312c65",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "vituscze/HoTT-lectures",
"max_issues_repo_path": "src/Sigma.agda",
"max_line_length": 52,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "7730385adfdbdda38ee8b124be3cdeebb7312c65",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "vituscze/HoTT-lectures",
"max_stars_repo_path": "src/Sigma.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 361,
"size": 686
} |
{-# OPTIONS --cubical #-}
module Multidimensional.Data.NNat.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Unit
open import Cubical.Data.Nat
open import Cubical.Data.Prod
open import Cubical.Data.Bool
open import Cubical.Relation.Nullary
open import Multidimensional.Data.Extra.Nat
open import Multidimensional.Data.Dir
open import Multidimensional.Data.DirNum
data N (r : ℕ) : Type₀ where
bn : DirNum r → N r
xr : DirNum r → N r → N r
-- should define induction principle for N r
-- we have 2ⁿ "unary" constructors, analogous to BNat with 2¹ (b0 and b1)
-- rename n to r
-- this likely introduces inefficiencies compared
-- to BinNat, with the max? check etc.
sucN : ∀ {n} → N n → N n
sucN {zero} (bn tt) = xr tt (bn tt)
sucN {zero} (xr tt x) = xr tt (sucN x)
sucN {suc n} (bn (↓ , ds)) = (bn (↑ , ds))
sucN {suc n} (bn (↑ , ds)) with max? ds
... | no _ = (bn (↓ , next ds))
... | yes _ = xr (zero-n (suc n)) (bn (one-n (suc n)))
sucN {suc n} (xr d x) with max? d
... | no _ = xr (next d) x
... | yes _ = xr (zero-n (suc n)) (sucN x)
sucnN : {r : ℕ} → (n : ℕ) → (N r → N r)
sucnN n = iter n sucN
doubleN : (r : ℕ) → N r → N r
doubleN zero (bn tt) = bn tt
doubleN zero (xr d x) = sucN (sucN (doubleN zero x))
doubleN (suc r) (bn x) with zero-n? x
... | yes _ = bn x
-- bad:
... | no _ = caseBool (bn (doubleDirNum (suc r) x)) (xr (zero-n (suc r)) (bn x)) (doubleable-n? x)
-- ... | no _ | doubleable = {!bn (doubleDirNum x)!}
-- ... | no _ | notdoubleable = xr (zero-n (suc r)) (bn x)
doubleN (suc r) (xr x x₁) = sucN (sucN (doubleN (suc r) x₁))
doublesN : (r : ℕ) → ℕ → N r → N r
doublesN r zero m = m
doublesN r (suc n) m = doublesN r n (doubleN r m)
N→ℕ : (r : ℕ) (x : N r) → ℕ
N→ℕ zero (bn tt) = zero
N→ℕ zero (xr tt x) = suc (N→ℕ zero x)
N→ℕ (suc r) (bn x) = DirNum→ℕ x
N→ℕ (suc r) (xr d x) = sucn (DirNum→ℕ d) (doublesℕ (suc r) (N→ℕ (suc r) x))
ℕ→N : (r : ℕ) → (n : ℕ) → N r
ℕ→N r zero = bn (zero-n r)
ℕ→N zero (suc n) = xr tt (ℕ→N zero n)
ℕ→N (suc r) (suc n) = sucN (ℕ→N (suc r) n)
| {
"alphanum_fraction": 0.5922141119,
"avg_line_length": 30.671641791,
"ext": "agda",
"hexsha": "d73c55121cae11815b40f8e9a6744800180f9c3c",
"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": "55709dd950e319c4a105ace33ddaf8b955354add",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "wrrnhttn/agda-cubical-multidimensional",
"max_forks_repo_path": "Multidimensional/Data/NNat/Base.agda",
"max_issues_count": 4,
"max_issues_repo_head_hexsha": "55709dd950e319c4a105ace33ddaf8b955354add",
"max_issues_repo_issues_event_max_datetime": "2019-07-02T16:24:01.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-06-19T20:40:07.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "wrrnhttn/agda-cubical-multidimensional",
"max_issues_repo_path": "Multidimensional/Data/NNat/Base.agda",
"max_line_length": 98,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "55709dd950e319c4a105ace33ddaf8b955354add",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "wrrnhttn/agda-cubical-multidimensional",
"max_stars_repo_path": "Multidimensional/Data/NNat/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 852,
"size": 2055
} |
{-# OPTIONS --safe #-}
module Cubical.Homotopy.HSpace where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed
open import Cubical.Foundations.HLevels
open import Cubical.HITs.S1
open import Cubical.HITs.Sn
record HSpace {ℓ : Level} (A : Pointed ℓ) : Type ℓ where
constructor HSp
field
μ : typ A → typ A → typ A
μₗ : (x : typ A) → μ (pt A) x ≡ x
μᵣ : (x : typ A) → μ x (pt A) ≡ x
μₗᵣ : μₗ (pt A) ≡ μᵣ (pt A)
record AssocHSpace {ℓ : Level} {A : Pointed ℓ} (e : HSpace A) : Type ℓ where
constructor AssocHSp
field
μ-assoc : (x y z : _)
→ HSpace.μ e (HSpace.μ e x y) z ≡ HSpace.μ e x (HSpace.μ e y z)
μ-assoc-filler : (y z : typ A)
→ PathP (λ i → HSpace.μ e (HSpace.μₗ e y i) z
≡ HSpace.μₗ e (HSpace.μ e y z) i)
(μ-assoc (pt A) y z)
refl
-- Instances
open HSpace
open AssocHSpace
-- S¹
S1-HSpace : HSpace (S₊∙ 1)
μ S1-HSpace = _·_
μₗ S1-HSpace x = refl
μᵣ S1-HSpace base = refl
μᵣ S1-HSpace (loop i) = refl
μₗᵣ S1-HSpace x = refl
S1-AssocHSpace : AssocHSpace S1-HSpace
μ-assoc S1-AssocHSpace base _ _ = refl
μ-assoc S1-AssocHSpace (loop i) x y j = h x y j i
where
h : (x y : S₊ 1) → cong (_· y) (rotLoop x) ≡ rotLoop (x · y)
h = wedgeconFun _ _ (λ _ _ → isOfHLevelPath 2 (isGroupoidS¹ _ _) _ _)
(λ x → refl)
(λ { base → refl ; (loop i) → refl})
refl
μ-assoc-filler S1-AssocHSpace _ _ = refl
| {
"alphanum_fraction": 0.5994475138,
"avg_line_length": 27.8461538462,
"ext": "agda",
"hexsha": "055f37e2acfcc13cc6f5fffb3fad03475d26befe",
"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/Homotopy/HSpace.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/Homotopy/HSpace.agda",
"max_line_length": 76,
"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/Homotopy/HSpace.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": 594,
"size": 1448
} |
module Prelude.Equality.Unsafe where
open import Prelude.Equality
open import Prelude.Empty
open import Prelude.Erased
open import Agda.Builtin.TrustMe
-- unsafeEqual {x = x} {y = y} evaluates to refl if x and y are
-- definitionally equal.
unsafeEqual : ∀ {a} {A : Set a} {x y : A} → x ≡ y
unsafeEqual = primTrustMe
{-# DISPLAY primTrustMe = [erased] #-}
-- Used in decidable equality for primitive types (String, Char and Float)
unsafeNotEqual : ∀ {a} {A : Set a} {x y : A} → ¬ (x ≡ y)
unsafeNotEqual _ = erase-⊥ trustme
where postulate trustme : ⊥
-- Erase an equality proof. Throws away the actual proof
-- and replaces it by unsafeEqual.
eraseEquality : ∀ {a} {A : Set a} {x y : A} → x ≡ y → x ≡ y
eraseEquality _ = unsafeEqual
unsafeCoerce : ∀ {a} {A : Set a} {B : Set a} → A → B
unsafeCoerce {A = A} {B} x with unsafeEqual {x = A} {y = B}
unsafeCoerce x | refl = x
| {
"alphanum_fraction": 0.6655328798,
"avg_line_length": 29.4,
"ext": "agda",
"hexsha": "11a0b286ce4731fba4474efa8290a5916025c677",
"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/Equality/Unsafe.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/Equality/Unsafe.agda",
"max_line_length": 74,
"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/Equality/Unsafe.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": 291,
"size": 882
} |
{-# OPTIONS --without-K --safe #-}
module Definition.Conversion.Lift where
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.Weakening
open import Definition.Typed.Properties
open import Definition.Typed.EqRelInstance
open import Definition.Conversion
open import Definition.Conversion.Whnf
open import Definition.Conversion.Soundness
open import Definition.Conversion.Weakening
open import Definition.LogicalRelation
open import Definition.LogicalRelation.Properties
open import Definition.LogicalRelation.Fundamental.Reducibility
open import Definition.Typed.Consequences.Syntactic
open import Definition.Typed.Consequences.Reduction
open import Tools.Product
import Tools.PropositionalEquality as PE
-- Lifting of algorithmic equality of types from WHNF to generic types.
liftConv : ∀ {A B Γ}
→ Γ ⊢ A [conv↓] B
→ Γ ⊢ A [conv↑] B
liftConv A<>B =
let ⊢A , ⊢B = syntacticEq (soundnessConv↓ A<>B)
whnfA , whnfB = whnfConv↓ A<>B
in [↑] _ _ (id ⊢A) (id ⊢B) whnfA whnfB A<>B
-- Lifting of algorithmic equality of terms from WHNF to generic terms.
liftConvTerm : ∀ {t u A Γ}
→ Γ ⊢ t [conv↓] u ∷ A
→ Γ ⊢ t [conv↑] u ∷ A
liftConvTerm t<>u =
let ⊢A , ⊢t , ⊢u = syntacticEqTerm (soundnessConv↓Term t<>u)
whnfA , whnfT , whnfU = whnfConv↓Term t<>u
in [↑]ₜ _ _ _ (id ⊢A) (id ⊢t) (id ⊢u) whnfA whnfT whnfU t<>u
mutual
-- Helper function for lifting from neutrals to generic terms in WHNF.
lift~toConv↓′ : ∀ {t u A A′ Γ l}
→ Γ ⊩⟨ l ⟩ A′
→ Γ ⊢ A′ ⇒* A
→ Γ ⊢ t ~ u ↓ A
→ Γ ⊢ t [conv↓] u ∷ A
lift~toConv↓′ (Uᵣ′ .⁰ 0<1 ⊢Γ) D ([~] A D₁ whnfB k~l)
rewrite PE.sym (whnfRed* D Uₙ) =
let _ , ⊢t , ⊢u = syntacticEqTerm (conv (soundness~↑ k~l) (subset* D₁))
in univ ⊢t ⊢u (ne ([~] A D₁ Uₙ k~l))
lift~toConv↓′ (ℕᵣ D) D₁ ([~] A D₂ whnfB k~l)
rewrite PE.sym (whrDet* (red D , ℕₙ) (D₁ , whnfB)) =
ℕ-ins ([~] A D₂ ℕₙ k~l)
lift~toConv↓′ (Emptyᵣ D) D₁ ([~] A D₂ whnfB k~l)
rewrite PE.sym (whrDet* (red D , Emptyₙ) (D₁ , whnfB)) =
Empty-ins ([~] A D₂ Emptyₙ k~l)
lift~toConv↓′ (Unitᵣ D) D₁ ([~] A D₂ whnfB k~l)
rewrite PE.sym (whrDet* (red D , Unitₙ) (D₁ , whnfB)) =
Unit-ins ([~] A D₂ Unitₙ k~l)
lift~toConv↓′ (ne′ K D neK K≡K) D₁ ([~] A D₂ whnfB k~l)
rewrite PE.sym (whrDet* (red D , ne neK) (D₁ , whnfB)) =
let _ , ⊢t , ⊢u = syntacticEqTerm (soundness~↑ k~l)
A≡K = subset* D₂
in ne-ins (conv ⊢t A≡K) (conv ⊢u A≡K) neK ([~] A D₂ (ne neK) k~l)
lift~toConv↓′ (Πᵣ′ F G D ⊢F ⊢G A≡A [F] [G] G-ext) D₁ ([~] A D₂ whnfB k~l)
rewrite PE.sym (whrDet* (red D , Πₙ) (D₁ , whnfB)) =
let ⊢ΠFG , ⊢t , ⊢u = syntacticEqTerm (soundness~↓ ([~] A D₂ Πₙ k~l))
⊢F , ⊢G = syntacticΠ ⊢ΠFG
neT , neU = ne~↑ k~l
⊢Γ = wf ⊢F
var0 = neuTerm ([F] (step id) (⊢Γ ∙ ⊢F)) (var 0) (var (⊢Γ ∙ ⊢F) here)
(refl (var (⊢Γ ∙ ⊢F) here))
0≡0 = lift~toConv↑′ ([F] (step id) (⊢Γ ∙ ⊢F)) (var-refl (var (⊢Γ ∙ ⊢F) here) PE.refl)
k∘0≡l∘0 = lift~toConv↑′ ([G] (step id) (⊢Γ ∙ ⊢F) var0)
(app-cong (wk~↓ (step id) (⊢Γ ∙ ⊢F) ([~] A D₂ Πₙ k~l))
0≡0)
in η-eq ⊢t ⊢u (ne neT) (ne neU)
(PE.subst (λ x → _ ⊢ _ [conv↑] _ ∷ x)
(wkSingleSubstId _)
k∘0≡l∘0)
lift~toConv↓′ (Σᵣ′ F G D ⊢F ⊢G Σ≡Σ [F] [G] G-ext) D₁ ([~] A″ D₂ whnfA t~u)
rewrite PE.sym (whrDet* (red D , Σₙ) (D₁ , whnfA)) {- Σ F ▹ G ≡ A -} =
let neT , neU = ne~↑ t~u
t~u↓ = [~] A″ D₂ Σₙ t~u
⊢ΣFG , ⊢t , ⊢u = syntacticEqTerm (soundness~↓ t~u↓)
⊢F , ⊢G = syntacticΣ ⊢ΣFG
⊢Γ = wf ⊢F
wkId = wk-id F
wkLiftId = PE.cong (λ x → x [ fst _ ]) (wk-lift-id G)
wk[F] = [F] id ⊢Γ
wk⊢fst = PE.subst (λ x → _ ⊢ _ ∷ x) (PE.sym wkId) (fstⱼ ⊢F ⊢G ⊢t)
wkfst≡ = PE.subst (λ x → _ ⊢ _ ≡ _ ∷ x) (PE.sym wkId) (fst-cong ⊢F ⊢G (refl ⊢t))
wk[fst] = neuTerm wk[F] (fstₙ neT) wk⊢fst wkfst≡
wk[Gfst] = [G] id ⊢Γ wk[fst]
wkfst~ = PE.subst (λ x → _ ⊢ _ ~ _ ↑ x) (PE.sym wkId) (fst-cong t~u↓)
wksnd~ = PE.subst (λ x → _ ⊢ _ ~ _ ↑ x) (PE.sym wkLiftId) (snd-cong t~u↓)
in Σ-η ⊢t ⊢u (ne neT) (ne neU)
(PE.subst (λ x → _ ⊢ _ [conv↑] _ ∷ x) wkId
(lift~toConv↑′ wk[F] wkfst~))
(PE.subst (λ x → _ ⊢ _ [conv↑] _ ∷ x) wkLiftId
(lift~toConv↑′ wk[Gfst] wksnd~))
lift~toConv↓′ (emb 0<1 [A]) D t~u = lift~toConv↓′ [A] D t~u
-- Helper function for lifting from neutrals to generic terms.
lift~toConv↑′ : ∀ {t u A Γ l}
→ Γ ⊩⟨ l ⟩ A
→ Γ ⊢ t ~ u ↑ A
→ Γ ⊢ t [conv↑] u ∷ A
lift~toConv↑′ [A] t~u =
let B , whnfB , D = whNorm′ [A]
t~u↓ = [~] _ (red D) whnfB t~u
neT , neU = ne~↑ t~u
_ , ⊢t , ⊢u = syntacticEqTerm (soundness~↓ t~u↓)
in [↑]ₜ _ _ _ (red D) (id ⊢t) (id ⊢u) whnfB
(ne neT) (ne neU) (lift~toConv↓′ [A] (red D) t~u↓)
-- Lifting of algorithmic equality of terms from neutrals to generic terms in WHNF.
lift~toConv↓ : ∀ {t u A Γ}
→ Γ ⊢ t ~ u ↓ A
→ Γ ⊢ t [conv↓] u ∷ A
lift~toConv↓ ([~] A₁ D whnfB k~l) =
lift~toConv↓′ (reducible (proj₁ (syntacticRed D))) D ([~] A₁ D whnfB k~l)
-- Lifting of algorithmic equality of terms from neutrals to generic terms.
lift~toConv↑ : ∀ {t u A Γ}
→ Γ ⊢ t ~ u ↑ A
→ Γ ⊢ t [conv↑] u ∷ A
lift~toConv↑ t~u =
lift~toConv↑′ (reducible (proj₁ (syntacticEqTerm (soundness~↑ t~u)))) t~u
| {
"alphanum_fraction": 0.5187554019,
"avg_line_length": 42.2262773723,
"ext": "agda",
"hexsha": "0fdec27f1a2e23991a56f402bc72962a4496fae7",
"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/Conversion/Lift.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/Conversion/Lift.agda",
"max_line_length": 93,
"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/Conversion/Lift.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2430,
"size": 5785
} |
{-# OPTIONS --without-K #-}
open import Types
open import Functions
module Paths where
-- Identity type
infix 4 _≡_ -- \equiv
data _≡_ {i} {A : Set i} (a : A) : A → Set i where
refl : a ≡ a
_==_ = _≡_
_≢_ : ∀ {i} {A : Set i} → (A → A → Set i)
x ≢ y = ¬ (x ≡ y)
-- -- This should not be provable
-- K : {A : Set} → (x : A) → (p : x ≡ x) → p ≡ refl x
-- K .x (refl x) = refl
-- Composition and opposite of paths
infixr 8 _∘_ -- \o
_∘_ : ∀ {i} {A : Set i} {x y z : A} → (x ≡ y → y ≡ z → x ≡ z)
refl ∘ q = q
-- Composition with the opposite definitional behaviour
_∘'_ : ∀ {i} {A : Set i} {x y z : A} → (x ≡ y → y ≡ z → x ≡ z)
q ∘' refl = q
! : ∀ {i} {A : Set i} {x y : A} → (x ≡ y → y ≡ x)
! refl = refl
-- Equational reasoning combinator
infix 2 _∎
infixr 2 _≡⟨_⟩_
_≡⟨_⟩_ : ∀ {i} {A : Set i} (x : A) {y z : A} → x ≡ y → y ≡ z → x ≡ z
_ ≡⟨ p1 ⟩ p2 = p1 ∘ p2
_∎ : ∀ {i} {A : Set i} (x : A) → x ≡ x
_∎ _ = refl
-- Obsolete, for retrocompatibility only
infixr 2 _≡⟨_⟩∎_
_≡⟨_⟩∎_ : ∀ {i} {A : Set i} (x : A) {y z : A} → x ≡ y → y ≡ z → x ≡ z
_≡⟨_⟩∎_ = _≡⟨_⟩_
-- Transport and ap
ap : ∀ {i j} {A : Set i} {B : Set j} (f : A → B) {x y : A}
→ (x ≡ y → f x ≡ f y)
ap f refl = refl
-- Make equational reasoning much more readable
syntax ap f p = p |in-ctx f
transport : ∀ {i j} {A : Set i} (P : A → Set j) {x y : A}
→ (x ≡ y → P x → P y)
transport P refl t = t
apd : ∀ {i j} {A : Set i} {P : A → Set j} (f : (a : A) → P a) {x y : A}
→ (p : x ≡ y) → transport P p (f x) ≡ f y
apd f refl = refl
apd! : ∀ {i j} {A : Set i} {P : A → Set j} (f : (a : A) → P a) {x y : A}
→ (p : x ≡ y) → f x ≡ transport P (! p) (f y)
apd! f refl = refl
-- Paths in Sigma types
module _ {i j} {A : Set i} {P : A → Set j} where
ap2 : ∀ {k} {Q : Set k} (f : (a : A) → P a → Q)
{x y : A} (p : x ≡ y) {u : P x} {v : P y}
(q : transport P p u ≡ v) → f x u ≡ f y v
ap2 f refl refl = refl
Σ-eq : {x y : A} (p : x ≡ y) {u : P x} {v : P y}
(q : transport P p u ≡ v) → (x , u) ≡ (y , v)
Σ-eq = ap2 _,_
-- Same as [Σ-eq] but with only one argument
total-Σ-eq : {xu yv : Σ A P}
(q : Σ (π₁ xu ≡ π₁ yv) (λ p → transport P p (π₂ xu) ≡ (π₂ yv)))
→ xu ≡ yv
total-Σ-eq (p , q) = Σ-eq p q
base-path : {x y : Σ A P} (p : x ≡ y) → π₁ x ≡ π₁ y
base-path = ap π₁
trans-base-path : {x y : Σ A P} (p : x ≡ y)
→ transport P (base-path p) (π₂ x) ≡ π₂ y
trans-base-path {_} {._} refl = refl
fiber-path : {x y : Σ A P} (p : x ≡ y)
→ transport P (base-path p) (π₂ x) ≡ π₂ y
fiber-path {x} {.x} refl = refl
abstract
base-path-Σ-eq : {x y : A} (p : x ≡ y) {u : P x} {v : P y}
(q : transport P p u ≡ v) → base-path (Σ-eq p q) ≡ p
base-path-Σ-eq refl refl = refl
fiber-path-Σ-eq : {x y : A} (p : x ≡ y) {u : P x} {v : P y}
(q : transport P p u ≡ v)
→ transport (λ t → transport P t u ≡ v) (base-path-Σ-eq p q)
(fiber-path (Σ-eq p q))
≡ q
fiber-path-Σ-eq refl refl = refl
Σ-eq-base-path-fiber-path : {x y : Σ A P} (p : x ≡ y)
→ Σ-eq (base-path p) (fiber-path p) ≡ p
Σ-eq-base-path-fiber-path {x} {.x} refl = refl
-- Some of the ∞-groupoid structure
module _ {i} {A : Set i} where
concat-assoc : {x y z t : A} (p : x ≡ y) (q : y ≡ z) (r : z ≡ t)
→ (p ∘ q) ∘ r ≡ p ∘ (q ∘ r)
concat-assoc refl _ _ = refl
-- [refl-left-unit] for _∘_ and [refl-right-unit] for _∘'_ are definitional
refl-right-unit : {x y : A} (q : x ≡ y) → q ∘ refl ≡ q
refl-right-unit refl = refl
refl-left-unit : {x y : A} (q : x ≡ y) → refl ∘' q ≡ q
refl-left-unit refl = refl
opposite-left-inverse : {x y : A} (p : x ≡ y) → (! p) ∘ p ≡ refl
opposite-left-inverse refl = refl
opposite-right-inverse : {x y : A} (p : x ≡ y) → p ∘ (! p) ≡ refl
opposite-right-inverse refl = refl
-- This is useless in the presence of ap & equation reasioning combinators
whisker-left : {x y z : A} (p : x ≡ y) {q r : y ≡ z}
→ (q ≡ r → p ∘ q ≡ p ∘ r)
whisker-left p refl = refl
-- This is useless in the presence of ap & equation reasioning combinators
whisker-right : {x y z : A} (p : y ≡ z) {q r : x ≡ y}
→ (q ≡ r → q ∘ p ≡ r ∘ p)
whisker-right p refl = refl
anti-whisker-right : {x y z : A} (p : y ≡ z) {q r : x ≡ y}
→ (q ∘ p ≡ r ∘ p → q ≡ r)
anti-whisker-right refl {q} {r} h =
! (refl-right-unit q) ∘ (h ∘ refl-right-unit r)
anti-whisker-left : {x y z : A} (p : x ≡ y) {q r : y ≡ z}
→ (p ∘ q ≡ p ∘ r → q ≡ r)
anti-whisker-left refl h = h
-- [opposite-concat …] gives a result of the form [opposite (concat …) ≡ …],
-- and so on
opposite-concat : {x y z : A} (p : x ≡ y) (q : y ≡ z) → ! (p ∘ q) ≡ ! q ∘ ! p
opposite-concat refl q = ! (refl-right-unit (! q))
concat-opposite : {x y z : A} (q : y ≡ z) (p : x ≡ y) → ! q ∘ ! p ≡ ! (p ∘ q)
concat-opposite q refl = refl-right-unit (! q)
opposite-opposite : {x y : A} (p : x ≡ y) → ! (! p) ≡ p
opposite-opposite refl = refl
-- Reduction rules for transport
module _ {i} {A : Set i} where
-- This first part is about transporting something in a known fibration. In
-- the names, [x] represents the variable of the fibration, [a] is a constant
-- term, [A] is a constant type, and [f] and [g] are constant functions.
trans-id≡cst : {a b c : A} (p : b ≡ c) (q : b ≡ a)
→ transport (λ x → x ≡ a) p q ≡ (! p) ∘ q
trans-id≡cst refl q = refl
trans-cst≡id : {a b c : A} (p : b ≡ c) (q : a ≡ b)
→ transport (λ x → a ≡ x) p q ≡ q ∘ p
trans-cst≡id refl q = ! (refl-right-unit q)
trans-app≡app : ∀ {j} {B : Set j} (f g : A → B) {x y : A} (p : x ≡ y)
(q : f x ≡ g x)
→ transport (λ x → f x ≡ g x) p q ≡ ! (ap f p) ∘ (q ∘ ap g p)
trans-app≡app f g refl q = ! (refl-right-unit q)
trans-move-app≡app : ∀ {j} {B : Set j} (f g : A → B) {x y : A} (p : x ≡ y)
(q : f x ≡ g x) {r : f y ≡ g y}
→ (q ∘ ap g p ≡ ap f p ∘ r → transport (λ x → f x ≡ g x) p q ≡ r)
trans-move-app≡app f g refl q h = ! (refl-right-unit q) ∘ h
trans-cst≡app : ∀ {j} {B : Set j} (a : B) (f : A → B) {x y : A} (p : x ≡ y)
(q : a ≡ f x)
→ transport (λ x → a ≡ f x) p q ≡ q ∘ ap f p
trans-cst≡app a f refl q = ! (refl-right-unit q)
trans-app≡cst : ∀ {j} {B : Set j} (f : A → B) (a : B) {x y : A} (p : x ≡ y)
(q : f x ≡ a)
→ transport (λ x → f x ≡ a) p q ≡ ! (ap f p) ∘ q
trans-app≡cst f a refl q = refl
trans-id≡app : (f : A → A) {x y : A} (p : x ≡ y) (q : x ≡ f x)
→ transport (λ x → x ≡ f x) p q ≡ ! p ∘ (q ∘ ap f p)
trans-id≡app f refl q = ! (refl-right-unit q)
trans-app≡id : (f : A → A) {x y : A} (p : x ≡ y) (q : f x ≡ x)
→ transport (λ x → f x ≡ x) p q ≡ ! (ap f p) ∘ (q ∘ p)
trans-app≡id f refl q = ! (refl-right-unit q)
trans-id≡id : {x y : A} (p : x ≡ y) (q : x ≡ x)
→ transport (λ x → x ≡ x) p q ≡ ! p ∘ (q ∘ p)
trans-id≡id refl q = ! (refl-right-unit _)
trans-cst : ∀ {j} {B : Set j} {x y : A} (p : x ≡ y) (q : B)
→ transport (λ _ → B) p q ≡ q
trans-cst refl q = refl
trans-Π2 : ∀ {j k} (B : Set j) (P : (x : A) (y : B) → Set k)
{b c : A} (p : b ≡ c) (q : (y : B) → P b y) (a : B)
→ transport (λ x → ((y : B) → P x y)) p q a
≡ transport (λ u → P u a) p (q a)
trans-Π2 B P refl q a = refl
trans-Π2-dep : ∀ {j k} (B : A → Set j) (P : (x : A) (y : B x) → Set k)
{a₁ a₂ : A} (p : a₁ ≡ a₂) (q : (y : B a₁) → P a₁ y) (b : B a₂)
→ transport (λ x → ((y : B x) → P x y)) p q b
≡ transport (uncurry P) (! (Σ-eq (! p) $ refl)) (q (transport B (! p) b))
trans-Π2-dep B P refl q b = refl
trans-→-trans : ∀ {j k} (B : A → Set j) (P : A → Set k)
{b c : A} (p : b ≡ c) (q : B b → P b) (a : B b)
→ transport (λ x → B x → P x) p q (transport B p a)
≡ transport P p (q a)
trans-→-trans B P refl q a = refl
trans-→ : ∀ {j k} (B : A → Set j) (P : A → Set k)
{b c : A} (p : b ≡ c) (q : B b → P b) (a : B c)
→ transport (λ x → B x → P x) p q a
≡ transport P p (q $ transport B (! p) a)
trans-→ B P refl q a = refl
-- This second part is about transporting something along a known path
trans-diag : ∀ {j} (P : A → A → Set j) {x y : A} (p : x ≡ y) (q : P x x)
→ transport (λ x → P x x) p q ≡ transport (λ z → P z y) p (transport (P x) p q)
trans-diag P refl q = refl
trans-concat : ∀ {j} (P : A → Set j) {x y z : A} (p : y ≡ z) (q : x ≡ y)
(u : P x)
→ transport P (q ∘ p) u ≡ transport P p (transport P q u)
trans-concat P p refl u = refl
compose-trans : ∀ {j} (P : A → Set j) {x y z : A} (p : y ≡ z) (q : x ≡ y)
(u : P x)
→ transport P p (transport P q u) ≡ transport P (q ∘ p) u
compose-trans P p refl u = refl
trans-ap : ∀ {j k} {B : Set j} (P : B → Set k) (f : A → B)
{x y : A} (p : x ≡ y) (u : P (f x))
→ transport P (ap f p) u ≡ transport (P ◯ f) p u
trans-ap P f refl u = refl
-- Unreadable, should be removed
trans-totalpath : ∀ {j k} (P : A → Set j) (Q : Σ A P → Set k) {x y : Σ A P}
(p : π₁ x ≡ π₁ y) (q : transport P p (π₂ x) ≡ π₂ y)
(f : (t : P (π₁ x)) → Q (π₁ x , t))
→ transport Q (Σ-eq p q) (f (π₂ x)) ≡
transport (λ x' → Q (π₁ y , x')) q
(transport (λ x' → (t : P x') → Q (x' , t)) p f
(transport P p (π₂ x)))
trans-totalpath P Q {(x₁ , x₂)} {(y₁ , y₂)} p q f =
trans-totalpath' P Q {x₁} {y₁} {x₂} {y₂} p q f where
trans-totalpath' : ∀ {j k} (P : A → Set j) (Q : Σ A P → Set k) {x₁ y₁ : A}
{x₂ : P x₁} {y₂ : P y₁}
(p : x₁ ≡ y₁) (q : transport P p (x₂) ≡ y₂) (f : (t : P x₁) → Q (x₁ , t))
→ transport Q (Σ-eq p q) (f x₂) ≡
transport (λ x' → Q (y₁ , x')) q
(transport (λ x' → (t : P x') → Q (x' , t)) p f
(transport P p x₂))
trans-totalpath' P Q refl refl f = refl
-- This third part is about various other convenient properties
trans-trans-opposite : ∀ {j} (P : A → Set j) {x y : A} (p : x ≡ y) (u : P y)
→ transport P p (transport P (! p) u) ≡ u
trans-trans-opposite P refl u = refl
trans-opposite-trans : ∀ {j} (P : A → Set j) {x y : A} (p : x ≡ y) (u : P x)
→ transport P (! p) (transport P p u) ≡ u
trans-opposite-trans P refl u = refl
ap-dep-trivial : ∀ {j} {B : Set j} (f : A → B) {x y : A} (p : x ≡ y)
→ ap f p ≡ ! (trans-cst p (f x)) ∘ apd f p
ap-dep-trivial f refl = refl
homotopy-naturality : ∀ {j} {B : Set j} (f g : A → B)
(p : (x : A) → f x ≡ g x) {x y : A} (q : x ≡ y)
→ ap f q ∘ p y ≡ p x ∘ ap g q
homotopy-naturality f g p refl = ! (refl-right-unit _)
homotopy-naturality-toid : (f : A -> A) (p : (x : A) → f x ≡ x)
{x y : A} (q : x ≡ y) → ap f q ∘ p y ≡ p x ∘ q
homotopy-naturality-toid f p refl = ! (refl-right-unit _)
homotopy-naturality-fromid : (g : A -> A) (p : (x : A) → x ≡ g x)
{x y : A} (q : x ≡ y) → q ∘ p y ≡ p x ∘ ap g q
homotopy-naturality-fromid g p refl = ! (refl-right-unit _)
opposite-ap : ∀ {j} {B : Set j} (f : A → B) {x y : A} (p : x ≡ y)
→ ! (ap f p) ≡ ap f (! p)
opposite-ap f refl = refl
ap-opposite : ∀ {j} {B : Set j} (f : A → B) {x y : A} (p : x ≡ y)
→ ap f (! p) ≡ ! (ap f p)
ap-opposite f refl = refl
concat-ap : ∀ {j} {B : Set j} (f : A → B) {x y z : A} (p : x ≡ y) (q : y ≡ z)
→ ap f p ∘ ap f q ≡ ap f (p ∘ q)
concat-ap f refl _ = refl
ap-concat : ∀ {j} {B : Set j} (f : A → B) {x y z : A} (p : x ≡ y) (q : y ≡ z)
→ ap f (p ∘ q) ≡ ap f p ∘ ap f q
ap-concat f refl _ = refl
compose-ap : ∀ {j k} {B : Set j} {C : Set k} (g : B → C) (f : A → B)
{x y : A} (p : x ≡ y) → ap g (ap f p) ≡ ap (g ◯ f) p
compose-ap f g refl = refl
ap-compose : ∀ {j k} {B : Set j} {C : Set k} (g : B → C) (f : A → B)
{x y : A} (p : x ≡ y) → ap (g ◯ f) p ≡ ap g (ap f p)
ap-compose f g refl = refl
ap-cst : ∀ {j} {B : Set j} (b : B) {x y : A} (p : x ≡ y)
→ ap (cst b) p ≡ refl
ap-cst b refl = refl
ap-id : {u v : A} (p : u ≡ v) → ap (id A) p ≡ p
ap-id refl = refl
app-trans : ∀ {j k} (B : A → Set j) (C : A → Set k) (f : ∀ x → B x → C x)
{x y} (p : x ≡ y) (a : B x)
→ f y (transport B p a) ≡ transport C p (f x a)
app-trans B C f refl a = refl
-- Move functions
-- These functions are used when the goal is to show that path is a
-- concatenation of two other paths, and that you want to prove it by moving a
-- path to the other side
--
-- The first [left/right] is the side (with respect to ≡) where will be the
-- path after moving (“after” means “after replacing the conclusion of the
-- proposition by its premisse”), and the second [left/right] is the side
-- (with respect to ∘) where the path is (and will still be)
-- If you want to prove something of the form [p ≡ q ∘ r] by moving [q] or [r]
-- to the left, use the functions move-left-on-left and move-left-on-right
-- If you want to prove something of the form [p ∘ q ≡ r] by moving [p] or [q]
-- to the right, use the functions move-right-on-left and move-right-on-right
-- Add a [0] after [move] if the big path is constant, a [1] if the other
-- small path is constant and then a [!] if the path you will move is an
-- opposite.
--
-- I’m not sure all of these functions are useful, but it can’t hurt to have
-- them.
move-left-on-left : {x y z : A} (p : x ≡ z) (q : x ≡ y) (r : y ≡ z)
→ ((! q) ∘ p ≡ r → p ≡ q ∘ r)
move-left-on-left p refl r h = h
move-left-on-right : {x y z : A} (p : x ≡ z) (q : x ≡ y) (r : y ≡ z)
→ (p ∘ (! r) ≡ q → p ≡ q ∘ r)
move-left-on-right p q refl h = ! (refl-right-unit p)
∘ (h ∘ ! (refl-right-unit q))
move-right-on-left : {x y z : A} (p : x ≡ y) (q : y ≡ z) (r : x ≡ z)
→ (q ≡ (! p) ∘ r → p ∘ q ≡ r)
move-right-on-left refl q r h = h
move-right-on-right : {x y z : A} (p : x ≡ y) (q : y ≡ z) (r : x ≡ z)
→ (p ≡ r ∘ (! q) → p ∘ q ≡ r)
move-right-on-right p refl r h = refl-right-unit p
∘ (h ∘ refl-right-unit r)
move!-left-on-left : {x y z : A} (p : x ≡ z) (q : y ≡ x) (r : y ≡ z)
→ (q ∘ p ≡ r → p ≡ (! q) ∘ r)
move!-left-on-left p refl r h = h
move!-left-on-right : {x y z : A} (p : x ≡ z) (q : x ≡ y) (r : z ≡ y)
→ (p ∘ r ≡ q → p ≡ q ∘ (! r))
move!-left-on-right p q refl h = ! (refl-right-unit p)
∘ (h ∘ ! (refl-right-unit q))
move!-right-on-left : {x y z : A} (p : y ≡ x) (q : y ≡ z) (r : x ≡ z)
→ (q ≡ p ∘ r → (! p) ∘ q ≡ r)
move!-right-on-left refl q r h = h
move!-right-on-right : {x y z : A} (p : x ≡ y) (q : z ≡ y) (r : x ≡ z)
→ (p ≡ r ∘ q → p ∘ (! q) ≡ r)
move!-right-on-right p refl r h = refl-right-unit p
∘ (h ∘ refl-right-unit r)
move0-left-on-left : {x y : A} (q : x ≡ y) (r : y ≡ x)
→ (! q ≡ r → refl ≡ q ∘ r)
move0-left-on-left refl r h = h
move0-left-on-right : {x y : A} (q : x ≡ y) (r : y ≡ x)
→ (! r ≡ q → refl ≡ q ∘ r)
move0-left-on-right q refl h = h ∘ ! (refl-right-unit q)
move0-right-on-left : {x y : A} (p : x ≡ y) (q : y ≡ x)
→ (q ≡ ! p → p ∘ q ≡ refl)
move0-right-on-left refl q h = h
move0-right-on-right : {x y : A} (p : x ≡ y) (q : y ≡ x)
→ (p ≡ ! q → p ∘ q ≡ refl)
move0-right-on-right p refl h = refl-right-unit p ∘ h
move0!-left-on-left : {x y : A} (q : y ≡ x) (r : y ≡ x)
→ (q ≡ r → refl ≡ (! q) ∘ r)
move0!-left-on-left refl r h = h
move0!-left-on-right : {x y : A} (q : x ≡ y) (r : x ≡ y)
→ (r ≡ q → refl ≡ q ∘ (! r))
move0!-left-on-right q refl h = h ∘ ! (refl-right-unit q)
move0!-right-on-left : {x y : A} (p : y ≡ x) (q : y ≡ x)
→ (q ≡ p → (! p) ∘ q ≡ refl)
move0!-right-on-left refl q h = h
move0!-right-on-right : {x y : A} (p : x ≡ y) (q : x ≡ y)
→ (p ≡ q → p ∘ (! q) ≡ refl)
move0!-right-on-right p refl h = refl-right-unit p ∘ h
move1-left-on-left : {x y : A} (p : x ≡ y) (q : x ≡ y)
→ ((! q) ∘ p ≡ refl → p ≡ q)
move1-left-on-left p refl h = h
move1-left-on-right : {x y : A} (p : x ≡ y) (r : x ≡ y)
→ (p ∘ (! r) ≡ refl → p ≡ r)
move1-left-on-right p refl h = ! (refl-right-unit p) ∘ h
move1-right-on-left : {x y : A} (p : x ≡ y) (r : x ≡ y)
→ (refl ≡ (! p) ∘ r → p ≡ r)
move1-right-on-left refl r h = h
move1-right-on-right : {x y : A} (q : x ≡ y) (r : x ≡ y)
→ (refl ≡ r ∘ (! q) → q ≡ r)
move1-right-on-right refl r h = h ∘ refl-right-unit r
move1!-left-on-left : {x y : A} (p : x ≡ y) (q : y ≡ x)
→ (q ∘ p ≡ refl → p ≡ ! q)
move1!-left-on-left p refl h = h
move1!-left-on-right : {x y : A} (p : x ≡ y) (r : y ≡ x)
→ (p ∘ r ≡ refl → p ≡ ! r)
move1!-left-on-right p refl h = ! (refl-right-unit p) ∘ h
move1!-right-on-left : {x y : A} (p : y ≡ x) (r : x ≡ y)
→ (refl ≡ p ∘ r → ! p ≡ r)
move1!-right-on-left refl r h = h
move1!-right-on-right : {x y : A} (q : y ≡ x) (r : x ≡ y)
→ (refl ≡ r ∘ q → ! q ≡ r)
move1!-right-on-right refl r h = h ∘ refl-right-unit r
move-transp-left : ∀ {j} (P : A → Set j) {x y : A} (u : P y) (p : x ≡ y)
(v : P x)
→ transport P (! p) u ≡ v → u ≡ transport P p v
move-transp-left P _ refl _ p = p
move-transp-right : ∀ {j} (P : A → Set j) {x y : A} (p : y ≡ x) (u : P y)
(v : P x)
→ u ≡ transport P (! p) v → transport P p u ≡ v
move-transp-right P refl _ _ p = p
move!-transp-left : ∀ {j} (P : A → Set j) {x y : A} (u : P y) (p : y ≡ x)
(v : P x)
→ transport P p u ≡ v → u ≡ transport P (! p) v
move!-transp-left P _ refl _ p = p
move!-transp-right : ∀ {j} (P : A → Set j) {x y : A} (p : x ≡ y) (u : P y)
(v : P x)
→ u ≡ transport P p v → transport P (! p) u ≡ v
move!-transp-right P refl _ _ p = p
| {
"alphanum_fraction": 0.4721000628,
"avg_line_length": 35.587398374,
"ext": "agda",
"hexsha": "19ee748e216b6c81cded149d4c55f8038d56e70c",
"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": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nicolaikraus/HoTT-Agda",
"max_forks_repo_path": "old/Paths.agda",
"max_issues_count": 31,
"max_issues_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"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": "nicolaikraus/HoTT-Agda",
"max_issues_repo_path": "old/Paths.agda",
"max_line_length": 83,
"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": "old/Paths.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": 7787,
"size": 17509
} |
-- Andreas, 2016-10-09, issue #2223
-- The level constraint solver needs to combine constraints
-- from different contexts and modules.
-- The parameter refinement broke this test case.
-- {-# OPTIONS -v tc.with.top:25 #-}
-- {-# OPTIONS -v tc.conv.nat:40 #-}
-- {-# OPTIONS -v tc.constr.add:45 #-}
open import Common.Level
module _ (a ℓ : Level) where
mutual
X : Level
X = _
data D : Set (lsuc a) where
c : Set X → D -- X <= a
test : Set₁
test with (lsuc ℓ) -- failed
... | _ = Set
-- test = Set -- works
where
data C : Set (lsuc X) where
c : Set a → C -- a <= X
-- Should solve all metas.
| {
"alphanum_fraction": 0.567322239,
"avg_line_length": 20.65625,
"ext": "agda",
"hexsha": "809a34375e03dbb1ddc6a3c952c2b98de9b036b7",
"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/Issue2223.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/Issue2223.agda",
"max_line_length": 59,
"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/Issue2223.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": 200,
"size": 661
} |
{-# OPTIONS --cubical --safe --postfix-projections #-}
module Data.Nat.Order where
open import Prelude
open import Data.Nat.Properties
open import Relation.Binary
<-trans : Transitive _<_
<-trans {zero} {suc y} {suc z} x<y y<z = tt
<-trans {suc x} {suc y} {suc z} x<y y<z = <-trans {x} {y} {z} x<y y<z
<-asym : Asymmetric _<_
<-asym {suc x} {suc y} x<y y<x = <-asym {x} {y} x<y y<x
<-irrefl : Irreflexive _<_
<-irrefl {suc x} = <-irrefl {x = x}
<-conn : Connected _<_
<-conn {zero} {zero} x≮y y≮x = refl
<-conn {zero} {suc y} x≮y y≮x = ⊥-elim (x≮y tt)
<-conn {suc x} {zero} x≮y y≮x = ⊥-elim (y≮x tt)
<-conn {suc x} {suc y} x≮y y≮x = cong suc (<-conn x≮y y≮x)
≤-antisym : Antisymmetric _≤_
≤-antisym {zero} {zero} x≤y y≤x = refl
≤-antisym {suc x} {suc y} x≤y y≤x = cong suc (≤-antisym x≤y y≤x)
ℕ-≰⇒> : ∀ x y → ¬ (x ≤ y) → y < x
ℕ-≰⇒> x y x≰y with y <ᴮ x
... | false = x≰y tt
... | true = tt
ℕ-≮⇒≥ : ∀ x y → ¬ (x < y) → y ≤ x
ℕ-≮⇒≥ x y x≮y with x <ᴮ y
... | false = tt
... | true = x≮y tt
totalOrder : TotalOrder ℕ ℓzero ℓzero
totalOrder .TotalOrder.strictPartialOrder .StrictPartialOrder.strictPreorder .StrictPreorder._<_ = _<_
totalOrder .TotalOrder.strictPartialOrder .StrictPartialOrder.strictPreorder .StrictPreorder.trans {x} {y} {z} = <-trans {x} {y} {z}
totalOrder .TotalOrder.strictPartialOrder .StrictPartialOrder.strictPreorder .StrictPreorder.irrefl {x} = <-irrefl {x = x}
totalOrder .TotalOrder.strictPartialOrder .StrictPartialOrder.conn = <-conn
totalOrder .TotalOrder.partialOrder .PartialOrder.preorder .Preorder._≤_ = _≤_
totalOrder .TotalOrder.partialOrder .PartialOrder.preorder .Preorder.refl {x} = ≤-refl x
totalOrder .TotalOrder.partialOrder .PartialOrder.preorder .Preorder.trans {x} {y} {z} = ≤-trans x y z
totalOrder .TotalOrder.partialOrder .PartialOrder.antisym = ≤-antisym
totalOrder .TotalOrder._<?_ x y = T? (x <ᴮ y)
totalOrder .TotalOrder.≰⇒> {x} {y} = ℕ-≰⇒> x y
totalOrder .TotalOrder.≮⇒≥ {x} {y} = ℕ-≮⇒≥ x y
| {
"alphanum_fraction": 0.6514607893,
"avg_line_length": 38.2549019608,
"ext": "agda",
"hexsha": "2379e1251c1d1e1be575ac976b768729a68a606a",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "oisdk/agda-playground",
"max_forks_repo_path": "Data/Nat/Order.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "oisdk/agda-playground",
"max_issues_repo_path": "Data/Nat/Order.agda",
"max_line_length": 132,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "oisdk/agda-playground",
"max_stars_repo_path": "Data/Nat/Order.agda",
"max_stars_repo_stars_event_max_datetime": "2021-11-16T08:11:34.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-09-11T17:45:41.000Z",
"num_tokens": 824,
"size": 1951
} |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2021, Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.Base.Types
import LibraBFT.Impl.Consensus.ConsensusTypes.Block as Block
import LibraBFT.Impl.Consensus.ConsensusTypes.BlockData as BlockData
import LibraBFT.Impl.Types.BlockInfo as BlockInfo
open import LibraBFT.ImplShared.Base.Types
open import LibraBFT.ImplShared.Consensus.Types
open import LibraBFT.ImplShared.Util.Dijkstra.All
open import Optics.All
open import Util.Encode as Encode
open import Util.Prelude
module LibraBFT.Impl.Consensus.Liveness.ProposalGenerator where
ensureHighestQuorumCertM : Round → LBFT (Either ErrLog QuorumCert)
generateNilBlockM : Round → LBFT (Either ErrLog Block)
generateNilBlockM round =
ensureHighestQuorumCertM round ∙?∙ (ok ∘ Block.newNil round)
generateProposalM : Instant → Round → LBFT (Either ErrLog BlockData)
generateProposalM _now round = do
lrg ← use (lProposalGenerator ∙ pgLastRoundGenerated)
ifD lrg <?ℕ round
then (do
lProposalGenerator ∙ pgLastRoundGenerated ∙= round
ensureHighestQuorumCertM round ∙?∙ λ hqc -> do
payload ← ifD BlockInfo.hasReconfiguration (hqc ^∙ qcCertifiedBlock)
-- IMPL-DIFF : create a fake TX
then pure (Encode.encode 0) -- (Payload [])
else pure (Encode.encode 0) -- use pgTxnManager <*> use (rmEpochState ∙ esEpoch) <*> pure round
use (lRoundManager ∙ pgAuthor) >>= λ where
nothing → bail fakeErr -- ErrL (here ["lRoundManager.pgAuthor", "Nothing"])
(just author) →
ok (BlockData.newProposal payload author round {-pure blockTimestamp <*>-} hqc))
else bail fakeErr
-- where
-- here t = "ProposalGenerator" ∷ "generateProposal" ∷ t
ensureHighestQuorumCertM round = do
hqc ← use (lBlockStore ∙ bsHighestQuorumCert)
ifD‖ (hqc ^∙ qcCertifiedBlock ∙ biRound) ≥?ℕ round ≔
bail fakeErr {- ErrL (here [ "given round is lower than hqc round"
, show (hqc^.qcCertifiedBlock.biRound) ]) -}
‖ hqc ^∙ qcEndsEpoch ≔
bail fakeErr {-ErrEpochEndedNoProposals (here ["further proposals not allowed"])-}
‖ otherwise≔
ok hqc
-- where
-- here t = "ProposalGenerator":"ensureHighestQuorumCertM":lsR round:t
| {
"alphanum_fraction": 0.6827722772,
"avg_line_length": 44.298245614,
"ext": "agda",
"hexsha": "03220a37c9ba8e8cb16e8a2ad2688365256ad822",
"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/Liveness/ProposalGenerator.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/Liveness/ProposalGenerator.agda",
"max_line_length": 117,
"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/Liveness/ProposalGenerator.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 685,
"size": 2525
} |
open import Relation.Binary.Core
module BubbleSort.Everything {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_)
(trans≤ : Transitive _≤_) where
open import BubbleSort.Correctness.Order _≤_ tot≤ trans≤
open import BubbleSort.Correctness.Permutation _≤_ tot≤
| {
"alphanum_fraction": 0.607028754,
"avg_line_length": 31.3,
"ext": "agda",
"hexsha": "e2b8ba63d250220fce85cdaa9ff334fc8ca8bd95",
"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/BubbleSort/Everything.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/BubbleSort/Everything.agda",
"max_line_length": 56,
"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/BubbleSort/Everything.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": 91,
"size": 313
} |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Equivalence.Strong where
-- Strong equivalence of categories. Same as ordinary equivalence in Cat.
-- May not include everything we'd like to think of as equivalences, namely
-- the full, faithful functors that are essentially surjective on objects.
open import Level
open import Relation.Binary using (IsEquivalence; module IsEquivalence)
open import Function using () renaming (_∘_ to _∙_)
open import Categories.Category
open import Categories.Functor hiding (equiv)
open import Categories.NaturalIsomorphism as NI hiding (equiv)
open import Categories.NaturalTransformation as NT hiding (id; equiv)
open import Categories.Morphisms using (Iso; module Iso)
record WeakInverse {o ℓ e o′ ℓ′ e′} {C : Category o ℓ e} {D : Category o′ ℓ′ e′} (F : Functor C D) (G : Functor D C) : Set (o ⊔ ℓ ⊔ e ⊔ o′ ⊔ ℓ′ ⊔ e′) where
field
F∘G≅id : NaturalIsomorphism (F ∘ G) id
G∘F≅id : NaturalIsomorphism (G ∘ F) id
F∘G⇒id = NaturalIsomorphism.F⇒G F∘G≅id
id⇒F∘G = NaturalIsomorphism.F⇐G F∘G≅id
G∘F⇒id = NaturalIsomorphism.F⇒G G∘F≅id
id⇒G∘F = NaturalIsomorphism.F⇐G G∘F≅id
.F∘G-iso : _
F∘G-iso = NaturalIsomorphism.iso F∘G≅id
.F∘G-isoˡ : _
F∘G-isoˡ = λ x → Iso.isoˡ {C = D} (F∘G-iso x)
.F∘G-isoʳ : _
F∘G-isoʳ = λ x → Iso.isoʳ {C = D} (F∘G-iso x)
.G∘F-iso : _
G∘F-iso = NaturalIsomorphism.iso G∘F≅id
.G∘F-isoˡ : _
G∘F-isoˡ = λ x → Iso.isoˡ {C = C} (G∘F-iso x)
.G∘F-isoʳ : _
G∘F-isoʳ = λ x → Iso.isoʳ {C = C} (G∘F-iso x)
record StrongEquivalence {o ℓ e o′ ℓ′ e′} (C : Category o ℓ e) (D : Category o′ ℓ′ e′) : Set (o ⊔ ℓ ⊔ e ⊔ o′ ⊔ ℓ′ ⊔ e′) where
field
F : Functor C D
G : Functor D C
weak-inverse : WeakInverse F G
open WeakInverse weak-inverse public
module Equiv where
refl : ∀ {o ℓ e} {C : Category o ℓ e} → StrongEquivalence C C
refl = record
{ F = id
; G = id
; weak-inverse = record
{ F∘G≅id = IsEquivalence.refl NI.equiv
; G∘F≅id = IsEquivalence.refl NI.equiv
}
}
sym : ∀ {o ℓ e o′ ℓ′ e′} {C : Category o ℓ e} {D : Category o′ ℓ′ e′} → StrongEquivalence C D → StrongEquivalence D C
sym Inv = record
{ F = Inv.G
; G = Inv.F
; weak-inverse = record
{ F∘G≅id = Inv.G∘F≅id
; G∘F≅id = Inv.F∘G≅id
}
}
where
module Inv = StrongEquivalence Inv
trans : ∀ {o₁ ℓ₁ e₁ o₂ ℓ₂ e₂ o₃ ℓ₃ e₃} {C₁ : Category o₁ ℓ₁ e₁} {C₂ : Category o₂ ℓ₂ e₂} {C₃ : Category o₃ ℓ₃ e₃} → StrongEquivalence C₁ C₂ → StrongEquivalence C₂ C₃ → StrongEquivalence C₁ C₃
trans {C₁ = C₁} {C₂} {C₃} A B = record
{ F = B.F ∘ A.F
; G = A.G ∘ B.G
; weak-inverse = record
{ F∘G≅id = IsEquivalence.trans NI.equiv ((B.F ⓘˡ A.F∘G≅id) ⓘʳ B.G) B.F∘G≅id
; G∘F≅id = IsEquivalence.trans NI.equiv ((A.G ⓘˡ B.G∘F≅id) ⓘʳ A.F) A.G∘F≅id
}
}
where
module A = StrongEquivalence A
module B = StrongEquivalence B
equiv : ∀ {o ℓ e} → IsEquivalence (StrongEquivalence {o} {ℓ} {e})
equiv = record { refl = Equiv.refl; sym = Equiv.sym; trans = Equiv.trans }
| {
"alphanum_fraction": 0.6243002963,
"avg_line_length": 36.1547619048,
"ext": "agda",
"hexsha": "c6d12ebfa8e56550ef6ce9578a880b54b2a563f9",
"lang": "Agda",
"max_forks_count": 23,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T13:50:56.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-02-05T13:03:09.000Z",
"max_forks_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "p-pavel/categories",
"max_forks_repo_path": "Categories/Equivalence/Strong.agda",
"max_issues_count": 19,
"max_issues_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2",
"max_issues_repo_issues_event_max_datetime": "2019-08-09T16:31:40.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-05-23T06:47:10.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "p-pavel/categories",
"max_issues_repo_path": "Categories/Equivalence/Strong.agda",
"max_line_length": 193,
"max_stars_count": 98,
"max_stars_repo_head_hexsha": "36f4181d751e2ecb54db219911d8c69afe8ba892",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "copumpkin/categories",
"max_stars_repo_path": "Categories/Equivalence/Strong.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-08T05:20:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-04-15T14:57:33.000Z",
"num_tokens": 1269,
"size": 3037
} |
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.S1 where
open import Cubical.HITs.S1.Base public
-- open import Cubical.HITs.S1.Properties public
| {
"alphanum_fraction": 0.7450980392,
"avg_line_length": 21.8571428571,
"ext": "agda",
"hexsha": "95b7e45bb9c04509043f6c55ab55c2995d2eb1cb",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cj-xu/cubical",
"max_forks_repo_path": "Cubical/HITs/S1.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cj-xu/cubical",
"max_issues_repo_path": "Cubical/HITs/S1.agda",
"max_line_length": 48,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cj-xu/cubical",
"max_stars_repo_path": "Cubical/HITs/S1.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 44,
"size": 153
} |
module Sets.IterativeSet.Relator.Proofs where
import Lvl
open import Data
open import Data.Boolean
open import Data.Boolean.Proofs
open import Data.Boolean.Stmt
open import Data.Boolean.Stmt.Proofs
open import Data.Either as Either using (_‖_)
open import Data.Tuple as Tuple using ()
open import Functional
open import Logic
open import Logic.Propositional
open import Logic.Predicate
open import Numeral.Natural
open import Relator.Equals using () renaming (_≡_ to Id ; [≡]-intro to intro)
open import Sets.IterativeSet.Relator
open import Sets.IterativeSet
open import Structure.Setoid using (Equiv)
open import Structure.Function.Domain
open import Structure.Function
open import Structure.Relator.Equivalence
open import Structure.Relator.Properties
open import Structure.Relator
open import Syntax.Function
open import Syntax.Transitivity
open import Type
open import Type.Dependent
module _ where
private variable {ℓ ℓ₁ ℓ₂} : Lvl.Level
open Iset
instance
[≡][⊆]-sub : (_≡_) ⊆₂ (_⊆_ {ℓ₁}{ℓ₂})
[≡][⊆]-sub = intro [∧]-elimᵣ
instance
[≡][⊇]-sub : (_≡_) ⊆₂ (_⊇_ {ℓ₁}{ℓ₂})
[≡][⊇]-sub = intro [∧]-elimₗ
[≡]-reflexivity-raw : ∀{A : Iset{ℓ}} → (A ≡ A)
[⊆]-reflexivity-raw : ∀{A : Iset{ℓ}} → (A ⊆ A)
[⊇]-reflexivity-raw : ∀{A : Iset{ℓ}} → (A ⊇ A)
[≡]-reflexivity-raw {A = A} = [∧]-intro [⊇]-reflexivity-raw [⊆]-reflexivity-raw
[⊆]-reflexivity-raw {A = set elem} = intro id (\{i} → [≡]-reflexivity-raw {A = elem(i)})
[⊇]-reflexivity-raw = [⊆]-reflexivity-raw
[≡]-symmetry-raw : ∀{A B : Iset{ℓ}} → (A ≡ B) → (B ≡ A)
[≡]-symmetry-raw {A = A}{B = B} ([∧]-intro l r) = [∧]-intro r l
[≡]-transitivity-raw : ∀{A B C : Iset{ℓ}} → (A ≡ B) → (B ≡ C) → (A ≡ C)
[⊆]-transitivity-raw : ∀{A B C : Iset{ℓ}} → (A ⊆ B) → (B ⊆ C) → (A ⊆ C)
[⊇]-transitivity-raw : ∀{A B C : Iset{ℓ}} → (A ⊇ B) → (B ⊇ C) → (A ⊇ C)
Tuple.left ([≡]-transitivity-raw {A = A}{B = B}{C = C} ab bc) = [⊇]-transitivity-raw(Tuple.left ab) (Tuple.left bc)
Tuple.right ([≡]-transitivity-raw {A = A}{B = B}{C = C} ab bc) = [⊆]-transitivity-raw(Tuple.right ab) (Tuple.right bc)
_⊆_.map ([⊆]-transitivity-raw {A = A} {B = B} {C = C} ab bc) = _⊆_.map bc ∘ _⊆_.map ab
_⊆_.proof ([⊆]-transitivity-raw {A = set elemA} {B = set elemB} {C = set elemC} ab bc) {ia} = [≡]-transitivity-raw {A = elemA(ia)}{B = elemB (_⊆_.map ab ia)} {C = elemC((_⊆_.map bc)((_⊆_.map ab)(ia)))} (_⊆_.proof ab {ia}) (_⊆_.proof bc)
[⊇]-transitivity-raw {A = A} {B = B} {C = C} ab bc = [⊆]-transitivity-raw {A = C}{B = B}{C = A} bc ab
instance
[≡]-reflexivity : Reflexivity(_≡_ {ℓ})
[≡]-reflexivity = intro [≡]-reflexivity-raw
instance
[⊆]-reflexivity : Reflexivity(_⊆_ {ℓ})
[⊆]-reflexivity = intro [⊆]-reflexivity-raw
instance
[⊇]-reflexivity : Reflexivity(_⊇_ {ℓ})
[⊇]-reflexivity = intro [⊇]-reflexivity-raw
instance
[≡]-symmetry : Symmetry(_≡_ {ℓ})
[≡]-symmetry = intro [≡]-symmetry-raw
instance
[⊆]-antisymmetry : Antisymmetry(_⊆_ {ℓ})(_≡_)
[⊆]-antisymmetry = intro (swap [∧]-intro)
instance
[⊇]-antisymmetry : Antisymmetry(_⊇_ {ℓ})(_≡_)
[⊇]-antisymmetry = intro [∧]-intro
instance
[≡]-transitivity : Transitivity(_≡_ {ℓ})
[≡]-transitivity = intro [≡]-transitivity-raw
instance
[⊆]-transitivity : Transitivity(_⊆_ {ℓ})
[⊆]-transitivity = intro [⊆]-transitivity-raw
instance
[⊇]-transitivity : Transitivity(_⊇_ {ℓ})
[⊇]-transitivity = intro [⊇]-transitivity-raw
instance
[≡]-equivalence : Equivalence(_≡_ {ℓ})
[≡]-equivalence = intro
instance
Iset-equiv : Equiv(Iset{ℓ})
Equiv._≡_ Iset-equiv = _≡_
Equiv.equivalence Iset-equiv = [≡]-equivalence
Iset-induction : ∀{P : Iset{ℓ₁} → Stmt{ℓ₂}} ⦃ _ : UnaryRelator(P) ⦄ → (∀{A : Iset{ℓ₁}} → (∀{a} → (a ∈ A) → P(a)) → P(A)) → (∀{A : Iset{ℓ₁}} → P(A))
Iset-induction {P = P} p = Iset-index-induction (\{A} pp → p{A} (\{a} aA → substitute₁ₗ(P) ([∃]-proof aA) (pp{[∃]-witness aA})))
[∈]-of-elem : ∀{A : Iset{ℓ}}{ia : Index(A)} → (elem(A)(ia) ∈ A)
∃.witness ([∈]-of-elem {ia = ia}) = ia
∃.proof [∈]-of-elem = [≡]-reflexivity-raw
Iset-intro-self-equality : ∀{A : Iset{ℓ}} → (set{Index = Index(A)}(elem(A)) ≡ A)
_⊆_.map (Tuple.left Iset-intro-self-equality) = id
_⊆_.map (Tuple.right Iset-intro-self-equality) = id
_⊆_.proof (Tuple.left Iset-intro-self-equality) = [≡]-reflexivity-raw
_⊆_.proof (Tuple.right Iset-intro-self-equality) = [≡]-reflexivity-raw
[⊆]-with-elem : ∀{x y : Iset{ℓ}} → (xy : x ⊆ y) → ∀{ix} → (elem x ix ≡ elem y (_⊆_.map xy ix))
[⊆]-with-elem xy {ix} = _⊆_.proof xy {ix}
[⊆]-membership : ∀{A : Iset{ℓ}}{B : Iset{ℓ}} → (∀{x : Iset{ℓ}} → (x ∈ A) → (x ∈ B)) ↔ (A ⊆ B)
[⊆]-membership {A = A}{B = B} = [↔]-intro l r where
l : (∀{x} → (x ∈ A) → (x ∈ B)) ← (A ⊆ B)
∃.witness (l AB {x} xa) = _⊆_.map AB (∃.witness xa)
∃.proof (l AB {x} xa) = [≡]-transitivity-raw (∃.proof xa) (_⊆_.proof AB)
r : (∀{x} → (x ∈ A) → (x ∈ B)) → (A ⊆ B)
_⊆_.map (r proof) ia = [∃]-witness (proof{x = elem(A)(ia)} ([∈]-of-elem {A = A}))
_⊆_.proof (r proof) {ia} = [∃]-proof (proof([∈]-of-elem {A = A}))
[⊇]-membership : ∀{A : Iset{ℓ}}{B : Iset{ℓ}} → (∀{x : Iset{ℓ}} → (x ∈ A) ← (x ∈ B)) ↔ (A ⊇ B)
[⊇]-membership {A = A}{B = B} = [⊆]-membership {A = B}{B = A}
[≡]-membership : ∀{A : Iset{ℓ}}{B : Iset{ℓ}} → (∀{x : Iset{ℓ}} → (x ∈ A) ↔ (x ∈ B)) ↔ (A ≡ B)
Tuple.left (Tuple.left ([≡]-membership {A = A} {B = B}) ab) = [↔]-to-[←] [⊇]-membership (Tuple.left ab)
Tuple.right (Tuple.left ([≡]-membership {A = A} {B = B}) ab) = [↔]-to-[←] [⊆]-membership (Tuple.right ab)
Tuple.left (Tuple.right ([≡]-membership {A = A} {B = B}) xaxb) = [↔]-to-[→] [⊇]-membership ([↔]-to-[←] xaxb)
Tuple.right (Tuple.right ([≡]-membership {A = A} {B = B}) xaxb) = [↔]-to-[→] [⊆]-membership ([↔]-to-[→] xaxb)
[∈]ₗ-unaryRelation-raw : ∀{A₁ A₂ B : Iset{ℓ}} → (A₁ ≡ A₂) → (A₁ ∈ B) → (A₂ ∈ B)
∃.witness ([∈]ₗ-unaryRelation-raw pa ([∃]-intro i ⦃ p ⦄)) = i
∃.proof ([∈]ₗ-unaryRelation-raw pa ([∃]-intro i ⦃ p ⦄)) = [≡]-transitivity-raw ([≡]-symmetry-raw pa) p
[∈]-binaryRelation-raw : ∀{A₁ A₂ B₁ B₂ : Iset{ℓ}} → (A₁ ≡ A₂) → (B₁ ≡ B₂) → ((A₁ ∈ B₁) → (A₂ ∈ B₂))
[∈]-binaryRelation-raw {B₂ = B₂} pa pb = [∈]ₗ-unaryRelation-raw {B = B₂} pa ∘ [↔]-to-[←] [⊆]-membership (sub₂(_≡_)(_⊆_) pb)
instance
[∈]-binaryRelation : BinaryRelator(_∈_ {ℓ})
[∈]-binaryRelation = intro [∈]-binaryRelation-raw
instance
[⊆]-binaryRelator : BinaryRelator(_⊆_ {ℓ}{ℓ})
BinaryRelator.substitution [⊆]-binaryRelator p1 p2 ps = sub₂(_≡_)(_⊇_) p1 🝖 ps 🝖 sub₂(_≡_)(_⊆_) p2
| {
"alphanum_fraction": 0.5653033298,
"avg_line_length": 41.8917197452,
"ext": "agda",
"hexsha": "b72a5537b5ecc2c117e2c811d9f0cb0eb14cc794",
"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": "Sets/IterativeSet/Relator/Proofs.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "Sets/IterativeSet/Relator/Proofs.agda",
"max_line_length": 238,
"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": "Sets/IterativeSet/Relator/Proofs.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-05T06:53:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:58:13.000Z",
"num_tokens": 2969,
"size": 6577
} |
module Pi-Calculus where
-- Local modules ---------------------------------------------------------------
open import Common
using (Id)
-- π-process definition --------------------------------------------------------
data π-process : Set where
recv_from_∙_ : Id → Id → π-process → π-process -- Receive
send_to_∙_ : Id → Id → π-process → π-process -- Send
_||_ : π-process → π-process → π-process -- Composition
ν_∙_ : Id → π-process → π-process -- Restriction
!_ : π-process → π-process -- Repetition
Zero : π-process -- Inactivity
| {
"alphanum_fraction": 0.4217585693,
"avg_line_length": 39.4705882353,
"ext": "agda",
"hexsha": "38627a8a9d1de54c8a32babc90199589403e1452",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "a81447af3ab2ba898bb7d57be71369abbba12d81",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "d-plaindoux/colca",
"max_forks_repo_path": "src/Pi-calculus.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "a81447af3ab2ba898bb7d57be71369abbba12d81",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "d-plaindoux/colca",
"max_issues_repo_path": "src/Pi-calculus.agda",
"max_line_length": 80,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "a81447af3ab2ba898bb7d57be71369abbba12d81",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "d-plaindoux/colca",
"max_stars_repo_path": "src/Pi-calculus.agda",
"max_stars_repo_stars_event_max_datetime": "2021-05-04T09:35:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-03-12T18:31:14.000Z",
"num_tokens": 142,
"size": 671
} |
------------------------------------------------------------------------
-- Properties of combinatorial functions on integers
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --exact-split #-}
module Math.Combinatorics.IntegerFunction.Properties where
open import Data.Nat as ℕ hiding (_*_; _+_; _≤_; _<_)
import Data.Nat.Properties as ℕₚ
open import Data.Integer as ℤ
import Data.Integer.Properties as ℤₚ
open import Relation.Binary.PropositionalEquality
open import Function.Base
import Math.Combinatorics.Function as ℕF
import Math.Combinatorics.Function.Properties as ℕFₚ
open import Math.Combinatorics.IntegerFunction
import Math.Combinatorics.IntegerFunction.Properties.Lemma as Lemma
------------------------------------------------------------------------
-- Properties of [-1]^_
[-1]^[1+n]≡-1*[-1]^n : ∀ n → [-1]^ (ℕ.suc n) ≡ -1ℤ * [-1]^ n
[-1]^[1+n]≡-1*[-1]^n zero = refl
[-1]^[1+n]≡-1*[-1]^n (ℕ.suc zero) = refl
[-1]^[1+n]≡-1*[-1]^n (ℕ.suc (ℕ.suc n)) = [-1]^[1+n]≡-1*[-1]^n n
[-1]^[m+n]≡[-1]^m*[-1]^n : ∀ m n → [-1]^ (m ℕ.+ n) ≡ [-1]^ m * [-1]^ n
[-1]^[m+n]≡[-1]^m*[-1]^n zero n = sym $ ℤₚ.*-identityˡ $ [-1]^ n
[-1]^[m+n]≡[-1]^m*[-1]^n (ℕ.suc zero) n = [-1]^[1+n]≡-1*[-1]^n n
[-1]^[m+n]≡[-1]^m*[-1]^n (ℕ.suc (ℕ.suc m)) n = [-1]^[m+n]≡[-1]^m*[-1]^n m n
-- TODO: [-1]^n≡-1∨[-1]^n≡1
[-1]^[2*n]≡1 : ∀ n → [-1]^ (2 ℕ.* n) ≡ + 1
[-1]^[2*n]≡1 zero = refl
[-1]^[2*n]≡1 (ℕ.suc n) = begin-equality
[-1]^ (2 ℕ.* ℕ.suc n) ≡⟨ cong ([-1]^_) $ ℕₚ.*-distribˡ-+ 2 1 n ⟩
[-1]^ (2 ℕ.+ 2 ℕ.* n) ≡⟨⟩
[-1]^ (2 ℕ.* n) ≡⟨ [-1]^[2*n]≡1 n ⟩
+ 1 ∎
where open ℤₚ.≤-Reasoning
[-1]^[1+2*n]≡-1 : ∀ n → [-1]^ (1 ℕ.+ 2 ℕ.* n) ≡ -1ℤ
[-1]^[1+2*n]≡-1 n = begin-equality
[-1]^ (1 ℕ.+ 2 ℕ.* n) ≡⟨ [-1]^[1+n]≡-1*[-1]^n (2 ℕ.* n) ⟩
-1ℤ * [-1]^ (2 ℕ.* n) ≡⟨ cong (-1ℤ *_) $ [-1]^[2*n]≡1 n ⟩
-1ℤ * + 1 ∎
where open ℤₚ.≤-Reasoning
------------------------------------------------------------------------
-- Properties of permutation
P[n,0]≡1 : ∀ n → P n 0 ≡ (+ 1)
P[n,0]≡1 (+ n) = refl
P[n,0]≡1 (-[1+ n ]) = refl
P[n,1]≡n : ∀ n → P n 1 ≡ n
P[n,1]≡n (+ n) = cong (+_) $ ℕFₚ.P[n,1]≡n n
P[n,1]≡n (-[1+ n ]) = begin-equality
-1ℤ * + ℕF.Poch (ℕ.suc n) 1
≡⟨ cong (λ v → -1ℤ * + v) $ ℕFₚ.Poch[n,1]≡n (ℕ.suc n) ⟩
-1ℤ * (+ (ℕ.suc n))
≡⟨ ℤₚ.-1*n≡-n (+ (ℕ.suc n)) ⟩
- (+ ℕ.suc n)
∎
where open ℤₚ.≤-Reasoning
module _ where
open ℤₚ.≤-Reasoning
P[-n,k]≡[-1]^k*ℕPoch[n,k] : ∀ n k → P (- (+ n)) k ≡ [-1]^ k * + ℕF.Poch n k
P[-n,k]≡[-1]^k*ℕPoch[n,k] zero zero = refl
P[-n,k]≡[-1]^k*ℕPoch[n,k] zero (ℕ.suc k) = sym $ ℤₚ.*-zeroʳ ([-1]^ ℕ.suc k)
P[-n,k]≡[-1]^k*ℕPoch[n,k] (ℕ.suc n) k = refl
P[-n,2*k]≡ℕPoch[n,2*k] : ∀ n k → P (- (+ n)) (2 ℕ.* k) ≡ + ℕF.Poch n (2 ℕ.* k)
P[-n,2*k]≡ℕPoch[n,2*k] n k = begin-equality
P (- (+ n)) (2 ℕ.* k) ≡⟨ P[-n,k]≡[-1]^k*ℕPoch[n,k] n (2 ℕ.* k) ⟩
[-1]^ (2 ℕ.* k) * p ≡⟨ cong (_* p) $ [-1]^[2*n]≡1 k ⟩
1ℤ * p ≡⟨ ℤₚ.*-identityˡ p ⟩
p ∎
where p = + ℕF.Poch n (2 ℕ.* k)
P[-n,1+2*k]≡-ℕPoch[n,1+2*k] : ∀ n k →
P (- (+ n)) (1 ℕ.+ 2 ℕ.* k) ≡ - (+ ℕF.Poch n (1 ℕ.+ 2 ℕ.* k))
P[-n,1+2*k]≡-ℕPoch[n,1+2*k] n k = begin-equality
P (- (+ n)) (1 ℕ.+ 2 ℕ.* k) ≡⟨ P[-n,k]≡[-1]^k*ℕPoch[n,k] n (1 ℕ.+ 2 ℕ.* k) ⟩
[-1]^ (1 ℕ.+ 2 ℕ.* k) * p ≡⟨ cong (_* p) $ [-1]^[1+2*n]≡-1 k ⟩
-1ℤ * p ≡⟨ ℤₚ.-1*n≡-n p ⟩
- p ∎
where p = + ℕF.Poch n (1 ℕ.+ 2 ℕ.* k)
0≤n∧n<k⇒P[n,k]≡0 : ∀ {n k} → 0ℤ ≤ n → n < + k → P n k ≡ + 0
0≤n∧n<k⇒P[n,k]≡0 {+_ n} {k} 0≤n (+<+ n<k) = cong (+_) $ ℕFₚ.n<k⇒P[n,k]≡0 n<k
P[1+n,1+k]≡[1+n]*P[n,k] : ∀ n k → P (ℤ.suc n) (ℕ.suc k) ≡ ℤ.suc n * P n k
P[1+n,1+k]≡[1+n]*P[n,k] (+ n) k = begin-equality
+ (ℕ.suc n ℕ.* ℕF.P n k) ≡⟨ sym $ ℤₚ.pos-distrib-* (ℕ.suc n) (ℕF.P n k) ⟩
+ (ℕ.suc n) * + ℕF.P n k ≡⟨⟩
ℤ.suc (+ n) * + ℕF.P n k ∎
P[1+n,1+k]≡[1+n]*P[n,k] (-[1+ 0 ]) k = refl
P[1+n,1+k]≡[1+n]*P[n,k] (-[1+ ℕ.suc n ]) k = begin-equality
[-1]^ (ℕ.suc k) * + ℕF.Poch (ℕ.suc n) (ℕ.suc k)
≡⟨⟩
[-1]^ (ℕ.suc k) * + (ℕ.suc n ℕ.* p)
≡⟨ cong (_* + (ℕ.suc n ℕ.* p)) $ [-1]^[1+n]≡-1*[-1]^n k ⟩
-1ℤ * [-1]^ k * + (ℕ.suc n ℕ.* p)
≡⟨ sym $ cong (-1ℤ * [-1]^ k *_) $ ℤₚ.pos-distrib-* (ℕ.suc n) p ⟩
-1ℤ * [-1]^ k * (+ ℕ.suc n * + p)
≡⟨ Lemma.lemma₁ -1ℤ ([-1]^ k) (+ ℕ.suc n) (+ p) ⟩
-1ℤ * + ℕ.suc n * ([-1]^ k * + p)
≡⟨ cong (_* ([-1]^ k * + p)) $ ℤₚ.-1*n≡-n (+ ℕ.suc n) ⟩
-[1+ n ] * ([-1]^ k * + p)
∎
where p = ℕF.Poch (ℕ.suc (ℕ.suc n)) k
P[n,1+k]≡n*P[n-1,k] : ∀ n k → P n (ℕ.suc k) ≡ n * P (n - 1ℤ) k
P[n,1+k]≡n*P[n-1,k] n k = begin-equality
P n (ℕ.suc k) ≡⟨ cong (λ v → P v (ℕ.suc k)) $ Lemma.lemma₂ n ⟩
P (1ℤ + (n - 1ℤ)) (ℕ.suc k) ≡⟨ P[1+n,1+k]≡[1+n]*P[n,k] (n - 1ℤ) k ⟩
(1ℤ + (n - 1ℤ)) * P (n - 1ℤ) k ≡⟨ sym $ cong (_* P (n - 1ℤ) k) $ Lemma.lemma₂ n ⟩
n * P (n - 1ℤ) k ∎
P-split : ∀ (m : ℕ) (n : ℤ) (o : ℕ) → P ((+ m) + n) (m ℕ.+ o) ≡ P ((+ m) + n) m * P n o
P-split zero n o = begin-equality
P (0ℤ + n) o ≡⟨ cong (λ v → P v o) $ ℤₚ.+-identityˡ n ⟩
P n o ≡⟨ sym $ ℤₚ.*-identityˡ (P n o) ⟩
1ℤ * P n o ≡⟨ sym $ cong (_* P n o) $ P[n,0]≡1 (0ℤ + n) ⟩
P (0ℤ + n) 0 * P n o ∎
P-split (ℕ.suc m) n o = begin-equality
P (ℤ.suc (+ m) + n) (ℕ.suc (m ℕ.+ o))
≡⟨ cong (λ v → P v (ℕ.suc (m ℕ.+ o))) $ ℤₚ.+-assoc 1ℤ (+ m) n ⟩
P (ℤ.suc (+ m + n)) (ℕ.suc (m ℕ.+ o))
≡⟨ P[1+n,1+k]≡[1+n]*P[n,k] (+ m + n) (m ℕ.+ o) ⟩
ℤ.suc (+ m + n) * P (+ m + n) (m ℕ.+ o)
≡⟨ cong (ℤ.suc (+ m + n) *_) $ P-split m n o ⟩
ℤ.suc (+ m + n) * (P (+ m + n) m * P n o)
≡⟨ sym $ ℤₚ.*-assoc (ℤ.suc (+ m + n)) (P (+ m + n) m) (P n o) ⟩
ℤ.suc (+ m + n) * P (+ m + n) m * P n o
≡⟨ sym $ cong (_* P n o) $ P[1+n,1+k]≡[1+n]*P[n,k] (+ m + n) m ⟩
P (ℤ.suc (+ m + n)) (ℕ.suc m) * P n o
≡⟨ sym $ cong (λ v → P v (ℕ.suc m) * P n o) $ ℤₚ.+-assoc 1ℤ (+ m) n ⟩
P (+ (ℕ.suc m) + n) (ℕ.suc m) * P n o
∎
P-split-minus : ∀ m n o → P m (n ℕ.+ o) ≡ P m n * P (m - + n) o
P-split-minus m n o = begin-equality
P m (n ℕ.+ o) ≡⟨ cong (λ v → P v (n ℕ.+ o)) m≡n+p ⟩
P (+ n + p) (n ℕ.+ o) ≡⟨ P-split n p o ⟩
P (+ n + p) n * P p o ≡⟨ sym $ cong (λ v → P v n * P p o) $ m≡n+p ⟩
P m n * P (m - + n) o ∎
where
p = m - + n
m≡n+p : m ≡ + n + (m - + n)
m≡n+p = Lemma.lemma₃ m (+ n)
| {
"alphanum_fraction": 0.3848498704,
"avg_line_length": 41.5253164557,
"ext": "agda",
"hexsha": "73ab1c26e4a59dfde4857991cbaae9cb168c95ba",
"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": "9fafa35c940ff7b893a80120f6a1f22b0a3917b7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "rei1024/agda-combinatorics",
"max_forks_repo_path": "Math/Combinatorics/IntegerFunction/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "9fafa35c940ff7b893a80120f6a1f22b0a3917b7",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "rei1024/agda-combinatorics",
"max_issues_repo_path": "Math/Combinatorics/IntegerFunction/Properties.agda",
"max_line_length": 89,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "9fafa35c940ff7b893a80120f6a1f22b0a3917b7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "rei1024/agda-combinatorics",
"max_stars_repo_path": "Math/Combinatorics/IntegerFunction/Properties.agda",
"max_stars_repo_stars_event_max_datetime": "2020-04-25T07:25:27.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-06-25T08:24:15.000Z",
"num_tokens": 3440,
"size": 6561
} |
data Unit : Set where
unit : Unit
F : Unit → Set₁
F unit = Set
data D (u : Unit) (f : F u) : Set where
variable
u : Unit
f : F u
d : D u f
postulate
P : {u : Unit} {f : F u} → D u f → Set
p : P d
p' : (u : Unit) (f : F u) (d : D u f) → P d
p' u f d = p {u} {f} {d}
| {
"alphanum_fraction": 0.4647887324,
"avg_line_length": 13.5238095238,
"ext": "agda",
"hexsha": "21ca2d356cd0c788b719c61efe9cb9914bcc882d",
"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/Issue3666.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/Issue3666.agda",
"max_line_length": 43,
"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/Issue3666.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": 133,
"size": 284
} |
Subsets and Splits