Subset (20)

agda · 17.5k rows

Split (2)

train · 17.4k rows

text stringlengths 4 690k
{-# 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)
{-# 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]′
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
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) ∎
{-# 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
{-# 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
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
{-# 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 = {!!}
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 "") -}
{-# 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)
{-# 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)
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 _∼_ _∼̇_ ε _↦_
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 _⇔_
------------------------------------------------------------------------ -- 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? _)
{-# OPTIONS --cubical --no-import-sorts --safe #-} module Cubical.Relation.Nullary.DecidableEq where open import Cubical.Relation.Nullary.Properties using (Dec→Stable; Discrete→isSet) public
{-# 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
{-# 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)
{-# 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
{-# 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 ℓ
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 -}
postulate A : Set module _ where {-# POLARITY A #-}
module UniDB.Subst where open import UniDB.Subst.Core public open import UniDB.Subst.Pair public open import UniDB.Subst.Inst public
{-# 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 = ?
-- 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) --------------------------------------------------------------------------------
{-# 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
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₁} = {!!} -}
{-# 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
------------------------------------------------------------------------ -- 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 _)
------------------------------------------------------------------------ -- 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 ] ŵk[ σ ] -- A synonym. weaken[_] : ∀ {Γ} (σ : Type Γ) → [ T ⟶ T ] ŵ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 (ρ̂ ∘̂ ŵk[ σ ]) wk-subst ρ = map weaken ρ wk-subst[_] : ∀ {Γ Δ} σ {ρ̂ : Γ ⇨̂ Δ} → Sub T ρ̂ → Sub T (ρ̂ ∘̂ ŵk[ σ ]) wk-subst[ _ ] = wk-subst -- N-ary weakening of substitutions. wk-subst⁺ : ∀ {Γ Δ} Δ⁺ {ρ̂ : Γ ⇨̂ Δ} → Sub T ρ̂ → Sub T (ρ̂ ∘̂ ŵk⁺ Δ⁺) wk-subst⁺ ε ρ = ρ wk-subst⁺ (Δ⁺ ▻ σ) ρ = wk-subst (wk-subst⁺ Δ⁺ ρ) wk-subst₊ : ∀ {Γ Δ} Δ₊ {ρ̂ : Γ ⇨̂ Δ} → Sub T ρ̂ → Sub T (ρ̂ ∘̂ ŵ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 îd[ Γ ] id[ ε ] = ε⇨ id[ Γ ▻ σ ] = id[ Γ ] ↑ id : ∀ {Γ} → Sub T îd[ Γ ] id = id[ _ ] -- N-ary weakening. wk⁺ : ∀ {Γ} (Γ⁺ : Ctxt⁺ Γ) → Sub T (ŵk⁺ Γ⁺) wk⁺ ε = id wk⁺ (Γ⁺ ▻ σ) = wk-subst (wk⁺ Γ⁺) wk₊ : ∀ {Γ} (Γ₊ : Ctxt₊ Γ) → Sub T (ŵk₊ Γ₊) wk₊ Γ₊ = wk-subst₊ Γ₊ id -- Weakening. wk[_] : ∀ {Γ} (σ : Type Γ) → Sub T ŵk[ σ ] wk[ σ ] = wk⁺ (ε ▻ σ) wk : ∀ {Γ} {σ : Type Γ} → Sub T ŵ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 (ŝ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 ⟩ [ Γ⁺ /̂⁺ îd ] ≡⟨ /̂⁺-îd Γ⁺ ⟩ [ Γ⁺ ] ∎ /₊-id : ∀ {Γ} (Γ₊ : Ctxt₊ Γ) → Γ₊ /₊ id ≅-Ctxt₊ Γ₊ /₊-id Γ₊ = begin [ Γ₊ /₊ id ] ≡⟨ P.refl ⟩ [ Γ₊ /̂₊ îd ] ≡⟨ /̂₊-î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 ρ̂) Γ₊ Γ₊₊ → ρ ↑₊ (Γ₊ ₊++₊ Γ₊₊) ≅-⇨ ρ ↑₊ Γ₊ ↑₊ Γ₊₊ ↑₊-₊++₊ ρ ε Γ₊₊ = ρ ↑₊ Γ₊₊ ∎-⟶ ↑₊-₊++₊ ρ (σ ◅ Γ₊) Γ₊₊ = ρ ↑ ↑₊ (Γ₊ ₊++₊ Γ₊₊) ≅-⟶⟨ ↑₊-₊++₊ (ρ ↑) Γ₊ Γ₊₊ ⟩ ρ ↑ ↑₊ Γ₊ ↑₊ Γ₊₊ ∎-⟶
{- 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
{-# 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)) }
{-# 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)
{-# 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
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 -- -- -- -- -}
{-# 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 ⇑⟧
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)
module _ where A : Set₁ A = Set
------------------------------------------------------------------------------ -- 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.
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 -- (,**)
{-# 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))
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
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" ∷ []
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 _==_
{-# 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
module _ where primitive primGlue : _
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 }
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
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
------------------------------------------------------------------------ -- 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 ∎)
------------------------------------------------------------------------------ -- 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)
{- 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)
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 }
{-# 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 = {!!}
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 -}
------------------------------------------------------------------------ -- 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
------------------------------------------------------------------------ -- 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
------------------------------------------------------------------------ -- 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
{-# 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] -}
-- 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
{-# 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
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)
module Issue203 where open import Common.Level -- shouldn't work data Bad {a b} (A : Set a) : Set b where [_] : (x : A) → Bad A
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 }
{-# 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)
-- 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 ρ₀
{- 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
{-# 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
{-# 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)
{-# 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.
{-# 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)))
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→ℕ
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 -}
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)
{-# 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
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
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 ⦄
------------------------------------------------------------------------ -- 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)
{-# 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)))
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'')))
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 ∎
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)
{-# OPTIONS --safe #-} useful-lemma : ∀ {a} {A : Set a} → A useful-lemma = useful-lemma
{-# 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 = {!!} -}
{-# 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
{-# 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)
{-# 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)
{-# 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
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
{-# 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
{-# 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
-- 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.
{-# 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
{- 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
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≤
{-# 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 }
{-# OPTIONS --cubical --safe #-} module Cubical.HITs.S1 where open import Cubical.HITs.S1.Base public -- open import Cubical.HITs.S1.Properties public
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
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
------------------------------------------------------------------------ -- 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]^[2n]≡1 : ∀ n → [-1]^ (2 ℕ. n) ≡ + 1 [-1]^[2n]≡1 zero = refl [-1]^[2n]≡1 (ℕ.suc n) = begin-equality [-1]^ (2 ℕ.* ℕ.suc n) ≡⟨ cong ([-1]^_) $ ℕₚ.-distribˡ-+ 2 1 n ⟩ [-1]^ (2 ℕ.+ 2 ℕ. n) ≡⟨⟩ [-1]^ (2 ℕ.* n) ≡⟨ [-1]^[2n]≡1 n ⟩ + 1 ∎ where open ℤₚ.≤-Reasoning [-1]^[1+2n]≡-1 : ∀ n → [-1]^ (1 ℕ.+ 2 ℕ.* n) ≡ -1ℤ [-1]^[1+2n]≡-1 n = begin-equality [-1]^ (1 ℕ.+ 2 ℕ. n) ≡⟨ [-1]^[1+n]≡-1[-1]^n (2 ℕ. n) ⟩ -1ℤ * [-1]^ (2 ℕ.* n) ≡⟨ cong (-1ℤ _) $ [-1]^[2n]≡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)) ≡⟨ ℤₚ.-1n≡-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,2k]≡ℕPoch[n,2k] : ∀ n k → P (- (+ n)) (2 ℕ.* k) ≡ + ℕF.Poch n (2 ℕ.* k) P[-n,2k]≡ℕPoch[n,2k] 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]^[2n]≡1 k ⟩ 1ℤ p ≡⟨ ℤₚ.-identityˡ p ⟩ p ∎ where p = + ℕF.Poch n (2 ℕ. k) P[-n,1+2k]≡-ℕPoch[n,1+2k] : ∀ n k → P (- (+ n)) (1 ℕ.+ 2 ℕ.* k) ≡ - (+ ℕF.Poch n (1 ℕ.+ 2 ℕ.* k)) P[-n,1+2k]≡-ℕPoch[n,1+2k] 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+2n]≡-1 k ⟩ -1ℤ p ≡⟨ ℤₚ.-1n≡-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)) $ ℤₚ.-1n≡-n (+ ℕ.suc n) ⟩ -[1+ n ] ([-1]^ k * + p) ∎ where p = ℕF.Poch (ℕ.suc (ℕ.suc n)) k P[n,1+k]≡nP[n-1,k] : ∀ n k → P n (ℕ.suc k) ≡ n P (n - 1ℤ) k P[n,1+k]≡nP[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)
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}

Subsets and Splits

No community queries yet

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