Search is not available for this dataset
text
string | meta
dict |
|---|---|
{-# OPTIONS --cubical --safe --guardedness #-}
module Data.PolyP.Derivations.Levels where
open import Data.PolyP
open import Level
open import Data.PolyP.Types
open import Data.Sum
open import Data.Sigma
open import Data.Unit
open import Data.Fin
open import Data.Nat
open import Data.Vec
open import Function
open import Literals.Number
open import Data.Fin.Literals
open import Data.Nat.Literals
levels : ⟦ FOREST ⟧ ~ A → ⟦ LEVELS ⟧ ~ A
levels t = go t []′
where
go : ⟦ FOREST ⟧ ~ A → ⟦ LEVELS ⟧ ~ A → ⟦ LEVELS ⟧ ~ A
go =
cata λ xs zs →
cata (λ { (inl _ ) → zs
; (inr (inl _ , qs ) ) → qs
; (inr (inr (x , xs) , []′ ) ) → (x ∷′ []′ ) ∷′ xs []′
; (inr (inr (x , xs) , q ∷′ qs ) ) → (x ∷′ q ) ∷′ xs qs
}) xs
|
{
"alphanum_fraction": 0.5211267606,
"avg_line_length": 28.4,
"ext": "agda",
"hexsha": "203d3890b67923dab46b0128035f2648601a9acd",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "oisdk/agda-playground",
"max_forks_repo_path": "Data/PolyP/Derivations/Levels.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "oisdk/agda-playground",
"max_issues_repo_path": "Data/PolyP/Derivations/Levels.agda",
"max_line_length": 79,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "oisdk/agda-playground",
"max_stars_repo_path": "Data/PolyP/Derivations/Levels.agda",
"max_stars_repo_stars_event_max_datetime": "2021-11-16T08:11:34.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-09-11T17:45:41.000Z",
"num_tokens": 297,
"size": 852
}
|
open import Agda.Builtin.Equality using (_≡_; refl)
record ∃ {A : Set} (B : A → Set) : Set where
constructor _,_
field
proj₁ : A
proj₂ : B proj₁
open ∃ public
uncurry : {A : Set} {B : A → Set} {C : ∃ B → Set₁} →
((x : A) (y : B x) → C (x , y)) →
((p : ∃ B) → C p)
uncurry f (x , y) = f x y
_⟶_ : {I : Set} → (I → Set) → (I → Set) → Set
A ⟶ B = ∀ {i} → A i → B i
postulate
I : Set
i j : I
R : I → I → Set
record P : Set where
field
f : ∀ {k} → R i k → ∃ λ l → R k l
Q : Set
Q =
∃ λ (f : ∀ {j} → R i j → I) →
(λ { (j , k) → ∃ λ (r : R i j) → f r ≡ k }) ⟶ uncurry R
to : P → Q
to f = (λ r → proj₁ (P.f f r))
, λ { (r , refl) → proj₂ (P.f f r) }
from : Q → P
P.f (from (f , g)) r = f r , g (r , refl)
-- Should produce a nice error and not throw an __IMPOSSIBLE__.
to∘from : ∀ q → to (from q) ≡ q
to∘from _ = refl
|
{
"alphanum_fraction": 0.4487471526,
"avg_line_length": 19.9545454545,
"ext": "agda",
"hexsha": "16c600e26955381ae7fd63225d6b3a3bfd8627d3",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Fail/Issue2550.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Fail/Issue2550.agda",
"max_line_length": 63,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Fail/Issue2550.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 398,
"size": 878
}
|
{-# OPTIONS --cubical --safe --no-import-sorts #-}
module Cubical.Algebra.Module.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.SIP
open import Cubical.Data.Sigma
open import Cubical.Structures.Axioms
open import Cubical.Structures.Auto
open import Cubical.Structures.Macro
open import Cubical.Algebra.Ring renaming (⟨_⟩ to ⟨_⟩r)
open import Cubical.Algebra.AbGroup hiding (⟨_⟩)
open import Cubical.Algebra.Group hiding (⟨_⟩)
open Iso
private
variable
ℓ : Level
record IsLeftModule (R : Ring {ℓ}) {M : Type ℓ}
(0m : M)
(_+_ : M → M → M)
(-_ : M → M)
(_⋆_ : ⟨ R ⟩r → M → M) : Type ℓ where
constructor ismodule
open Ring R using (_·_; 1r) renaming (_+_ to _+r_)
field
+-isAbGroup : IsAbGroup 0m _+_ -_
⋆-assoc : (r s : ⟨ R ⟩r) (x : M) → (r · s) ⋆ x ≡ r ⋆ (s ⋆ x)
⋆-ldist : (r s : ⟨ R ⟩r) (x : M) → (r +r s) ⋆ x ≡ (r ⋆ x) + (s ⋆ x)
⋆-rdist : (r : ⟨ R ⟩r) (x y : M) → r ⋆ (x + y) ≡ (r ⋆ x) + (r ⋆ y)
⋆-lid : (x : M) → 1r ⋆ x ≡ x
open IsAbGroup +-isAbGroup public
renaming
( assoc to +-assoc
; identity to +-identity
; lid to +-lid
; rid to +-rid
; inverse to +-inv
; invl to +-linv
; invr to +-rinv
; comm to +-comm
; isSemigroup to +-isSemigroup
; isMonoid to +-isMonoid
; isGroup to +-isGroup
)
record LeftModule (R : Ring {ℓ}) : Type (ℓ-suc ℓ) where
constructor leftmodule
field
Carrier : Type ℓ
0m : Carrier
_+_ : Carrier → Carrier → Carrier
-_ : Carrier → Carrier
_⋆_ : ⟨ R ⟩r → Carrier → Carrier
isLeftModule : IsLeftModule R 0m _+_ -_ _⋆_
open IsLeftModule isLeftModule public
module _ {R : Ring {ℓ}} where
⟨_⟩ : LeftModule R → Type ℓ
⟨_⟩ = LeftModule.Carrier
LeftModule→AbGroup : (M : LeftModule R) → AbGroup {ℓ}
LeftModule→AbGroup (leftmodule _ _ _ _ _ isLeftModule) =
abgroup _ _ _ _ (IsLeftModule.+-isAbGroup isLeftModule)
isSetLeftModule : (M : LeftModule R) → isSet ⟨ M ⟩
isSetLeftModule M = isSetAbGroup (LeftModule→AbGroup M)
open Ring R using (1r) renaming (_+_ to _+r_; _·_ to _·s_)
makeIsLeftModule : {M : Type ℓ} {0m : M}
{_+_ : M → M → M} { -_ : M → M} {_⋆_ : ⟨ R ⟩r → M → M}
(isSet-M : isSet M)
(+-assoc : (x y z : M) → x + (y + z) ≡ (x + y) + z)
(+-rid : (x : M) → x + 0m ≡ x)
(+-rinv : (x : M) → x + (- x) ≡ 0m)
(+-comm : (x y : M) → x + y ≡ y + x)
(⋆-assoc : (r s : ⟨ R ⟩r) (x : M) → (r ·s s) ⋆ x ≡ r ⋆ (s ⋆ x))
(⋆-ldist : (r s : ⟨ R ⟩r) (x : M) → (r +r s) ⋆ x ≡ (r ⋆ x) + (s ⋆ x))
(⋆-rdist : (r : ⟨ R ⟩r) (x y : M) → r ⋆ (x + y) ≡ (r ⋆ x) + (r ⋆ y))
(⋆-lid : (x : M) → 1r ⋆ x ≡ x)
→ IsLeftModule R 0m _+_ -_ _⋆_
makeIsLeftModule isSet-M
+-assoc +-rid +-rinv +-comm
⋆-assoc ⋆-ldist ⋆-rdist ⋆-lid =
ismodule (makeIsAbGroup isSet-M +-assoc +-rid +-rinv +-comm)
⋆-assoc ⋆-ldist ⋆-rdist ⋆-lid
record LeftModuleEquiv {R : Ring {ℓ}} (M N : LeftModule R) : Type ℓ where
constructor moduleiso
private
instance
_ : LeftModule R
_ = M
_ : LeftModule R
_ = N
open LeftModule {{...}}
field
e : ⟨ M ⟩ ≃ ⟨ N ⟩
isHom+ : (x y : ⟨ M ⟩) → equivFun e (x + y) ≡ equivFun e x + equivFun e y
comm⋆ : (r : ⟨ R ⟩r) (x : ⟨ M ⟩) → equivFun e (r ⋆ x) ≡ r ⋆ equivFun e x
module LeftModuleΣTheory (R : Ring {ℓ}) where
RawLeftModuleStructure = λ (M : Type ℓ) → (M → M → M) × (⟨ R ⟩r → M → M)
RawLeftModuleEquivStr = AutoEquivStr RawLeftModuleStructure
rawLeftModuleUnivalentStr : UnivalentStr _ RawLeftModuleEquivStr
rawLeftModuleUnivalentStr = autoUnivalentStr RawLeftModuleStructure
open Ring R using (_·_; 1r) renaming (_+_ to _+r_)
LeftModuleAxioms : (M : Type ℓ) (s : RawLeftModuleStructure M) → Type ℓ
LeftModuleAxioms M (_+_ , _⋆_) = AbGroupΣTheory.AbGroupAxioms M _+_
× ((r s : ⟨ R ⟩r) (x : M) → (r · s) ⋆ x ≡ r ⋆ (s ⋆ x))
× ((r s : ⟨ R ⟩r) (x : M) → (r +r s) ⋆ x ≡ (r ⋆ x) + (s ⋆ x))
× ((r : ⟨ R ⟩r) (x y : M) → r ⋆ (x + y) ≡ (r ⋆ x) + (r ⋆ y))
× ((x : M) → 1r ⋆ x ≡ x)
LeftModuleStructure : Type ℓ → Type ℓ
LeftModuleStructure = AxiomsStructure RawLeftModuleStructure LeftModuleAxioms
LeftModuleΣ : Type (ℓ-suc ℓ)
LeftModuleΣ = TypeWithStr ℓ LeftModuleStructure
LeftModuleEquivStr : StrEquiv LeftModuleStructure ℓ
LeftModuleEquivStr = AxiomsEquivStr RawLeftModuleEquivStr LeftModuleAxioms
open AbGroupΣTheory using (isSetAbGroupΣ)
isSetLeftModuleΣ : (M : LeftModuleΣ) → isSet _
isSetLeftModuleΣ (M , (_+_ , _) , (isAbGroup-M , _)) = isSetAbGroupΣ (M , _+_ , isAbGroup-M)
isPropLeftModuleAxioms : (M : Type ℓ) (s : RawLeftModuleStructure M)
→ isProp (LeftModuleAxioms M s)
isPropLeftModuleAxioms M (_+_ , _⋆_) =
isPropΣ (AbGroupΣTheory.isPropAbGroupAxioms M _+_)
λ isAbGroup-M →
isProp× (isPropΠ3 λ _ _ _ → (isSetAbGroupΣ (M , _+_ , isAbGroup-M)) _ _)
(isProp× (isPropΠ3 λ _ _ _ → (isSetAbGroupΣ (M , _+_ , isAbGroup-M)) _ _)
(isProp× (isPropΠ3 λ _ _ _ → (isSetAbGroupΣ (M , _+_ , isAbGroup-M)) _ _)
(isPropΠ λ _ → (isSetAbGroupΣ (M , _+_ , isAbGroup-M)) _ _)))
LeftModule→LeftModuleΣ : LeftModule R → LeftModuleΣ
LeftModule→LeftModuleΣ
(leftmodule M 0m _+_ -_ _⋆_ (ismodule +-isAbGroup ⋆-assoc ⋆-ldist ⋆-rdist ⋆-lid)) =
M , (_+_ , _⋆_) ,
AbGroupΣTheory.AbGroup→AbGroupΣ (abgroup _ _ _ _ +-isAbGroup) .snd .snd ,
⋆-assoc , ⋆-ldist , ⋆-rdist , ⋆-lid
LeftModuleΣ→LeftModule : LeftModuleΣ → LeftModule R
LeftModuleΣ→LeftModule (M , (_+_ , _⋆_) , isAbGroup-M , ⋆-assoc , ⋆-ldist , ⋆-rdist , ⋆-lid) =
let isAbGroup = AbGroupΣTheory.AbGroupΣ→AbGroup (_ , _ , isAbGroup-M ) .AbGroup.isAbGroup
in leftmodule M _ _+_ _ _⋆_
(ismodule isAbGroup ⋆-assoc ⋆-ldist ⋆-rdist ⋆-lid)
LeftModuleIsoLeftModuleΣ : Iso (LeftModule R) LeftModuleΣ
LeftModuleIsoLeftModuleΣ = iso LeftModule→LeftModuleΣ LeftModuleΣ→LeftModule
(λ _ → refl) helper
where
open AbGroupΣTheory
abgroup-helper : retract (AbGroup→AbGroupΣ {ℓ}) AbGroupΣ→AbGroup
abgroup-helper = Iso.leftInv AbGroupIsoAbGroupΣ
open LeftModule
open IsLeftModule
helper : _
Carrier (helper M i) = Carrier M
0m (helper M i) = 0m M
_+_ (helper M i) = _+_ M
-_ (helper M i) = -_ M
_⋆_ (helper M i) = _⋆_ M
+-isAbGroup (isLeftModule (helper M i)) =
AbGroup.isAbGroup (abgroup-helper (abgroup _ _ _ _ (+-isAbGroup M)) i)
⋆-assoc (isLeftModule (helper M i)) = ⋆-assoc M
⋆-ldist (isLeftModule (helper M i)) = ⋆-ldist M
⋆-rdist (isLeftModule (helper M i)) = ⋆-rdist M
⋆-lid (isLeftModule (helper M i)) = ⋆-lid M
leftModuleUnivalentStr : UnivalentStr LeftModuleStructure LeftModuleEquivStr
leftModuleUnivalentStr = axiomsUnivalentStr _ isPropLeftModuleAxioms rawLeftModuleUnivalentStr
LeftModuleΣPath : (M N : LeftModuleΣ) → (M ≃[ LeftModuleEquivStr ] N) ≃ (M ≡ N)
LeftModuleΣPath = SIP leftModuleUnivalentStr
LeftModuleEquivStrΣ : (M N : LeftModule R) → Type ℓ
LeftModuleEquivStrΣ M N = LeftModule→LeftModuleΣ M ≃[ LeftModuleEquivStr ] LeftModule→LeftModuleΣ N
LeftModuleEquivStrΣPath : {M N : LeftModule R} → Iso (LeftModuleEquiv M N) (LeftModuleEquivStrΣ M N)
fun LeftModuleEquivStrΣPath (moduleiso e isHom+ comm⋆) = e , isHom+ , comm⋆
inv LeftModuleEquivStrΣPath (e , isHom+ , comm⋆) = moduleiso e isHom+ comm⋆
rightInv LeftModuleEquivStrΣPath _ = refl
leftInv LeftModuleEquivStrΣPath _ = refl
LeftModulePath : (M N : LeftModule R) → (LeftModuleEquiv M N) ≃ (M ≡ N)
LeftModulePath M N =
LeftModuleEquiv M N ≃⟨ isoToEquiv LeftModuleEquivStrΣPath ⟩
LeftModuleEquivStrΣ M N ≃⟨ LeftModuleΣPath _ _ ⟩
LeftModule→LeftModuleΣ M ≡ LeftModule→LeftModuleΣ N ≃⟨ isoToEquiv
(invIso
(congIso
LeftModuleIsoLeftModuleΣ))
⟩
M ≡ N ■
LeftModulePath : {R : Ring {ℓ}} (M N : LeftModule R) → (LeftModuleEquiv M N) ≃ (M ≡ N)
LeftModulePath {ℓ} {R} = LeftModuleΣTheory.LeftModulePath R
|
{
"alphanum_fraction": 0.5577583343,
"avg_line_length": 39.4279475983,
"ext": "agda",
"hexsha": "a822028e513958b86bec85e9494af64b97129844",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "f6771617374bfe65a7043d00731fed5a673aa729",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "knrafto/cubical",
"max_forks_repo_path": "Cubical/Algebra/Module/Base.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "f6771617374bfe65a7043d00731fed5a673aa729",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "knrafto/cubical",
"max_issues_repo_path": "Cubical/Algebra/Module/Base.agda",
"max_line_length": 102,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "f6771617374bfe65a7043d00731fed5a673aa729",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "knrafto/cubical",
"max_stars_repo_path": "Cubical/Algebra/Module/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 3338,
"size": 9029
}
|
module Highlighting where
Set-one : Set₂
Set-one = Set₁
record R (A : Set) : Set-one where
constructor con
field X : Set
F : Set → Set → Set
F A B = B
field P : F A X → Set
Q : F A X → Set
Q = Q
postulate P : _
open import Highlighting.M
data D (A : Set) : Set-one where
d : let X = D in X A
|
{
"alphanum_fraction": 0.5899053628,
"avg_line_length": 12.68,
"ext": "agda",
"hexsha": "209f81d43eec8e1809188b41a32aec02dec25fd7",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "masondesu/agda",
"max_forks_repo_path": "test/interaction/Highlighting.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "masondesu/agda",
"max_issues_repo_path": "test/interaction/Highlighting.agda",
"max_line_length": 34,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "477c8c37f948e6038b773409358fd8f38395f827",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "larrytheliquid/agda",
"max_stars_repo_path": "test/interaction/Highlighting.agda",
"max_stars_repo_stars_event_max_datetime": "2019-11-27T04:41:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-11-27T04:41:05.000Z",
"num_tokens": 113,
"size": 317
}
|
{-# OPTIONS --without-K --safe #-}
module Categories.Adjoint.Equivalence where
open import Level
open import Categories.Adjoint
open import Categories.Category
open import Categories.Functor renaming (id to idF)
open import Categories.Functor.Properties
open import Categories.NaturalTransformation using (ntHelper)
open import Categories.NaturalTransformation.NaturalIsomorphism as ≃ using (_≃_; NaturalIsomorphism)
open import Categories.NaturalTransformation.NaturalIsomorphism.Properties
import Categories.Morphism.Reasoning as MR
open import Relation.Binary using (Setoid; IsEquivalence)
private
variable
o ℓ e : Level
o′ ℓ′ e′ : Level
C D E : Category o ℓ e
infix 5 _⊣⊢_
record _⊣⊢_ (L : Functor C D) (R : Functor D C) : Set (levelOfTerm L ⊔ levelOfTerm R) where
field
unit : idF ≃ (R ∘F L)
counit : (L ∘F R) ≃ idF
module unit = NaturalIsomorphism unit
module counit = NaturalIsomorphism counit
private
module C = Category C
module D = Category D
module L = Functor L
module R = Functor R
field
zig : ∀ {A : C.Obj} → counit.⇒.η (L.₀ A) D.∘ L.₁ (unit.⇒.η A) D.≈ D.id
zag : ∀ {B : D.Obj} → R.₁ (counit.⇒.η B) C.∘ unit.⇒.η (R.₀ B) C.≈ C.id
op₁ : R.op ⊣⊢ L.op
op₁ = record
{ unit = counit.op
; counit = unit.op
; zig = zag
; zag = zig
}
zag⁻¹ : {B : D.Obj} → unit.⇐.η (R.F₀ B) C.∘ R.F₁ (counit.⇐.η B) C.≈ C.id
zag⁻¹ {B} = begin
unit.⇐.η (R.₀ B) C.∘ R.₁ (counit.⇐.η B) ≈˘⟨ flip-fromʳ unit.FX≅GX zag ⟩∘⟨refl ⟩
R.₁ (counit.⇒.η B) C.∘ R.₁ (counit.⇐.η B) ≈⟨ [ R ]-resp-∘ (counit.iso.isoʳ B) ⟩
R.₁ D.id ≈⟨ R.identity ⟩
C.id ∎
where open C.HomReasoning
open MR C
zig⁻¹ : {A : C.Obj} → L.F₁ (unit.⇐.η A) D.∘ counit.⇐.η (L.F₀ A) D.≈ D.id
zig⁻¹ {A} = begin
L.₁ (unit.⇐.η A) D.∘ counit.⇐.η (L.₀ A) ≈˘⟨ refl⟩∘⟨ flip-fromˡ counit.FX≅GX zig ⟩
L.₁ (unit.⇐.η A) D.∘ L.₁ (unit.⇒.η A) ≈⟨ [ L ]-resp-∘ (unit.iso.isoˡ A) ⟩
L.₁ C.id ≈⟨ L.identity ⟩
D.id ∎
where open D.HomReasoning
open MR D
op₂ : R ⊣⊢ L
op₂ = record
{ unit = ≃.sym counit
; counit = ≃.sym unit
; zig = zag⁻¹
; zag = zig⁻¹
}
L⊣R : L ⊣ R
L⊣R = record
{ unit = unit.F⇒G
; counit = counit.F⇒G
; zig = zig
; zag = zag
}
module L⊣R = Adjoint L⊣R
open L⊣R hiding (unit; counit; zig; zag; op) public
R⊣L : R ⊣ L
R⊣L = record
{ unit = counit.F⇐G
; counit = unit.F⇐G
; zig = zag⁻¹
; zag = zig⁻¹
}
module R⊣L = Adjoint R⊣L
private
record WithZig (L : Functor C D) (R : Functor D C) : Set (levelOfTerm L ⊔ levelOfTerm R) where
field
unit : idF ≃ (R ∘F L)
counit : (L ∘F R) ≃ idF
module unit = NaturalIsomorphism unit
module counit = NaturalIsomorphism counit
private
module C = Category C
module D = Category D
module L = Functor L
module R = Functor R
module ℱ = Functor
field
zig : ∀ {A : C.Obj} → counit.⇒.η (L.₀ A) D.∘ L.₁ (unit.⇒.η A) D.≈ D.id
zag : ∀ {B : D.Obj} → R.₁ (counit.⇒.η B) C.∘ unit.⇒.η (R.₀ B) C.≈ C.id
zag {B} = F≃id⇒id (≃.sym unit) helper
where open C
open HomReasoning
helper : R.₁ (L.₁ (R.₁ (counit.⇒.η B) ∘ unit.⇒.η (R.₀ B))) ≈ id
helper = begin
R.₁ (L.₁ (R.₁ (counit.⇒.η B) ∘ unit.⇒.η (R.₀ B))) ≈⟨ ℱ.homomorphism (R ∘F L) ⟩
R.₁ (L.₁ (R.₁ (counit.⇒.η B))) ∘ R.₁ (L.₁ (unit.⇒.η (R.₀ B))) ≈˘⟨ R.F-resp-≈ (F≃id-comm₁ counit) ⟩∘⟨refl ⟩
R.₁ (counit.⇒.η (L.₀ (R.₀ B))) ∘ R.₁ (L.₁ (unit.⇒.η (R.₀ B))) ≈⟨ [ R ]-resp-∘ zig ⟩
R.₁ D.id ≈⟨ R.identity ⟩
id ∎
record WithZag (L : Functor C D) (R : Functor D C) : Set (levelOfTerm L ⊔ levelOfTerm R) where
field
unit : idF ≃ (R ∘F L)
counit : (L ∘F R) ≃ idF
module unit = NaturalIsomorphism unit
module counit = NaturalIsomorphism counit
private
module C = Category C
module D = Category D
module L = Functor L
module R = Functor R
module ℱ = Functor
field
zag : ∀ {B : D.Obj} → R.₁ (counit.⇒.η B) C.∘ unit.⇒.η (R.₀ B) C.≈ C.id
zig : ∀ {A : C.Obj} → counit.⇒.η (L.₀ A) D.∘ L.₁ (unit.⇒.η A) D.≈ D.id
zig {A} = F≃id⇒id counit helper
where open D
open HomReasoning
helper : L.₁ (R.₁ (counit.⇒.η (L.₀ A) ∘ L.₁ (unit.⇒.η A))) ≈ id
helper = begin
L.₁ (R.₁ (counit.⇒.η (L.₀ A) ∘ L.₁ (unit.⇒.η A))) ≈⟨ ℱ.homomorphism (L ∘F R) ⟩
(L.₁ (R.₁ (counit.⇒.η (L.₀ A))) ∘ L.₁ (R.₁ (L.₁ (unit.⇒.η A)))) ≈˘⟨ refl⟩∘⟨ L.F-resp-≈ (F≃id-comm₂ (≃.sym unit)) ⟩
L.₁ (R.₁ (counit.⇒.η (L.₀ A))) ∘ L.₁ (unit.⇒.η (R.₀ (L.₀ A))) ≈⟨ [ L ]-resp-∘ zag ⟩
L.₁ C.id ≈⟨ L.identity ⟩
id ∎
module _ {L : Functor C D} {R : Functor D C} where
withZig : WithZig L R → L ⊣⊢ R
withZig LR = record
{ unit = unit
; counit = counit
; zig = zig
; zag = zag
}
where open WithZig LR
withZag : WithZag L R → L ⊣⊢ R
withZag LR = record
{ unit = unit
; counit = counit
; zig = zig
; zag = zag
}
where open WithZag LR
id⊣⊢id : idF {C = C} ⊣⊢ idF
id⊣⊢id {C = C} = record
{ unit = ≃.sym ≃.unitor²
; counit = ≃.unitor²
; zig = identity²
; zag = identity²
}
where open Category C
module _ {L : Functor C D} {R : Functor D C} {L′ : Functor D E} {R′ : Functor E D}
(L⊣⊢R : L ⊣⊢ R) (L′⊣⊢R′ : L′ ⊣⊢ R′) where
private
module C = Category C
module D = Category D
module E = Category E
module L = Functor L
module R = Functor R
module L′ = Functor L′
module R′ = Functor R′
module ⊣⊢₁ = _⊣⊢_ L⊣⊢R
module ⊣⊢₂ = _⊣⊢_ L′⊣⊢R′
unit : idF ≃ (R ∘F R′) ∘F L′ ∘F L
unit = record
{ F⇒G = ntHelper record
{ η = λ c → R.₁ (⊣⊢₂.unit.⇒.η (L.₀ c)) ∘ ⊣⊢₁.unit.⇒.η c
; commute = λ {x} {y} f → begin
(R.₁ (⊣⊢₂.unit.⇒.η (L.₀ y)) ∘ ⊣⊢₁.unit.⇒.η y) ∘ f
≈⟨ pullʳ (⊣⊢₁.unit.⇒.commute f) ⟩
R.₁ (⊣⊢₂.unit.⇒.η (L.₀ y)) ∘ R.₁ (L.₁ f) ∘ ⊣⊢₁.unit.⇒.η x
≈⟨ pullˡ ([ R ]-resp-square (⊣⊢₂.unit.⇒.commute (L.₁ f))) ⟩
(R.₁ (R′.₁ (L′.₁ (L.₁ f))) ∘ R.₁ (⊣⊢₂.unit.⇒.η (L.₀ x))) ∘ ⊣⊢₁.unit.⇒.η x
≈⟨ assoc ⟩
R.₁ (R′.₁ (L′.₁ (L.₁ f))) ∘ R.₁ (⊣⊢₂.unit.⇒.η (L.₀ x)) ∘ ⊣⊢₁.unit.⇒.η x
∎
}
; F⇐G = ntHelper record
{ η = λ c → ⊣⊢₁.unit.⇐.η c ∘ R.₁ (⊣⊢₂.unit.⇐.η (L.₀ c))
; commute = λ {x} {y} f → begin
(⊣⊢₁.unit.⇐.η y ∘ R.₁ (⊣⊢₂.unit.⇐.η (L.₀ y))) ∘ R.₁ (R′.₁ (L′.₁ (L.₁ f)))
≈⟨ pullʳ ([ R ]-resp-square (⊣⊢₂.unit.⇐.commute (L.₁ f))) ⟩
⊣⊢₁.unit.⇐.η y ∘ R.₁ (L.₁ f) ∘ R.₁ (⊣⊢₂.unit.⇐.η (L.₀ x))
≈⟨ pullˡ (⊣⊢₁.unit.⇐.commute f) ⟩
(f ∘ ⊣⊢₁.unit.⇐.η x) ∘ R.₁ (⊣⊢₂.unit.⇐.η (L.₀ x))
≈⟨ assoc ⟩
f ∘ ⊣⊢₁.unit.⇐.η x ∘ R.₁ (⊣⊢₂.unit.⇐.η (L.₀ x))
∎
}
; iso = λ c → record
{ isoˡ = begin
(⊣⊢₁.unit.⇐.η c ∘ R.₁ (⊣⊢₂.unit.⇐.η (L.₀ c))) ∘ R.₁ (⊣⊢₂.unit.⇒.η (L.₀ c)) ∘ ⊣⊢₁.unit.⇒.η c
≈⟨ center ([ R ]-resp-∘ (⊣⊢₂.unit.iso.isoˡ (L.₀ c))) ⟩
⊣⊢₁.unit.⇐.η c ∘ R.₁ D.id ∘ ⊣⊢₁.unit.⇒.η c
≈⟨ refl⟩∘⟨ elimˡ R.identity ⟩
⊣⊢₁.unit.⇐.η c ∘ ⊣⊢₁.unit.⇒.η c
≈⟨ ⊣⊢₁.unit.iso.isoˡ c ⟩
id
∎
; isoʳ = begin
(R.₁ (⊣⊢₂.unit.⇒.η (L.₀ c)) ∘ ⊣⊢₁.unit.⇒.η c) ∘ ⊣⊢₁.unit.⇐.η c ∘ R.₁ (⊣⊢₂.unit.⇐.η (L.₀ c))
≈⟨ center (⊣⊢₁.unit.iso.isoʳ c) ⟩
R.₁ (⊣⊢₂.unit.⇒.η (L.₀ c)) ∘ id ∘ R.₁ (⊣⊢₂.unit.⇐.η (L.₀ c))
≈⟨ refl⟩∘⟨ identityˡ ⟩
R.₁ (⊣⊢₂.unit.⇒.η (L.₀ c)) ∘ R.₁ (⊣⊢₂.unit.⇐.η (L.₀ c))
≈⟨ [ R ]-resp-∘ (⊣⊢₂.unit.iso.isoʳ (L.₀ c)) ⟩
R.₁ D.id
≈⟨ R.identity ⟩
id
∎
}
}
where open C
open HomReasoning
open MR C
module unit = NaturalIsomorphism unit
counit : (L′ ∘F L) ∘F R ∘F R′ ≃ idF
counit = record
{ F⇒G = ntHelper record
{ η = λ e → ⊣⊢₂.counit.⇒.η e ∘ L′.₁ (⊣⊢₁.counit.⇒.η (R′.₀ e))
; commute = λ {x} {y} f → begin
(⊣⊢₂.counit.⇒.η y ∘ L′.₁ (⊣⊢₁.counit.⇒.η (R′.₀ y))) ∘ L′.₁ (L.₁ (R.₁ (R′.₁ f)))
≈⟨ pullʳ ([ L′ ]-resp-square (⊣⊢₁.counit.⇒.commute (R′.₁ f))) ⟩
⊣⊢₂.counit.⇒.η y ∘ L′.₁ (R′.₁ f) ∘ L′.₁ (⊣⊢₁.counit.⇒.η (R′.₀ x))
≈⟨ pullˡ (⊣⊢₂.counit.⇒.commute f) ⟩
(f ∘ ⊣⊢₂.counit.⇒.η x) ∘ L′.₁ (⊣⊢₁.counit.⇒.η (R′.₀ x))
≈⟨ assoc ⟩
f ∘ ⊣⊢₂.counit.⇒.η x ∘ L′.₁ (⊣⊢₁.counit.⇒.η (R′.₀ x))
∎
}
; F⇐G = ntHelper record
{ η = λ e → L′.₁ (⊣⊢₁.counit.⇐.η (R′.₀ e)) ∘ ⊣⊢₂.counit.⇐.η e
; commute = λ {x} {y} f → begin
(L′.₁ (⊣⊢₁.counit.⇐.η (R′.₀ y)) ∘ ⊣⊢₂.counit.⇐.η y) ∘ f
≈⟨ pullʳ (⊣⊢₂.counit.⇐.commute f) ⟩
L′.₁ (⊣⊢₁.counit.⇐.η (R′.₀ y)) ∘ L′.₁ (R′.₁ f) ∘ ⊣⊢₂.counit.⇐.η x
≈⟨ pullˡ ([ L′ ]-resp-square (⊣⊢₁.counit.⇐.commute (R′.₁ f))) ⟩
(L′.₁ (L.₁ (R.₁ (R′.₁ f))) ∘ L′.₁ (⊣⊢₁.counit.⇐.η (R′.₀ x))) ∘ ⊣⊢₂.counit.⇐.η x
≈⟨ assoc ⟩
L′.₁ (L.₁ (R.₁ (R′.₁ f))) ∘ L′.₁ (⊣⊢₁.counit.⇐.η (R′.₀ x)) ∘ ⊣⊢₂.counit.⇐.η x
∎
}
; iso = λ e → record
{ isoˡ = begin
(L′.₁ (⊣⊢₁.counit.⇐.η (R′.₀ e)) ∘ ⊣⊢₂.counit.⇐.η e) ∘ ⊣⊢₂.counit.⇒.η e ∘ L′.₁ (⊣⊢₁.counit.⇒.η (R′.₀ e))
≈⟨ center (⊣⊢₂.counit.iso.isoˡ e) ⟩
L′.₁ (⊣⊢₁.counit.⇐.η (R′.₀ e)) ∘ id ∘ L′.₁ (⊣⊢₁.counit.⇒.η (R′.₀ e))
≈⟨ refl⟩∘⟨ identityˡ ⟩
L′.₁ (⊣⊢₁.counit.⇐.η (R′.₀ e)) ∘ L′.₁ (⊣⊢₁.counit.⇒.η (R′.₀ e))
≈⟨ [ L′ ]-resp-∘ (⊣⊢₁.counit.iso.isoˡ (R′.₀ e)) ⟩
L′.₁ D.id
≈⟨ L′.identity ⟩
id
∎
; isoʳ = begin
(⊣⊢₂.counit.⇒.η e ∘ L′.₁ (⊣⊢₁.counit.⇒.η (R′.₀ e))) ∘ L′.₁ (⊣⊢₁.counit.⇐.η (R′.₀ e)) ∘ ⊣⊢₂.counit.⇐.η e
≈⟨ center ([ L′ ]-resp-∘ (⊣⊢₁.counit.iso.isoʳ (R′.₀ e))) ⟩
⊣⊢₂.counit.⇒.η e ∘ L′.₁ D.id ∘ ⊣⊢₂.counit.⇐.η e
≈⟨ refl⟩∘⟨ elimˡ L′.identity ⟩
⊣⊢₂.counit.⇒.η e ∘ ⊣⊢₂.counit.⇐.η e
≈⟨ ⊣⊢₂.counit.iso.isoʳ e ⟩
id
∎
}
}
where open E
open HomReasoning
open MR E
module counit = NaturalIsomorphism counit
zig : ∀ {c} → counit.⇒.η (L′.₀ (L.₀ c)) E.∘ L′.₁ (L.₁ (unit.⇒.η c)) E.≈ E.id
zig {c} = begin
counit.⇒.η (L′.₀ (L.₀ c)) ∘ L′.₁ (L.₁ (unit.⇒.η c))
≈⟨ refl⟩∘⟨ Functor.homomorphism (L′ ∘F L) ⟩
counit.⇒.η (L′.₀ (L.₀ c)) ∘ L′.₁ (L.₁ (R.₁ (⊣⊢₂.unit.⇒.η (L.₀ c)))) ∘ L′.₁ (L.₁ (⊣⊢₁.unit.⇒.η c))
≈⟨ center ([ L′ ]-resp-square (⊣⊢₁.counit.⇒.commute (⊣⊢₂.unit.⇒.η (L.₀ c)))) ⟩
⊣⊢₂.counit.⇒.η (L′.₀ (L.₀ c)) ∘ (L′.₁ (⊣⊢₂.unit.⇒.η (L.₀ c)) ∘ L′.₁ (⊣⊢₁.counit.⇒.η (L.₀ c))) ∘ L′.₁ (L.₁ (⊣⊢₁.unit.⇒.η c))
≈⟨ pull-first ⊣⊢₂.zig ⟩
id ∘ L′.₁ (⊣⊢₁.counit.⇒.η (L.₀ c)) ∘ L′.₁ (L.₁ (⊣⊢₁.unit.⇒.η c))
≈⟨ elimʳ (([ L′ ]-resp-∘ ⊣⊢₁.zig) ○ L′.identity) ⟩
id
∎
where open E
open HomReasoning
open MR E
_∘⊣⊢_ : (L′ ∘F L) ⊣⊢ (R ∘F R′)
_∘⊣⊢_ = withZig record
{ unit = unit
; counit = counit
; zig = zig
}
record ⊣Equivalence (C : Category o ℓ e) (D : Category o′ ℓ′ e′) : Set (o ⊔ ℓ ⊔ e ⊔ o′ ⊔ ℓ′ ⊔ e′) where
field
L : Functor C D
R : Functor D C
L⊣⊢R : L ⊣⊢ R
module L = Functor L
module R = Functor R
module L⊣⊢R = _⊣⊢_ L⊣⊢R
open L⊣⊢R public
refl : ⊣Equivalence C C
refl = record
{ L = idF
; R = idF
; L⊣⊢R = id⊣⊢id
}
sym : ⊣Equivalence C D → ⊣Equivalence D C
sym e = record
{ L = R
; R = L
; L⊣⊢R = op₂
}
where open ⊣Equivalence e
trans : ⊣Equivalence C D → ⊣Equivalence D E → ⊣Equivalence C E
trans e e′ = record
{ L = e′.L ∘F e.L
; R = e.R ∘F e′.R
; L⊣⊢R = e.L⊣⊢R ∘⊣⊢ e′.L⊣⊢R
}
where module e = ⊣Equivalence e
module e′ = ⊣Equivalence e′
isEquivalence : ∀ {o ℓ e} → IsEquivalence (⊣Equivalence {o} {ℓ} {e})
isEquivalence = record
{ refl = refl
; sym = sym
; trans = trans
}
setoid : ∀ o ℓ e → Setoid _ _
setoid o ℓ e = record
{ Carrier = Category o ℓ e
; _≈_ = ⊣Equivalence
; isEquivalence = isEquivalence
}
|
{
"alphanum_fraction": 0.4381628197,
"avg_line_length": 33.3090909091,
"ext": "agda",
"hexsha": "194925b0dc7de5d6f8d7b4a6c6e23e68f20373e0",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "58e5ec015781be5413bdf968f7ec4fdae0ab4b21",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "MirceaS/agda-categories",
"max_forks_repo_path": "src/Categories/Adjoint/Equivalence.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "58e5ec015781be5413bdf968f7ec4fdae0ab4b21",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "MirceaS/agda-categories",
"max_issues_repo_path": "src/Categories/Adjoint/Equivalence.agda",
"max_line_length": 129,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "58e5ec015781be5413bdf968f7ec4fdae0ab4b21",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "MirceaS/agda-categories",
"max_stars_repo_path": "src/Categories/Adjoint/Equivalence.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 6622,
"size": 12824
}
|
-- MIT License
-- Copyright (c) 2021 Luca Ciccone and Luca Padovani
-- Permission is hereby granted, free of charge, to any person
-- obtaining a copy of this software and associated documentation
-- files (the "Software"), to deal in the Software without
-- restriction, including without limitation the rights to use,
-- copy, modify, merge, publish, distribute, sublicense, and/or sell
-- copies of the Software, and to permit persons to whom the
-- Software is furnished to do so, subject to the following
-- conditions:
-- The above copyright notice and this permission notice shall be
-- included in all copies or substantial portions of the Software.
-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-- OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-- HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-- WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-- FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-- OTHER DEALINGS IN THE SOFTWARE.
{-# OPTIONS --guardedness #-}
open import Data.Empty
open import Data.Product
open import Data.List using ([]; _∷_; _++_)
open import Relation.Nullary
open import Relation.Unary using (_⊆_)
open import Relation.Nullary.Negation using (contraposition)
open import Common
module TraceInclusion {ℙ : Set} (message : Message ℙ)
where
open import Trace message
open import SessionType message
open import Transitions message
open import Session message
open import HasTrace message
open import TraceSet message
TraceInclusionS : SessionType -> SessionType -> Set
TraceInclusionS T S = ⟦ T ⟧ ⊆ ⟦ S ⟧
TraceExclusionS : SessionType -> SessionType -> Set
TraceExclusionS T S = ∃[ φ ] (T HasTrace φ × ¬ S HasTrace φ)
nil<=any : ∀{T} -> TraceInclusionS nil T
nil<=any (_ , () , refl)
nil<=any (_ , _ , step () _)
end<=def : ∀{T S} -> End T -> Defined S -> TraceInclusionS T S
end<=def e def (_ , tdef , refl) = _ , def , refl
end<=def (inp U) _ (_ , tdef , step inp tr) = ⊥-elim (U _ (transitions+defined->defined tr tdef))
end<=def (out U) _ (_ , tdef , step (out !x) _) = ⊥-elim (U _ !x)
inclusion-preserves-success : ∀{T S} -> TraceInclusionS T S -> ImplyS MaySucceed T S
inclusion-preserves-success spec ((R' # T') , reds , win#def w def) =
let as , rr , tr = unzip-red* reds in
let (S' , def' , sr) = spec (_ , def , tr) in
_ , zip-red* rr sr , win#def w def'
input-excluded-trace :
∀{f : Continuation}{x as}
(ntr : ¬ inp f HasTrace (I x ∷ as)) ->
¬ f x .force HasTrace as
input-excluded-trace ntr (_ , def , tr) = ntr (_ , def , step inp tr)
output-excluded-trace :
∀{f x as}
(ntr : ¬ out f HasTrace (O x ∷ as)) ->
¬ f x .force HasTrace as
output-excluded-trace {f} {x} ntr (_ , def , tr) with x ∈? f
... | yes fx = ntr (_ , def , step (out fx) tr)
output-excluded-trace {_} {_} _ (_ , def , refl) | no nfx = ⊥-elim (nfx def)
output-excluded-trace {_} {_} _ (_ , _ , step t _) | no nfx = ⊥-elim (nfx (transition->defined t))
has-trace-input : ∀{f x as} -> inp f HasTrace (I x ∷ as) -> f x .force HasTrace as
has-trace-input (_ , def , step inp tr) = _ , def , tr
has-trace-output : ∀{f x as} -> out f HasTrace (O x ∷ as) -> f x .force HasTrace as
has-trace-output (_ , def , step (out _) tr) = _ , def , tr
|
{
"alphanum_fraction": 0.6796690307,
"avg_line_length": 38.0224719101,
"ext": "agda",
"hexsha": "8dd36808accc8f0863a790b6b04bf519d935b5ee",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "c4b78e70c3caf68d509f4360b9171d9f80ecb825",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "boystrange/FairSubtypingAgda",
"max_forks_repo_path": "src/TraceInclusion.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c4b78e70c3caf68d509f4360b9171d9f80ecb825",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "boystrange/FairSubtypingAgda",
"max_issues_repo_path": "src/TraceInclusion.agda",
"max_line_length": 98,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "c4b78e70c3caf68d509f4360b9171d9f80ecb825",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "boystrange/FairSubtypingAgda",
"max_stars_repo_path": "src/TraceInclusion.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-24T14:38:47.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-07-29T14:32:30.000Z",
"num_tokens": 1002,
"size": 3384
}
|
mutual
record R : Set₁ where
field
A : Set
B : Set
B = A
field
C : Set
D : Set
D = A → B → C
record S : Set₁ where
field
A : Set
B : Set
B = A
field
C : Set
D : Set
D = A → B → C
|
{
"alphanum_fraction": 0.3878326996,
"avg_line_length": 9.3928571429,
"ext": "agda",
"hexsha": "8e194ad5d3a6e35ca63f701e569f002587628882",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/interaction/Issue3020-2.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/interaction/Issue3020-2.agda",
"max_line_length": 23,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/interaction/Issue3020-2.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 99,
"size": 263
}
|
module plfa-exercises.Practice2 where
-- Trying exercises:
-- 5.2 pp 340
-- 5.7 pp 386
-- 6.1 pp 423
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; subst)
open import Data.Nat using (ℕ; zero; suc; _+_; _*_)
open import Relation.Nullary using (¬_)
open import Data.Product using (_×_; proj₁; ∃-syntax) renaming (_,_ to ⟨_,_⟩)
open import Data.Sum using (_⊎_; inj₁; inj₂)
--open import plfa.part1.Isomorphism using (_≃_; extensionality)
∀-elim : ∀ {A : Set} {B : A → Set} → (L : ∀ (x : A) → B x) → (M : A) → B M
∀-elim l m = l m
--totype : ℕ → Set
--totype 0 = ℕ
--totype 1 = 4 ≡ 2 + 2
--totype _ = ℕ
-- λ noidea → ∀-elim {ℕ} {totype} noidea 4
------- Preliminary proofs -------
modus-tollens : ∀ {A B : Set}
→ (A → B)
-------------
→ (¬ B → ¬ A)
modus-tollens a→b = λ{¬b → λ{a → ¬b (a→b a)}}
----------------------------------
postulate
dne : ∀ {A : Set} → ¬ ¬ A → A
--data Σ (A : Set) (B : A → Set) : Set where
-- ⟨_,_⟩ : (x : A) → B x → Σ A B
--
--Σ-syntax = Σ
--infix 2 Σ-syntax
--syntax Σ-syntax A (λ x → B) = Σ[ x ∈ A ] B
--
--∃ : ∀ {A : Set} (B : A → Set) → Set
--∃ {A} B = Σ A B
--
--∃-syntax = ∃
--syntax ∃-syntax (λ x → B) = ∃[ x ] B
--⟨,⟩-syntax : ∀ {A : Set} {B : A → Set} (x : A) → B x → Σ A B
--⟨,⟩-syntax = ⟨_,_⟩
----⟨,⟩-syntax = Σ.⟨_,_⟩
--syntax ⟨,⟩-syntax x p = the-proof-for x is p
--∃-elim : ∀ {A : Set} {B : A → Set} {C : Set}
-- → (∀ x → B x → C)
-- → ∃[ x ] B x
-- ---------------
-- → C
--∃-elim f ⟨ x , y ⟩ = f x y
record _⇔_ (A B : Set) : Set where
field
to : A → B
from : B → A
---------------------- Athena book exercises ----------------------
exercise531 : ∀ {A : Set} {R : A → A → Set}
→ (∀ (x y : A) → R x y)
→ (∀ (x : A) → R x x)
exercise531 R x = R x x
exercise532 : ∀ {A : Set} (x : A) → ∃[ y ] (x ≡ y)
exercise532 e = ⟨ e , refl ⟩
exercise533 : ∀ {A : Set} {P Q S : A → Set}
→ (∀ {x} → (P x ⊎ Q x) → S x)
→ (∃[ y ] (Q y))
-------------------------
→ (∃[ y ] (S y))
exercise533 Px⊎Qx→Sx ⟨ y , qy ⟩ =
let
-- P x ⊎ Q x
py⊎qy = inj₂ qy
in ⟨ y , Px⊎Qx→Sx py⊎qy ⟩
exercise534 : ∀ {A : Set} {P Q S : A → Set}
→ (∃[ y ] (P y × Q y))
→ (∀ {y} → P y → S y)
-------------------------
→ (∃[ y ] (S y × Q y))
exercise534 ⟨ y , ⟨ py , qy ⟩ ⟩ py→sy = ⟨ y , ⟨ py→sy py , qy ⟩ ⟩
exercise535 : ∀ {A : Set} {P Q : A → Set}
→ (¬ ∃[ x ] (Q x))
→ (∀ {x} → P x → Q x)
-------------------------
→ (¬ ∃[ x ] (P x))
exercise535 ¬∃x-qx ∀x→px→qx = λ{ ∃x-px@(⟨ x , px ⟩) → ¬∃x-qx ⟨ x , ∀x→px→qx px ⟩ }
exercise536 : ∀ {A : Set} {P Q S : A → Set}
→ (∀ {y} → P y → Q y)
→ (∃[ y ] (S y × ¬ Q y))
------------------------
→ (∃[ y ] (S y × ¬ P y))
exercise536 ∀y→py→qy ⟨ y , ⟨ sy , ¬qy ⟩ ⟩ = ⟨ y , ⟨ sy , modus-tollens ∀y→py→qy ¬qy ⟩ ⟩
exercise537 : ∀ {A : Set} {P Q : A → Set} {R : A → A → Set}
→ (∀ {x} → R x x → P x)
→ (∃[ x ] (P x) → ¬ ∃[ x ] (Q x))
-------------------------------
→ ((∀ {x} → Q x) → ¬ ∃[ x ] (R x x))
exercise537 ∀x→rxx→px ∃x-px→¬∃x-qx ∀x→qx = λ{∃x-rxx@(⟨ x , rxx ⟩) → ∃x-px→¬∃x-qx ⟨ x , ∀x→rxx→px rxx ⟩ ⟨ x , ∀x→qx {x} ⟩ }
exercise538 : ∀ {A : Set} {P Q : A → Set}
→ (∃[ x ] (P x ⊎ Q x)) ⇔ (∃[ x ] (P x) ⊎ ∃[ x ] (Q x))
exercise538 = record { to = to ; from = from }
where
to : ∀ {A : Set} {P Q : A → Set}
→ ∃[ x ] (P x ⊎ Q x)
-----------------------------
→ ∃[ x ] (P x) ⊎ ∃[ x ] (Q x)
to ⟨ x , (inj₁ px) ⟩ = inj₁ ⟨ x , px ⟩
to ⟨ x , (inj₂ qx) ⟩ = inj₂ ⟨ x , qx ⟩
from : ∀ {A : Set} {P Q : A → Set}
→ ∃[ x ] (P x) ⊎ ∃[ x ] (Q x)
-----------------------------
→ ∃[ x ] (P x ⊎ Q x)
from (inj₁ ⟨ x , px ⟩) = ⟨ x , inj₁ px ⟩
from (inj₂ ⟨ x , qx ⟩) = ⟨ x , inj₂ qx ⟩
------------------
exercise571 : ∀ {A : Set} {P Q : A → Set}
→ (∀ {x} → P x ⇔ Q x)
→ (∀ {x} → P x) ⇔ (∀ {x} → Q x)
exercise571 px⇔qx =
record
{ to = λ{px → (_⇔_.to px⇔qx) px}
; from = λ{qx → (_⇔_.from px⇔qx) qx}
}
--exercise571 ∀x→px⇔qx =
-- record
-- { to = λ{∀x→px → (_⇔_.to (∀x→px⇔qx {x})) (∀x→px {x})}
-- ; from = λ{∀x→qx → (_⇔_.from (∀x→px⇔qx {x})) (∀x→qx {x})}
-- }
exercise572 : ∀ {A : Set} {B : Set} {Q S : B → Set} {R T : B → B → Set}
→ (∃[ y ] (R y y × A))
→ (∃[ y ] (Q y × T y y))
→ (∀ y → A × Q y → ¬ S y)
→ (∃[ y ] (¬ S y × T y y))
exercise572 ⟨ _ , ⟨ _ , a ⟩ ⟩ ⟨ y , ⟨ qy , tyy ⟩ ⟩ ∀y→a×qy→¬sy = ⟨ y , ⟨ ∀y→a×qy→¬sy y ⟨ a , qy ⟩ , tyy ⟩ ⟩
-- This is fucking false!!!
--postulate
-- existence : {A : Set} {P : A → Set}
-- → (∀ x → P x)
-- ----------------
-- → (∃[ x ] (P x))
-- This cannot be proved! Take the empty set as an example. For any function
-- and relation the ∀'s are trivially true, but there is no element that
-- actually fulfills the function or the relation
--exercise574 : ∀ {A : Set} {F : A → A} {R : A → A → Set}
-- → (∀ x → R x x)
-- → (∀ x → F x ≡ F (F x))
-- -----------------------
-- → (∃[ y ] (R y (F y)))
--exercise574 ∀x→rxx ∀x→fx≡ffx = ⟨ ? , ? ⟩
exercise574 : ∀ {F : ℕ → ℕ} {R : ℕ → ℕ → Set}
→ (∀ x → R x x)
→ (∀ x → F x ≡ F (F x))
-----------------------
→ (∃[ y ] (R y (F y)))
exercise574 {f} {r} ∀x→rxx ∀x→fx≡ffx =
let y = f 0
y≡fy = ∀x→fx≡ffx 0 -- F 0 ≡ F (F 0) => y ≡ F y
ryy = ∀x→rxx y -- R (F 0) (F 0) => R y y
ryfy = subst (r y) y≡fy ryy -- R (F 0) (F (F 0)) => R y (F y)
in ⟨ y , ryfy ⟩
------------------
exercise61a : ∀ {A B : Set}
→ (B ⊎ (A → B))
→ A
---------------
→ B
exercise61a (inj₁ b) _ = b
exercise61a (inj₂ a→b) a = a→b a
exercise61b : ∀ {A B C : Set}
→ (¬ B → ¬ C)
→ ((A × B) ⊎ ¬ ¬ C)
-------------------
→ B
exercise61b ¬b→¬c (inj₁ ⟨ a , b ⟩) = b
exercise61b ¬b→¬c (inj₂ ¬¬c) = dne ((modus-tollens ¬b→¬c) ¬¬c)
¬¬ : ∀ {A : Set}
→ A
→ ¬ ¬ A
¬¬ a = λ{¬a → ¬a a}
-- What is the difference between: ∀ x → P x → ∀ y → R y → L and (∀ x → P x) → (∀ y → R y) → L
---- Can the following be proved without Double Negation Elimination (dne)?
--lemma₁ : ∀ {A B : Set}
-- → (¬ B → ¬ A)
-- → A
-- -------------------
-- → B
--lemma₁ = ?
--
--lemma₂ : ∀ {A B : Set}
-- → (¬ B → ¬ A)
-- → ¬ ¬ A
-- -------------------
-- → B
--lemma₂ = ?
--
---- `lemma₁` seems not to imply `dne` but it can't be proven without it.
----
---- The answer is NO (for the second one)! Because from it we can prove `dne`!
---- `dne` cannot be proved in vanila Agda.
--dne₁ : ∀ {A : Set} → ¬ ¬ A → A
--dne₁ ¬¬a = lemma₁ ? ?
--
--dne₂ : ∀ {A : Set} → ¬ ¬ A → A
--dne₂ ¬¬a = lemma₂ (λ{x → x}) ¬¬a
|
{
"alphanum_fraction": 0.3674845745,
"avg_line_length": 29.5296610169,
"ext": "agda",
"hexsha": "4d9fcdd4c267536aad667ade0858f53562932f86",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "a432faf1b340cb379190a2f2b11b997b02d1cd8d",
"max_forks_repo_licenses": [
"CC0-1.0"
],
"max_forks_repo_name": "helq/old_code",
"max_forks_repo_path": "proglangs-learning/Agda/plfa-exercises/Practice2.agda",
"max_issues_count": 4,
"max_issues_repo_head_hexsha": "a432faf1b340cb379190a2f2b11b997b02d1cd8d",
"max_issues_repo_issues_event_max_datetime": "2021-06-07T15:39:48.000Z",
"max_issues_repo_issues_event_min_datetime": "2020-03-10T19:20:21.000Z",
"max_issues_repo_licenses": [
"CC0-1.0"
],
"max_issues_repo_name": "helq/old_code",
"max_issues_repo_path": "proglangs-learning/Agda/plfa-exercises/Practice2.agda",
"max_line_length": 122,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "a432faf1b340cb379190a2f2b11b997b02d1cd8d",
"max_stars_repo_licenses": [
"CC0-1.0"
],
"max_stars_repo_name": "helq/old_code",
"max_stars_repo_path": "proglangs-learning/Agda/plfa-exercises/Practice2.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2930,
"size": 6969
}
|
open import Issue623.B
|
{
"alphanum_fraction": 0.8260869565,
"avg_line_length": 11.5,
"ext": "agda",
"hexsha": "0649efb65f6d5abf8fa90ee642ae46f738785d83",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Fail/Issue623.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Fail/Issue623.agda",
"max_line_length": 22,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Fail/Issue623.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 6,
"size": 23
}
|
-- Soundness of term equality
module Semantics.Soundness where
open import Syntax.Types
open import Syntax.Context renaming (_,_ to _,,_)
open import Syntax.Terms
open import Syntax.Equality
open import Syntax.Substitution
open import Semantics.Types
open import Semantics.Context
open import Semantics.Terms
open import Semantics.Substitution
open import Semantics.Bind
open import CategoryTheory.Categories using (ext)
open import CategoryTheory.BCCCs.Cartesian using (Product)
open import CategoryTheory.BCCCs
open import CategoryTheory.Instances.Reactive renaming (top to Top)
open import CategoryTheory.NatTrans
open import CategoryTheory.Monad
open import TemporalOps.Diamond
open import TemporalOps.OtherOps
open import Data.Sum
open import Data.Product using (_,_ ; proj₁ ; proj₂)
open import Relation.Binary.PropositionalEquality as ≡
using (_≡_ ; refl ; sym ; trans ; cong ; cong₂ ; subst)
open ≡.≡-Reasoning
open Monad M-◇
open import Holes.Term using (⌞_⌟)
open import Holes.Cong.Propositional
open ⟦Kit⟧ ⟦𝒯erm⟧
open Kit 𝒯erm
open ⟦K⟧ ⟦𝒯erm⟧
open K 𝒯erm
mutual
-- Soundness of term equality: equal terms have equal denotations
sound : ∀{A Γ} {M₁ M₂ : Γ ⊢ A}
-> Γ ⊢ M₁ ≡ M₂ ∷ A
-> ⟦ M₁ ⟧ₘ ≈ ⟦ M₂ ⟧ₘ
sound (refl M) = refl
sound (Eq.sym eq) = ≡.sym (sound eq)
sound (Eq.trans eq₁ eq₂) = ≡.trans (sound eq₁) (sound eq₂)
sound (β-lam N M) {n} {⟦Γ⟧} rewrite subst-sound M N {n} {⟦Γ⟧} = refl
sound (β-fst M N) = refl
sound (β-snd M N) = refl
sound (β-inl M N₁ N₂) {n} {⟦Γ⟧} rewrite subst-sound M N₁ {n} {⟦Γ⟧} = refl
sound (β-inr M N₁ N₂) {n} {⟦Γ⟧} rewrite subst-sound M N₂ {n} {⟦Γ⟧} = refl
sound (β-sig N M) {n} {⟦Γ⟧} rewrite subst-sound M N {n} {⟦Γ⟧} = refl
sound (η-lam {A} M) {n} {⟦Γ⟧} = ext λ ⟦A⟧ →
cong (λ x → x ⟦A⟧) (≡.sym (⟦𝓌⟧ (A now) M {n} {⟦Γ⟧ , ⟦A⟧}))
sound (η-pair M) = ≡.sym (⊗-η-exp {m = ⟦ M ⟧ₘ})
sound (η-unit M) = refl
sound (η-sum M) {n} {⟦Γ⟧} with ⟦ M ⟧ₘ n ⟦Γ⟧
sound (η-sum M) {n} {a} | inj₁ _ = refl
sound (η-sum M) {n} {a} | inj₂ _ = refl
sound (η-sig M) = refl
sound {Γ = Γ} (η-evt {A} M) {n} {a}
rewrite bind-to->>= Γ (⟦ M ⟧ₘ) (η.at ⟦ A ⟧ₜ ∘ π₂) n a
= ≡.sym (>>=-unit-right (⟦ M ⟧ₘ n a))
sound (cong-pair eq₁ eq₂) {n} {a} rewrite sound eq₁ {n} {a}
| sound eq₂ {n} {a} = refl
sound (cong-fst eq) {n} {a} rewrite sound eq {n} {a} = refl
sound (cong-snd eq) {n} {a} rewrite sound eq {n} {a} = refl
sound (cong-lam eq) {n} {a} = ext λ ⟦A⟧ → sound eq
sound (cong-app eq₁ eq₂) {n} {a} rewrite sound eq₁ {n} {a}
| sound eq₂ {n} {a} = refl
sound (cong-inl eq) {n} {a} rewrite sound eq {n} {a} = refl
sound (cong-inr eq) {n} {a} rewrite sound eq {n} {a} = refl
sound (cong-case eq N₁ N₂) {n} {a} rewrite sound eq {n} {a} = refl
sound (cong-sig eq) {n} {a} rewrite sound eq {n} {a} = refl
sound (cong-letSig eq N) {n} {a} rewrite sound eq {n} {a} = refl
sound (cong-sample eq) {n} {a} rewrite sound eq {n} {a} = refl
sound (cong-stable eq) = ext λ k → sound eq
sound (cong-event eq) {n} {a} rewrite sound′ eq {n} {a} = refl
-- Soundness of computational term equality: equal terms have equal denotations
sound′ : ∀{A Γ} {M₁ M₂ : Γ ⊨ A}
-> Γ ⊨ M₁ ≡ M₂ ∷ A
-> ⟦ M₁ ⟧ᵐ ≈ ⟦ M₂ ⟧ᵐ
sound′ (refl M) = refl
sound′ (Eq′.sym eq) = ≡.sym (sound′ eq)
sound′ (Eq′.trans eq₁ eq₂) = ≡.trans (sound′ eq₁) (sound′ eq₂)
sound′ (β-sig′ C M) {n} {⟦Γ⟧} rewrite subst′-sound M C {n} {⟦Γ⟧} = refl
sound′ (β-evt′ C D) {n} {⟦Γ⟧} rewrite subst″-sound D C {n} {⟦Γ⟧} = refl
sound′ {_}{Γ} (β-selectₚ {A}{B}{C} C₁ C₂ C₃ M₁ M₂) {n} {⟦Γ⟧} =
begin
⟦ select event (pure M₁) ↦ C₁ || event (pure M₂) ↦ C₂ ||both↦ C₃ ⟧ᵐ n ⟦Γ⟧
≡⟨⟩
⟦ C₃ ⟧ᵐ n ((⌞ ⟦ Γ ˢ⟧□ n ⟦Γ⟧ n ⌟ , ⟦ M₁ ⟧ₘ n ⟦Γ⟧) , ⟦ M₂ ⟧ₘ n ⟦Γ⟧)
≡⟨ cong! (⟦ˢ⟧-factor Γ {n} {⟦Γ⟧}) ⟩
⟦ C₃ ⟧ᵐ n ((⌞ ⟦ Γ ˢ⟧ n ⟦Γ⟧ ⌟ , ⟦ M₁ ⟧ₘ n ⟦Γ⟧) , ⟦ M₂ ⟧ₘ n ⟦Γ⟧)
≡⟨ cong! (⟦subst⟧-Γˢ⊆Γ Γ {n} {⟦Γ⟧}) ⟩
⟦ C₃ ⟧ᵐ n (⌞ (⟦subst⟧ (Γˢ⊆Γ Γ ⊆ₛ 𝒯erm) n ⟦Γ⟧ , ⟦ M₁ ⟧ₘ n ⟦Γ⟧) ⌟ , ⟦ M₂ ⟧ₘ n ⟦Γ⟧ )
≡⟨ cong! (⟦↑⟧ (A now) (Γˢ⊆Γ Γ ⊆ₛ 𝒯erm) {n} {⟦Γ⟧ , (⟦ M₁ ⟧ₘ n ⟦Γ⟧)}) ⟩
⟦ C₃ ⟧ᵐ n ⌞ ((⟦subst⟧ (_↑_ {A now} (Γˢ⊆Γ Γ ⊆ₛ 𝒯erm) 𝒯erm) n (⟦Γ⟧ , ⟦ M₁ ⟧ₘ n ⟦Γ⟧)) , ⟦ M₂ ⟧ₘ n ⟦Γ⟧) ⌟
≡⟨ cong! (⟦↑⟧ (B now) (_↑_ {A now} (Γˢ⊆Γ Γ ⊆ₛ 𝒯erm) 𝒯erm) {n} {(⟦Γ⟧ , ⟦ M₁ ⟧ₘ n ⟦Γ⟧) , (⟦ M₂ ⟧ₘ n ⟦Γ⟧)}) ⟩
⟦ C₃ ⟧ᵐ n (⟦subst⟧ (_↑_ {B now} (_↑_ {A now} (Γˢ⊆Γ Γ ⊆ₛ 𝒯erm) 𝒯erm) 𝒯erm) n ((⟦Γ⟧ , ⟦ M₁ ⟧ₘ n ⟦Γ⟧) , ⌞ ⟦ M₂ ⟧ₘ n ⟦Γ⟧ ⌟))
≡⟨ cong! (⟦𝓌⟧ (A now) M₂ {n} {⟦Γ⟧ , (⟦ M₁ ⟧ₘ n ⟦Γ⟧)}) ⟩
⟦ C₃ ⟧ᵐ n (⟦subst⟧ (weakₛ 𝒯ermₛ s) n ((⟦Γ⟧ , ⟦ M₁ ⟧ₘ n ⟦Γ⟧) , ⟦ 𝓌 M₂ ⟧ₘ n (⟦Γ⟧ , ⟦ M₁ ⟧ₘ n ⟦Γ⟧)))
≡⟨ ≡.sym (traverse′-sound ⟦𝒯erm⟧ (weakₛ 𝒯ermₛ s) C₃ {n} {(⟦Γ⟧ , ⟦ M₁ ⟧ₘ n ⟦Γ⟧) , ⟦ 𝓌 M₂ ⟧ₘ n (⟦Γ⟧ , (⟦ M₁ ⟧ₘ n ⟦Γ⟧))}) ⟩
⟦ traverse′ (weakₛ 𝒯ermₛ s) C₃ ⟧ᵐ n ((⟦Γ⟧ , ⟦ M₁ ⟧ₘ n ⟦Γ⟧) , ⟦ 𝓌 M₂ ⟧ₘ n (⟦Γ⟧ , (⟦ M₁ ⟧ₘ n ⟦Γ⟧)))
≡⟨ ≡.sym (subst′-sound (𝓌 M₂) (weakening′ s C₃) {n} {⟦Γ⟧ , (⟦ M₁ ⟧ₘ n ⟦Γ⟧)}) ⟩
⟦ [ 𝓌 M₂ /′] (weakening′ s C₃) ⟧ᵐ n (⟦Γ⟧ , (⟦ M₁ ⟧ₘ n ⟦Γ⟧))
≡⟨ ≡.sym (subst′-sound M₁ ([ 𝓌 M₂ /′] (weakening′ s C₃)) {n} {⟦Γ⟧} ) ⟩
⟦ [ M₁ /′] ([ 𝓌 M₂ /′] (weakening′ s C₃)) ⟧ᵐ n ⟦Γ⟧
∎
where
s : Γ ˢ ,, A now ,, B now ⊆ Γ ,, A now ,, B now
s = keep (keep (Γˢ⊆Γ Γ))
sound′ (η-sig′ M) = refl
sound′ (cong-pure′ eq) {n} {⟦Γ⟧} rewrite sound eq {n} {⟦Γ⟧} = refl
sound′ (cong-letSig′ eq B) {n} {⟦Γ⟧} rewrite sound eq {n} {⟦Γ⟧} = refl
sound′ (cong-letEvt′ eq D) {n} {⟦Γ⟧} rewrite sound eq {n} {⟦Γ⟧} = refl
|
{
"alphanum_fraction": 0.5054754041,
"avg_line_length": 46.7723577236,
"ext": "agda",
"hexsha": "57c897b5070243d157f710d6e07e241b9de0cbb3",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7d993ba55e502d5ef8707ca216519012121a08dd",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "DimaSamoz/temporal-type-systems",
"max_forks_repo_path": "src/Semantics/Soundness.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7d993ba55e502d5ef8707ca216519012121a08dd",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "DimaSamoz/temporal-type-systems",
"max_issues_repo_path": "src/Semantics/Soundness.agda",
"max_line_length": 132,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "7d993ba55e502d5ef8707ca216519012121a08dd",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "DimaSamoz/temporal-type-systems",
"max_stars_repo_path": "src/Semantics/Soundness.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-04T09:33:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-05-31T20:37:04.000Z",
"num_tokens": 2983,
"size": 5753
}
|
module _ where
postulate
A B : Set
{-# DISPLAY A = B #-}
{-# DISPLAY B = A #-}
loop : A
loop = {!!}
|
{
"alphanum_fraction": 0.5,
"avg_line_length": 8.8333333333,
"ext": "agda",
"hexsha": "fd3e89cb89848f21ca93f687bf3b33174b841d38",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Fail/Issue1644.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Fail/Issue1644.agda",
"max_line_length": 21,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Fail/Issue1644.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 34,
"size": 106
}
|
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Decidable.Relations
open import Boolean.Definition
module Decidable.Reduction where
squash : {a b : _} {A : Set a} {f : A → Set b} → DecidableRelation f → A → Bool
squash rel a with rel a
... | inl x = BoolTrue
... | inr x = BoolFalse
unsquash : {a b : _} {A : Set a} {f : A → Set b} → (rel : DecidableRelation f) → {x : A} → .(squash rel x ≡ BoolTrue) → f x
unsquash rel {x} pr with rel x
... | inl ans = ans
|
{
"alphanum_fraction": 0.6376237624,
"avg_line_length": 29.7058823529,
"ext": "agda",
"hexsha": "f4e801381723e451f04557fb387e67b823f97f6d",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-29T13:23:07.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-29T13:23:07.000Z",
"max_forks_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Smaug123/agdaproofs",
"max_forks_repo_path": "Decidable/Reduction.agda",
"max_issues_count": 14,
"max_issues_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_issues_repo_issues_event_max_datetime": "2020-04-11T11:03:39.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-06T21:11:59.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Smaug123/agdaproofs",
"max_issues_repo_path": "Decidable/Reduction.agda",
"max_line_length": 123,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Smaug123/agdaproofs",
"max_stars_repo_path": "Decidable/Reduction.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-28T06:04:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-08-08T12:44:19.000Z",
"num_tokens": 172,
"size": 505
}
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- All predicate transformer for fresh lists
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Fresh.Relation.Unary.All where
open import Level using (Level; _⊔_; Lift)
open import Data.Product using (_×_; _,_; proj₁; uncurry)
open import Relation.Nullary
import Relation.Nullary.Decidable as Dec
open import Relation.Nullary.Product using (_×-dec_)
open import Relation.Unary as U
open import Relation.Binary as B using (Rel)
open import Data.List.Fresh using (List#; []; cons; _∷#_; _#_)
open import Data.List.Fresh.Relation.Unary.Any as Any using (Any; here; there)
private
variable
a p q r : Level
A : Set a
module _ {A : Set a} {R : Rel A r} (P : Pred A p) where
data All : List# A R → Set (p ⊔ a ⊔ r) where
[] : All []
_∷_ : ∀ {x xs pr} → P x → All xs → All (cons x xs pr)
module _ {R : Rel A r} {P : Pred A p} where
uncons : ∀ {x} {xs : List# A R} {pr} →
All P (cons x xs pr) → P x × All P xs
uncons (p ∷ ps) = p , ps
module _ {R : Rel A r} where
append : (xs ys : List# A R) → All (_# ys) xs → List# A R
append-# : ∀ {x} xs ys {ps} → x # xs → x # ys → x # append xs ys ps
append [] ys _ = ys
append (cons x xs pr) ys ps =
let (p , ps) = uncons ps in
cons x (append xs ys ps) (append-# xs ys pr p)
append-# [] ys x#xs x#ys = x#ys
append-# (cons x xs pr) ys (r , x#xs) x#ys = r , append-# xs ys x#xs x#ys
module _ {R : Rel A r} {P : Pred A p} {Q : Pred A q} where
map : ∀ {xs : List# A R} → ∀[ P ⇒ Q ] → All P xs → All Q xs
map p⇒q [] = []
map p⇒q (p ∷ ps) = p⇒q p ∷ map p⇒q ps
lookup : ∀ {xs : List# A R} → All Q xs → (ps : Any P xs) →
Q (proj₁ (Any.witness ps))
lookup (q ∷ _) (here _) = q
lookup (_ ∷ qs) (there k) = lookup qs k
module _ {R : Rel A r} {P : Pred A p} (P? : Decidable P) where
all? : (xs : List# A R) → Dec (All P xs)
all? [] = yes []
all? (x ∷# xs) = Dec.map′ (uncurry _∷_) uncons (P? x ×-dec all? xs)
|
{
"alphanum_fraction": 0.5178323298,
"avg_line_length": 31.75,
"ext": "agda",
"hexsha": "a4046909775314e68020c240e06e2188e61e722a",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-04T06:54:45.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-04T06:54:45.000Z",
"max_forks_repo_head_hexsha": "fb380f2e67dcb4a94f353dbaec91624fcb5b8933",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "DreamLinuxer/popl21-artifact",
"max_forks_repo_path": "agda-stdlib/src/Data/List/Fresh/Relation/Unary/All.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "fb380f2e67dcb4a94f353dbaec91624fcb5b8933",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "DreamLinuxer/popl21-artifact",
"max_issues_repo_path": "agda-stdlib/src/Data/List/Fresh/Relation/Unary/All.agda",
"max_line_length": 78,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "fb380f2e67dcb4a94f353dbaec91624fcb5b8933",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "DreamLinuxer/popl21-artifact",
"max_stars_repo_path": "agda-stdlib/src/Data/List/Fresh/Relation/Unary/All.agda",
"max_stars_repo_stars_event_max_datetime": "2020-10-10T21:41:32.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-10-07T12:07:53.000Z",
"num_tokens": 749,
"size": 2159
}
|
module Data.Bit where
open import Data.Nat.Literal using (Number; ℕ-num; Fin-num)
open import Data.Nat using (ℕ ; suc; zero; ⌊_/2⌋)
renaming (_*_ to ℕ*; _+_ to ℕ+; _≤_ to ℕ≤; _^_ to ℕ^)
open import Data.Int.Literal using (Negative)
open import Data.Fin using (Fin; suc; zero; raise)
renaming (toℕ to finToℕ; fromℕ to finFromℕ)
open import Data.Product using (_×_; _,_; proj₁; proj₂)
open import Data.Vec using (Vec; []; _∷_; _++_; replicate; insert; head; tail)
renaming (map to mapVec)
open import Data.Unit using (⊤)
open import Data.Empty using (⊥)
open import Level using (_⊔_)
open import Data.Bool using (Bool; false; true) renaming (_∧_ to Bool-∧)
open import Data.Maybe using (Maybe; just; nothing; map)
record WithCarry {a} {c} (A : Set a) (C : Set c) : Set (a ⊔ c) where
constructor _with-carry:_
field
result : A
carry : C
open WithCarry public
record Overflowing {a} (A : Set a) : Set a where
constructor _overflow:_
field
result : A
overflow : Bool
open Overflowing public
data Bit : Set where
b0 : Bit
b1 : Bit
infixl 8 _-_ _+_
infixl 7 _<<_ _>>_
infixl 6 _∧_ _&_
infixl 5 _⊕_ _^_
infixl 4 _∨_ _~|_
infixl 3 _↔_ _==_
infixl 1 _with-carry:_
fromBool : Bool → Bit
fromBool false = b0
fromBool true = b1
toBool : Bit → Bool
toBool b0 = false
toBool b1 = true
! : Bit → Bit
! b0 = b1
! b1 = b0
_∧_ : Bit → Bit → Bit
b0 ∧ _ = b0
b1 ∧ q = q
_∨_ : Bit → Bit → Bit
b0 ∨ q = q
b1 ∨ _ = b1
_⊕_ : Bit → Bit → Bit
b0 ⊕ q = q
b1 ⊕ q = ! q
_↔_ : Bit → Bit → Bit
b0 ↔ q = ! q
b1 ↔ q = q
maj3 : Bit → Bit → Bit → Bit
maj3 p q r = p ∧ q ∨ p ∧ r ∨ q ∧ r
half-add : Bit → Bit → WithCarry Bit Bit
half-add p q = p ⊕ q with-carry: p ∧ q
full-add : Bit → Bit → Bit → WithCarry Bit Bit
full-add p q r = p ⊕ q ⊕ r with-carry: maj3 p q r
full-addₙ : {n : ℕ} →
Vec Bit n →
Vec Bit n →
Bit →
WithCarry (Vec Bit n) (Vec Bit 2)
full-addₙ [] [] r = [] with-carry: b0 ∷ r ∷ []
full-addₙ (p ∷ []) (q ∷ []) r = result s ∷ [] with-carry: r ∷ carry s ∷ [] where
s = full-add p q r
full-addₙ (p ∷ ps) (q ∷ qs) r = result s ∷ result ss with-carry: carry ss where
s = full-add p q r
ss = full-addₙ ps qs (carry s)
!ₙ : {n : ℕ} → Vec Bit n → Vec Bit n
!ₙ = mapVec !
_+_ : {n : ℕ} → Vec Bit n → Vec Bit n → WithCarry (Vec Bit n) (Vec Bit 2)
ps + qs = full-addₙ ps qs b0
_-_ : {n : ℕ} → Vec Bit n → Vec Bit n → WithCarry (Vec Bit n) (Vec Bit 2)
ps - qs = full-addₙ ps (!ₙ qs) b1
inc : {n : ℕ} → Vec Bit n → WithCarry (Vec Bit n) (Vec Bit 2)
inc ps = full-addₙ ps (replicate b0) b1
dec : {n : ℕ} → Vec Bit n → WithCarry (Vec Bit n) (Vec Bit 2)
dec ps = full-addₙ ps (replicate b1) b0
_>>_ : {m : ℕ} → Vec Bit m → Fin m → WithCarry (Vec Bit m) (Vec Bit m)
ps >> zero = ps with-carry: replicate b0
_>>_ {suc m} (p ∷ ps) (suc i) = new-result with-carry: new-carry
where
qs : WithCarry (Vec Bit m) (Vec Bit m)
qs = ps >> i
new-result : Vec Bit (suc m)
new-result = insert (result qs) (finFromℕ m) b0
new-carry : Vec Bit (suc m)
new-carry = insert (carry qs) (finFromℕ m) p
_<<_ : {m : ℕ} → Vec Bit m → Fin m → WithCarry (Vec Bit m) (Vec Bit m)
_<<_ {m} ps i = proj₂ (do-shift ps) where
do-shift : {n : ℕ} → Vec Bit n → Fin m × WithCarry (Vec Bit n) (Vec Bit n)
do-shift [] = i , ([] with-carry: [])
do-shift {suc n} (p ∷ ps) = ret (proj₁ pair) where
pair : Fin m × WithCarry (Vec Bit n) (Vec Bit n)
pair = do-shift ps
qs : WithCarry (Vec Bit n) (Vec Bit n)
qs = proj₂ pair
ret : Fin m → Fin m × WithCarry (Vec Bit (suc n)) (Vec Bit (suc n))
ret zero = zero , (b0 ∷ result qs with-carry: p ∷ carry qs)
ret (suc j) = raise 1 j , (p ∷ result qs with-carry: b0 ∷ carry qs)
_>>>_ : {m : ℕ} → Vec Bit m → Fin m → WithCarry (Vec Bit m) (Vec Bit m)
ps >>> zero = ps with-carry: replicate b0
_>>>_ {suc m} (p ∷ ps) (suc i) = new-result with-carry: new-carry where
qs : WithCarry (Vec Bit m) (Vec Bit m)
qs = ps >> i
new-result : Vec Bit (suc m)
new-result = insert (result qs) (finFromℕ m) p
new-carry : Vec Bit (suc m)
new-carry = b0 ∷ carry qs
_<<<_ : {m : ℕ} → Vec Bit m → Fin m → WithCarry (Vec Bit m) (Vec Bit m)
ps <<< zero = ps with-carry: replicate b0
_<<<_ {suc m} (p ∷ ps) (suc i) = new-result with-carry: new-carry where
qs : WithCarry (Vec Bit m) (Vec Bit m)
qs = ps << i
new-result : Vec Bit (suc m)
new-result = p ∷ result qs
new-carry : Vec Bit (suc m)
new-carry = insert (result qs) (finFromℕ m) b0
_&_ : {n : ℕ} → Vec Bit n → Vec Bit n → Vec Bit n
[] & [] = []
(p ∷ ps) & (q ∷ qs) = p ∧ q ∷ ps & qs
_~|_ : {n : ℕ} → Vec Bit n → Vec Bit n → Vec Bit n
[] ~| [] = []
(p ∷ ps) ~| (q ∷ qs) = (p ∨ q) ∷ (ps ~| qs)
_^_ : {n : ℕ} → Vec Bit n → Vec Bit n → Vec Bit n
[] ^ [] = []
(p ∷ ps) ^ (q ∷ qs) = (p ⊕ q) ∷ (ps ^ qs)
~ : {n : ℕ} → Vec Bit n → WithCarry (Vec Bit n) (Vec Bit 2)
~ n = inc (!ₙ n)
toℕ : Bit → ℕ
toℕ b0 = 0
toℕ b1 = 1
toFin : {n : ℕ} → Bit → Fin (suc (suc n))
toFin b0 = 0
toFin b1 = 1
toℕₙ : {n : ℕ} → Vec Bit n → ℕ
toℕₙ [] = 0
toℕₙ (p ∷ ps) = ℕ+ (toℕ p) (ℕ* 2 (toℕₙ ps))
tryToFinₙ : {m n : ℕ} → Vec Bit m → Maybe (Fin n)
tryToFinₙ {_} {n} ps = tryℕ n (toℕₙ ps) where
tryℕ : (k : ℕ) → ℕ → Maybe (Fin k)
tryℕ zero _ = nothing
tryℕ (suc _) zero = just zero
tryℕ (suc m) (suc n) = map suc (tryℕ m n)
ℕ-mod2 : ℕ → Bit
ℕ-mod2 zero = b0
ℕ-mod2 (suc zero) = b1
ℕ-mod2 (suc (suc n)) = ℕ-mod2 n
instance
Bit-num : Number Bit
Bit-num .Number.Constraint n = constrain n where
constrain : ℕ → Set
constrain zero = ⊤
constrain (suc zero) = ⊤
constrain _ = ⊥
Bit-num .Number.fromNat n ⦃ p ⦄ = fromNat n p where
fromNat : (m : ℕ) → (Number.Constraint Bit-num) m → Bit
fromNat zero _ = b0
fromNat (suc zero) _ = b1
fromNat (suc (suc _)) ()
instance
Bits-num : {m : ℕ} → Number (Vec Bit m)
Bits-num {m} .Number.Constraint n = ℕ≤ (suc n) (ℕ^ 2 m)
Bits-num {m} .Number.fromNat n = fromNat m n where
fromNat : (m : ℕ) → ℕ → Vec Bit m
fromNat zero _ = []
fromNat (suc m) n = ℕ-mod2 n ∷ fromNat m ⌊ n /2⌋
instance
Bits-neg : {m : ℕ} → Negative (Vec Bit (suc m))
Bits-neg {m} .Negative.Constraint n = ℕ≤ n (ℕ^ 2 m)
Bits-neg {m} .Negative.fromNeg n = number where
iterateBits : (m : ℕ) → ℕ → Vec Bit m × Bit
iterateBits zero _ = [] , b0 where
iterateBits (suc m) n = newVec , newSign where
subRes : Vec Bit m × Bit
subRes = iterateBits m ⌊ n /2⌋
newVec : Vec Bit (suc m)
newVec = ℕ-mod2 n ∷ proj₁ subRes
newSign : Bit
newSign = ℕ-mod2 n ∨ proj₂ subRes
iteration : Vec Bit (suc m) × Bit
iteration = iterateBits (suc m) n
preNumber : Vec Bit (suc m)
preNumber = proj₁ iteration
signBit : Bit
signBit = proj₂ iteration
number : Vec Bit (suc m)
number = (head preNumber ∨ signBit) ∷ tail preNumber
_==_ : {n : ℕ} → Vec Bit n → Vec Bit n → Bool
[] == [] = true
p ∷ ps == q ∷ qs = Bool-∧ (toBool (p ↔ q)) (ps == qs)
|
{
"alphanum_fraction": 0.5673667667,
"avg_line_length": 29.0414937759,
"ext": "agda",
"hexsha": "310dde3d3b482ad31915f9c7bcd69bafcea192ef",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "9f5129d97ee7b89fb8e43136779a78806b7506ab",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "brunoczim/Celeste",
"max_forks_repo_path": "formalization/Data/Bit.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "9f5129d97ee7b89fb8e43136779a78806b7506ab",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "brunoczim/Celeste",
"max_issues_repo_path": "formalization/Data/Bit.agda",
"max_line_length": 80,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "9f5129d97ee7b89fb8e43136779a78806b7506ab",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "brunoczim/Celeste",
"max_stars_repo_path": "formalization/Data/Bit.agda",
"max_stars_repo_stars_event_max_datetime": "2020-09-16T17:31:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-09-16T17:31:57.000Z",
"num_tokens": 2822,
"size": 6999
}
|
{-# OPTIONS --without-K --safe #-}
module Cats.Category.Fun.Facts where
open import Cats.Category.Fun.Facts.Iso public using
( ≈→≅ ; ≅→≈ )
open import Cats.Category.Fun.Facts.Limit public using
( complete )
open import Cats.Category.Fun.Facts.Product public using
( hasBinaryProducts ; hasFiniteProducts )
open import Cats.Category.Fun.Facts.Terminal public using
( hasTerminal )
|
{
"alphanum_fraction": 0.7455012853,
"avg_line_length": 32.4166666667,
"ext": "agda",
"hexsha": "182c65f5d4799af74661321cd765ad8654172fbf",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-18T15:35:07.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-18T15:35:07.000Z",
"max_forks_repo_head_hexsha": "1ad7b243acb622d46731e9ae7029408db6e561f1",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "JLimperg/cats",
"max_forks_repo_path": "Cats/Category/Fun/Facts.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "1ad7b243acb622d46731e9ae7029408db6e561f1",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "JLimperg/cats",
"max_issues_repo_path": "Cats/Category/Fun/Facts.agda",
"max_line_length": 57,
"max_stars_count": 24,
"max_stars_repo_head_hexsha": "1ad7b243acb622d46731e9ae7029408db6e561f1",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "JLimperg/cats",
"max_stars_repo_path": "Cats/Category/Fun/Facts.agda",
"max_stars_repo_stars_event_max_datetime": "2021-08-06T05:00:46.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-11-03T15:18:57.000Z",
"num_tokens": 101,
"size": 389
}
|
-- Andreas, 2012-09-15
{-# OPTIONS --show-implicit #-}
-- {-# OPTIONS -v tc.meta:50 #-}
-- {-# OPTIONS -v tc.conv:50 #-}
-- {-# OPTIONS -v tc.polarity:10 #-}
-- {-# OPTIONS -v tc.constr.findInScope:50 #-}
module BrokenInferenceDueToNonvariantPolarity where
import Common.Level
data ⊥ : Set where
record ⊤ : Set where
data Nat : Set where
zero : Nat
suc : Nat → Nat
False : Nat → Set
False zero = ⊥
False (suc n) = False n
module Invariant where
record Bla (n : Nat)(p : False n) : Set where
-- phantom arguments to Bla get polarity 'Invariant'
module Nonvariant where
Bla : (n : Nat) → False n → Set
Bla n p = ⊤
-- polarity checker infers arguments to be 'Nonvariant'
-- open Invariant -- succeeds
open Nonvariant -- fails
module Works where
drop-suc : {n : Nat}{{p : False n}} → Bla (suc n) p → Bla n p
drop-suc _ = _
works : (n : Nat) → {{p : False n}} → Bla n p → ⊥
works zero {{()}} b
works (suc n) b = works n (drop-suc {n} b)
module Fails where
drop-suc : {n : Nat}{{p : False n}} → Bla (suc n) p → Bla n p
drop-suc _ = _
bla : (n : Nat) → {p : False n} → Bla n p → ⊥
bla zero {()} b
bla (suc n) b = bla n (drop-suc b)
-- Since Bla is analysed as constant function, the constraint
-- Bla n p = Bla X Y does not provide unique solutions for X and Y.
-- And since the positivity checker runs after constraint solving,
-- Agda does not recognize that bla is Nonvariant in argument p
-- and that it hence could search for any solution.
|
{
"alphanum_fraction": 0.6271637816,
"avg_line_length": 26.350877193,
"ext": "agda",
"hexsha": "5fc06db32dd1bdcbc116a401a6f8802925cefa5a",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Fail/BrokenInferenceDueToNonvariantPolarity.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Fail/BrokenInferenceDueToNonvariantPolarity.agda",
"max_line_length": 69,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Fail/BrokenInferenceDueToNonvariantPolarity.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 491,
"size": 1502
}
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Data.SumFin where
open import Cubical.Data.SumFin.Base public
open import Cubical.Data.SumFin.Properties public
|
{
"alphanum_fraction": 0.7765363128,
"avg_line_length": 29.8333333333,
"ext": "agda",
"hexsha": "dda8267b061cbb1e3e8d8b5d14107ba1b1eecff9",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-22T02:02:01.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-22T02:02:01.000Z",
"max_forks_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "dan-iel-lee/cubical",
"max_forks_repo_path": "Cubical/Data/SumFin.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_issues_repo_issues_event_max_datetime": "2022-01-27T02:07:48.000Z",
"max_issues_repo_issues_event_min_datetime": "2022-01-27T02:07:48.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "dan-iel-lee/cubical",
"max_issues_repo_path": "Cubical/Data/SumFin.agda",
"max_line_length": 50,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "dan-iel-lee/cubical",
"max_stars_repo_path": "Cubical/Data/SumFin.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 42,
"size": 179
}
|
-- Interacting with the real world ---Compilation, Haskell, and IO
-- :PROPERTIES:
-- :header-args: :tangle "CompilingAgda.agda" :comments org
-- :CUSTOM_ID: agda-interacting-with-the-real-world
-- :END:
-- # C-c C-v C-t tangles the following code into CompilingAgda.agda.
-- # Then we may compile the result using:
-- # (shell-command "NAME=CompilingAgda; time agda --compile $NAME.agda; ./$NAME")
-- #
-- # Btw: (find-file "./MAlonzo/Code/CompilingAgda.hs")
-- #+latex: {\color{white}.} \vspace{-1em}
-- #+begin_quote org
-- /Let's demonstrate how we can reach into Haskell, thereby subverting Agda!/
-- #+end_quote
-- An Agda program module containing a ~main~ function is compiled into a standalone executable
-- with ~agda --compile myfile.agda~. If the module has no main file, use the flag ~--no-main~.
-- If you only want the resulting Haskell, not necessarily an executable program, then use the flag
-- ~--ghc-dont-call-ghc~.
-- The type of ~main~ should be ~Agda.Builtin.IO.IO A~, for some ~A~;
-- this is just a proxy to Haskell's ~IO~.
-- We may ~open import IO.Primitive~ to get /this/ ~IO~, but
-- this one works with costrings, which are a bit awkward.
-- Instead, we use the standard library's wrapper type, also named ~IO~.
-- Then we use ~run~ to move from ~IO~ to ~Primitive.IO~; conversely one uses ~lift~.
-- #+latex: \begin{minipage}[c]{0.55\linewidth}
-- #+latex: \begin{tiny}
open import Data.Nat using (ℕ; suc)
open import Data.Nat.Show using (show)
open import Data.Char using (Char)
open import Data.List as L using (map; sum; upTo)
open import Function using (_$_; const; _∘_)
open import Data.String as S using (String; _++_; fromList)
open import Agda.Builtin.Unit using (⊤)
open import Codata.Musical.Colist using (take)
open import Codata.Musical.Costring using (Costring)
open import Data.BoundedVec.Inefficient as B using (toList)
open import Agda.Builtin.Coinduction using (♯_)
open import IO as IO using (run ; putStrLn ; IO)
import IO.Primitive as Primitive
-- #+latex: \end{tiny}
-- #+latex: \end{minipage} % no space if you would like to put them side by side
-- #+latex: \begin{minipage}[c]{0.5\linewidth}
-- #+begin_quote org
-- /Agda has *no* primitives for side-effects, instead it allows arbitrary/
-- /Haskell functions to be imported as axioms, whose definitions are only/
-- /used at run-time./
-- #+end_quote
-- #+latex: \end{minipage}
-- Agda lets us use “do”-notation as in Haskell.
-- To do so, methods named ~_>>_~ and ~_>>=_~ need to be in scope ---that is all.
-- The type of ~IO._>>_~ takes two “lazy” IO actions and yield a non-lazy IO action.
-- The one below is a homogeneously typed version.
infixr 1 _>>=_ _>>_
_>>=_ : ∀ {ℓ} {α β : Set ℓ} → IO α → (α → IO β) → IO β
this >>= f = ♯ this IO.>>= λ x → ♯ f x
_>>_ : ∀{ℓ} {α β : Set ℓ} → IO α → IO β → IO β
x >> y = x >>= const y
-- Oddly, Agda's standard library comes with ~readFile~ and
-- ~writeFile~, but the symmetry ends there since it provides ~putStrLn~
-- but not [[https://hackage.haskell.org/package/base-4.12.0.0/docs/Prelude.html#v:getLine][~getLine~]]. Mimicking the ~IO.Primitive~ module, we define /two/
-- versions ourselves as proxies for Haskell's ~getLine~ ---the second one
-- below is bounded by 100 characters, whereas the first is not.
postulate
getLine∞ : Primitive.IO Costring
{-# FOREIGN GHC
toColist :: [a] -> MAlonzo.Code.Codata.Musical.Colist.AgdaColist a
toColist [] = MAlonzo.Code.Codata.Musical.Colist.Nil
toColist (x : xs) =
MAlonzo.Code.Codata.Musical.Colist.Cons x (MAlonzo.RTE.Sharp (toColist xs))
#-}
{- Haskell's prelude is implicitly available; this is for demonstration. -}
{-# FOREIGN GHC import Prelude as Haskell #-}
{-# COMPILE GHC getLine∞ = fmap toColist Haskell.getLine #-}
-- (1)
-- getLine : IO Costring
-- getLine = IO.lift getLine∞
getLine : IO String
getLine = IO.lift
$ getLine∞ Primitive.>>= (Primitive.return ∘ S.fromList ∘ B.toList ∘ take 100)
-- We obtain ~MAlonzo~ strings, then convert those to colists, then
-- eventually lift those to the wrapper ~IO~ type.
-- Let's also give ourselves Haskell's ~read~ method.
postulate readInt : L.List Char → ℕ
{-# COMPILE GHC readInt = \x -> read x :: Integer #-}
-- Now we write our ~main~ method.
main : Primitive.IO ⊤
main = run do putStrLn "Hello, world! I'm a compiled Agda program!"
putStrLn "What is your name?"
name ← getLine
putStrLn "Please enter a number."
num ← getLine
let tri = show $ sum $ upTo $ suc $ readInt $ S.toList num
putStrLn $ "The triangle number of " ++ num ++ " is " ++ tri
putStrLn "Bye, "
-- IO.putStrLn∞ name {- If we use approach (1) above. -}
putStrLn $ "\t" ++ name
|
{
"alphanum_fraction": 0.6545231273,
"avg_line_length": 39.7235772358,
"ext": "agda",
"hexsha": "b466ce19c8eb8d86ac59abcc896e0ab8aa80765a",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2022-01-06T19:34:26.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-11-13T12:44:41.000Z",
"max_forks_repo_head_hexsha": "34e2980af98ff2ded500619edce3e0907a6e9050",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "ajnavarro/language-dataset",
"max_forks_repo_path": "data/github.com/alhassy/AgdaCheatSheet/14597cf3ce5bb985ba4dcb1a3f7384fda8f129c3/CompilingAgda.agda",
"max_issues_count": 91,
"max_issues_repo_head_hexsha": "34e2980af98ff2ded500619edce3e0907a6e9050",
"max_issues_repo_issues_event_max_datetime": "2022-03-21T04:17:18.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-11-11T15:41:26.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "ajnavarro/language-dataset",
"max_issues_repo_path": "data/github.com/alhassy/AgdaCheatSheet/14597cf3ce5bb985ba4dcb1a3f7384fda8f129c3/CompilingAgda.agda",
"max_line_length": 157,
"max_stars_count": 9,
"max_stars_repo_head_hexsha": "34e2980af98ff2ded500619edce3e0907a6e9050",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "ajnavarro/language-dataset",
"max_stars_repo_path": "data/github.com/alhassy/AgdaCheatSheet/14597cf3ce5bb985ba4dcb1a3f7384fda8f129c3/CompilingAgda.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-11T09:48:45.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-08-07T11:54:33.000Z",
"num_tokens": 1432,
"size": 4886
}
|
{- Terms of the language.
Based on Pfenning and Davies' "Judgmental reconstruction of modal logic."
-}
module Syntax.Terms where
open import Syntax.Types
open import Syntax.Context
mutual
-- Pure terms of the language, expressed as typing judgements
infix 10 _⊢_
data _⊢_ : Context -> Judgement -> Set where
-- | Simply typed lambda calculus
-- Variables
var : ∀{Γ A} -> A ∈ Γ
-------
-> Γ ⊢ A
-- Lambda abstraction
lam : ∀{Γ A B} -> Γ , A now ⊢ B now
-------------------
-> Γ ⊢ A => B now
-- Application
_$_ : ∀{Γ A B} -> Γ ⊢ A => B now -> Γ ⊢ A now
-------------------------------
-> Γ ⊢ B now
-- | Basic data types
-- Unit ---------------
unit : ∀{Γ} -> Γ ⊢ Unit now
-- Pair of two terms
[_,,_] : ∀{Γ A B} -> Γ ⊢ A now -> Γ ⊢ B now
----------------------------
-> Γ ⊢ A & B now
-- First projection
fst : ∀{Γ A B} -> Γ ⊢ A & B now
---------------
-> Γ ⊢ A now
-- Second projection
snd : ∀{Γ A B} -> Γ ⊢ A & B now
---------------
-> Γ ⊢ B now
-- Left injection
inl : ∀{Γ A B} -> Γ ⊢ A now
---------------
-> Γ ⊢ A + B now
-- Right injection
inr : ∀{Γ A B} -> Γ ⊢ B now
---------------
-> Γ ⊢ A + B now
-- Case split
case_inl↦_||inr↦_ : ∀{Γ A B C}
-> Γ ⊢ A + B now
-> Γ , A now ⊢ C now -> Γ , B now ⊢ C now
-------------------------------------------
-> Γ ⊢ C now
-- | Modal operators
-- A stable type can be sampled now
sample : ∀{A Γ} -> Γ ⊢ A always
--------------
-> Γ ⊢ A now
-- Types in stable contexts are always inhabited
stable : ∀{Γ A} -> Γ ˢ ⊢ A now
--------------
-> Γ ⊢ A always
-- Signal constructor
sig : ∀{Γ A} -> Γ ⊢ A always
------------------
-> Γ ⊢ Signal A now
-- Signal destructor
letSig_In_ : ∀{Γ A B} -> Γ ⊢ Signal A now -> Γ , A always ⊢ B now
----------------------------------------
-> Γ ⊢ B now
-- Event constructor
event : ∀{Γ A} -> Γ ⊨ A now
------------------
-> Γ ⊢ Event A now
-- Computational terms of the language
infix 10 _⊨_
data _⊨_ : Context -> Judgement -> Set where
-- Pure term is a computational term
pure : ∀{A Γ} -> Γ ⊢ A
-------
-> Γ ⊨ A
-- Computational signal destructor
letSig_InC_ : ∀{Γ A B} -> Γ ⊢ Signal A now -> Γ , A always ⊨ B now
----------------------------------------------
-> Γ ⊨ B now
-- Event destructor
letEvt_In_ : ∀{Γ A B} -> Γ ⊢ Event A now -> Γ ˢ , A now ⊨ B now
--------------------------------------------
-> Γ ⊨ B now
-- Select the event that happens first
select_↦_||_↦_||both↦_ : ∀{Γ A B C}
-> Γ ⊢ Event A now -> Γ ˢ , A now , Event B now ⊨ C now -- A happens first
-> Γ ⊢ Event B now -> Γ ˢ , Event A now , B now ⊨ C now -- B happens first
-> Γ ˢ , A now , B now ⊨ C now -- A and B happen at the same time
-------------------------------------------------
-> Γ ⊨ C now
|
{
"alphanum_fraction": 0.2420528533,
"avg_line_length": 44.6324786325,
"ext": "agda",
"hexsha": "497b3b6c1faa7be933e2c7ea9b765a6478077bf2",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7d993ba55e502d5ef8707ca216519012121a08dd",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "DimaSamoz/temporal-type-systems",
"max_forks_repo_path": "src/Syntax/Terms.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7d993ba55e502d5ef8707ca216519012121a08dd",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "DimaSamoz/temporal-type-systems",
"max_issues_repo_path": "src/Syntax/Terms.agda",
"max_line_length": 108,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "7d993ba55e502d5ef8707ca216519012121a08dd",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "DimaSamoz/temporal-type-systems",
"max_stars_repo_path": "src/Syntax/Terms.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-04T09:33:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-05-31T20:37:04.000Z",
"num_tokens": 1046,
"size": 5222
}
|
{-
Technical results about row transformation applied to matrices
-}
{-# OPTIONS --safe #-}
module Cubical.Algebra.Matrix.RowTransformation where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Data.Nat hiding (_+_ ; _·_)
open import Cubical.Data.Nat.Order
open import Cubical.Data.Empty as Empty
open import Cubical.Data.Sigma
open import Cubical.Data.Bool
open import Cubical.Data.FinData renaming (znots to znotsFin ; snotz to snotzFin)
open import Cubical.Relation.Nullary
open import Cubical.Algebra.Matrix
open import Cubical.Algebra.RingSolver.Reflection
open import Cubical.Algebra.Ring
open import Cubical.Algebra.Ring.BigOps
open import Cubical.Algebra.CommRing
open import Cubical.Algebra.RingSolver.Reflection
open import Cubical.Algebra.Matrix.CommRingCoefficient
private
variable
ℓ : Level
A : Type ℓ
m n k l : ℕ
takeRows : FinMatrix A (suc (suc m)) n → FinMatrix A 2 n
takeRows M zero = M zero
takeRows M one = M one
takeRowsᶜ : FinMatrix A (suc (suc m)) n → FinMatrix A (suc m) n
takeRowsᶜ M zero = M zero
takeRowsᶜ M (suc i) = M (suc (suc i))
combRows : FinMatrix A (suc (suc m)) n → FinMatrix A 2 n → FinMatrix A (suc m) n
combRows M M₀ zero = M₀ zero
combRows M M₀ (suc i) = M (suc (suc i))
shufRows : FinMatrix A 2 n → FinMatrix A (suc m) n → FinMatrix A (suc (suc m)) n
shufRows M₀ M₁ zero = M₁ zero
shufRows M₀ M₁ one = M₀ one
shufRows M₀ M₁ (suc (suc i)) = M₁ (suc i)
module _
(T₀ : FinMatrix A 2 n → FinMatrix A 2 n)
(M : FinMatrix A (suc (suc m)) n) where
private
M₀ = T₀ (takeRows M)
takeTrans : FinMatrix A (suc (suc m)) n
takeTrans zero = M₀ zero
takeTrans one = M₀ one
takeTrans (suc (suc i)) = M (suc (suc i))
module _
(T₁ : FinMatrix A (suc m) n → FinMatrix A (suc m) n)
(M : FinMatrix A (suc (suc m)) n) where
private
M₁ = T₁ (takeRowsᶜ M)
combTrans : FinMatrix A (suc (suc m)) n
combTrans zero = M₁ zero
combTrans one = M one
combTrans (suc (suc i)) = M₁ (suc i)
module _
(T₀ : FinMatrix A 2 n → FinMatrix A 2 n)
(T₁ : FinMatrix A (suc m) n → FinMatrix A (suc m) n)
(M : FinMatrix A (suc (suc m)) n) where
private
M₀ = T₀ (takeRows M)
M₁ = T₁ (combRows M M₀)
helper : takeRowsᶜ (takeTrans T₀ M) ≡ combRows M M₀
helper t zero = M₀ zero
helper t (suc i) = M (suc (suc i))
takeCombShufRows : FinMatrix A (suc (suc m)) n
takeCombShufRows = shufRows M₀ M₁
takeCombShufEquiv : combTrans T₁ (takeTrans T₀ M) ≡ takeCombShufRows
takeCombShufEquiv t zero = T₁ (helper t) zero
takeCombShufEquiv t one = M₀ one
takeCombShufEquiv t (suc (suc i)) = T₁ (helper t) (suc i)
-- The iterated row transformation
module _
(T : FinMatrix A 2 n → FinMatrix A 2 n) where
transRows : FinMatrix A (suc m) n → FinMatrix A (suc m) n
transRows {m = 0} M = M
transRows {m = suc m} = takeCombShufRows T transRows
-- Several induction principle to prove properties after transformation
module _
(invRow : (M : FinMatrix A 2 n) → M zero ≡ T M zero) where
invRow₀ : (M : FinMatrix A (suc m) n) → M zero ≡ transRows M zero
invRow₀ {m = 0} _ = refl
invRow₀ {m = suc m} M = invRow _ ∙ invRow₀ (combRows M _)
module _
(P : FinVec A n → Type ℓ)
(indP : (M : FinMatrix A 2 n) → P (M zero) → P (T M zero)) where
transRowsIndP : (M : FinMatrix A (suc m) n) → P (M zero) → P (transRows M zero)
transRowsIndP {m = 0} _ h = h
transRowsIndP {m = suc m} M h = transRowsIndP (combRows M _) (indP _ h)
module _
(P : FinVec A n → Type ℓ)
(indP : (M : FinMatrix A 2 n) → P (T M one)) where
transRowsIndP' : (M : FinMatrix A (suc m) n) → (i : Fin m) → P (transRows M (suc i))
transRowsIndP' {m = suc m} M zero = indP _
transRowsIndP' {m = suc m} M (suc i) = transRowsIndP' _ i
module _
(Q : FinVec A n → Type ℓ)
(P : FinVec A n → Type ℓ)
(indQ : (M : FinMatrix A 2 n) → Q (M zero) → Q (T M zero))
(indP : (M : FinMatrix A 2 n) → Q (M zero) → P (T M one )) where
transRowsIndPQ : (M : FinMatrix A (suc m) n) → Q (M zero) → (i : Fin m) → P (transRows M (suc i))
transRowsIndPQ {m = suc m} M p zero = indP _ p
transRowsIndPQ {m = suc m} M p (suc i) = transRowsIndPQ _ (indQ _ p) i
module _
(Q : FinVec A n → Type ℓ)
(P : FinVec A n → Type ℓ)
(indQ : (M : FinMatrix A 2 n) → Q (M zero) → Q (T M zero))
(indP : (M : FinMatrix A 2 n) → P (M one ) → Q (T M zero)) where
transRowsIndPQ' : (M : FinMatrix A (suc m) n) → (i : Fin m) → P (M (suc i)) → Q (transRows M zero)
transRowsIndPQ' {m = suc m} M zero p = transRowsIndP Q indQ (combRows M _) (indP _ p)
transRowsIndPQ' {m = suc m} M (suc i) p = transRowsIndPQ' (combRows M _) _ p
module _
(Rel : FinVec A n → FinVec A n → Type ℓ)
(indRel : (M : FinMatrix A 2 n) → Rel (M one) (T M one)) where
transRowsIndRel : (M : FinMatrix A (suc m) n) → (i : Fin m) → Rel (M (suc i)) (transRows M (suc i))
transRowsIndRel {m = suc m} M zero = indRel _
transRowsIndRel {m = suc m} M (suc i) = transRowsIndRel _ i
module _
(Rel3 : FinVec A n → FinVec A n → FinVec A n → Type ℓ)
(invRow : (M : FinMatrix A 2 n) → M zero ≡ T M zero)
(indRel3 : (M : FinMatrix A 2 n) → Rel3 (M zero) (M one) (T M one)) where
transRowsIndRel3 : (M : FinMatrix A (suc m) n) → (i : Fin m) → Rel3 (M zero) (M (suc i)) (transRows M (suc i))
transRowsIndRel3 {m = suc m} M zero = indRel3 _
transRowsIndRel3 {m = suc m} M (suc i) =
subst (λ V → Rel3 V (M (suc (suc i)))
(transRows M (suc (suc i)))) (sym (invRow _)) (transRowsIndRel3 _ i)
module _
(Rel : FinVec A n → FinVec A n → Type ℓ)
(indRel : (M : FinMatrix A 2 n) → Rel (M zero) (M one) → M zero ≡ T M zero) where
transRowsIndRelInv :
(M : FinMatrix A (suc m) n)
→ ((i : Fin m) → Rel (M zero) (M (suc i)))
→ M zero ≡ transRows M zero
transRowsIndRelInv {m = 0} _ _ = refl
transRowsIndRelInv {m = suc m} M rel =
let invRow = indRel _ (rel zero)
rel₁ = (λ i → subst (λ V → Rel V (M (suc (suc i)))) invRow (rel (suc i)))
in invRow ∙ transRowsIndRelInv _ rel₁
module _
(P : FinVec A n → Type ℓ)
(Rel : FinVec A n → FinVec A n → Type ℓ)
(indPRel : (M : FinMatrix A 2 n) → P (M zero) → Rel (M zero) (M one) → M zero ≡ T M zero) where
transRowsIndPRelInv :
(M : FinMatrix A (suc m) n)
→ P (M zero)
→ ((i : Fin m) → Rel (M zero) (M (suc i)))
→ M zero ≡ transRows M zero
transRowsIndPRelInv {m = 0} _ _ _ = refl
transRowsIndPRelInv {m = suc m} M p rel =
let invRow = indPRel _ p (rel zero)
p₁ = subst P invRow p
rel₁ = (λ i → subst (λ V → Rel V (M (suc (suc i)))) invRow (rel (suc i)))
in invRow ∙ transRowsIndPRelInv _ p₁ rel₁
module _
(P : FinVec A n → Type ℓ)
(indP₀ : (M : FinMatrix A 2 n) → P (M zero) → P (M one) → P (T M zero))
(indP₁ : (M : FinMatrix A 2 n) → P (M zero) → P (M one) → P (T M one )) where
transRowsIndP₀ :
(M : FinMatrix A (suc m) n)
→ P (M zero)
→ ((i : Fin m) → P (M (suc i)))
→ P (transRows M zero)
transRowsIndP₀ {m = 0} _ p _ = p
transRowsIndP₀ {m = suc m} _ p q = transRowsIndP₀ _ (indP₀ _ p (q zero)) (q ∘ suc)
transRowsIndP₁ :
(M : FinMatrix A (suc m) n)
→ P (M zero)
→ ((i : Fin m) → P (M (suc i)))
→ (i : Fin m) → P (transRows M (suc i))
transRowsIndP₁ {m = 0} _ _ q = q
transRowsIndP₁ {m = suc m} _ p q zero = indP₁ _ p (q zero)
transRowsIndP₁ {m = suc m} M p q (suc i) = transRowsIndP₁ _ (indP₀ _ p (q zero)) (q ∘ suc) i
-- Row transformation of linear coefficient matrices
module LinearTransformation (𝓡 : CommRing ℓ) where
private
R = 𝓡 .fst
𝑹 = CommRing→Ring 𝓡
AbR = Ring→AbGroup 𝑹
open CommRingStr (𝓡 .snd) renaming ( is-set to isSetR )
open CommRingTheory 𝓡
open RingTheory 𝑹
open KroneckerDelta 𝑹
open Sum 𝑹
open Coefficient 𝓡
-- Definition of linear transformation
record isLinear2×2 (T : Mat 2 n → Mat 2 n) : Type ℓ where
field
transMat : (M : Mat 2 n) → Mat 2 2
transEq : (M : Mat 2 n) → T M ≡ transMat M ⋆ M
record isLinear (T : Mat m n → Mat k n) : Type ℓ where
field
transMat : (M : Mat m n) → Mat k m
transEq : (M : Mat m n) → T M ≡ transMat M ⋆ M
open isLinear2×2
open isLinear
isLinearId : isLinear {m = m} {n = n} (idfun _)
isLinearId .transMat _ = 𝟙
isLinearId .transEq _ = sym (⋆lUnit _)
isInvId : (M : Mat (suc m) (suc n)) → isInv (isLinearId .transMat M)
isInvId _ = isInv𝟙
module _
{T₁ : Mat (suc m) (suc n) → Mat (suc k) (suc n)}
{T₂ : Mat (suc k) (suc n) → Mat (suc l) (suc n)}
(isLinearT₁ : isLinear T₁)
(isLinearT₂ : isLinear T₂) where
isLinearComp : isLinear (T₂ ∘ T₁)
isLinearComp .transMat M =
let T₁M = isLinearT₁ .transMat M in
isLinearT₂ .transMat (T₁ M) ⋆ T₁M
isLinearComp .transEq M =
isLinearT₂ .transEq _
∙ (λ t → isLinearT₂ .transMat (T₁ M) ⋆ (isLinearT₁ .transEq M t))
∙ ⋆Assoc (isLinearT₂ .transMat _) (isLinearT₁ .transMat M) M
module _
{T₁ : Mat (suc m) (suc n) → Mat (suc m) (suc n)}
{T₂ : Mat (suc m) (suc n) → Mat (suc m) (suc n)}
(isLinearT₁ : isLinear T₁)
(isLinearT₂ : isLinear T₂) where
module _
(isInvT₁ : (M : Mat (suc m) (suc n)) → isInv (isLinearT₁ .transMat M))
(isInvT₂ : (M : Mat (suc m) (suc n)) → isInv (isLinearT₂ .transMat M)) where
isInvComp : (M : Mat (suc m) (suc n)) → isInv (isLinearComp isLinearT₁ isLinearT₂ .transMat M)
isInvComp M =
let T₁M = isLinearT₁ .transMat M in
isInv⋆ {M = isLinearT₂ .transMat (T₁ M)} {M' = T₁M} (isInvT₂ (T₁ M)) (isInvT₁ M)
module _
(P : FinVec R (suc n) → Type ℓ)
(indP : (M : Mat (suc m) (suc n)) → P (M zero) → P (T₁ M zero))
(isInvT₁ : (M : Mat (suc m) (suc n)) → P (M zero) → isInv (isLinearT₁ .transMat M))
(isInvT₂ : (M : Mat (suc m) (suc n)) → P (M zero) → isInv (isLinearT₂ .transMat M)) where
isInvCompInd : (M : Mat (suc m) (suc n)) → P (M zero) → isInv (isLinearComp isLinearT₁ isLinearT₂ .transMat M)
isInvCompInd M p =
let T₁M = isLinearT₁ .transMat M in
isInv⋆ {M = isLinearT₂ .transMat (T₁ M)} {M' = T₁M} (isInvT₂ (T₁ M) (indP _ p)) (isInvT₁ M p)
-- Linearity of row transformation
takeTransMat : Mat 2 2 → Mat (suc (suc m)) (suc (suc m))
takeTransMat P zero zero = P zero zero
takeTransMat P one zero = P one zero
takeTransMat P zero one = P zero one
takeTransMat P one one = P one one
takeTransMat _ zero (suc (suc j)) = 0r
takeTransMat _ one (suc (suc j)) = 0r
takeTransMat _ (suc (suc i)) zero = 0r
takeTransMat _ (suc (suc i)) one = 0r
takeTransMat _ (suc (suc i)) (suc (suc j)) = 𝟙 i j
takeTransMat𝟙 : takeTransMat {m = m} 𝟙 ≡ 𝟙
takeTransMat𝟙 t zero zero = 1r
takeTransMat𝟙 t one zero = 0r
takeTransMat𝟙 t zero one = 0r
takeTransMat𝟙 t one one = 1r
takeTransMat𝟙 t zero (suc (suc j)) = 0r
takeTransMat𝟙 t one (suc (suc j)) = 0r
takeTransMat𝟙 t (suc (suc i)) zero = 0r
takeTransMat𝟙 t (suc (suc i)) one = 0r
takeTransMat𝟙 t (suc (suc i)) (suc (suc j)) = δ i j
module _
(M N : Mat 2 2) where
⋆TakeTransMat : takeTransMat M ⋆ takeTransMat N ≡ takeTransMat {m = m} (M ⋆ N)
⋆TakeTransMat {m = m} t zero zero =
M zero zero · N zero zero + (M zero one · N one zero + ∑Mul0r {n = m} (λ i → 0r) t)
⋆TakeTransMat {m = m} t one zero =
M one zero · N zero zero + (M one one · N one zero + ∑Mul0r {n = m} (λ i → 0r) t)
⋆TakeTransMat {m = m} t zero one =
M zero zero · N zero one + (M zero one · N one one + ∑Mul0r {n = m} (λ i → 0r) t)
⋆TakeTransMat {m = m} t one one =
M one zero · N zero one + (M one one · N one one + ∑Mul0r {n = m} (λ i → 0r) t)
⋆TakeTransMat t zero (suc (suc j)) =
(helper (M zero zero) (M zero one ) _ ∙ ∑Mul0r (λ i → 𝟙 i j)) t
where helper : (a b c : R) → a · 0r + (b · 0r + c) ≡ c
helper = solve 𝓡
⋆TakeTransMat t one (suc (suc j)) =
(helper (M one zero) (M one one ) _ ∙ ∑Mul0r (λ i → 𝟙 i j)) t
where helper : (a b c : R) → a · 0r + (b · 0r + c) ≡ c
helper = solve 𝓡
⋆TakeTransMat t (suc (suc i)) zero =
(helper (N zero zero) (N one zero) _ ∙ ∑Mulr0 (λ j → 𝟙 i j)) t
where helper : (a b c : R) → 0r · a + (0r · b + c) ≡ c
helper = solve 𝓡
⋆TakeTransMat t (suc (suc i)) one =
(helper (N zero one ) (N one one ) _ ∙ ∑Mulr0 (λ j → 𝟙 i j)) t
where helper : (a b c : R) → 0r · a + (0r · b + c) ≡ c
helper = solve 𝓡
⋆TakeTransMat t (suc (suc i)) (suc (suc j)) =
(helper _
∙ (λ t → ⋆lUnit 𝟙 t i j)) t
where helper : (c : R) → 0r · 0r + (0r · 0r + c) ≡ c
helper = solve 𝓡
module _
(T₀ : Mat 2 (suc n) → Mat 2 (suc n))
(isLinear2×2T₀ : isLinear2×2 T₀) where
module _
(M : Mat (suc (suc m)) (suc n)) where
private
P = isLinear2×2T₀ .transMat (takeRows M)
takeTransEquiv : takeTrans T₀ M ≡ takeTransMat P ⋆ M
takeTransEquiv t zero j =
((λ t → isLinear2×2T₀ .transEq (takeRows M) t zero j)
∙ mul2 P (takeRows M) _ _
∙ helper _ _
∙ (λ t → P zero zero · M zero j + (P zero one · M one j
+ ∑Mul0r (λ i → M (suc (suc i)) j) (~ t)))) t
where helper : (a b : R) → a + b ≡ a + (b + 0r)
helper = solve 𝓡
takeTransEquiv t one j =
((λ t → isLinear2×2T₀ .transEq (takeRows M) t one j)
∙ mul2 P (takeRows M) _ _
∙ helper _ _
∙ (λ t → P one zero · M zero j + (P one one · M one j
+ ∑Mul0r (λ i → M (suc (suc i)) j) (~ t)))) t
where helper : (a b : R) → a + b ≡ a + (b + 0r)
helper = solve 𝓡
takeTransEquiv t (suc (suc i)) j =
((λ t → ⋆lUnit (λ i j → M (suc (suc i)) j) (~ t) i j)
∙ helper (M zero j) (M one j) _) t
where helper : (a b c : R) → c ≡ 0r · a + (0r · b + c)
helper = solve 𝓡
isLinearTakeRowsTrans : isLinear (takeTrans {m = m} T₀)
isLinearTakeRowsTrans .transMat M = takeTransMat _
isLinearTakeRowsTrans .transEq = takeTransEquiv
isInvTakeTransMat : (M : Mat 2 2)(isInvM : isInv M) → isInv (takeTransMat {m = m} M)
isInvTakeTransMat M isInvM .fst = takeTransMat (isInvM .fst)
isInvTakeTransMat M isInvM .snd .fst =
⋆TakeTransMat _ _ ∙ (λ t → takeTransMat (isInvM .snd .fst t)) ∙ takeTransMat𝟙
isInvTakeTransMat M isInvM .snd .snd =
⋆TakeTransMat _ _ ∙ (λ t → takeTransMat (isInvM .snd .snd t)) ∙ takeTransMat𝟙
combTransMat : Mat (suc m) (suc m) → Mat (suc (suc m)) (suc (suc m))
combTransMat P zero zero = P zero zero
combTransMat _ zero one = 0r
combTransMat _ one zero = 0r
combTransMat _ one one = 1r
combTransMat P zero (suc (suc j)) = P zero (suc j)
combTransMat _ one (suc (suc j)) = 0r
combTransMat P (suc (suc i)) zero = P (suc i) zero
combTransMat _ (suc (suc i)) one = 0r
combTransMat P (suc (suc i)) (suc (suc j)) = P (suc i) (suc j)
combTransMat𝟙 : combTransMat {m = m} 𝟙 ≡ 𝟙
combTransMat𝟙 t zero zero = 1r
combTransMat𝟙 t zero one = 0r
combTransMat𝟙 t one zero = 0r
combTransMat𝟙 t one one = 1r
combTransMat𝟙 t zero (suc (suc j)) = 0r
combTransMat𝟙 t one (suc (suc j)) = 0r
combTransMat𝟙 t (suc (suc i)) zero = 0r
combTransMat𝟙 t (suc (suc i)) one = 0r
combTransMat𝟙 t (suc (suc i)) (suc (suc j)) = δ i j
module _
(M N : Mat (suc m) (suc m)) where
⋆CombTransMat : combTransMat M ⋆ combTransMat N ≡ combTransMat (M ⋆ N)
⋆CombTransMat t zero zero =
helper (M zero zero · N zero zero) (∑ (λ l → M zero (suc l) · N (suc l) zero)) t
where helper : (a c : R) → a + (0r · 0r + c) ≡ a + c
helper = solve 𝓡
⋆CombTransMat t zero one =
(helper (M zero zero) _ ∙ ∑Mulr0 (λ j → M zero (suc j))) t
where helper : (a c : R) → a · 0r + (0r · 1r + c) ≡ c
helper = solve 𝓡
⋆CombTransMat t one zero =
(helper (N zero zero) _ ∙ ∑Mul0r (λ i → N (suc i) zero)) t
where helper : (a c : R) → 0r · a + (1r · 0r + c) ≡ c
helper = solve 𝓡
⋆CombTransMat t one one =
((λ t → 0r · 0r + (1r · 1r + ∑Mul0r {n = m} (λ i → 0r) t))
∙ helper) t
where helper : 0r · 0r + (1r · 1r + 0r) ≡ 1r
helper = solve 𝓡
⋆CombTransMat t zero (suc (suc j)) =
helper (M zero zero · N zero (suc j)) (∑ (λ l → M zero (suc l) · N (suc l) (suc j))) t
where helper : (a c : R) → a + (0r · 0r + c) ≡ a + c
helper = solve 𝓡
⋆CombTransMat t one (suc (suc j)) =
(helper (N zero (suc j)) _ ∙ ∑Mul0r (λ i → N (suc i) (suc j))) t
where helper : (a c : R) → 0r · a + (1r · 0r + c) ≡ c
helper = solve 𝓡
⋆CombTransMat t (suc (suc i)) zero =
helper (M (suc i) zero · N zero zero) (∑ (λ l → M (suc i) (suc l) · N (suc l) zero)) t
where helper : (a c : R) → a + (0r · 0r + c) ≡ a + c
helper = solve 𝓡
⋆CombTransMat t (suc (suc i)) one =
(helper (M (suc i) zero) _ ∙ ∑Mulr0 (λ j → M (suc i) (suc j))) t
where helper : (a c : R) → a · 0r + (0r · 1r + c) ≡ c
helper = solve 𝓡
⋆CombTransMat t (suc (suc i)) (suc (suc j)) =
helper (M (suc i) zero · N zero (suc j)) (∑ (λ l → M (suc i) (suc l) · N (suc l) (suc j))) t
where helper : (a c : R) → a + (0r · 0r + c) ≡ a + c
helper = solve 𝓡
module _
(T₁ : Mat (suc m) (suc n) → Mat (suc m) (suc n))
(isLinearT₁ : isLinear T₁) where
module _
(M : Mat (suc (suc m)) (suc n)) where
private
P = isLinearT₁ .transMat (takeRowsᶜ M)
combTransEquiv : combTrans T₁ M ≡ combTransMat P ⋆ M
combTransEquiv t zero j =
((λ t → isLinearT₁ .transEq (takeRowsᶜ M) t zero j)
∙ helper _ (M one j) _) t
where helper : (a b c : R) → a + c ≡ a + (0r · b + c)
helper = solve 𝓡
combTransEquiv t one j =
(helper _ _
∙ (λ t → 0r · M zero j + (1r · M one j
+ ∑Mul0r (λ i → M (suc (suc i)) j) (~ t)))) t
where helper : (a b : R) → b ≡ 0r · a + (1r · b + 0r)
helper = solve 𝓡
combTransEquiv t (suc (suc i)) j =
((λ t → isLinearT₁ .transEq (takeRowsᶜ M) t (suc i) j)
∙ helper _ (M one j) _) t
where helper : (a b c : R) → a + c ≡ a + (0r · b + c)
helper = solve 𝓡
isLinearCombRowsTrans : isLinear (combTrans T₁)
isLinearCombRowsTrans .transMat M = combTransMat _
isLinearCombRowsTrans .transEq = combTransEquiv
isInvCombTransMat : (M : Mat (suc m) (suc m))(isInvM : isInv M) → isInv (combTransMat M)
isInvCombTransMat M isInvM .fst = combTransMat (isInvM .fst)
isInvCombTransMat M isInvM .snd .fst =
⋆CombTransMat _ _ ∙ (λ t → combTransMat (isInvM .snd .fst t)) ∙ combTransMat𝟙
isInvCombTransMat M isInvM .snd .snd =
⋆CombTransMat _ _ ∙ (λ t → combTransMat (isInvM .snd .snd t)) ∙ combTransMat𝟙
module _
{T₁ : Mat 2 (suc n) → Mat 2 (suc n)}
{T₂ : Mat (suc m) (suc n) → Mat (suc m) (suc n)}
(isLinearT₁ : isLinear2×2 T₁)
(isLinearT₂ : isLinear T₂) where
private
compL = isLinearComp (isLinearTakeRowsTrans _ isLinearT₁) (isLinearCombRowsTrans _ isLinearT₂)
isLinearTakeCombShufRows : isLinear (takeCombShufRows {m = m} T₁ T₂)
isLinearTakeCombShufRows .transMat = compL .transMat
isLinearTakeCombShufRows .transEq M = sym (takeCombShufEquiv _ _ _) ∙ compL .transEq _
module _
(T : Mat 2 (suc n) → Mat 2 (suc n))
(isLinear2×2T : isLinear2×2 T) where
isLinearTransRows : (m : ℕ) → isLinear (transRows T {m = m})
isLinearTransRows 0 = isLinearId
isLinearTransRows (suc m) = isLinearTakeCombShufRows isLinear2×2T (isLinearTransRows m)
module _
(isInvT : (M : Mat 2 (suc n)) → isInv (isLinear2×2T .transMat M)) where
isInvTransRows : (M : Mat (suc m) (suc n)) → isInv (isLinearTransRows _ .transMat M)
isInvTransRows {m = 0} _ = isInv𝟙
isInvTransRows {m = suc m} M =
isInv⋆ {M = combTransMat _} {M' = takeTransMat _}
(isInvCombTransMat _ (isInvTransRows _))
(isInvTakeTransMat _ (isInvT _))
module _
(P : FinVec R (suc n) → Type ℓ)
(indP : (M : Mat 2 (suc n)) → P (M zero) → P (T M zero))
(isInvT : (M : Mat 2 (suc n)) → P (M zero) → isInv (isLinear2×2T .transMat M)) where
isInvTransRowsInd :
(M : Mat (suc m) (suc n)) → P (M zero) → isInv (isLinearTransRows _ .transMat M)
isInvTransRowsInd {m = 0} M _ = isInvId M
isInvTransRowsInd {m = suc m} M p =
isInv⋆ {M = combTransMat _} {M' = takeTransMat _}
(isInvCombTransMat _ (isInvTransRowsInd _ (indP _ p)))
(isInvTakeTransMat _ (isInvT _ p))
-- Some useful properties of 2-rows transformation
symδ : (i j : Fin m) → δ i j ≡ δ j i
symδ zero zero = refl
symδ zero (suc _) = refl
symδ (suc _) zero = refl
symδ (suc i) (suc j) = symδ i j
diagδ : (i j : Fin m)(p : i ≡ j) → δ i j ≡ 1r
diagδ zero zero _ = refl
diagδ (suc _) zero p = Empty.rec (snotzFin p)
diagδ zero (suc _) p = Empty.rec (znotsFin p)
diagδ (suc i) (suc j) p = diagδ _ _ (injSucFin p)
skewδ : (i j : Fin m)(p : ¬ i ≡ j) → δ i j ≡ 0r
skewδ zero zero p = Empty.rec (p refl)
skewδ (suc _) zero _ = refl
skewδ zero (suc _) _ = refl
skewδ (suc i) (suc j) p = skewδ _ _ (λ r → p (cong suc r))
diagSet : (i₀ : Fin m)(a : R) → Mat m m
diagSet {m = suc m} zero a zero zero = a
diagSet {m = suc m} zero _ (suc i) zero = 0r
diagSet {m = suc m} zero _ zero (suc j) = 0r
diagSet {m = suc m} zero _ (suc i) (suc j) = δ i j
diagSet {m = suc m} (suc i₀) _ zero zero = 1r
diagSet {m = suc m} (suc i₀) _ (suc i) zero = 0r
diagSet {m = suc m} (suc i₀) _ zero (suc j) = 0r
diagSet {m = suc m} (suc i₀) a (suc i) (suc j) = diagSet i₀ a i j
diagSet≡diagSetᵗ : (i₀ : Fin m)(a : R) → diagSet i₀ a ≡ (diagSet i₀ a)ᵗ
diagSet≡diagSetᵗ {m = suc m} zero a t zero zero = a
diagSet≡diagSetᵗ {m = suc m} zero _ t (suc i) zero = 0r
diagSet≡diagSetᵗ {m = suc m} zero _ t zero (suc j) = 0r
diagSet≡diagSetᵗ {m = suc m} zero _ t (suc i) (suc j) = symδ i j t
diagSet≡diagSetᵗ {m = suc m} (suc i₀) _ t zero zero = 1r
diagSet≡diagSetᵗ {m = suc m} (suc i₀) _ t (suc i) zero = 0r
diagSet≡diagSetᵗ {m = suc m} (suc i₀) _ t zero (suc j) = 0r
diagSet≡diagSetᵗ {m = suc m} (suc i₀) a t (suc i) (suc j) = diagSet≡diagSetᵗ i₀ a t i j
diagSet1≡𝟙 : (i₀ : Fin m) → diagSet i₀ 1r ≡ 𝟙
diagSet1≡𝟙 {m = suc m} zero t zero zero = 1r
diagSet1≡𝟙 {m = suc m} zero t (suc i) zero = 0r
diagSet1≡𝟙 {m = suc m} zero t zero (suc j) = 0r
diagSet1≡𝟙 {m = suc m} zero t (suc i) (suc j) = δ i j
diagSet1≡𝟙 {m = suc m} (suc i₀) t zero zero = 1r
diagSet1≡𝟙 {m = suc m} (suc i₀) t (suc i) zero = 0r
diagSet1≡𝟙 {m = suc m} (suc i₀) t zero (suc j) = 0r
diagSet1≡𝟙 {m = suc m} (suc i₀) t (suc i) (suc j) = diagSet1≡𝟙 i₀ t i j
module _
(a b c : R) where
·DiagSetˡ : (i₀ : Fin m)(i : Fin m) → a · δ i₀ i + diagSet i₀ b i i₀ · c ≡ (a + (b · c + 0r)) · δ i₀ i
·DiagSetˡ {m = suc m} zero zero = helper _ _ _
where helper : (a b c : R) → a · 1r + b · c ≡ (a + (b · c + 0r)) · 1r
helper = solve 𝓡
·DiagSetˡ {m = suc m} (suc i₀) zero = helper _ _ _
where helper : (a b c : R) → a · 0r + 0r · c ≡ (a + (b · c + 0r)) · 0r
helper = solve 𝓡
·DiagSetˡ {m = suc m} zero (suc j) = helper _ _ _
where helper : (a b c : R) → a · 0r + 0r · c ≡ (a + (b · c + 0r)) · 0r
helper = solve 𝓡
·DiagSetˡ {m = suc m} (suc i₀) (suc j) = ·DiagSetˡ i₀ j
·DiagSetʳ : (i₀ : Fin m)(i : Fin m) → a · δ i₀ i + b · diagSet i₀ c i₀ i ≡ (a + (b · c + 0r)) · δ i₀ i
·DiagSetʳ {m = suc m} zero zero = helper _ _ _
where helper : (a b c : R) → a · 1r + b · c ≡ (a + (b · c + 0r)) · 1r
helper = solve 𝓡
·DiagSetʳ {m = suc m} (suc i₀) zero = helper _ _ _
where helper : (a b c : R) → a · 0r + b · 0r ≡ (a + (b · c + 0r)) · 0r
helper = solve 𝓡
·DiagSetʳ {m = suc m} zero (suc j) = helper _ _ _
where helper : (a b c : R) → a · 0r + b · 0r ≡ (a + (b · c + 0r)) · 0r
helper = solve 𝓡
·DiagSetʳ {m = suc m} (suc i₀) (suc j) = ·DiagSetʳ i₀ j
module _
(a b : R) where
⋆DiagSet : (i₀ : Fin m) → diagSet i₀ a ⋆ diagSet i₀ b ≡ diagSet i₀ (a · b)
⋆DiagSet {m = suc m} zero t zero zero =
((λ t → a · b + ∑Mul0r {n = m} (λ i → 0r) t) ∙ helper _) t
where helper : (a : R) → a + 0r ≡ a
helper = solve 𝓡
⋆DiagSet {m = suc m} zero t (suc i) zero =
((λ t → 0r · b + ∑Mulr0 (λ j → diagSet zero a (suc i) (suc j)) t) ∙ helper _) t
where helper : (b : R) → 0r · b + 0r ≡ 0r
helper = solve 𝓡
⋆DiagSet {m = suc m} zero t zero (suc j) =
((λ t → a · 0r + ∑Mul0r (λ i → diagSet zero b (suc i) (suc j)) t) ∙ helper _) t
where helper : (a : R) → a · 0r + 0r ≡ 0r
helper = solve 𝓡
⋆DiagSet {m = suc m} zero t (suc i) (suc j) =
((λ t → 0r · 0r + ∑Mulr1 _ (λ l → δ i l) j t) ∙ helper _) t
where helper : (d : R) → 0r · 0r + d ≡ d
helper = solve 𝓡
⋆DiagSet {m = suc m} (suc i₀) t zero zero =
((λ t → 1r · 1r + ∑Mul0r {n = m} (λ i → 0r) t) ∙ helper) t
where helper : 1r · 1r + 0r ≡ 1r
helper = solve 𝓡
⋆DiagSet {m = suc m} (suc i₀) t (suc i) zero =
((λ t → 0r · 1r + ∑Mulr0 (λ j → diagSet (suc i₀) a (suc i) (suc j)) t) ∙ helper) t
where helper : 0r · 1r + 0r ≡ 0r
helper = solve 𝓡
⋆DiagSet {m = suc m} (suc i₀) t zero (suc j) =
((λ t → 1r · 0r + ∑Mul0r (λ i → diagSet (suc i₀) b (suc i) (suc j)) t) ∙ helper) t
where helper : 1r · 0r + 0r ≡ 0r
helper = solve 𝓡
⋆DiagSet {m = suc m} (suc i₀) t (suc i) (suc j) =
((λ t → 0r · 0r + ⋆DiagSet i₀ t i j) ∙ helper _) t
where helper : (a : R) → 0r · 0r + a ≡ a
helper = solve 𝓡
module _
(a b c : R) where
+DiagSet :
(i₀ i j : Fin m)
→ (a · δ i₀ i) · (b · δ i₀ j) + diagSet i₀ c i j ≡ diagSet i₀ (a · b + (c + 0r)) i j
+DiagSet {m = suc m} zero zero zero = helper _ _ _
where helper : (a b c : R) → (a · 1r) · (b · 1r) + c ≡ a · b + (c + 0r)
helper = solve 𝓡
+DiagSet {m = suc m} zero (suc i) zero = helper _ _
where helper : (a b : R) → (a · 0r) · (b · 1r) + 0r ≡ 0r
helper = solve 𝓡
+DiagSet {m = suc m} zero zero (suc j) = helper _ _
where helper : (a b : R) → (a · 1r) · (b · 0r) + 0r ≡ 0r
helper = solve 𝓡
+DiagSet {m = suc m} zero (suc i) (suc j) = helper _ _ _
where helper : (a b d : R) → (a · 0r) · (b · 0r) + d ≡ d
helper = solve 𝓡
+DiagSet {m = suc m} (suc i₀) zero zero = helper _ _
where helper : (a b : R) → (a · 0r) · (b · 0r) + 1r ≡ 1r
helper = solve 𝓡
+DiagSet {m = suc m} (suc i₀) (suc i) zero = helper _ _
where helper : (a b : R) → a · (b · 0r) + 0r ≡ 0r
helper = solve 𝓡
+DiagSet {m = suc m} (suc i₀) zero (suc j) = helper _ _
where helper : (a b : R) → (a · 0r) · b + 0r ≡ 0r
helper = solve 𝓡
+DiagSet {m = suc m} (suc i₀) (suc i) (suc j) = +DiagSet i₀ i j
module _
(M : Mat 2 2)(i₀ : Fin m) where
trans2RowsMat : Mat (suc m) (suc m)
trans2RowsMat zero zero = M zero zero
trans2RowsMat (suc i) zero = M one zero · δ i₀ i
trans2RowsMat zero (suc j) = M zero one · δ i₀ j
trans2RowsMat (suc i) (suc j) = diagSet i₀ (M one one) i j
module _
(i₀ : Fin m) where
trans2RowsMat𝟙 : trans2RowsMat 𝟙 i₀ ≡ 𝟙
trans2RowsMat𝟙 t zero zero = 1r
trans2RowsMat𝟙 t (suc i) zero = 0LeftAnnihilates (δ i₀ i) t
trans2RowsMat𝟙 t zero (suc j) = 0LeftAnnihilates (δ i₀ j) t
trans2RowsMat𝟙 t (suc i) (suc j) = diagSet1≡𝟙 i₀ t i j
module _
(M N : Mat 2 2)(i₀ : Fin m) where
private
∑helper00 : (x a b : R) → x + ∑(λ l → (a · δ i₀ l) · (b · δ i₀ l)) ≡ x + a · b
∑helper00 x a b =
(λ t → x + ∑(λ l → helper a b (δ i₀ l) (δ i₀ l) t))
∙ (λ t → x + ∑Mul1r _ (λ l → (δ i₀ l · (a · b))) i₀ t)
∙ (λ t → x + diagδ i₀ i₀ refl t · (a · b))
∙ (λ t → x + ·Lid (a · b) t)
where helper : (a b x y : R) → (a · x) · (b · y) ≡ x · (y · (a · b))
helper = solve 𝓡
∑helper10 :
(a b c : R)(K : Mat m m)(i : Fin m)
→ (a · δ i₀ i) · b + ∑ (λ l → K i l · (c · δ i₀ l)) ≡ (a · b) · δ i₀ i + K i i₀ · c
∑helper10 a b c K i =
(λ t → helper1 a b (δ i₀ i) t + ∑ (λ l → helper2 (K i l) c (δ i₀ l) t))
∙ (λ t → (a · b) · δ i₀ i + ∑Mul1r _ (λ l → K i l · c) i₀ t)
where helper1 : (a b c : R) → (a · c) · b ≡ (a · b) · c
helper1 = solve 𝓡
helper2 : (a b c : R) → a · (b · c) ≡ c · (a · b)
helper2 = solve 𝓡
∑helper01 :
(a b c : R)(K : Mat m m)(i : Fin m)
→ a · (b · δ i₀ i) + ∑ (λ l → (c · δ i₀ l) · K l i) ≡ (a · b) · δ i₀ i + c · K i₀ i
∑helper01 a b c K i =
(λ t → helper1 a b (δ i₀ i) t + ∑ (λ l → helper2 c (K l i) (δ i₀ l) t))
∙ (λ t → (a · b) · δ i₀ i + ∑Mul1r _ (λ l → c · K l i) i₀ t)
where helper1 : (a b c : R) → a · (b · c) ≡ (a · b) · c
helper1 = solve 𝓡
helper2 : (a b c : R) → (a · c) · b ≡ c · (a · b)
helper2 = solve 𝓡
⋆Trans2RowsMat : trans2RowsMat M i₀ ⋆ trans2RowsMat N i₀ ≡ trans2RowsMat (M ⋆ N) i₀
⋆Trans2RowsMat t zero zero =
(∑helper00 _ _ _ ∙ sym (mul2 M N zero zero)) t
⋆Trans2RowsMat t (suc i) zero =
(∑helper10 (M one zero) (N zero zero)
(N one zero) (diagSet i₀ (M one one)) i
∙ ·DiagSetˡ _ _ _ i₀ i) t
⋆Trans2RowsMat t zero (suc j) =
(∑helper01 (M zero zero) (N zero one)
(M zero one ) (diagSet i₀ (N one one)) j
∙ ·DiagSetʳ _ _ _ i₀ j) t
⋆Trans2RowsMat t (suc i) (suc j) =
((λ t → (M one zero · δ i₀ i) · (N zero one · δ i₀ j)
+ ⋆DiagSet (M one one) (N one one) i₀ t i j)
∙ +DiagSet _ _ _ i₀ i j) t
isInvTrans2RowsMat : (M : Mat 2 2)(i₀ : Fin m)(isInvM : isInv M) → isInv (trans2RowsMat M i₀)
isInvTrans2RowsMat M i₀ isInvM .fst = trans2RowsMat (isInvM .fst) i₀
isInvTrans2RowsMat M i₀ isInvM .snd .fst =
⋆Trans2RowsMat _ _ _ ∙ (λ t → trans2RowsMat (isInvM .snd .fst t) i₀) ∙ trans2RowsMat𝟙 _
isInvTrans2RowsMat M i₀ isInvM .snd .snd =
⋆Trans2RowsMat _ _ _ ∙ (λ t → trans2RowsMat (isInvM .snd .snd t) i₀) ∙ trans2RowsMat𝟙 _
|
{
"alphanum_fraction": 0.541751396,
"avg_line_length": 40.1308290155,
"ext": "agda",
"hexsha": "669585295ceb26b8dbd2274d2b166249c19b5fd0",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "howsiyu/cubical",
"max_forks_repo_path": "Cubical/Algebra/Matrix/RowTransformation.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "howsiyu/cubical",
"max_issues_repo_path": "Cubical/Algebra/Matrix/RowTransformation.agda",
"max_line_length": 116,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "howsiyu/cubical",
"max_stars_repo_path": "Cubical/Algebra/Matrix/RowTransformation.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 13228,
"size": 30981
}
|
------------------------------------------------------------------------
-- AVL trees
------------------------------------------------------------------------
-- AVL trees are balanced binary search trees. The search tree
-- invariant is not statically enforced in the current implementation,
-- just the balance invariant.
open import Relation.Binary
module Data.AVL (OrderedKeySet : StrictTotalOrder)
(Value : StrictTotalOrder.carrier OrderedKeySet → Set)
where
open import Data.Nat hiding (compare)
open StrictTotalOrder OrderedKeySet renaming (carrier to Key)
open import Data.Product
open import Data.Maybe
open import Data.Bool
open import Data.List as List using (List)
import Data.DifferenceList as DiffList
open import Relation.Binary.PropositionalEquality
------------------------------------------------------------------------
-- Types and functions which are used to keep track of invariants
module Invariants where
-- Bits. (I would use Fin 2 instead if Agda had "defined patterns",
-- so that I could pattern match on 1# instead of suc zero; the text
-- "suc zero" takes up a lot more space.)
data ℕ₂ : Set where
0# : ℕ₂
1# : ℕ₂
-- Addition.
infixl 6 _⊕_
_⊕_ : ℕ₂ → ℕ → ℕ
0# ⊕ n = n
1# ⊕ n = 1 + n
-- i ⊕ n -1 = pred (i ⊕ n).
_⊕_-1 : ℕ₂ → ℕ → ℕ
i ⊕ zero -1 = 0
i ⊕ suc n -1 = i ⊕ n
infix 4 _∼_
-- If m ∼ n, then the difference between m and n is at most 1. _∼_
-- is used to record the balance factor of the AVL trees, and also
-- to ensure that the absolute value of the balance factor is never
-- more than 1.
data _∼_ : ℕ → ℕ → Set where
∼+ : ∀ {n} → n ∼ 1 + n
∼0 : ∀ {n} → n ∼ n
∼- : ∀ {n} → 1 + n ∼ n
-- The maximum of m and n.
max : ∀ {m n} → m ∼ n → ℕ
max (∼+ {n}) = 1 + n
max (∼0 {n}) = n
max (∼- {n}) = 1 + n
-- Some lemmas.
1+ : ∀ {m n} → m ∼ n → 1 + m ∼ 1 + n
1+ ∼+ = ∼+
1+ ∼0 = ∼0
1+ ∼- = ∼-
max∼ : ∀ {i j} (bal : i ∼ j) → max bal ∼ i
max∼ ∼+ = ∼-
max∼ ∼0 = ∼0
max∼ ∼- = ∼0
∼max : ∀ {i j} (bal : i ∼ j) → j ∼ max bal
∼max ∼+ = ∼0
∼max ∼0 = ∼0
∼max ∼- = ∼+
max∼max : ∀ {i j} (bal : i ∼ j) → max (max∼ bal) ∼ max (∼max bal)
max∼max ∼+ = ∼0
max∼max ∼0 = ∼0
max∼max ∼- = ∼0
max-lemma : ∀ {m n} (bal : m ∼ n) →
1 + max (1+ (max∼max bal)) ≡ 2 + max bal
max-lemma ∼+ = refl
max-lemma ∼0 = refl
max-lemma ∼- = refl
------------------------------------------------------------------------
-- AVL trees
-- Key/value pairs.
KV : Set
KV = Σ Key Value
module Indexed where
open Invariants
-- The trees are indexed on their height. (bal is the balance
-- factor.)
data Tree : ℕ → Set where
leaf : Tree 0
node : ∀ {hˡ hʳ}
(l : Tree hˡ) (k : KV) (r : Tree hʳ) (bal : hˡ ∼ hʳ) →
Tree (1 + max bal)
-- Various constant-time functions which construct trees out of
-- smaller pieces, sometimes using rotation.
joinˡ⁺ : ∀ {hˡ hʳ} →
(∃ λ i → Tree (i ⊕ hˡ)) → KV → Tree hʳ → (bal : hˡ ∼ hʳ) →
∃ λ i → Tree (i ⊕ (1 + max bal))
joinˡ⁺ (1# , node t₁ k₂
(node t₃ k₄ t₅ bal)
∼+) k₆ t₇ ∼- = (0# , subst Tree (max-lemma bal)
(node (node t₁ k₂ t₃ (max∼ bal))
k₄
(node t₅ k₆ t₇ (∼max bal))
(1+ (max∼max bal))))
joinˡ⁺ (1# , node t₁ k₂ t₃ ∼-) k₄ t₅ ∼- = (0# , node t₁ k₂ (node t₃ k₄ t₅ ∼0) ∼0)
joinˡ⁺ (1# , node t₁ k₂ t₃ ∼0) k₄ t₅ ∼- = (1# , node t₁ k₂ (node t₃ k₄ t₅ ∼-) ∼+)
joinˡ⁺ (1# , t₁) k₂ t₃ ∼0 = (1# , node t₁ k₂ t₃ ∼-)
joinˡ⁺ (1# , t₁) k₂ t₃ ∼+ = (0# , node t₁ k₂ t₃ ∼0)
joinˡ⁺ (0# , t₁) k₂ t₃ bal = (0# , node t₁ k₂ t₃ bal)
joinʳ⁺ : ∀ {hˡ hʳ} →
Tree hˡ → KV → (∃ λ i → Tree (i ⊕ hʳ)) → (bal : hˡ ∼ hʳ) →
∃ λ i → Tree (i ⊕ (1 + max bal))
joinʳ⁺ t₁ k₂ (1# , node
(node t₃ k₄ t₅ bal)
k₆ t₇ ∼-) ∼+ = (0# , subst Tree (max-lemma bal)
(node (node t₁ k₂ t₃ (max∼ bal))
k₄
(node t₅ k₆ t₇ (∼max bal))
(1+ (max∼max bal))))
joinʳ⁺ t₁ k₂ (1# , node t₃ k₄ t₅ ∼+) ∼+ = (0# , node (node t₁ k₂ t₃ ∼0) k₄ t₅ ∼0)
joinʳ⁺ t₁ k₂ (1# , node t₃ k₄ t₅ ∼0) ∼+ = (1# , node (node t₁ k₂ t₃ ∼+) k₄ t₅ ∼-)
joinʳ⁺ t₁ k₂ (1# , t₃) ∼0 = (1# , node t₁ k₂ t₃ ∼+)
joinʳ⁺ t₁ k₂ (1# , t₃) ∼- = (0# , node t₁ k₂ t₃ ∼0)
joinʳ⁺ t₁ k₂ (0# , t₃) bal = (0# , node t₁ k₂ t₃ bal)
joinˡ⁻ : ∀ hˡ {hʳ} →
(∃ λ i → Tree (i ⊕ hˡ -1)) → KV → Tree hʳ → (bal : hˡ ∼ hʳ) →
∃ λ i → Tree (i ⊕ max bal)
joinˡ⁻ zero (0# , t₁) k₂ t₃ bal = (1# , node t₁ k₂ t₃ bal)
joinˡ⁻ zero (1# , t₁) k₂ t₃ bal = (1# , node t₁ k₂ t₃ bal)
joinˡ⁻ (suc _) (0# , t₁) k₂ t₃ ∼+ = joinʳ⁺ t₁ k₂ (1# , t₃) ∼+
joinˡ⁻ (suc _) (0# , t₁) k₂ t₃ ∼0 = (1# , node t₁ k₂ t₃ ∼+)
joinˡ⁻ (suc _) (0# , t₁) k₂ t₃ ∼- = (0# , node t₁ k₂ t₃ ∼0)
joinˡ⁻ (suc _) (1# , t₁) k₂ t₃ bal = (1# , node t₁ k₂ t₃ bal)
joinʳ⁻ : ∀ {hˡ} hʳ →
Tree hˡ → KV → (∃ λ i → Tree (i ⊕ hʳ -1)) → (bal : hˡ ∼ hʳ) →
∃ λ i → Tree (i ⊕ max bal)
joinʳ⁻ zero t₁ k₂ (0# , t₃) bal = (1# , node t₁ k₂ t₃ bal)
joinʳ⁻ zero t₁ k₂ (1# , t₃) bal = (1# , node t₁ k₂ t₃ bal)
joinʳ⁻ (suc _) t₁ k₂ (0# , t₃) ∼- = joinˡ⁺ (1# , t₁) k₂ t₃ ∼-
joinʳ⁻ (suc _) t₁ k₂ (0# , t₃) ∼0 = (1# , node t₁ k₂ t₃ ∼-)
joinʳ⁻ (suc _) t₁ k₂ (0# , t₃) ∼+ = (0# , node t₁ k₂ t₃ ∼0)
joinʳ⁻ (suc _) t₁ k₂ (1# , t₃) bal = (1# , node t₁ k₂ t₃ bal)
-- Extracts the smallest element from the tree, plus the rest.
-- Logarithmic in the size of the tree.
headTail : ∀ {h} → Tree (1 + h) →
KV × ∃ λ i → Tree (i ⊕ h)
headTail (node leaf k₁ t₂ ∼+) = (k₁ , 0# , t₂)
headTail (node leaf k₁ t₂ ∼0) = (k₁ , 0# , t₂)
headTail (node {hˡ = suc _} t₁₂ k₃ t₄ bal) with headTail t₁₂
... | (k₁ , t₂) = (k₁ , joinˡ⁻ _ t₂ k₃ t₄ bal)
-- Extracts the largest element from the tree, plus the rest.
-- Logarithmic in the size of the tree.
initLast : ∀ {h} → Tree (1 + h) →
∃ (λ i → Tree (i ⊕ h)) × KV
initLast (node t₁ k₂ leaf ∼-) = ((0# , t₁) , k₂)
initLast (node t₁ k₂ leaf ∼0) = ((0# , t₁) , k₂)
initLast (node {hʳ = suc _} t₁ k₂ t₃₄ bal) with initLast t₃₄
... | (t₃ , k₄) = (joinʳ⁻ _ t₁ k₂ t₃ bal , k₄)
-- Another joining function. Logarithmic in the size of the tree.
join : ∀ {hˡ hʳ} →
Tree hˡ → Tree hʳ → (bal : hˡ ∼ hʳ) →
∃ λ i → Tree (i ⊕ max bal)
join t₁ leaf ∼0 = (0# , t₁)
join t₁ leaf ∼- = (0# , t₁)
join {hʳ = suc _} t₁ t₂₃ bal with headTail t₂₃
... | (k₂ , t₃) = joinʳ⁻ _ t₁ k₂ t₃ bal
-- An empty tree.
empty : Tree 0
empty = leaf
-- A singleton tree.
singleton : (k : Key) → Value k → Tree 1
singleton k v = node leaf (k , v) leaf ∼0
-- Inserts a key into the tree. If the key already exists, then it
-- is replaced. Logarithmic in the size of the tree (assuming
-- constant-time comparisons).
insert : ∀ {h} → (k : Key) → Value k → Tree h →
∃ λ i → Tree (i ⊕ h)
insert k v leaf = (1# , singleton k v)
insert k v (node l p r bal) with compare k (proj₁ p)
... | tri< _ _ _ = joinˡ⁺ (insert k v l) p r bal
... | tri≈ _ _ _ = (0# , node l (k , v) r bal)
... | tri> _ _ _ = joinʳ⁺ l p (insert k v r) bal
-- Deletes the key/value pair containing the given key, if any.
-- Logarithmic in the size of the tree (assuming constant-time
-- comparisons).
delete : ∀ {h} → Key → Tree h →
∃ λ i → Tree (i ⊕ h -1)
delete k leaf = (0# , leaf)
delete k (node l p r bal) with compare k (proj₁ p)
... | tri< _ _ _ = joinˡ⁻ _ (delete k l) p r bal
... | tri≈ _ _ _ = join l r bal
... | tri> _ _ _ = joinʳ⁻ _ l p (delete k r) bal
-- Looks up a key in the tree. Logarithmic in the size of the tree
-- (assuming constant-time comparisons).
lookup : ∀ {h} → (k : Key) → Tree h →
Maybe (∃ λ k′ → Value k′ × k ≈ k′)
lookup k leaf = nothing
lookup k (node l (k′ , v) r _) with compare k k′
... | tri< _ _ _ = lookup k l
... | tri≈ _ eq _ = just (k′ , v , eq)
... | tri> _ _ _ = lookup k r
-- Converts the tree to an ordered list. Linear in the size of the
-- tree.
open DiffList
toDiffList : ∀ {h} → Tree h → DiffList KV
toDiffList leaf = []
toDiffList (node l k r _) = toDiffList l ++ [ k ] ++ toDiffList r
------------------------------------------------------------------------
-- Types and functions with hidden indices
data Tree : Set where
tree : ∀ {h} → Indexed.Tree h → Tree
empty : Tree
empty = tree Indexed.empty
singleton : (k : Key) → Value k → Tree
singleton k v = tree (Indexed.singleton k v)
insert : (k : Key) → Value k → Tree → Tree
insert k v (tree t) with Indexed.insert k v t
... | (_ , t′) = tree t′
delete : Key → Tree → Tree
delete k (tree t) with Indexed.delete k t
... | (_ , t′) = tree t′
lookup : (k : Key) → Tree → Maybe (∃ λ k′ → Value k′ × k ≈ k′)
lookup k (tree t) = Indexed.lookup k t
_∈?_ : Key → Tree → Bool
k ∈? t = maybeToBool (lookup k t)
headTail : Tree → Maybe (KV × Tree)
headTail (tree Indexed.leaf) = nothing
headTail (tree {h = suc _} t) with Indexed.headTail t
... | (k , _ , t′) = just (k , tree t′)
initLast : Tree → Maybe (Tree × KV)
initLast (tree Indexed.leaf) = nothing
initLast (tree {h = suc _} t) with Indexed.initLast t
... | ((_ , t′) , k) = just (tree t′ , k)
-- The input does not need to be ordered.
fromList : List KV → Tree
fromList = List.foldr (uncurry insert) empty
-- Returns an ordered list.
toList : Tree → List KV
toList (tree t) = DiffList.toList (Indexed.toDiffList t)
|
{
"alphanum_fraction": 0.4841301329,
"avg_line_length": 33.2739273927,
"ext": "agda",
"hexsha": "ae5210447f557e4005da4a1c1b0fd60bd6258c7b",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:54:10.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-07-21T16:37:58.000Z",
"max_forks_repo_head_hexsha": "8ef786b40e4a9ab274c6103dc697dcb658cf3db3",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "isabella232/Lemmachine",
"max_forks_repo_path": "vendor/stdlib/src/Data/AVL.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "8ef786b40e4a9ab274c6103dc697dcb658cf3db3",
"max_issues_repo_issues_event_max_datetime": "2022-03-12T12:17:51.000Z",
"max_issues_repo_issues_event_min_datetime": "2022-03-12T12:17:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "larrytheliquid/Lemmachine",
"max_issues_repo_path": "vendor/stdlib/src/Data/AVL.agda",
"max_line_length": 85,
"max_stars_count": 56,
"max_stars_repo_head_hexsha": "8ef786b40e4a9ab274c6103dc697dcb658cf3db3",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "isabella232/Lemmachine",
"max_stars_repo_path": "vendor/stdlib/src/Data/AVL.agda",
"max_stars_repo_stars_event_max_datetime": "2021-12-21T17:02:19.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-20T02:11:42.000Z",
"num_tokens": 3980,
"size": 10082
}
|
module RandomAccessList.Zeroless.Core.Properties where
open import BuildingBlock
open import BuildingBlock.BinaryLeafTree using (BinaryLeafTree; Node; Leaf)
open import RandomAccessList.Zeroless.Core
open import Data.Nat
open import Data.Nat.Etc
open import Data.Nat.Properties.Simple
open import Relation.Binary.PropositionalEquality as PropEq
using (_≡_; _≢_; refl; cong; cong₂; trans; sym; inspect)
open PropEq.≡-Reasoning
--------------------------------------------------------------------------------
-- On ⟦_⟧ and ⟦_⟧ₙ
-- identity
⟦[]⟧ₙ≡0 : ∀ {A n} → (xs : 1-2-RAL A n) → xs ≡ [] → ⟦ xs ⟧ₙ ≡ 0
⟦[]⟧ₙ≡0 [] p = refl
⟦[]⟧ₙ≡0 (x 1∷ xs) ()
⟦[]⟧ₙ≡0 (x , y 2∷ xs) ()
⟦[]⟧≡0 : ∀ {n A} → (xs : 1-2-RAL A n) → xs ≡ [] → ⟦ xs ⟧ ≡ 0
⟦[]⟧≡0 {zero} [] p = refl
⟦[]⟧≡0 {suc n} [] p = *-right-zero (2 * 2 ^ n)
⟦[]⟧≡0 (x 1∷ xs) ()
⟦[]⟧≡0 (x , y 2∷ xs) ()
{-
begin
{! !}
≡⟨ {! !} ⟩
{! !}
≡⟨ {! !} ⟩
{! !}
≡⟨ {! !} ⟩
{! !}
≡⟨ {! !} ⟩
{! !}
∎
-}
|
{
"alphanum_fraction": 0.444971537,
"avg_line_length": 25.0952380952,
"ext": "agda",
"hexsha": "7ece03c76afa6f4dd34cbf530d0ea67a459a513d",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2015-05-30T05:50:50.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-05-30T05:50:50.000Z",
"max_forks_repo_head_hexsha": "aae093cc9bf21f11064e7f7b12049448cd6449f1",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "banacorn/numeral",
"max_forks_repo_path": "legacy/RandomAccessList/Zeroless/Core/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "aae093cc9bf21f11064e7f7b12049448cd6449f1",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "banacorn/numeral",
"max_issues_repo_path": "legacy/RandomAccessList/Zeroless/Core/Properties.agda",
"max_line_length": 80,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "aae093cc9bf21f11064e7f7b12049448cd6449f1",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "banacorn/numeral",
"max_stars_repo_path": "legacy/RandomAccessList/Zeroless/Core/Properties.agda",
"max_stars_repo_stars_event_max_datetime": "2015-04-23T15:58:28.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-04-23T15:58:28.000Z",
"num_tokens": 446,
"size": 1054
}
|
------------------------------------------------------------------------------
-- Inductive PA arithmetic properties using Agsy
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
-- Tested with the development version of the Agda standard library on
-- 02 February 2012.
module Agsy.PA.Inductive.Properties where
open import Data.Nat renaming ( suc to succ )
open import Relation.Binary.PropositionalEquality
open ≡-Reasoning
------------------------------------------------------------------------------
+-rightIdentity : ∀ n → n + zero ≡ n -- via Agsy {-c}
+-rightIdentity zero = refl
+-rightIdentity (succ n) = cong succ (+-rightIdentity n)
+-assoc : ∀ m n o → m + n + o ≡ m + (n + o) -- via Agsy {-c}
+-assoc zero n o = refl
+-assoc (succ m) n o = cong succ (+-assoc m n o)
x+Sy≡S[x+y] : ∀ m n → m + succ n ≡ succ (m + n) -- via Agsy {-c}
x+Sy≡S[x+y] zero n = refl
x+Sy≡S[x+y] (succ m) n = cong succ (x+Sy≡S[x+y] m n)
+-comm : ∀ m n → m + n ≡ n + m -- via Agsy {-c -m}
+-comm zero n = sym (+-rightIdentity n)
+-comm (succ m) n =
begin
succ (m + n) ≡⟨ cong succ (+-comm m n) ⟩
succ (n + m) ≡⟨ sym (x+Sy≡S[x+y] n m) ⟩
n + succ m
∎
|
{
"alphanum_fraction": 0.469521045,
"avg_line_length": 32.8095238095,
"ext": "agda",
"hexsha": "31eb389fd2228102386c8345f88a758f1c696bbc",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z",
"max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/fotc",
"max_forks_repo_path": "src/fot/Agsy/PA/Inductive/Properties.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/fotc",
"max_issues_repo_path": "src/fot/Agsy/PA/Inductive/Properties.agda",
"max_line_length": 78,
"max_stars_count": 11,
"max_stars_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/fotc",
"max_stars_repo_path": "src/fot/Agsy/PA/Inductive/Properties.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-12T16:09:54.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:53:42.000Z",
"num_tokens": 398,
"size": 1378
}
|
{-# OPTIONS --without-K --safe #-}
module Categories.Functor.Instance.StrictCore where
-- The 'strict' core functor (from StrictCats to StrictGroupoids).
-- This is the right-adjoint of the forgetful functor from
-- StrictGroupoids to StrictCats
-- (see Categories.Functor.Adjoint.Instance.StrictCore)
open import Data.Product
open import Level using (_⊔_)
open import Function using (_on_; _$_) renaming (id to idf)
open import Relation.Binary.PropositionalEquality as ≡ using (cong; cong-id)
open import Categories.Category
import Categories.Category.Construction.Core as C
open import Categories.Category.Instance.StrictCats
open import Categories.Category.Instance.StrictGroupoids
open import Categories.Functor
open import Categories.Functor.Equivalence
open import Categories.Functor.Instance.Core renaming (Core to WeakCore)
open import Categories.Functor.Properties using ([_]-resp-≅)
import Categories.Morphism as Morphism
import Categories.Morphism.Reasoning as MR
import Categories.Morphism.HeterogeneousIdentity as HId
import Categories.Morphism.HeterogeneousIdentity.Properties as HIdProps
open import Categories.Morphism.IsoEquiv using (⌞_⌟)
Core : ∀ {o ℓ e} → Functor (Cats o ℓ e) (Groupoids o (ℓ ⊔ e) e)
Core {o} {ℓ} {e} = record
{ F₀ = F₀
; F₁ = F₁
; identity = λ {A} →
record { eq₀ = λ _ → ≡.refl ; eq₁ = λ _ → ⌞ MR.id-comm-sym A ⌟ }
; homomorphism = λ {A B C} →
record { eq₀ = λ _ → ≡.refl ; eq₁ = λ _ → ⌞ MR.id-comm-sym C ⌟ }
; F-resp-≈ = λ {A B F G} → CoreRespFEq {A} {B} {F} {G}
}
where
open Functor WeakCore
CoreRespFEq : {A B : Category o ℓ e} {F G : Functor A B} →
F ≡F G → F₁ F ≡F F₁ G
CoreRespFEq {A} {B} {F} {G} F≡G = record
{ eq₀ = eq₀
; eq₁ = λ {X} {Y} f → ⌞ begin
(from $ hid BC $ eq₀ Y) ∘ F.F₁ (from f)
≈⟨ ∘-resp-≈ˡ (hid-identity BC B from Equiv.refl (eq₀ Y)) ⟩
(hid B $ ≡.cong idf $ eq₀ Y) ∘ F.F₁ (from f)
≡⟨ cong (λ p → hid B p ∘ _) (cong-id (eq₀ Y)) ⟩
hid B (eq₀ Y) ∘ F.F₁ (from f)
≈⟨ eq₁ (from f) ⟩
G.F₁ (from f) ∘ hid B (eq₀ X)
≡˘⟨ cong (λ p → _ ∘ hid B p) (cong-id (eq₀ X)) ⟩
G.F₁ (from f) ∘ (hid B $ cong idf $ eq₀ X)
≈˘⟨ ∘-resp-≈ʳ (hid-identity BC B from Equiv.refl (eq₀ X)) ⟩
G.F₁ (from f) ∘ (from $ hid BC $ eq₀ X)
∎ ⌟
}
where
BC = C.Core B
module F = Functor F
module G = Functor G
open Category B
open HomReasoning hiding (refl)
open HId
open HIdProps
open _≡F_ F≡G
open Morphism._≅_
|
{
"alphanum_fraction": 0.6079027356,
"avg_line_length": 37.6,
"ext": "agda",
"hexsha": "e6c22d869e7a8e10004101139f309be13bc5d001",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "58e5ec015781be5413bdf968f7ec4fdae0ab4b21",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "MirceaS/agda-categories",
"max_forks_repo_path": "src/Categories/Functor/Instance/StrictCore.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "58e5ec015781be5413bdf968f7ec4fdae0ab4b21",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "MirceaS/agda-categories",
"max_issues_repo_path": "src/Categories/Functor/Instance/StrictCore.agda",
"max_line_length": 76,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "58e5ec015781be5413bdf968f7ec4fdae0ab4b21",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "MirceaS/agda-categories",
"max_stars_repo_path": "src/Categories/Functor/Instance/StrictCore.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 899,
"size": 2632
}
|
------------------------------------------------------------------------------
-- Testing the translation of definitions
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module Definition06 where
postulate
D : Set
_≡_ : D → D → Set
a c : D
b : D
b = a
{-# ATP definition b #-}
postulate
foo : c ≡ b
-- We test the use of an ATP definition by a local hint.
postulate bar : c ≡ a
{-# ATP prove bar foo #-}
|
{
"alphanum_fraction": 0.4196141479,
"avg_line_length": 23.037037037,
"ext": "agda",
"hexsha": "b13bd59a7c6669bd8124c7a032edc94f4e7654e0",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2016-08-03T03:54:55.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-05-10T23:06:19.000Z",
"max_forks_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/apia",
"max_forks_repo_path": "test/Succeed/fol-theorems/Definition06.agda",
"max_issues_count": 121,
"max_issues_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_issues_repo_issues_event_max_datetime": "2018-04-22T06:01:44.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-25T13:22:12.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/apia",
"max_issues_repo_path": "test/Succeed/fol-theorems/Definition06.agda",
"max_line_length": 78,
"max_stars_count": 10,
"max_stars_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/apia",
"max_stars_repo_path": "test/Succeed/fol-theorems/Definition06.agda",
"max_stars_repo_stars_event_max_datetime": "2019-12-03T13:44:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:54:16.000Z",
"num_tokens": 128,
"size": 622
}
|
{- 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 Util.KVMap as Map
open import Util.Prelude
module LibraBFT.Impl.OBM.Prelude where
lookupOrInsert : ∀ {K V : Set} → K → V → Map.KVMap K V → Map.KVMap K V
lookupOrInsert k v m =
if Map.kvm-member k m
then m
else Map.insert k v m
|
{
"alphanum_fraction": 0.7306122449,
"avg_line_length": 28.8235294118,
"ext": "agda",
"hexsha": "bbee54079708e1a2e9c75b75b6b77b6de9c7bdf4",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "a4674fc473f2457fd3fe5123af48253cfb2404ef",
"max_forks_repo_licenses": [
"UPL-1.0"
],
"max_forks_repo_name": "LaudateCorpus1/bft-consensus-agda",
"max_forks_repo_path": "src/LibraBFT/Impl/OBM/Prelude.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "a4674fc473f2457fd3fe5123af48253cfb2404ef",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"UPL-1.0"
],
"max_issues_repo_name": "LaudateCorpus1/bft-consensus-agda",
"max_issues_repo_path": "src/LibraBFT/Impl/OBM/Prelude.agda",
"max_line_length": 111,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "a4674fc473f2457fd3fe5123af48253cfb2404ef",
"max_stars_repo_licenses": [
"UPL-1.0"
],
"max_stars_repo_name": "LaudateCorpus1/bft-consensus-agda",
"max_stars_repo_path": "src/LibraBFT/Impl/OBM/Prelude.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 148,
"size": 490
}
|
-- 2012-10-20 Andreas
module Issue721b where
data Bool : Set where
false true : Bool
record Foo (b : Bool) : Set where
field
_*_ : Bool → Bool → Bool
data _≡_ {A : Set} (x : A) : A → Set where
refl : x ≡ x
test : (F : Foo false) → let open Foo F in (x : Bool) → _*_ x ≡ (λ x → x)
test F x = x
where open Foo F
-- Don't want to see any anonymous module
|
{
"alphanum_fraction": 0.597826087,
"avg_line_length": 20.4444444444,
"ext": "agda",
"hexsha": "3564307722fb2da9a947f067d590b2e35c24c26c",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Fail/Issue721b.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Fail/Issue721b.agda",
"max_line_length": 73,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Fail/Issue721b.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 134,
"size": 368
}
|
-- {-# OPTIONS -v tc.lhs:10 -v tc.lhs.split:50 #-}
postulate A : Set
record R : Set where
field f : A
record S : Set where
field f : A
test : _ → A
test record{f = a} = a
|
{
"alphanum_fraction": 0.5810055866,
"avg_line_length": 13.7692307692,
"ext": "agda",
"hexsha": "cffa7879cd0fa4433ab5ff8ad5816ef3f505c10a",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Fail/RecordPattern3.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Fail/RecordPattern3.agda",
"max_line_length": 50,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Fail/RecordPattern3.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 66,
"size": 179
}
|
{-# OPTIONS --safe #-}
module Definition.Conversion.Stability where
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.Weakening
open import Definition.Conversion
open import Definition.Typed.Consequences.Syntactic
open import Definition.Typed.Consequences.Substitution
open import Tools.Product
import Tools.PropositionalEquality as PE
-- Equality of contexts.
data ⊢_≡_ : (Γ Δ : Con Term) → Set where
ε : ⊢ ε ≡ ε
_∙_ : ∀ {Γ Δ A B r} → ⊢ Γ ≡ Δ → Γ ⊢ A ≡ B ^ r → ⊢ Γ ∙ A ^ r ≡ Δ ∙ B ^ r
mutual
-- Syntactic validity and conversion substitution of a context equality.
contextConvSubst : ∀ {Γ Δ} → ⊢ Γ ≡ Δ → ⊢ Γ × ⊢ Δ × Δ ⊢ˢ idSubst ∷ Γ
contextConvSubst ε = ε , ε , id
contextConvSubst (_∙_ {Γ} {Δ} {A} {B} Γ≡Δ A≡B) =
let ⊢Γ , ⊢Δ , [σ] = contextConvSubst Γ≡Δ
⊢A , ⊢B = syntacticEq A≡B
Δ⊢B = stability Γ≡Δ ⊢B
in ⊢Γ ∙ ⊢A , ⊢Δ ∙ Δ⊢B
, (wk1Subst′ ⊢Γ ⊢Δ Δ⊢B [σ]
, conv (var (⊢Δ ∙ Δ⊢B) here)
(PE.subst (λ x → _ ⊢ _ ≡ x ^ _)
(wk1-tailId A)
(wkEq (step id) (⊢Δ ∙ Δ⊢B) (stabilityEq Γ≡Δ (sym A≡B)))))
-- Stability of types under equal contexts.
stability : ∀ {A rA Γ Δ} → ⊢ Γ ≡ Δ → Γ ⊢ A ^ rA → Δ ⊢ A ^ rA
stability Γ≡Δ A =
let ⊢Γ , ⊢Δ , σ = contextConvSubst Γ≡Δ
q = substitution A σ ⊢Δ
in PE.subst (λ x → _ ⊢ x ^ _) (subst-id _) q
-- Stability of type equality.
stabilityEq : ∀ {A B rA Γ Δ} → ⊢ Γ ≡ Δ → Γ ⊢ A ≡ B ^ rA → Δ ⊢ A ≡ B ^ rA
stabilityEq Γ≡Δ A≡B =
let ⊢Γ , ⊢Δ , σ = contextConvSubst Γ≡Δ
q = substitutionEq A≡B (substRefl σ) ⊢Δ
in PE.subst₂ (λ x y → _ ⊢ x ≡ y ^ _) (subst-id _) (subst-id _) q
-- Reflexivity of context equality.
reflConEq : ∀ {Γ} → ⊢ Γ → ⊢ Γ ≡ Γ
reflConEq ε = ε
reflConEq (⊢Γ ∙ ⊢A) = reflConEq ⊢Γ ∙ refl ⊢A
-- Symmetry of context equality.
symConEq : ∀ {Γ Δ} → ⊢ Γ ≡ Δ → ⊢ Δ ≡ Γ
symConEq ε = ε
symConEq (Γ≡Δ ∙ A≡B) = symConEq Γ≡Δ ∙ stabilityEq Γ≡Δ (sym A≡B)
-- Stability of terms.
stabilityTerm : ∀ {t A rA Γ Δ} → ⊢ Γ ≡ Δ → Γ ⊢ t ∷ A ^ rA → Δ ⊢ t ∷ A ^ rA
stabilityTerm Γ≡Δ t =
let ⊢Γ , ⊢Δ , σ = contextConvSubst Γ≡Δ
q = substitutionTerm t σ ⊢Δ
in PE.subst₂ (λ x y → _ ⊢ x ∷ y ^ _) (subst-id _) (subst-id _) q
-- Stability of term reduction.
stabilityRedTerm : ∀ {t u A Γ Δ l} → ⊢ Γ ≡ Δ → Γ ⊢ t ⇒ u ∷ A ^ l → Δ ⊢ t ⇒ u ∷ A ^ l
stabilityRedTerm Γ≡Δ (conv d x) =
conv (stabilityRedTerm Γ≡Δ d) (stabilityEq Γ≡Δ x)
stabilityRedTerm Γ≡Δ (app-subst d x) =
app-subst (stabilityRedTerm Γ≡Δ d) (stabilityTerm Γ≡Δ x)
stabilityRedTerm Γ≡Δ (β-red l< l<' x x₁ x₂) =
β-red l< l<' (stability Γ≡Δ x) (stabilityTerm (Γ≡Δ ∙ refl x) x₁)
(stabilityTerm Γ≡Δ x₂)
stabilityRedTerm Γ≡Δ (natrec-subst x x₁ x₂ d) =
let ⊢Γ , _ , _ = contextConvSubst Γ≡Δ
in natrec-subst (stability (Γ≡Δ ∙ refl (univ (ℕⱼ ⊢Γ))) x) (stabilityTerm Γ≡Δ x₁)
(stabilityTerm Γ≡Δ x₂) (stabilityRedTerm Γ≡Δ d)
stabilityRedTerm Γ≡Δ (natrec-zero x x₁ x₂) =
let ⊢Γ , _ , _ = contextConvSubst Γ≡Δ
in natrec-zero (stability (Γ≡Δ ∙ refl (univ (ℕⱼ ⊢Γ))) x) (stabilityTerm Γ≡Δ x₁)
(stabilityTerm Γ≡Δ x₂)
stabilityRedTerm Γ≡Δ (natrec-suc x x₁ x₂ x₃) =
let ⊢Γ , _ , _ = contextConvSubst Γ≡Δ
in natrec-suc (stabilityTerm Γ≡Δ x) (stability (Γ≡Δ ∙ refl (univ (ℕⱼ ⊢Γ))) x₁)
(stabilityTerm Γ≡Δ x₂) (stabilityTerm Γ≡Δ x₃)
stabilityRedTerm Γ≡Δ (Id-subst X x x₁) = Id-subst (stabilityRedTerm Γ≡Δ X) (stabilityTerm Γ≡Δ x) (stabilityTerm Γ≡Δ x₁)
stabilityRedTerm Γ≡Δ (Id-ℕ-subst X x) = Id-ℕ-subst (stabilityRedTerm Γ≡Δ X) (stabilityTerm Γ≡Δ x)
stabilityRedTerm Γ≡Δ (Id-ℕ-0-subst X) = Id-ℕ-0-subst (stabilityRedTerm Γ≡Δ X)
stabilityRedTerm Γ≡Δ (Id-ℕ-S-subst x X) = Id-ℕ-S-subst (stabilityTerm Γ≡Δ x) (stabilityRedTerm Γ≡Δ X)
stabilityRedTerm Γ≡Δ (Id-U-subst X x) = Id-U-subst (stabilityRedTerm Γ≡Δ X) (stabilityTerm Γ≡Δ x)
stabilityRedTerm Γ≡Δ (Id-U-ℕ-subst X) = Id-U-ℕ-subst (stabilityRedTerm Γ≡Δ X)
stabilityRedTerm Γ≡Δ (Id-U-Π-subst x x₁ X) = Id-U-Π-subst (stabilityTerm Γ≡Δ x) (stabilityTerm (Γ≡Δ ∙ refl (univ x)) x₁) (stabilityRedTerm Γ≡Δ X)
stabilityRedTerm Γ≡Δ (Id-Π l< l<' x x₁ x₂ x₃) = Id-Π l< l<' (stabilityTerm Γ≡Δ x) (stabilityTerm (Γ≡Δ ∙ refl (univ x)) x₁) (stabilityTerm Γ≡Δ x₂) (stabilityTerm Γ≡Δ x₃)
stabilityRedTerm Γ≡Δ (Id-ℕ-00 x) = let _ , ⊢Δ , _ = contextConvSubst Γ≡Δ in Id-ℕ-00 ⊢Δ
stabilityRedTerm Γ≡Δ (Id-ℕ-SS x x₁) = Id-ℕ-SS (stabilityTerm Γ≡Δ x) (stabilityTerm Γ≡Δ x₁)
stabilityRedTerm Γ≡Δ (Id-U-ΠΠ x x₁ x₂ x₃) = Id-U-ΠΠ (stabilityTerm Γ≡Δ x) (stabilityTerm (Γ≡Δ ∙ refl (univ x)) x₁) (stabilityTerm Γ≡Δ x₂) (stabilityTerm (Γ≡Δ ∙ refl (univ x₂)) x₃)
stabilityRedTerm Γ≡Δ (Id-U-ℕℕ x) = let _ , ⊢Δ , _ = contextConvSubst Γ≡Δ in Id-U-ℕℕ ⊢Δ
stabilityRedTerm Γ≡Δ (Id-SProp x x₁) = Id-SProp (stabilityTerm Γ≡Δ x) (stabilityTerm Γ≡Δ x₁)
stabilityRedTerm Γ≡Δ (Id-ℕ-0S x) = Id-ℕ-0S (stabilityTerm Γ≡Δ x)
stabilityRedTerm Γ≡Δ (Id-ℕ-S0 x) = Id-ℕ-S0 (stabilityTerm Γ≡Δ x)
stabilityRedTerm Γ≡Δ (Id-U-ℕΠ x x₁) = Id-U-ℕΠ (stabilityTerm Γ≡Δ x) (stabilityTerm (Γ≡Δ ∙ refl (univ x)) x₁)
stabilityRedTerm Γ≡Δ (Id-U-Πℕ x x₁) = Id-U-Πℕ (stabilityTerm Γ≡Δ x) (stabilityTerm (Γ≡Δ ∙ refl (univ x)) x₁)
stabilityRedTerm Γ≡Δ (Id-U-ΠΠ!% x x₁ x₂ x₃ x₄) =
Id-U-ΠΠ!% x (stabilityTerm Γ≡Δ x₁) (stabilityTerm (Γ≡Δ ∙ refl (univ x₁)) x₂) (stabilityTerm Γ≡Δ x₃) (stabilityTerm (Γ≡Δ ∙ refl (univ x₃)) x₄)
stabilityRedTerm Γ≡Δ (cast-subst X x x₁ x₂) = cast-subst (stabilityRedTerm Γ≡Δ X) (stabilityTerm Γ≡Δ x) (stabilityTerm Γ≡Δ x₁) (stabilityTerm Γ≡Δ x₂)
stabilityRedTerm Γ≡Δ (cast-ℕ-subst X x x₁) =
cast-ℕ-subst (stabilityRedTerm Γ≡Δ X) (stabilityTerm Γ≡Δ x) (stabilityTerm Γ≡Δ x₁)
stabilityRedTerm Γ≡Δ (cast-Π-subst x x₁ X x₂ x₃) =
cast-Π-subst (stabilityTerm Γ≡Δ x) (stabilityTerm (Γ≡Δ ∙ refl (univ x)) x₁) (stabilityRedTerm Γ≡Δ X) (stabilityTerm Γ≡Δ x₂) (stabilityTerm Γ≡Δ x₃)
stabilityRedTerm Γ≡Δ (cast-Π x x₁ x₂ x₃ x₄ x₅) =
cast-Π (stabilityTerm Γ≡Δ x) (stabilityTerm (Γ≡Δ ∙ refl (univ x)) x₁) (stabilityTerm Γ≡Δ x₂) (stabilityTerm (Γ≡Δ ∙ refl (univ x₂)) x₃) (stabilityTerm Γ≡Δ x₄) (stabilityTerm Γ≡Δ x₅)
stabilityRedTerm Γ≡Δ (cast-ℕ-0 x) = cast-ℕ-0 (stabilityTerm Γ≡Δ x)
stabilityRedTerm Γ≡Δ (cast-ℕ-S x x₁) = cast-ℕ-S (stabilityTerm Γ≡Δ x) (stabilityTerm Γ≡Δ x₁)
stabilityRedTerm Γ≡Δ (cast-ℕ-cong x X) = cast-ℕ-cong (stabilityTerm Γ≡Δ x) (stabilityRedTerm Γ≡Δ X)
-- Stability of type reductions.
stabilityRed : ∀ {A B r Γ Δ} → ⊢ Γ ≡ Δ → Γ ⊢ A ⇒ B ^ r → Δ ⊢ A ⇒ B ^ r
stabilityRed Γ≡Δ (univ x) = univ (stabilityRedTerm Γ≡Δ x)
-- Stability of type reduction closures.
stabilityRed* : ∀ {A B r Γ Δ} → ⊢ Γ ≡ Δ → Γ ⊢ A ⇒* B ^ r → Δ ⊢ A ⇒* B ^ r
stabilityRed* Γ≡Δ (id x) = id (stability Γ≡Δ x)
stabilityRed* Γ≡Δ (x ⇨ D) = stabilityRed Γ≡Δ x ⇨ stabilityRed* Γ≡Δ D
-- Stability of term reduction closures.
stabilityRed*Term : ∀ {t u A Γ Δ l} → ⊢ Γ ≡ Δ → Γ ⊢ t ⇒* u ∷ A ^ l → Δ ⊢ t ⇒* u ∷ A ^ l
stabilityRed*Term Γ≡Δ (id x) = id (stabilityTerm Γ≡Δ x)
stabilityRed*Term Γ≡Δ (x ⇨ d) = stabilityRedTerm Γ≡Δ x ⇨ stabilityRed*Term Γ≡Δ d
mutual
-- Stability of algorithmic equality of neutrals.
stability~↑! : ∀ {k l A Γ Δ lA}
→ ⊢ Γ ≡ Δ
→ Γ ⊢ k ~ l ↑! A ^ lA
→ Δ ⊢ k ~ l ↑! A ^ lA
stability~↑! Γ≡Δ (var-refl x x≡y) =
var-refl (stabilityTerm Γ≡Δ x) x≡y
stability~↑! Γ≡Δ (app-cong {rF = ! } k~l x) =
app-cong (stability~↓! Γ≡Δ k~l) (stabilityConv↑Term Γ≡Δ x)
stability~↑! Γ≡Δ (app-cong {rF = %} k~l x) =
app-cong (stability~↓! Γ≡Δ k~l) (stability~↑% Γ≡Δ x)
stability~↑! Γ≡Δ (natrec-cong x₁ x₂ x₃ k~l) =
let ⊢Γ , _ , _ = contextConvSubst Γ≡Δ
in natrec-cong (stabilityConv↑ (Γ≡Δ ∙ (refl (univ (ℕⱼ ⊢Γ)))) x₁)
(stabilityConv↑Term Γ≡Δ x₂)
(stabilityConv↑Term Γ≡Δ x₃)
(stability~↓! Γ≡Δ k~l)
stability~↑! Γ≡Δ (Emptyrec-cong x₁ k~l) =
Emptyrec-cong (stabilityConv↑ Γ≡Δ x₁)
(stability~↑% Γ≡Δ k~l)
stability~↑! Γ≡Δ (Id-cong X x x₁) = Id-cong (stability~↓! Γ≡Δ X) (stabilityConv↑Term Γ≡Δ x) (stabilityConv↑Term Γ≡Δ x₁)
stability~↑! Γ≡Δ (Id-ℕ X x) = Id-ℕ (stability~↓! Γ≡Δ X) (stabilityConv↑Term Γ≡Δ x)
stability~↑! Γ≡Δ (Id-ℕ0 X) = Id-ℕ0 (stability~↓! Γ≡Δ X)
stability~↑! Γ≡Δ (Id-ℕS x X) = Id-ℕS (stabilityConv↑Term Γ≡Δ x) (stability~↓! Γ≡Δ X)
stability~↑! Γ≡Δ (Id-U X x) = Id-U (stability~↓! Γ≡Δ X) (stabilityConv↑Term Γ≡Δ x)
stability~↑! Γ≡Δ (Id-Uℕ X) = Id-Uℕ (stability~↓! Γ≡Δ X)
stability~↑! Γ≡Δ (Id-UΠ x X) = Id-UΠ (stabilityConv↑Term Γ≡Δ x) (stability~↓! Γ≡Δ X)
stability~↑! Γ≡Δ (cast-cong X x x₁ x₂ x₃) = cast-cong (stability~↓! Γ≡Δ X) (stabilityConv↑Term Γ≡Δ x) (stabilityConv↑Term Γ≡Δ x₁) (stabilityTerm Γ≡Δ x₂) (stabilityTerm Γ≡Δ x₃)
stability~↑! Γ≡Δ (cast-ℕ X x x₁ x₂) = cast-ℕ (stability~↓! Γ≡Δ X) (stabilityConv↑Term Γ≡Δ x) (stabilityTerm Γ≡Δ x₁) (stabilityTerm Γ≡Δ x₂)
stability~↑! Γ≡Δ (cast-ℕℕ X x x₁) = cast-ℕℕ (stability~↓! Γ≡Δ X) (stabilityTerm Γ≡Δ x) (stabilityTerm Γ≡Δ x₁)
stability~↑! Γ≡Δ (cast-Π x X x₁ x₂ x₃) = cast-Π (stabilityConv↑Term Γ≡Δ x) (stability~↓! Γ≡Δ X) (stabilityConv↑Term Γ≡Δ x₁) (stabilityTerm Γ≡Δ x₂) (stabilityTerm Γ≡Δ x₃)
stability~↑! Γ≡Δ (cast-Πℕ x x₁ x₂ x₃) = cast-Πℕ (stabilityConv↑Term Γ≡Δ x) (stabilityConv↑Term Γ≡Δ x₁) (stabilityTerm Γ≡Δ x₂) (stabilityTerm Γ≡Δ x₃)
stability~↑! Γ≡Δ (cast-ℕΠ x x₁ x₂ x₃) = cast-ℕΠ (stabilityConv↑Term Γ≡Δ x) (stabilityConv↑Term Γ≡Δ x₁) (stabilityTerm Γ≡Δ x₂) (stabilityTerm Γ≡Δ x₃)
stability~↑! Γ≡Δ (cast-ΠΠ%! x x₁ x₂ x₃ x₄) = cast-ΠΠ%! (stabilityConv↑Term Γ≡Δ x) (stabilityConv↑Term Γ≡Δ x₁) (stabilityConv↑Term Γ≡Δ x₂) (stabilityTerm Γ≡Δ x₃) (stabilityTerm Γ≡Δ x₄)
stability~↑! Γ≡Δ (cast-ΠΠ!% x x₁ x₂ x₃ x₄) = cast-ΠΠ!% (stabilityConv↑Term Γ≡Δ x) (stabilityConv↑Term Γ≡Δ x₁) (stabilityConv↑Term Γ≡Δ x₂) (stabilityTerm Γ≡Δ x₃) (stabilityTerm Γ≡Δ x₄)
stability~↑% : ∀ {k l A Γ Δ lA}
→ ⊢ Γ ≡ Δ
→ Γ ⊢ k ~ l ↑% A ^ lA
→ Δ ⊢ k ~ l ↑% A ^ lA
stability~↑% Γ≡Δ (%~↑ ⊢k ⊢l) = %~↑ (stabilityTerm Γ≡Δ ⊢k) (stabilityTerm Γ≡Δ ⊢l)
stability~↑ : ∀ {k l A rA lA Γ Δ}
→ ⊢ Γ ≡ Δ
→ Γ ⊢ k ~ l ↑ A ^ [ rA , lA ]
→ Δ ⊢ k ~ l ↑ A ^ [ rA , lA ]
stability~↑ Γ≡Δ (~↑! x) = ~↑! (stability~↑! Γ≡Δ x)
stability~↑ Γ≡Δ (~↑% x) = ~↑% (stability~↑% Γ≡Δ x)
-- Stability of algorithmic equality of neutrals of types in WHNF.
stability~↓! : ∀ {k l A lA Γ Δ}
→ ⊢ Γ ≡ Δ
→ Γ ⊢ k ~ l ↓! A ^ lA
→ Δ ⊢ k ~ l ↓! A ^ lA
stability~↓! Γ≡Δ ([~] A D whnfA k~l) =
[~] A (stabilityRed* Γ≡Δ D) whnfA (stability~↑! Γ≡Δ k~l)
-- Stability of algorithmic equality of types.
stabilityConv↑ : ∀ {A B r Γ Δ}
→ ⊢ Γ ≡ Δ
→ Γ ⊢ A [conv↑] B ^ r
→ Δ ⊢ A [conv↑] B ^ r
stabilityConv↑ Γ≡Δ ([↑] A′ B′ D D′ whnfA′ whnfB′ A′<>B′) =
[↑] A′ B′ (stabilityRed* Γ≡Δ D) (stabilityRed* Γ≡Δ D′) whnfA′ whnfB′
(stabilityConv↓ Γ≡Δ A′<>B′)
-- Stability of algorithmic equality of types in WHNF.
stabilityConv↓ : ∀ {A B r Γ Δ}
→ ⊢ Γ ≡ Δ
→ Γ ⊢ A [conv↓] B ^ r
→ Δ ⊢ A [conv↓] B ^ r
stabilityConv↓ Γ≡Δ (U-refl PE.refl x) =
let _ , ⊢Δ , _ = contextConvSubst Γ≡Δ
in U-refl PE.refl ⊢Δ
stabilityConv↓ Γ≡Δ (univ x) = univ (stabilityConv↓Term Γ≡Δ x)
-- Stability of algorithmic equality of terms.
stabilityConv↑Term : ∀ {t u A lA Γ Δ}
→ ⊢ Γ ≡ Δ
→ Γ ⊢ t [conv↑] u ∷ A ^ lA
→ Δ ⊢ t [conv↑] u ∷ A ^ lA
stabilityConv↑Term Γ≡Δ ([↑]ₜ B t′ u′ D d d′ whnfB whnft′ whnfu′ t<>u) =
[↑]ₜ B t′ u′ (stabilityRed* Γ≡Δ D) (stabilityRed*Term Γ≡Δ d)
(stabilityRed*Term Γ≡Δ d′) whnfB whnft′ whnfu′
(stabilityConv↓Term Γ≡Δ t<>u)
-- Stability of algorithmic equality of terms in WHNF.
stabilityConv↓Term : ∀ {t u A lA Γ Δ}
→ ⊢ Γ ≡ Δ
→ Γ ⊢ t [conv↓] u ∷ A ^ lA
→ Δ ⊢ t [conv↓] u ∷ A ^ lA
stabilityConv↓Term Γ≡Δ (U-refl PE.refl x) =
let _ , ⊢Δ , _ = contextConvSubst Γ≡Δ
in U-refl PE.refl ⊢Δ
stabilityConv↓Term Γ≡Δ (ne x) = ne (stability~↓! Γ≡Δ x)
stabilityConv↓Term Γ≡Δ (ℕ-refl x) =
let _ , ⊢Δ , _ = contextConvSubst Γ≡Δ
in ℕ-refl ⊢Δ
stabilityConv↓Term Γ≡Δ (Empty-refl x _) =
let _ , ⊢Δ , _ = contextConvSubst Γ≡Δ
in Empty-refl x ⊢Δ
stabilityConv↓Term Γ≡Δ (Π-cong PE.refl PE.refl PE.refl PE.refl l< l<' F A<>B A<>B₁) =
Π-cong PE.refl PE.refl PE.refl PE.refl l< l<' (stability Γ≡Δ F) (stabilityConv↑Term Γ≡Δ A<>B)
(stabilityConv↑Term (Γ≡Δ ∙ refl F) A<>B₁)
stabilityConv↓Term Γ≡Δ (∃-cong PE.refl F A<>B A<>B₁) =
∃-cong PE.refl (stability Γ≡Δ F) (stabilityConv↑Term Γ≡Δ A<>B)
(stabilityConv↑Term (Γ≡Δ ∙ refl F) A<>B₁)
stabilityConv↓Term Γ≡Δ (ℕ-ins x) =
ℕ-ins (stability~↓! Γ≡Δ x)
-- stabilityConv↓Term Γ≡Δ (Empty-ins x) =
-- Empty-ins (stability~↓% Γ≡Δ x)
stabilityConv↓Term Γ≡Δ (ne-ins t u neN x) =
ne-ins (stabilityTerm Γ≡Δ t) (stabilityTerm Γ≡Δ u) neN (stability~↓! Γ≡Δ x)
stabilityConv↓Term Γ≡Δ (zero-refl x) =
let _ , ⊢Δ , _ = contextConvSubst Γ≡Δ
in zero-refl ⊢Δ
stabilityConv↓Term Γ≡Δ (suc-cong t<>u) = suc-cong (stabilityConv↑Term Γ≡Δ t<>u)
stabilityConv↓Term Γ≡Δ (η-eq l< l<' F x x₁ y y₁ t<>u) =
η-eq l< l<' (stability Γ≡Δ F) (stabilityTerm Γ≡Δ x) (stabilityTerm Γ≡Δ x₁)
y y₁ (stabilityConv↑Term (Γ≡Δ ∙ refl F) t<>u)
|
{
"alphanum_fraction": 0.5920131128,
"avg_line_length": 52.6352941176,
"ext": "agda",
"hexsha": "f0a5a43f75c995f51f70ca19923a2c87cc0f30ea",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2022-02-15T19:42:19.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-01-26T14:55:51.000Z",
"max_forks_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "CoqHott/logrel-mltt",
"max_forks_repo_path": "Definition/Conversion/Stability.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "CoqHott/logrel-mltt",
"max_issues_repo_path": "Definition/Conversion/Stability.agda",
"max_line_length": 185,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "CoqHott/logrel-mltt",
"max_stars_repo_path": "Definition/Conversion/Stability.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-17T16:13:53.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-06-21T08:39:01.000Z",
"num_tokens": 6475,
"size": 13422
}
|
{-# OPTIONS --without-K --copatterns #-}
open import HoTT
module experimental.GlobularTypes where
{- Globular types as a coinductive record -}
record Glob (i : ULevel) : Type (suc i) where
coinductive
constructor glob
field
Ob : Type i
Hom : (a b : Ob) → Glob i
open Glob public
{- The terminal globular type -}
Unit-glob : Glob zero
Ob Unit-glob = Unit
Hom Unit-glob _ _ = Unit-glob
{- The tower of identity types -}
Id-glob : ∀ {i} (A : Type i) → Glob zero
Ob (Id-glob A) = A
Hom (Id-glob A) a b = Id-glob (a == b)
{- Bisimulation between globular types -}
record _~_ {i} (G H : Glob i) : Type (suc i) where
coinductive
constructor glob~
field
Ob= : Ob G == Ob H
Hom= : {a : Ob G} {a' : Ob H} (p : a == a' [ (λ x → x) ↓ Ob= ])
{b : Ob G} {b' : Ob H} (q : b == b' [ (λ x → x) ↓ Ob= ])
→ Hom G a b ~ Hom H a' b'
open _~_ public
=-to-~ : ∀ {i} {G H : Glob i} → G == H → G ~ H
Ob= (=-to-~ p) = ap Ob p
Hom= (=-to-~ p) q r =
=-to-~ (↓-app→cst-out (↓-→-out (apd Hom p)
(↓-ap-out _ Ob p q))
(↓-ap-out _ Ob p r))
-- The definition of [Hom= (=-to-~ p) q r] would/should just be
-- [=-to-~ (apd Hom p q r)] in infinite-dimensional type theory, but here we
-- need to add a lot of non-sense to make it type-check.
{-
We postulate that bisimilarity is equality, because this should be true.
-}
postulate
bisim-is-equiv : ∀ {i} {G H : Glob i} → is-equiv (=-to-~ :> (G == H → G ~ H))
bisim-equiv : ∀ {i} {G H : Glob i} → (G == H) ≃ (G ~ H)
bisim-equiv = (=-to-~ , bisim-is-equiv)
bisim : ∀ {i} {G H : Glob i} → (G ~ H) → G == H
bisim e = <– bisim-equiv e
{-
The type of globular types is the terminal coalgebra of the appropriate thing.
This is proved in the following two lemmas.
-}
Glob-corec : ∀ {i} {A : Type (suc i)} (Ob* : A → Type i)
(Hom* : (x : A) (a b : Ob* x) → A) → (A → Glob i)
Ob (Glob-corec Ob* Hom* x) = Ob* x
Hom (Glob-corec Ob* Hom* x) a b = Glob-corec Ob* Hom* (Hom* x a b)
eta : ∀ {i} {A : Type (suc i)} (Ob* : A → Type i)
(Hom* : (x : A) (a b : Ob* x) → A)
(f g : A → Glob i) (s : (x : A) → f x ~ g x) → f == g
eta Ob* Hom* f g s = funext (λ x → bisim (s x))
|
{
"alphanum_fraction": 0.534121929,
"avg_line_length": 30.1095890411,
"ext": "agda",
"hexsha": "d1d7b5a554c84bf3c79e6f36fd657c48a67c1817",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nicolaikraus/HoTT-Agda",
"max_forks_repo_path": "experimental/GlobularTypes.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nicolaikraus/HoTT-Agda",
"max_issues_repo_path": "experimental/GlobularTypes.agda",
"max_line_length": 79,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "f8fa68bf753d64d7f45556ca09d0da7976709afa",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "UlrikBuchholtz/HoTT-Agda",
"max_stars_repo_path": "experimental/GlobularTypes.agda",
"max_stars_repo_stars_event_max_datetime": "2021-06-30T00:17:55.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-06-30T00:17:55.000Z",
"num_tokens": 841,
"size": 2198
}
|
------------------------------------------------------------------------
-- The delay monad defined as the greatest fixpoint of an indexed
-- container
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
module Indexed-container.Delay-monad where
open import Equality.Propositional as E using (_≡_; refl)
open import Logical-equivalence using (_⇔_)
open import Prelude
open import Prelude.Size
open import Bijection E.equality-with-J as Bijection using (_↔_)
open import Function-universe E.equality-with-J as F hiding (_∘_)
open import Delay-monad
open import Delay-monad.Bisimilarity as B
open import Indexed-container
open import Indexed-container.Combinators as C hiding (_∘_)
open import Relation
-- A container for the delay monad.
DelayC : ∀ {ℓ} → Type ℓ → Container (↑ ℓ ⊤) (↑ ℓ ⊤)
DelayC A =
(λ _ → Maybe A) ◁ λ { (just _) _ → ⊥; nothing _ → ↑ _ ⊤ }
-- An alternative definition.
DelayC′ : ∀ {ℓ} → Type ℓ → Container (↑ ℓ ⊤) (↑ ℓ ⊤)
DelayC′ A = C.id ⊕ C.const (λ _ → A)
-- The two containers' interpretations are pointwise logically
-- equivalent, and in the presence of extensionality they are
-- pointwise isomorphic.
⟦DelayC⟧↔⟦DelayC′⟧ :
∀ {k a x} {A : Type a} {X : Rel x (↑ a ⊤)} {i} →
Extensionality? k a (a ⊔ x) →
⟦ DelayC A ⟧ X i ↝[ k ] ⟦ DelayC′ A ⟧ X i
⟦DelayC⟧↔⟦DelayC′⟧ {k} {a} {A = A} {X} {i} ext =
⟦ DelayC A ⟧ X i ↔⟨⟩
(∃ λ (s : Maybe A) → Container.Position (DelayC A) s ⊆ X) ↝⟨ Σ-cong (inverse Bijection.↑↔ ⊎-cong F.id)
[ (λ _ → implicit-∀-cong ext $
Π-cong (lower-extensionality? k lzero a ext) lemma λ _ →
F.id)
, (λ _ → F.id)
] ⟩
(∃ λ (s : ↑ _ ⊤ ⊎ A) → [ (λ _ → _ ≡_) , (λ _ _ → ⊥) ] s ⊆ X) ↔⟨⟩
⟦ DelayC′ A ⟧ X i □
where
lemma : ↑ a ⊤ ↔ lift {ℓ = a} tt ≡ lift tt
lemma = record
{ surjection = record
{ logical-equivalence = record
{ to = λ _ → refl
}
; right-inverse-of = λ { refl → refl }
}
; left-inverse-of = λ _ → refl
}
-- An unfolding lemma.
νDelayC↔ : ∀ {k a i} {A : Type a} →
Extensionality? k a a →
ν (DelayC A) i _ ↝[ k ] A ⊎ ν′ (DelayC A) i _
νDelayC↔ {i = i} {A} ext =
ν (DelayC A) i _ ↔⟨⟩
⟦ DelayC A ⟧ (ν′ (DelayC A) i) _ ↝⟨ ⟦DelayC⟧↔⟦DelayC′⟧ ext ⟩
⟦ DelayC′ A ⟧ (ν′ (DelayC A) i) _ ↔⟨ ⟦⊕⟧↔ C.id (C.const (λ _ → A)) ⟩
⟦ C.id ⟧ (ν′ (DelayC A) i) _ ⊎
⟦ C.const (λ _ → A) ⟧ (ν′ (DelayC A) i) _ ↝⟨ ⟦id⟧↔ ext ⊎-cong ⟦const⟧↔ _ ext ⟩
ν′ (DelayC A) i _ ⊎ A ↔⟨ ⊎-comm ⟩□
A ⊎ ν′ (DelayC A) i _ □
-- There is a (size-preserving) logical equivalence between the direct
-- definition of the delay monad and an indirect definition using the
-- container DelayC and ν.
mutual
Delay⇔νDelayC : ∀ {a i} {A : Type a} → Delay A i ⇔ ν (DelayC A) i _
Delay⇔νDelayC {i = i} {A} =
Delay A i ↔⟨ Delay↔ ⟩
A ⊎ Delay′ A i ↝⟨ F.id ⊎-cong Delay′⇔ν′DelayC ⟩
A ⊎ ν′ (DelayC A) i _ ↝⟨ inverse $ νDelayC↔ _ ⟩□
ν (DelayC A) i _ □
Delay′⇔ν′DelayC :
∀ {a i} {A : Type a} → Delay′ A i ⇔ ν′ (DelayC A) i _
Delay′⇔ν′DelayC = record
{ to = λ x → λ { .force → _⇔_.to Delay⇔νDelayC (force x) }
; from = λ x → λ { .force → _⇔_.from Delay⇔νDelayC (force x) }
}
-- The two components of Delay⇔νDelayC {i = ∞} are inverses up to
-- (strong) bisimilarity.
Delay⇔νDelayC-inverses :
∀ {a} {A : Type a} →
let to = _⇔_.to (Delay⇔νDelayC {i = ∞})
from = _⇔_.from (Delay⇔νDelayC {i = ∞})
in
(∀ x → ν-bisimilar ∞ (to (from x) , x))
×
(∀ x → [ ∞ ] from (to x) ∼ x)
Delay⇔νDelayC-inverses {A = A} = to∘from , from∘to
where
to : ∀ {i} → Delay A i → ν (DelayC A) i _
to = _⇔_.to Delay⇔νDelayC
from : ∀ {i} → ν (DelayC A) i _ → Delay A i
from = _⇔_.from Delay⇔νDelayC
abstract
from∘to : ∀ {i} x → [ i ] from (to x) ∼ x
from∘to (now x) = now x ∎
from∘to (later x) = later λ { .force →
from (to (force x)) ∼⟨ from∘to (force x) ⟩∼
force x ∎ }
to∘from : ∀ {i} x → ν-bisimilar i (to (from x) , x)
to∘from x@(just _ , _) =
_⇔_.from (ν-bisimilar↔ _ (to (from x)) x)
( refl
, λ ()
)
to∘from x@(nothing , f) =
_⇔_.from (ν-bisimilar↔ _ (to (from x)) x)
( refl
, λ p → λ { .force → to∘from (force (f p)) }
)
-- There is an isomorphism between the direct definition of the delay
-- monad and an indirect definition using the container DelayC and ν
-- (assuming three kinds of extensionality).
Delay↔νDelayC :
∀ {a} {A : Type a} →
E.Extensionality a a →
B.Extensionality a →
ν′-extensionality (DelayC A) →
Delay A ∞ ↔ ν (DelayC A) ∞ _
Delay↔νDelayC ext ∼-ext ν′-ext = record
{ surjection = record
{ logical-equivalence = Delay⇔νDelayC
; right-inverse-of = ν-extensionality ext ν′-ext ∘
proj₁ Delay⇔νDelayC-inverses
}
; left-inverse-of = ∼-ext ∘ proj₂ Delay⇔νDelayC-inverses
}
|
{
"alphanum_fraction": 0.4876260312,
"avg_line_length": 33.6728395062,
"ext": "agda",
"hexsha": "ced30b0a6c65b77a530d22f011059d1092560212",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b936ff85411baf3401ad85ce85d5ff2e9aa0ca14",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/up-to",
"max_forks_repo_path": "src/Indexed-container/Delay-monad.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b936ff85411baf3401ad85ce85d5ff2e9aa0ca14",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/up-to",
"max_issues_repo_path": "src/Indexed-container/Delay-monad.agda",
"max_line_length": 134,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "b936ff85411baf3401ad85ce85d5ff2e9aa0ca14",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/up-to",
"max_stars_repo_path": "src/Indexed-container/Delay-monad.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1957,
"size": 5455
}
|
{-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Library.Relation.Binary where
open import Light.Level using (Setω ; Level)
open import Light.Variable.Levels
open import Light.Variable.Sets
open import Light.Library.Relation using (Base ; Index ; Proposition ; True ; _⇢_)
module _ ⦃ base : Base ⦄ where
record Binary (𝕒 : Set aℓ) (𝕓 : Set bℓ) : Setω where
field if : 𝕒 → 𝕓 → Index
field are : ∀ a b → Proposition (if a b)
SelfBinary : Set aℓ → Setω
SelfBinary 𝕒 = Binary 𝕒 𝕒
open Binary using (are)
private variable a : 𝕒
private variable b : 𝕓
private variable c : 𝕔
record Transitive
(a‐b‐valid : Binary 𝕒 𝕓)
(b‐c‐valid : Binary 𝕓 𝕔)
(a‐c‐valid : Binary 𝕒 𝕔)
: Setω where
field transitivity : True (are a‐b‐valid a b ⇢ (are b‐c‐valid b c ⇢ are a‐c‐valid a c))
record Symmetric
(a‐b‐valid : Binary 𝕒 𝕓)
(b‐a‐valid : Binary 𝕓 𝕒)
: Setω where
field symmetry : True (are a‐b‐valid a b ⇢ are b‐a‐valid b a)
record Reflexive (valid : SelfBinary 𝕒) : Setω where
field reflexivity : True (are valid a a)
SelfTransitive : ∀ (valid : SelfBinary 𝕒) → Setω
SelfTransitive valid = Transitive valid valid valid
SelfSymmetric : ∀ (valid : SelfBinary 𝕒) → Setω
SelfSymmetric valid = Symmetric valid valid
record Preserved
(f : 𝕒 → 𝕓) (g : 𝕔 → 𝕕)
(a‐c‐valid : Binary 𝕒 𝕔)
(b‐d‐valid : Binary 𝕓 𝕕)
: Setω where
field preservation : True (are a‐c‐valid a c ⇢ are b‐d‐valid (f a) (g c))
congruence = preservation
CongruentFor :
(𝕒 → 𝕓)
→ SelfBinary 𝕒
→ SelfBinary 𝕓
→ Setω
CongruentFor f = Preserved f f
SelfCongruentFor :
(𝕒 → 𝕒)
→ SelfBinary 𝕒
→ Setω
SelfCongruentFor f 𝕒 = CongruentFor f 𝕒 𝕒
record Bijective
(f : 𝕒 → 𝕓) (g : 𝕔 → 𝕕)
(b‐d‐valid : Binary 𝕓 𝕕)
(a‐c‐valid : Binary 𝕒 𝕔)
: Setω where
field bijectivity : True (are b‐d‐valid (f a) (g c) ⇢ are a‐c‐valid a c)
injectivity = bijectivity
Injective :
(𝕒 → 𝕓)
→ SelfBinary 𝕓
→ SelfBinary 𝕒
→ Setω
Injective f = Bijective f f
SelfInjective :
(𝕒 → 𝕒)
→ SelfBinary 𝕒
→ Setω
SelfInjective f 𝕒 = Injective f 𝕒 𝕒
open Transitive ⦃ ... ⦄ public
open Symmetric ⦃ ... ⦄ public
open Reflexive ⦃ ... ⦄ public
open Preserved ⦃ ... ⦄ public
open Bijective ⦃ ... ⦄ public
|
{
"alphanum_fraction": 0.5115636866,
"avg_line_length": 29.8659793814,
"ext": "agda",
"hexsha": "6e1fcf652ce048dee719bf480d188d6482f4b1b8",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "44b1c724f2de95d3a9effe87ca36ef9eca8b4756",
"max_forks_repo_licenses": [
"0BSD"
],
"max_forks_repo_name": "Zambonifofex/lightlib",
"max_forks_repo_path": "Light/Library/Relation/Binary.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "44b1c724f2de95d3a9effe87ca36ef9eca8b4756",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"0BSD"
],
"max_issues_repo_name": "Zambonifofex/lightlib",
"max_issues_repo_path": "Light/Library/Relation/Binary.agda",
"max_line_length": 99,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "44b1c724f2de95d3a9effe87ca36ef9eca8b4756",
"max_stars_repo_licenses": [
"0BSD"
],
"max_stars_repo_name": "zamfofex/lightlib",
"max_stars_repo_path": "Light/Library/Relation/Binary.agda",
"max_stars_repo_stars_event_max_datetime": "2019-12-20T21:33:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-12-20T21:33:05.000Z",
"num_tokens": 926,
"size": 2897
}
|
import Agda.Builtin.Size
postulate
F : (A : Set) (B : A → Set) → ((x : A) → B x) → Set
variable
A : Set
P : A → Set
postulate
f : (r : (x : _) → P x) → F _ P (λ x → r x)
|
{
"alphanum_fraction": 0.4725274725,
"avg_line_length": 14,
"ext": "agda",
"hexsha": "8b10379c64f7c196751bb45a1e5384869199ac8d",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-04-01T18:30:09.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-04-01T18:30:09.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue3694.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2019-04-01T19:39:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-11-14T15:31:44.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue3694.agda",
"max_line_length": 53,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue3694.agda",
"max_stars_repo_stars_event_max_datetime": "2020-09-20T00:28:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-10-29T09:40:30.000Z",
"num_tokens": 81,
"size": 182
}
|
-- {-# OPTIONS --copatterns #-}
-- {-# OPTIONS -v tc.lhs:20 #-}
open import Common.Size
record Stream (i : Size) (A : Set) : Set where
coinductive
constructor _::_
field
head : A
tail : ∀ {j : Size< i} → Stream j A
open Stream public
-- size forgetful cons
cons : ∀ i {A} → A → Stream i A → Stream (↑ i) A
cons i a as = a :: as
-- Should work
|
{
"alphanum_fraction": 0.5785123967,
"avg_line_length": 19.1052631579,
"ext": "agda",
"hexsha": "8c08777949d7a6e052e38d6d0f3693abc4b5ad60",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue1523b.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2019-04-01T19:39:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-11-14T15:31:44.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue1523b.agda",
"max_line_length": 48,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue1523b.agda",
"max_stars_repo_stars_event_max_datetime": "2015-12-07T20:14:00.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-03-28T14:51:03.000Z",
"num_tokens": 122,
"size": 363
}
|
-- Properties of insertion sort
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary as B
module Algorithms.List.Sort.Insertion.Properties
{c ℓ₁ ℓ₂} (DTO : DecTotalOrder c ℓ₁ ℓ₂)
where
-- agda-stdlib
open import Level
open import Data.Bool hiding (_≤_; _≤?_; _<_)
open import Data.Empty using (⊥; ⊥-elim)
open import Data.List
import Data.List.Properties as Listₚ
import Data.Nat as ℕ
import Data.Nat.Properties as ℕₚ
open import Data.Product hiding (swap)
open import Data.Sum using (_⊎_; inj₁; inj₂)
import Data.List.Relation.Binary.Equality.Setoid as ListSetoidEquality
import Data.List.Relation.Binary.Permutation.Setoid as PermutationSetoid
import Data.List.Relation.Binary.Permutation.Setoid.Properties
as PermutationSetoidProperties
open import Data.List.Relation.Unary.All as All
import Data.List.Relation.Unary.All.Properties as Allₚ
open import Data.List.Relation.Unary.Linked as Linked
open import Data.List.Relation.Unary.Linked.Properties as Linkedₚ
open import Data.List.Relation.Unary.AllPairs as AllPairs
import Data.List.Relation.Unary.AllPairs.Properties as AllPairsₚ
open import Function.Base using (_∘_; _$_; flip)
import Relation.Binary.Properties.DecTotalOrder as DecTotalOrderProperties
open import Relation.Binary.PropositionalEquality using (_≡_)
import Relation.Binary.PropositionalEquality as ≡ hiding ([_])
import Relation.Binary.Reasoning.Setoid as SetoidReasoning
open import Relation.Nullary
open import Relation.Unary as U
-- agda-misc
open import Algorithms.List.Sort.Common DTO
open import Algorithms.List.Sort.Insertion
open import Experiment.ListRelationProperties
using (foldr-preservesʳ; Linked-∷⁻ʳ; Linked-resp-≋)
open DecTotalOrder DTO renaming (Carrier to A)
open DecTotalOrderProperties DTO
open PermutationSetoid Eq.setoid renaming (refl to PSrefl; trans to PStrans)
open PermutationSetoidProperties Eq.setoid
open ListSetoidEquality Eq.setoid
open InsertionSortOperation _≤?_
private
_≰_ : Rel A _
x ≰ y = ¬ (x ≤ y)
-- stdlib
<⇒≤ : ∀ {x y} → x < y → x ≤ y
<⇒≤ = proj₁
≰⇒≥ : ∀ {x y} → x ≰ y → y ≤ x
≰⇒≥ = <⇒≤ ∘ ≰⇒>
≰∧≱⇒⊥ : ∀ {x y} → x ≰ y → y ≰ x → ⊥
≰∧≱⇒⊥ x≰y y≰x = x≰y (≰⇒≥ y≰x)
≰⇒≉ : ∀ {x y} → x ≰ y → ¬ (x ≈ y)
≰⇒≉ x≰y x≈y = x≰y (≤-respʳ-≈ x≈y refl)
≱⇒≉ : ∀ {x y} → y ≰ x → ¬ (x ≈ y)
≱⇒≉ x≱y x≈y = ≰⇒≉ x≱y (Eq.sym x≈y)
-- stdlib
_≈?_ : ∀ x y → Dec (x ≈ y)
x ≈? y with x ≤? y | y ≤? x
... | yes x≤y | yes y≤x = yes (antisym x≤y y≤x)
... | yes x≤y | no y≰x = no (≱⇒≉ y≰x)
... | no x≰y | yes y≤x = no (≰⇒≉ x≰y)
... | no x≰y | no y≰x = ⊥-elim $ ≰∧≱⇒⊥ x≰y y≰x
≤⇒<∨≈ : ∀ {x y} → x ≤ y → x < y ⊎ x ≈ y
≤⇒<∨≈ {x} {y} x≤y with x ≈? y
... | yes x≈y = inj₂ x≈y
... | no x≉y = inj₁ (≤∧≉⇒< x≤y x≉y)
insert-permutation : ∀ x xs → insert x xs ↭ x ∷ xs
insert-permutation x [] = ↭-refl
insert-permutation x (y ∷ ys) with x ≤? y
... | true because _ = ↭-refl
... | false because _ = ↭-trans (prep Eq.refl (insert-permutation x ys))
(swap Eq.refl Eq.refl ↭-refl)
insert-pres-Sorted : ∀ x {xs} → Sorted xs → Sorted (insert x xs)
insert-pres-Sorted x {[]} _ = [-]
insert-pres-Sorted x {y ∷ ys} xs-Sorted with x ≤? y
... | yes x≤y = x≤y ∷ xs-Sorted
... | no x≰y = Linkedₚ.AllPairs⇒Linked (hd ∷ tl)
where
y≤x : y ≤ x
y≤x = ≰⇒≥ x≰y
lem : All (y ≤_) ys
lem = AllPairs.head (toAllPairs xs-Sorted)
hd : All (y ≤_) (insert x ys)
hd = All-resp-↭ ≤-respʳ-≈ (↭-sym (insert-permutation x ys)) (y≤x ∷ lem)
insert[x,ys]-Sorted : Sorted (insert x ys)
insert[x,ys]-Sorted = insert-pres-Sorted x {ys} (Linked-∷⁻ʳ xs-Sorted)
tl : AllPairs _≤_ (insert x ys)
tl = toAllPairs insert[x,ys]-Sorted
sort-Sorted : ∀ xs → Sorted (sort xs)
sort-Sorted xs = foldr-preservesʳ insert-pres-Sorted [] xs
sort-permutation : ∀ xs → sort xs ↭ xs
sort-permutation [] = ↭-refl
sort-permutation (x ∷ xs) = begin
sort (x ∷ xs) ≡⟨⟩
insert x (sort xs) ≈⟨ insert-permutation x (sort xs) ⟩
x ∷ sort xs ≈⟨ prep Eq.refl (sort-permutation xs) ⟩
x ∷ xs ∎
where open SetoidReasoning ↭-setoid
insert-cong-≋ : ∀ {x y xs ys} → x ≈ y → xs ≋ ys → insert x xs ≋ insert y ys
insert-cong-≋ {x} {y} {[]} {[]} x≈y xs≋ys = x≈y ∷ []
insert-cong-≋ {x} {y} {x₁ ∷ xs} {y₁ ∷ ys} x≈y (x₁≈y₁ ∷ xs≋ys) with x ≤? x₁ | y ≤? y₁
... | yes p | yes p₁ = x≈y ∷ x₁≈y₁ ∷ xs≋ys
... | yes p | no ¬p = ⊥-elim (¬p (≤-respʳ-≈ x₁≈y₁ (≤-respˡ-≈ x≈y p)))
... | no ¬p | yes p = ⊥-elim (¬p (≤-respʳ-≈ (Eq.sym x₁≈y₁) (≤-respˡ-≈ (Eq.sym x≈y) p)))
... | no ¬p | no ¬p₁ = x₁≈y₁ ∷ insert-cong-≋ x≈y xs≋ys
insert-stop : ∀ {x y} ys → x ≤ y → insert x (y ∷ ys) ≋ x ∷ y ∷ ys
insert-stop {x} {y} ys x≤y with x ≤? y
... | yes _ = ≋-refl
... | no x≰y = ⊥-elim (x≰y x≤y)
insert-into : ∀ {x y} ys → x ≰ y → insert x (y ∷ ys) ≋ y ∷ insert x ys
insert-into {x} {y} ys x≰y with x ≤? y
... | yes x≤y = ⊥-elim (x≰y x≤y)
... | no _ = ≋-refl
Sorted-insert : ∀ {x xs} → Sorted (x ∷ xs) → insert x xs ≋ x ∷ xs
Sorted-insert {x} {[]} _ = ≋-refl
Sorted-insert {x} {y ∷ ys} (x≤y ∷ _) = insert-stop ys x≤y
sort-Sorted-id : ∀ xs → Sorted xs → sort xs ≋ xs
sort-Sorted-id [] xs-Sorted = ≋-refl
sort-Sorted-id (x ∷ xs) x∷xs-Sorted = begin
sort (x ∷ xs)
≡⟨⟩
insert x (sort xs)
≈⟨ insert-cong-≋ Eq.refl
(sort-Sorted-id xs (Linked-∷⁻ʳ x∷xs-Sorted)) ⟩
insert x xs
≈⟨ Sorted-insert x∷xs-Sorted ⟩
x ∷ xs
∎
where open SetoidReasoning ≋-setoid
sort-idem : ∀ xs → sort (sort xs) ≋ sort xs
sort-idem xs = sort-Sorted-id (sort xs) (sort-Sorted xs)
module _ where
open SetoidReasoning ≋-setoid
insert-swap : ∀ x y xs → insert x (insert y xs) ≋ insert y (insert x xs)
insert-swap x y [] with x ≤? y | y ≤? x
... | yes x≤y | yes y≤x = x≈y ∷ Eq.sym x≈y ∷ []
where x≈y = antisym x≤y y≤x
... | yes _ | no _ = ≋-refl
... | no _ | yes _ = ≋-refl
... | no x≰y | no y≰x = ⊥-elim $ ≰∧≱⇒⊥ x≰y y≰x
insert-swap x y (z ∷ zs) with y ≤? z | x ≤? z
insert-swap x y (z ∷ zs) | yes _ | yes _ with x ≤? y | y ≤? x
insert-swap x y (z ∷ zs) | yes y≤z | yes x≤z | yes x≤y | yes y≤x =
x≈y ∷ Eq.sym x≈y ∷ ≋-refl
where x≈y = antisym x≤y y≤x
insert-swap x y (z ∷ zs) | yes y≤z | yes _ | yes _ | no _ = begin
x ∷ y ∷ z ∷ zs ≈˘⟨ Eq.refl ∷ insert-stop zs y≤z ⟩
x ∷ insert y (z ∷ zs) ∎
insert-swap x y (z ∷ zs) | yes _ | yes x≤z | no _ | yes _ = begin
y ∷ insert x (z ∷ zs) ≈⟨ Eq.refl ∷ insert-stop zs x≤z ⟩
y ∷ x ∷ z ∷ zs ∎
insert-swap x y (z ∷ zs) | yes y≤z | yes x≤z | no x≰y | no y≰x =
⊥-elim $ ≰∧≱⇒⊥ x≰y y≰x
insert-swap x y (z ∷ zs) | yes _ | no _ with x ≤? y
insert-swap x y (z ∷ zs) | yes y≤z | no x≰z | yes x≤y =
⊥-elim $ x≰z (trans x≤y y≤z)
insert-swap x y (z ∷ zs) | yes y≤z | no x≰z | no x≰y = begin
y ∷ insert x (z ∷ zs) ≈⟨ Eq.refl ∷ insert-into zs x≰z ⟩
y ∷ z ∷ insert x zs ≈˘⟨ insert-stop (insert x zs) y≤z ⟩
insert y (z ∷ insert x zs) ∎
insert-swap x y (z ∷ zs) | no _ | yes _ with y ≤? x
insert-swap x y (z ∷ zs) | no y≰z | yes x≤z | yes y≤x =
⊥-elim (y≰z (trans y≤x x≤z))
insert-swap x y (z ∷ zs) | no y≰z | yes x≤z | no _ = begin
insert x (z ∷ insert y zs) ≈⟨ insert-stop (insert y zs) x≤z ⟩
x ∷ z ∷ insert y zs ≈˘⟨ Eq.refl ∷ insert-into zs y≰z ⟩
x ∷ insert y (z ∷ zs) ∎
insert-swap x y (z ∷ zs) | no y≰z | no x≰z = begin
insert x (z ∷ insert y zs) ≈⟨ insert-into (insert y zs) x≰z ⟩
z ∷ insert x (insert y zs) ≈⟨ Eq.refl ∷ insert-swap x y zs ⟩
z ∷ insert y (insert x zs) ≈˘⟨ insert-into (insert x zs) y≰z ⟩
insert y (z ∷ insert x zs) ∎
sort-cong-↭-≋ : ∀ {xs ys} → xs ↭ ys → sort xs ≋ sort ys
sort-cong-↭-≋ {xs} {.xs} PSrefl = ≋-refl
sort-cong-↭-≋ {_ ∷ _} {_ ∷ _} (prep eq xs↭ys) =
insert-cong-≋ eq (sort-cong-↭-≋ xs↭ys)
sort-cong-↭-≋ {x ∷ y ∷ xs} {y′ ∷ x′ ∷ ys} (swap eq₁ eq₂ xs↭ys) = begin
insert x (insert y (sort xs)) ≈⟨ insert-cong-≋ eq₁
(insert-cong-≋ eq₂ (sort-cong-↭-≋ xs↭ys)) ⟩
insert x′ (insert y′ (sort ys)) ≈⟨ insert-swap x′ y′ (sort ys) ⟩
insert y′ (insert x′ (sort ys)) ∎
where open SetoidReasoning ≋-setoid
sort-cong-↭-≋ {xs} {ys} (PStrans {ys = zs} xs↭zs zs↭ys) = begin
sort xs ≈⟨ sort-cong-↭-≋ xs↭zs ⟩
sort zs ≈⟨ sort-cong-↭-≋ zs↭ys ⟩
sort ys ∎
where open SetoidReasoning ≋-setoid
Sorted-unique : ∀ {xs ys} → xs ↭ ys → Sorted xs → Sorted ys → xs ≋ ys
Sorted-unique {xs} {ys} xs↭ys ixs iys = begin
xs ≈⟨ ≋-sym $ sort-Sorted-id xs ixs ⟩
sort xs ≈⟨ sort-cong-↭-≋ xs↭ys ⟩
sort ys ≈⟨ sort-Sorted-id ys iys ⟩
ys ∎
where open SetoidReasoning ≋-setoid
|
{
"alphanum_fraction": 0.5617319398,
"avg_line_length": 37.8565217391,
"ext": "agda",
"hexsha": "87bf4379cb424bd6fee67303a7457cf483df9725",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "37200ea91d34a6603d395d8ac81294068303f577",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "rei1024/agda-misc",
"max_forks_repo_path": "Algorithms/List/Sort/Insertion/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "37200ea91d34a6603d395d8ac81294068303f577",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "rei1024/agda-misc",
"max_issues_repo_path": "Algorithms/List/Sort/Insertion/Properties.agda",
"max_line_length": 88,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "37200ea91d34a6603d395d8ac81294068303f577",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "rei1024/agda-misc",
"max_stars_repo_path": "Algorithms/List/Sort/Insertion/Properties.agda",
"max_stars_repo_stars_event_max_datetime": "2020-04-21T00:03:43.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:49:42.000Z",
"num_tokens": 3885,
"size": 8707
}
|
------------------------------------------------------------------------------
-- Stream properties
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module FOT.FOTC.Data.Stream.PropertiesI where
open import FOTC.Base
open import FOTC.Base.List
open import FOTC.Data.Colist.Type
open import FOTC.Data.List
open import FOTC.Data.List.PropertiesI
open import FOTC.Data.Stream.PropertiesI
open import FOTC.Data.Stream.Type
------------------------------------------------------------------------------
{-# TERMINATING #-}
++-Stream : ∀ {xs ys} → Colist xs → Stream ys → Stream (xs ++ ys)
++-Stream {xs} {ys} CLxs Sys with Colist-out CLxs
... | inj₁ prf = subst Stream (sym prf₁) Sys
where
prf₁ : xs ++ ys ≡ ys
prf₁ = trans (++-leftCong prf) (++-[] ys)
... | inj₂ (x' , xs' , prf , CLxs') = subst Stream (sym prf₁) prf₂
where
prf₁ : xs ++ ys ≡ x' ∷ (xs' ++ ys)
prf₁ = trans (++-leftCong prf) (++-∷ x' xs' ys)
prf₂ : Stream (x' ∷ xs' ++ ys)
prf₂ = Stream-in (x' , (xs' ++ ys) , refl , ++-Stream CLxs' Sys)
-- ++-Stream with a diferent type.
{-# TERMINATING #-}
++-Stream' : ∀ {xs ys} → Stream xs → Stream ys → Stream (xs ++ ys)
++-Stream' {xs} {ys} Sxs Sys with Stream-out Sxs
... | x' , xs' , prf , Sxs' = subst Stream prf₁ prf₂
where
prf₁ : x' ∷ (xs' ++ ys) ≡ xs ++ ys
prf₁ = trans (sym (++-∷ x' xs' ys)) (++-leftCong (sym prf))
prf₂ : Stream (x' ∷ xs' ++ ys)
prf₂ = Stream-in (x' , xs' ++ ys , refl , ++-Stream' Sxs' Sys)
|
{
"alphanum_fraction": 0.4957780458,
"avg_line_length": 33.8367346939,
"ext": "agda",
"hexsha": "32b2a4b347a7db374dbb29364689db6806e7ab4d",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z",
"max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/fotc",
"max_forks_repo_path": "notes/FOT/FOTC/Data/Stream/PropertiesI.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/fotc",
"max_issues_repo_path": "notes/FOT/FOTC/Data/Stream/PropertiesI.agda",
"max_line_length": 78,
"max_stars_count": 11,
"max_stars_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/fotc",
"max_stars_repo_path": "notes/FOT/FOTC/Data/Stream/PropertiesI.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-12T16:09:54.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:53:42.000Z",
"num_tokens": 503,
"size": 1658
}
|
{-# OPTIONS --without-K #-}
module K where
open import NTypes.Contractible
open import PathOperations
open import PathStructure.Sigma
open import Types
-- Not strictly related to the lectures.
--
-- Here we show that the various forms of extending
-- pure ITT to propositionally extensional TT are
-- (logically) equivalent.
-- The most general form of axiom K.
K-gen : ∀ a p → Set _
K-gen a p = {A : Set a} (x : A) (P : x ≡ x → Set p) (h : x ≡ x) →
P refl → P h
-- Specialized form of axiom K.
K : ∀ a → Set _
K a = {A : Set a} (x : A) (p : x ≡ x) → p ≡ refl
uip : ∀ a → Set _
uip a = {A : Set a} (x y : A) (p q : x ≡ y) → p ≡ q
π₂-Id : ∀ a b → Set _
π₂-Id a b = {A : Set a} {B : A → Set b} (a : A) (b₁ b₂ : B a) →
Id (Σ A B) (a , b₁) (a , b₂) → b₁ ≡ b₂
-- Relation between K and its specialized version.
K-gen→K : ∀ {a} → K-gen a a → K a
K-gen→K K x p = K x (λ p → p ≡ refl) p refl
K→K-gen : ∀ {a p} → K a → K-gen a p
K→K-gen K x P h p = tr P (K x h ⁻¹) p
-- Relation between K and UIP.
K→uip : ∀ {a} → K a → uip a
K→uip K x y p q = J (λ _ _ p → ∀ q → q ≡ p) K _ _ q p
uip→K : ∀ {a} → uip a → K a
uip→K uip x p = uip x x p refl
-- Relation between K and π₂-Id.
K→π₂-Id : ∀ {a b} → K a → π₂-Id a b
K→π₂-Id K {B = B} _ b₁ b₂ p = tr
(λ z → tr B z b₁ ≡ b₂)
(K _ (π₁ (split-path p)))
(π₂ (split-path p))
π₂-Id→K : ∀ {a} → π₂-Id a a → K a
π₂-Id→K πId x p =
πId x p refl (π₂ (pp-space-contr x) (x , p) ⁻¹)
|
{
"alphanum_fraction": 0.5434782609,
"avg_line_length": 25.4642857143,
"ext": "agda",
"hexsha": "ed2c9a7fa95406ef2eaa4171ec3cb4fda8f1ba9d",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7730385adfdbdda38ee8b124be3cdeebb7312c65",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "vituscze/HoTT-lectures",
"max_forks_repo_path": "src/K.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7730385adfdbdda38ee8b124be3cdeebb7312c65",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "vituscze/HoTT-lectures",
"max_issues_repo_path": "src/K.agda",
"max_line_length": 65,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "7730385adfdbdda38ee8b124be3cdeebb7312c65",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "vituscze/HoTT-lectures",
"max_stars_repo_path": "src/K.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 618,
"size": 1426
}
|
module zf where
open import Level
open import logic
open import Relation.Nullary
open import Relation.Binary hiding (_⇔_)
open import Data.Empty
record IsZF {n m : Level }
(ZFSet : Set n)
(_∋_ : ( A x : ZFSet ) → Set m)
(_≈_ : Rel ZFSet m)
(∅ : ZFSet)
(_,_ : ( A B : ZFSet ) → ZFSet)
(Union : ( A : ZFSet ) → ZFSet)
(Power : ( A : ZFSet ) → ZFSet)
(Select : (X : ZFSet ) → ( ψ : (x : ZFSet ) → Set m ) → ZFSet )
(Replace : ZFSet → ( ZFSet → ZFSet ) → ZFSet )
(infinite : ZFSet)
: Set (suc (n ⊔ suc m)) where
field
isEquivalence : IsEquivalence {n} {m} {ZFSet} _≈_
-- ∀ x ∀ y ∃ z ∀ t ( z ∋ t → t ≈ x ∨ t ≈ y)
pair→ : ( x y t : ZFSet ) → (x , y) ∋ t → ( t ≈ x ) ∨ ( t ≈ y )
pair← : ( x y t : ZFSet ) → ( t ≈ x ) ∨ ( t ≈ y ) → (x , y) ∋ t
-- ∀ x ∃ y ∀ z (z ∈ y ⇔ ∃ u ∈ x ∧ (z ∈ u))
union→ : ( X z u : ZFSet ) → ( X ∋ u ) ∧ (u ∋ z ) → Union X ∋ z
union← : ( X z : ZFSet ) → (X∋z : Union X ∋ z ) → ¬ ( (u : ZFSet ) → ¬ ((X ∋ u) ∧ (u ∋ z )))
_∈_ : ( A B : ZFSet ) → Set m
A ∈ B = B ∋ A
_⊆_ : ( A B : ZFSet ) → ∀{ x : ZFSet } → Set m
_⊆_ A B {x} = A ∋ x → B ∋ x
_∩_ : ( A B : ZFSet ) → ZFSet
A ∩ B = Select A ( λ x → ( A ∋ x ) ∧ ( B ∋ x ) )
_∪_ : ( A B : ZFSet ) → ZFSet
A ∪ B = Union (A , B)
｛_｝ : ZFSet → ZFSet
｛ x ｝ = ( x , x )
infixr 200 _∈_
infixr 230 _∩_ _∪_
infixr 220 _⊆_
field
empty : ∀( x : ZFSet ) → ¬ ( ∅ ∋ x )
-- power : ∀ X ∃ A ∀ t ( t ∈ A ↔ t ⊆ X ) )
power→ : ∀( A t : ZFSet ) → Power A ∋ t → ∀ {x} → t ∋ x → ¬ ¬ ( A ∋ x ) -- _⊆_ t A {x}
power← : ∀( A t : ZFSet ) → ( ∀ {x} → _⊆_ t A {x}) → Power A ∋ t
-- extensionality : ∀ z ( z ∈ x ⇔ z ∈ y ) ⇒ ∀ w ( x ∈ w ⇔ y ∈ w )
extensionality : { A B w : ZFSet } → ( (z : ZFSet) → ( A ∋ z ) ⇔ (B ∋ z) ) → ( A ∈ w ⇔ B ∈ w )
-- regularity without minimum
ε-induction : { ψ : ZFSet → Set (suc m)}
→ ( {x : ZFSet } → ({ y : ZFSet } → x ∋ y → ψ y ) → ψ x )
→ (x : ZFSet ) → ψ x
-- infinity : ∃ A ( ∅ ∈ A ∧ ∀ x ∈ A ( x ∪ { x } ∈ A ) )
infinity∅ : ∅ ∈ infinite
infinity : ∀( x : ZFSet ) → x ∈ infinite → ( x ∪ ｛ x ｝) ∈ infinite
selection : { ψ : ZFSet → Set m } → ∀ { X y : ZFSet } → ( ( y ∈ X ) ∧ ψ y ) ⇔ (y ∈ Select X ψ )
-- replacement : ∀ x ∀ y ∀ z ( ( ψ ( x , y ) ∧ ψ ( x , z ) ) → y = z ) → ∀ X ∃ A ∀ y ( y ∈ A ↔ ∃ x ∈ X ψ ( x , y ) )
replacement← : {ψ : ZFSet → ZFSet} → ∀ ( X x : ZFSet ) → x ∈ X → ψ x ∈ Replace X ψ
replacement→ : {ψ : ZFSet → ZFSet} → ∀ ( X x : ZFSet ) → ( lt : x ∈ Replace X ψ ) → ¬ ( ∀ (y : ZFSet) → ¬ ( x ≈ ψ y ) )
record ZF {n m : Level } : Set (suc (n ⊔ suc m)) where
infixr 210 _,_
infixl 200 _∋_
infixr 220 _≈_
field
ZFSet : Set n
_∋_ : ( A x : ZFSet ) → Set m
_≈_ : ( A B : ZFSet ) → Set m
-- ZF Set constructor
∅ : ZFSet
_,_ : ( A B : ZFSet ) → ZFSet
Union : ( A : ZFSet ) → ZFSet
Power : ( A : ZFSet ) → ZFSet
Select : (X : ZFSet ) → ( ψ : (x : ZFSet ) → Set m ) → ZFSet
Replace : ZFSet → ( ZFSet → ZFSet ) → ZFSet
infinite : ZFSet
isZF : IsZF ZFSet _∋_ _≈_ ∅ _,_ Union Power Select Replace infinite
|
{
"alphanum_fraction": 0.4088262335,
"avg_line_length": 40.2839506173,
"ext": "agda",
"hexsha": "bca100bfbb56b588422776f44c87ce3fbffdb31e",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "031f1ea3a3037cd51eb022dbfb5c75b037bf8aa0",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "shinji-kono/zf-in-agda",
"max_forks_repo_path": "src/zf.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "031f1ea3a3037cd51eb022dbfb5c75b037bf8aa0",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "shinji-kono/zf-in-agda",
"max_issues_repo_path": "src/zf.agda",
"max_line_length": 129,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "031f1ea3a3037cd51eb022dbfb5c75b037bf8aa0",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "shinji-kono/zf-in-agda",
"max_stars_repo_path": "src/zf.agda",
"max_stars_repo_stars_event_max_datetime": "2021-01-10T13:27:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-10-02T13:46:23.000Z",
"num_tokens": 1548,
"size": 3263
}
|
-- An implementation of Olivier Danvy's Type-Directed Partial Evaluation (POPL 1996)
-- for STLC with sum types using continuations in form of shift and reset.
--
-- The algorithm was originally for a two-level lambda-calculus.
-- Our use of Kripke semantics makes the effect of fresh variable generation explicit and formal.
open import Library
module DanvyShiftResetLiftable where
data Base : Set where
α β : Base
open import Formulas Base
open import Derivations Base
-- Continutation monad with answer type R.
-- (Cf. Haskell's Control.Monad.Cont.Cont = (A → R) → R).
record M (R A : Cxt → Set) (Γ : Cxt) : Set where
constructor shift
field run : KFun (KFun A R) R Γ
open M
-- shift : ∀{R A Γ} (f : KFun (KFun A R) R Γ) → M R A Γ
-- shift f .run σ k = f σ k
reset : ∀{A} → M A A →̇ A
reset m = m .run id≤ λ τ → id
return : ∀{R A} → □ A →̇ M R A
return x .run τ k = k id≤ (x τ)
return' : ∀{R A} → □ A →̇ M R (□ A)
return' x .run τ k = k id≤ λ τ₁ → x (τ₁ • τ)
-- Bind
_>>=_ : ∀{R A B Γ} (m : M R A Γ) (f : KFun A (M R B) Γ) → M R B Γ
(m >>= f) .run σ k = m .run σ λ τ a → f (τ • σ) a .run id≤ λ τ′ → k (τ′ • τ)
-- Map
_<$>_ : ∀{R A B} (f : A →̇ B) → M R A →̇ M R B
(f <$> m) .run σ k = m .run σ λ τ → k τ ∘ f
_<&>_ : ∀{R A B Γ} (m : M R A Γ) (f : A →̇ B) → M R B Γ
(m <&> f) .run σ k = m .run σ λ τ → k τ ∘ f
-- Kripke map
K$ : ∀{R A B} → KFun A B →̇ KFun (M R A) (M R B)
K$ f τ m .run σ k = m .run σ λ τ′ a → k τ′ (f (τ′ • (σ • τ)) a)
-- We use a continuation monad with answer type Nf.
M' : (X : Cxt → Set) (Γ : Cxt) → Set
M' X Γ = ∀ {C} → M (Nf' C) X Γ
T⟦_⟧ : (A : Form) (Γ : Cxt) → Set
T⟦ Atom P ⟧ = □ (Nf' (Atom P))
T⟦ True ⟧ Γ = ⊤
T⟦ False ⟧ Γ = ⊥
T⟦ A ∨ B ⟧ Γ = T⟦ A ⟧ Γ ⊎ T⟦ B ⟧ Γ
T⟦ A ∧ B ⟧ Γ = T⟦ A ⟧ Γ × T⟦ B ⟧ Γ
T⟦ A ⇒ B ⟧ Γ = ∀{Δ} (τ : Δ ≤ Γ) → T⟦ A ⟧ Δ → M' T⟦ B ⟧ Δ
-- Monotonicity of the model is proven by induction on the proposition.
-- monT : ∀ A {Γ Δ} (τ : Δ ≤ Γ) → T⟦ A ⟧ Γ → T⟦ A ⟧ Δ
monT : ∀ A → Mon T⟦ A ⟧
monT (Atom P) = mon□
monT True = _
monT False τ ()
monT (A ∨ B) τ = map-⊎ (monT A τ) (monT B τ)
monT (A ∧ B) τ (a , b) = monT A τ a , monT B τ b
monT (A ⇒ B) τ f σ = f (σ • τ)
fresh : ∀{A Γ} → □ (Ne' A) (Γ ∙ A)
fresh τ′ = hyp (monH τ′ top)
-- Reflection / reification, proven simultaneously by induction on the proposition.
-- Reflection is η-expansion (and recursively reflection);
mutual
reflect : ∀ A → □ (Ne' A) →̇ M' T⟦ A ⟧
reflect (Atom P) t = return' (ne ∘′ t) -- λ τ → ne (monNe τ t)
reflect True t = return _
reflect False t = shift λ τ k → falseE (t τ)
reflect (A ∨ B) t = shift λ τ k → orE (t τ)
(reset (K$ k (weak id≤) (inj₁ <$> reflect A fresh)))
(reset (K$ k (weak id≤) (inj₂ <$> reflect B fresh)))
-- ((inj₂ <$> reflect B (hyp top)) .run λ τ → k (τ • weak id≤))
-- Wrong:
-- (reset (k (weak id≤) <$> (inj₁ <$> reflect A (hyp top))))
-- reflect (A ∧ B) t = do
-- a ← reflect A (andE₁ t)
-- b ← reflect B (andE₂ t)
-- return (a , b)
reflect (A ∧ B) t =
reflect A ( andE₁ ∘ t ) >>= λ τ a →
reflect B (mon□ {Ne' B} τ (andE₂ ∘ t)) >>= λ τ′ b →
return λ τ₁ → monT A (τ₁ • τ′) a , monT B τ₁ b
reflect (A ⇒ B) t = return' λ τ a → reflect B λ τ′ → impE (t (τ′ • τ)) (reify A a τ′)
reify : ∀ A → T⟦ A ⟧ →̇ □ (Nf' A)
reify (Atom P) t = t
reify True _ τ = trueI
reify False ()
reify (A ∨ B) (inj₁ a) τ = orI₁ (reify A a τ)
reify (A ∨ B) (inj₂ b) τ = orI₂ (reify B b τ)
reify (A ∧ B) (a , b) τ = andI (reify A a τ) (reify B b τ)
reify (A ⇒ B) f τ = impI $ reset $
reflect A fresh >>= λ τ′ a →
f (τ′ • weak τ) a <&> λ b →
reify B b id≤
-- Fundamental theorem
-- Delayed lifting
record ◇ (G : Cxt → Set) (Γ : Cxt) : Set where
constructor dia; field
{Δ} : Cxt
τ : Γ ≤ Δ
γ : G Δ
mon◇ : ∀{P} → Mon (◇ P)
mon◇ τ′ (dia τ p) = dia (τ′ • τ) p
-- NB: ◇ is a monad
module Monad◇ where
return◇ : ∀{P} → P →̇ ◇ P
return◇ = dia id≤
join◇ : ∀{P} → ◇ (◇ P) →̇ ◇ P
join◇ (dia τ d) = mon◇ τ d
-- join◇ (dia τ (dia τ′ a)) = dia (τ • τ′) a
map◇ : ∀{P Q} → (P →̇ Q) → ◇ P →̇ ◇ Q
map◇ f (dia τ p) = dia τ (f p)
-- Extension of T⟦_⟧ to contexts to classify semantic environments.
G⟦_⟧ : ∀ (Γ Δ : Cxt) → Set
G⟦ ε ⟧ _ = ⊤
G⟦ Γ ∙ A ⟧ = ◇ λ Δ → G⟦ Γ ⟧ Δ × T⟦ A ⟧ Δ
-- monG is lazy except for matching on the context.
monG : ∀{Γ} → Mon G⟦ Γ ⟧
monG {ε} τ _ = _
monG {Γ ∙ A} τ γ = mon◇ τ γ
-- Environment extension.
ext : ∀ A {Γ Δ₁ Δ} →
(τ : Δ ≤ Δ₁) (γ : G⟦ Γ ⟧ Δ₁) →
(a : T⟦ A ⟧ Δ) →
□ G⟦ Γ ∙ A ⟧ Δ
ext A τ γ a τ′ = dia τ′ (monG τ γ , a)
-- Lookup in the environment.
-- Accumulates embedded weakenings from environment.
fundH : ∀{A Γ} (x : Hyp A Γ) → G⟦ Γ ⟧ →̇ □ T⟦ A ⟧
fundH {A} top (dia τ′ (_ , a)) τ = monT A (τ • τ′) a
fundH (pop x) (dia τ′ (γ , _)) τ = fundH x γ (τ • τ′)
-- The fundamental theorem:
-- A call-by-value interpreter.
fund : ∀{Γ A} (t : Γ ⊢ A) → G⟦ Γ ⟧ →̇ M' T⟦ A ⟧
fund (hyp {A} x) γ = return (fundH x γ)
fund (impI {A} t) γ = return' λ τ a → fund t (ext A τ γ a id≤)
fund (impE t u) γ =
fund t γ >>= λ τ f →
fund u (monG τ γ) >>= λ τ′ a →
f τ′ a
fund (andI {A} {B} t u) γ =
fund t γ >>= λ τ a →
fund u (monG τ γ) >>= λ τ′ b →
return λ τ₁ → monT A (τ₁ • τ′) a , monT B τ₁ b
fund (andE₁ t) γ = proj₁ <$> fund t γ
fund (andE₂ t) γ = proj₂ <$> fund t γ
fund (orI₁ t) γ = inj₁ <$> fund t γ
fund (orI₂ t) γ = inj₂ <$> fund t γ
fund (orE {A} {B} t u v) γ = fund t γ >>= λ τ →
[ (λ a → fund u (ext A τ γ a id≤))
, (λ b → fund v (ext B τ γ b id≤))
]
fund (falseE t) γ = fund t γ >>= λ τ ()
fund trueI γ = return _
-- Identity environment
ide : ∀ Γ → □ (M' G⟦ Γ ⟧) Γ
ide ε τ = return _
ide (Γ ∙ A) τ =
ide Γ (τ • weak id≤) >>= λ τ₁ γ →
reflect A (mon□ (τ₁ • τ) fresh) >>= λ τ₂ a →
return (ext A τ₂ γ a)
-- return λ τ₃ → dia τ₃ (monG τ₂ γ , a)
-- Normalization
norm : ∀{A Γ} (t : Γ ⊢ A) → Nf Γ A
norm {A} {Γ} t = reset $
ide Γ id≤ >>= λ _ γ →
fund t γ <&> λ a →
reify A a id≤
-- Testing
idD : (A : Form) → ε ⊢ (A ⇒ A)
idD A = impI (hyp top)
test : let A = Atom α; B = Atom β in Nf ε (A ∨ B ⇒ A ∨ B)
test = norm (idD (Atom α ∨ Atom β))
test2 = norm (idD (Atom α ∨ Atom β ∨ Atom α))
test3 = norm (idD False)
-- Q.E.D. -}
-- -}
-- -}
-- -}
-- -}
-- -}
-- -}
|
{
"alphanum_fraction": 0.4939341421,
"avg_line_length": 25.1865079365,
"ext": "agda",
"hexsha": "7db9014ce7c77bee66243fb5c0e169b1b22b15c9",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2021-02-25T20:39:03.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-11-13T16:01:46.000Z",
"max_forks_repo_head_hexsha": "9a6151ad1f0977674b8cc9e9cefb49ae83e8a42a",
"max_forks_repo_licenses": [
"Unlicense"
],
"max_forks_repo_name": "andreasabel/ipl",
"max_forks_repo_path": "src/DanvyShiftResetLiftable.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "9a6151ad1f0977674b8cc9e9cefb49ae83e8a42a",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Unlicense"
],
"max_issues_repo_name": "andreasabel/ipl",
"max_issues_repo_path": "src/DanvyShiftResetLiftable.agda",
"max_line_length": 97,
"max_stars_count": 19,
"max_stars_repo_head_hexsha": "9a6151ad1f0977674b8cc9e9cefb49ae83e8a42a",
"max_stars_repo_licenses": [
"Unlicense"
],
"max_stars_repo_name": "andreasabel/ipl",
"max_stars_repo_path": "src/DanvyShiftResetLiftable.agda",
"max_stars_repo_stars_event_max_datetime": "2021-04-27T19:10:49.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-05-16T08:08:51.000Z",
"num_tokens": 2834,
"size": 6347
}
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use the
-- Relation.Binary.Reasoning.StrictPartialOrder module directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
module Relation.Binary.StrictPartialOrderReasoning
{p₁ p₂ p₃} (S : StrictPartialOrder p₁ p₂ p₃) where
open import Relation.Binary.Reasoning.StrictPartialOrder S public
|
{
"alphanum_fraction": 0.5545112782,
"avg_line_length": 33.25,
"ext": "agda",
"hexsha": "119ee55e9a3ee14782778d4b7ff61ff975af10cb",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "omega12345/agda-mode",
"max_forks_repo_path": "test/asset/agda-stdlib-1.0/Relation/Binary/StrictPartialOrderReasoning.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "omega12345/agda-mode",
"max_issues_repo_path": "test/asset/agda-stdlib-1.0/Relation/Binary/StrictPartialOrderReasoning.agda",
"max_line_length": 72,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "omega12345/agda-mode",
"max_stars_repo_path": "test/asset/agda-stdlib-1.0/Relation/Binary/StrictPartialOrderReasoning.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 96,
"size": 532
}
|
{-# OPTIONS --rewriting #-}
open import Agda.Builtin.Equality
{-# BUILTIN REWRITE _≡_ #-}
postulate
X : Set₁
rew : X ≡ Set
{-# REWRITE rew #-}
{-# REWRITE rew #-}
|
{
"alphanum_fraction": 0.5895953757,
"avg_line_length": 13.3076923077,
"ext": "agda",
"hexsha": "c850cb0b7f597e2ad0872cef3b3a3272bb381815",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "alhassy/agda",
"max_forks_repo_path": "test/Succeed/Issue2925.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "alhassy/agda",
"max_issues_repo_path": "test/Succeed/Issue2925.agda",
"max_line_length": 33,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "alhassy/agda",
"max_stars_repo_path": "test/Succeed/Issue2925.agda",
"max_stars_repo_stars_event_max_datetime": "2016-03-17T01:45:59.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-03-17T01:45:59.000Z",
"num_tokens": 53,
"size": 173
}
|
{- Formal verification of authenticated append-only skiplists in Agda, version 1.0.
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
-}
open import Data.Empty
open import Data.Nat
open import Data.Product
open import Data.Nat.Divisibility
open import Data.Nat.Properties
open import Relation.Nullary
open import Relation.Nullary.Negation
open import Relation.Binary.PropositionalEquality
open import Relation.Binary.HeterogeneousEquality
using (_≅_; ≅-to-≡; ≡-to-≅; _≇_)
renaming (cong to ≅-cong; refl to ≅-refl; cong₂ to ≅-cong₂)
open import Function
-- This module proves a number of properties about even numbers.
-- We borrow some things from Data.Nat.Divisibility but specialize most
-- of them to divisibility-by-2.
module Data.Nat.Even where
open import AAOSL.Lemmas
Even : ℕ → Set
Even n = 2 ∣ n
even? : (n : ℕ) → Dec (Even n)
even? n = 2 ∣? n
Odd : ℕ → Set
Odd = ¬_ ∘ Even
even-irrelevant : ∀{n}(p q : Even n) → p ≡ q
even-irrelevant (divides q₁ e₁) (divides q₂ e₂)
with *2-injective q₁ q₂ (trans (sym e₁) e₂)
...| refl = cong (divides q₁) (≡-irrelevant e₁ e₂)
--------------------------------------------------
-- Properties about stepping and unstepping 'Even'
even-unstep : ∀ k → Even (2 + k) → Even k
even-unstep k (divides (suc q) e) = divides q (suc-injective (suc-injective e))
even-step : ∀ k → Even k → Even (2 + k)
even-step k (divides q₁ eq) = divides (1 + q₁) (cong (suc ∘ suc) eq)
-----------------------------
-- Properties of Even and Odd
mutual
even-odd-suc : ∀ k → Even k → Odd (suc k)
even-odd-suc zero x (divides q e) = ⊥-1≡m*2 q e
even-odd-suc (suc k) x x₁ = even-suc-odd (suc k) x₁ x
even-suc-odd : ∀ k → Even (suc k) → Odd k
even-suc-odd zero (divides q e) x₁ = ⊥-1≡m*2 q e
even-suc-odd (suc k) x x₁ = even-odd-suc k (even-unstep k x) x₁
mutual
odd-suc-suc : ∀ k → Odd k → Even (suc k)
odd-suc-suc zero x = ⊥-elim (x (divides 0 refl))
odd-suc-suc (suc k) x = even-step k (odd-pred-even (suc k) x)
odd-pred-even : ∀ k → Odd k → Even (pred k)
odd-pred-even zero x = ⊥-elim (x (divides 0 refl))
odd-pred-even (suc k) x with even? k
...| no imp = ⊥-elim (x (odd-suc-suc k imp))
...| yes prf = prf
-----------------------------
-- Properties of Even and _*_
*-preserve-even : ∀ k d → Even k → Even (k * d)
*-preserve-even k d = ∣m⇒∣m*n d
-----------------------------
-- Properties of Even and _≤_
even>0⇒>1 : ∀ {k} → 0 < k → Even k → 1 < k
even>0⇒>1 {0} ()
even>0⇒>1 {1} 0<k e = ⊥-elim ((even-odd-suc 0 (divides 0 refl)) e)
even>0⇒>1 {suc (suc k)} (s≤s z≤n) _ = s≤s (s≤s z≤n)
0<odd : ∀{d} → Odd d → 0 < d
0<odd {zero} imp = ⊥-elim (imp (divides zero refl))
0<odd {suc d} _ = s≤s z≤n
-----------------------------
-- Properties of Even and _∸_
even∸1-odd : ∀ {k} → 1 < k → Even k → Odd (k ∸ 1)
even∸1-odd {suc zero} 1<k ek = λ x → contradiction refl (<⇒≢ 1<k)
even∸1-odd {suc (suc k)} 1<k ek = λ x → even-suc-odd (suc k) ek x
odd∸1-even : ∀ {k} → Odd k → Even (k ∸ 1)
odd∸1-even {zero} ok = ⊥-elim (ok (divides 0 refl))
odd∸1-even {suc zero} ok = divides 0 refl
odd∸1-even {suc (suc k)} ok = odd-pred-even (suc (suc k)) ok
-----------------------------
-- Properties of Even and _^_
even-2^k : ∀ {k} → 0 < k → Even (2 ^ k)
even-2^k {suc k} x = *-preserve-even 2 (2 ^ k) (divides 1 refl)
odd-2^kd-1 : ∀ k d → 0 < k → 0 < d → ¬ Even (2 ^ k * d ∸ 1)
odd-2^kd-1 k d 0<k 0<d x
= even∸1-odd {2 ^ k * d} (pow*d>1 k d 0<k 0<d)
(*-preserve-even (2 ^ k) d (even-2^k 0<k))
x
----------------------------------------------------------------
-- Every natural number can be viewed as a power of two times
-- an odd number. We can witness that conversion in the from and
-- to functions below.
data Pow2 : ℕ → Set where
zero : Pow2 zero
pos : ∀ {n} l d → Odd d → n ≡ 2 ^ l * d → Pow2 n
pos-cong : ∀{n₁ n₂} (p : n₁ ≡ n₂)
→ ∀{d₁ d₂} (q : d₁ ≡ d₂)
→ (o₁ : Odd d₁)(o₂ : Odd d₂)
→ ∀{m} (r₁ : m ≡ 2 ^ n₁ * d₁) (r₂ : m ≡ 2 ^ n₂ * d₂)
→ pos n₁ d₁ o₁ r₁ ≡ pos n₂ d₂ o₂ r₂
pos-cong {n₁ = n} refl {d₁ = d} refl o₁ o₂ r₁ r₂
= cong₂ (pos n d) (fun-ext (λ x → ⊥-elim (o₁ x))) (≡-irrelevant r₁ r₂)
-- One must mark this as terminating. The recursive call
-- is made with 'quotient prf', and although we know it is
-- strictly smaller than (suc n), Agda can't infer it.
{-# TERMINATING #-}
to : (n : ℕ) → Pow2 n
to 0 = zero
to (suc n) with even? (suc n)
...| no odd = pos 0 (suc n) odd (cong suc (+-comm 0 n))
...| yes prf with to (quotient prf)
...| zero = ⊥-elim (1+n≢0 (_∣_.equality prf))
...| pos l d odd prf' = pos (suc l) d odd
(trans (_∣_.equality prf)
(trans (cong (λ x → x * 2) prf')
(a*b*2-lemma (2 ^ l) d)))
-- Converting from a Pow2 is trivial, since we kept the
-- original number there.
from : ∀{n} → Pow2 n → ℕ
from zero = zero
from (pos {n} _ _ _ _) = n
-- From and To form an isomorphism
-- TODO-1: Document and justify this pragma
{-# TERMINATING #-}
from-to-iso : ∀ n → from (to n) ≡ n
from-to-iso zero = refl
from-to-iso (suc n) with even? (suc n)
...| no odd = refl
...| yes prf with to (quotient prf)
...| zero = ⊥-elim (1+n≢0 (_∣_.equality prf))
...| pos l d odd prf' = refl
--------------------------------
-- Properties of to and equality
inj-to : ∀ {m n} → m ≡ n → to m ≅ to n
inj-to refl = ≅-refl
to-inj : ∀ {m n} → to m ≇ to n → m ≢ n
to-inj x x₁ = x (inj-to x₁)
---------------------------
-- Uniqueness of 2^k*d form
2^kd-≢-d : ∀{k d₁ d₂}
→ d₁ ≢ d₂
→ 2 ^ k * d₁ ≢ 2 ^ k * d₂
2^kd-≢-d {k} hip abs with 2^k-is-suc k
...| r , prf rewrite prf = hip (*-cancelˡ-≡ r abs)
2^kd-≢-k : ∀{k₁ k₂ d₁ d₂}
→ k₁ ≢ k₂
→ Odd d₁ → Odd d₂
→ 2 ^ k₁ * d₁ ≢ 2 ^ k₂ * d₂
2^kd-≢-k {zero} {zero} {d₁} {d₂} k₁≢k₂ o₁ o₂ e₁≡e₂ = k₁≢k₂ refl
2^kd-≢-k {zero} {suc k₂} {d₁} {d₂} k₁≢k₂ o₁ o₂ e₁≡e₂
rewrite +-identityʳ d₁
| *-assoc 2 (2 ^ k₂) d₂
| *-comm 2 (2 ^ k₂ * d₂) = o₁ (divides (2 ^ k₂ * d₂) e₁≡e₂)
2^kd-≢-k {suc k₁} {zero} {d₁} {d₂} k₁≢k₂ o₁ o₂ e₁≡e₂
rewrite +-identityʳ d₂
| *-assoc 2 (2 ^ k₁) d₁
| *-comm 2 (2 ^ k₁ * d₁) = o₂ (divides (2 ^ k₁ * d₁) (sym e₁≡e₂))
2^kd-≢-k {suc k₁} {suc k₂} {d₁} {d₂} k₁≢k₂ o₁ o₂ e₁≡e₂
rewrite *-assoc 2 (2 ^ k₁) d₁
| *-assoc 2 (2 ^ k₂) d₂ = *-cong-≢ 2 (s≤s z≤n) (2^kd-≢-k (suc-≢ k₁≢k₂) o₁ o₂) e₁≡e₂
----------------------
-- Correctness of 'to'
-- The trick to 2^kd is to use heterogeneous equality first.
-- The problem stems from the type of arguments of pos depending
-- on each other. Agda has trouble understanding that the different
-- ways to write 'n' are all equal. Hence, we abstract that away.
to-2^kd-≅ : ∀{n d} k → (o : Odd d)(p : n ≡ 2 ^ k * d)
→ to n ≅ pos k d o refl
to-2^kd-≅ {n} {d} k o p with to n
...| zero = ⊥-elim (0≢a*b-magic (1≤2^n k) (0<odd o) p)
to-2^kd-≅ {n} {d} k o p
| pos k₀ d₀ o₀ p₀
with k ≟ k₀
...| no abs = ⊥-elim (2^kd-≢-k abs o o₀ (trans (sym p) p₀))
...| yes refl
with d ≟ d₀
...| no abs = ⊥-elim (2^kd-≢-d {k₀} abs (trans (sym p) p₀))
to-2^kd-≅ {n} {d} .k₀ o p
| pos k₀ d₀ o₀ p₀ | yes refl | yes refl
rewrite fun-ext {f = o} {o₀} (λ x → ⊥-elim (o x)) | p
with p₀
...| refl = ≅-refl
-- And then, Agda is happy to understand it is equal after all.
to-2^kd : ∀{d} k → (o : Odd d) → to (2 ^ k * d) ≡ pos k d o refl
to-2^kd {d} k p = ≅-to-≡ (to-2^kd-≅ k p refl)
to-reduce : ∀ {m k d}
→ (mprf : m ≡ (2 ^ k) * d)
→ (od : Odd d)
→ to m ≡ pos k d od mprf
to-reduce {m} {k} {d} refl od = to-2^kd k od
|
{
"alphanum_fraction": 0.5217993952,
"avg_line_length": 34.2068965517,
"ext": "agda",
"hexsha": "0750a7c0f582c9a6e498617307a301ffbda592e8",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2022-02-18T04:33:50.000Z",
"max_forks_repo_forks_event_min_datetime": "2020-12-22T00:01:03.000Z",
"max_forks_repo_head_hexsha": "318881fb24af06bbaafa33edeea0745eca1873f0",
"max_forks_repo_licenses": [
"UPL-1.0"
],
"max_forks_repo_name": "LaudateCorpus1/aaosl-agda",
"max_forks_repo_path": "Data/Nat/Even.agda",
"max_issues_count": 5,
"max_issues_repo_head_hexsha": "318881fb24af06bbaafa33edeea0745eca1873f0",
"max_issues_repo_issues_event_max_datetime": "2021-02-12T04:16:40.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-01-04T03:45:34.000Z",
"max_issues_repo_licenses": [
"UPL-1.0"
],
"max_issues_repo_name": "LaudateCorpus1/aaosl-agda",
"max_issues_repo_path": "Data/Nat/Even.agda",
"max_line_length": 111,
"max_stars_count": 9,
"max_stars_repo_head_hexsha": "318881fb24af06bbaafa33edeea0745eca1873f0",
"max_stars_repo_licenses": [
"UPL-1.0"
],
"max_stars_repo_name": "LaudateCorpus1/aaosl-agda",
"max_stars_repo_path": "Data/Nat/Even.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-31T10:16:38.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-12-22T00:01:00.000Z",
"num_tokens": 3208,
"size": 7936
}
|
{-# OPTIONS --cubical --safe #-}
module Data.List.Properties where
open import Data.List
open import Prelude
open import Data.Fin
open import Strict.Properties
map-length : (f : A → B) (xs : List A)
→ length xs ≡ length (map f xs)
map-length f [] _ = zero
map-length f (x ∷ xs) i = suc (map-length f xs i)
map-ind : (f : A → B) (xs : List A)
→ PathP (λ i → Fin (map-length f xs i) → B) (f ∘ (xs !_)) (map f xs !_)
map-ind f [] i ()
map-ind f (x ∷ xs) i f0 = f x
map-ind f (x ∷ xs) i (fs n) = map-ind f xs i n
tab-length : ∀ n (f : Fin n → A) → length (tabulate n f) ≡ n
tab-length zero f _ = zero
tab-length (suc n) f i = suc (tab-length n (f ∘ fs) i)
tab-distrib : ∀ n (f : Fin n → A) m → ∃ i × (f i ≡ tabulate n f ! m)
tab-distrib (suc n) f f0 = f0 , refl
tab-distrib (suc n) f (fs m) = let i , p = tab-distrib n (f ∘ fs) m in fs i , p
tab-id : ∀ n (f : Fin n → A) → PathP (λ i → Fin (tab-length n f i) → A) (_!_ (tabulate n f)) f
tab-id zero f _ ()
tab-id (suc n) f i f0 = f f0
tab-id (suc n) f i (fs m) = tab-id n (f ∘ fs) i m
list-elim : ∀ {p} (P : List A → Type p) →
(∀ x xs → P xs → P (x ∷ xs)) →
(P []) →
∀ xs → P xs
list-elim P f b [] = b
list-elim P f b (x ∷ xs) = f x xs (list-elim P f b xs)
foldr-universal : ∀ (h : List B → A) f e
→ (h [] ≡ e)
→ (∀ x xs → h (x ∷ xs) ≡ f x (h xs))
→ ∀ xs → h xs ≡ foldr f e xs
foldr-universal h f e base step [] = base
foldr-universal h f e base step (x ∷ xs) =
step x xs ; cong (f x) (foldr-universal h f e base step xs)
foldr-id : (xs : List A) → xs ≡ foldr _∷_ [] xs
foldr-id = foldr-universal id _∷_ [] refl (λ _ _ → refl)
foldr-fusion : ∀ (f : C → A) {_⊕_ : B → C → C} {_⊗_ : B → A → A} e
→ (∀ x y → f (x ⊕ y) ≡ x ⊗ f y)
→ ∀ xs → f (foldr _⊕_ e xs) ≡ foldr _⊗_ (f e) xs
foldr-fusion h {f} {g} e fuse =
foldr-universal (h ∘ foldr f e) g (h e) refl (λ x xs → fuse x (foldr f e xs))
foldl-is-foldr : (f : B → A → B) (z : B) (xs : List A) →
foldl f z xs ≡ foldr (λ x k xs → k (f xs x)) id xs z
foldl-is-foldr f z xs =
cong (_$ z) (foldr-universal (flip (foldl f)) (λ x k xs → k (f xs x)) id refl (λ x xs → refl) xs)
foldl-fusion : ∀ (f : C → A) {_⊕_ : C → B → C} {_⊗_ : A → B → A} e →
(∀ x y → f (x ⊕ y) ≡ f x ⊗ y) →
∀ xs → f (foldl _⊕_ e xs) ≡ foldl _⊗_ (f e) xs
foldl-fusion h {f} {g} e fuse [] = refl
foldl-fusion h {f} {g} e fuse (x ∷ xs) =
foldl-fusion h (f e x) fuse xs ; cong (flip (foldl g) xs) (fuse e x)
++-assoc : (xs ys zs : List A) → (xs ++ ys) ++ zs ≡ xs ++ (ys ++ zs)
++-assoc xs ys zs = foldr-fusion (_++ zs) ys (λ _ _ → refl) xs
map-fusion : ∀ f (b : C) (g : A → B) xs → foldr f b (map g xs) ≡ foldr (f ∘ g) b xs
map-fusion f b g = foldr-fusion (foldr f b) [] λ _ _ → refl
++-idʳ : (xs : List A) → xs ++ [] ≡ xs
++-idʳ [] = refl
++-idʳ (x ∷ xs) = cong (x ∷_) (++-idʳ xs)
open import Function.Injective
∷-inj : (x : A) → Injective (x ∷_)
∷-inj x xs ys = cong λ where [] → []
(_ ∷ zs) → zs
++-inj : (xs : List A) → Injective (xs ++_)
++-inj [] ys zs ys≡zs = ys≡zs
++-inj (x ∷ xs) ys zs ys≡zs = ++-inj xs ys zs (∷-inj x (xs ++ ys) (xs ++ zs) ys≡zs)
open import Algebra
module _ (mon : Monoid b) where
open Monoid mon
module _ (f : A → 𝑆) where
monStepL : 𝑆 → A → 𝑆
monStepL xs x = xs ∙ f x
{-# INLINE monStepL #-}
foldMapL : List A → 𝑆
foldMapL = foldl monStepL ε
foldMapLStep : ∀ x xs → f x ∙ foldMapL xs ≡ foldMapL (x ∷ xs)
foldMapLStep x xs = foldl-fusion (f x ∙_) ε (λ y z → sym (assoc (f x) y (f z))) xs ; cong (flip (foldl monStepL) xs) (∙ε (f x) ; sym (ε∙ (f x)))
foldl-foldr-monoid : (xs : List A) → foldMapL xs ≡ foldr (_∙_ ∘ f) ε xs
foldl-foldr-monoid = foldr-universal _ (_∙_ ∘ f) ε refl λ x xs → sym (foldMapLStep x xs)
module _ (A : Type a) where
listMonoid : Monoid a
listMonoid .Monoid.𝑆 = List A
listMonoid .Monoid._∙_ = _++_
listMonoid .Monoid.ε = []
listMonoid .Monoid.assoc = ++-assoc
listMonoid .Monoid.ε∙ _ = refl
listMonoid .Monoid.∙ε = ++-idʳ
foldl′-foldl : (f : B → A → B) (z : B) (xs : List A) → foldl′ f z xs ≡ foldl f z xs
foldl′-foldl f z [] = refl
foldl′-foldl f z (x ∷ xs) = $!-≡ (λ y → foldl′ f y xs) (f z x) ; foldl′-foldl f (f z x) xs
foldr′-foldr : (f : A → B → B) (z : B) (xs : List A) → foldr′ f z xs ≡ foldr f z xs
foldr′-foldr f z [] = refl
foldr′-foldr f z (x ∷ xs) = $!-≡ (f x) (foldr′ f z xs) ; cong (f x) (foldr′-foldr f z xs)
is-empty : List A → Bool
is-empty [] = true
is-empty (_ ∷ _) = false
NonEmpty : List A → Type
NonEmpty = T ∘ not ∘ is-empty
open import Data.Maybe.Properties
foldrMay-nonEmpty : (f : A → A → A) (xs : List A) → NonEmpty xs → IsJust (foldrMay f xs)
foldrMay-nonEmpty f (x ∷ xs) _ = tt
foldr1 : (A → A → A) → (xs : List A) → ⦃ NonEmpty xs ⦄ → A
foldr1 f xs ⦃ xsne ⦄ = fromJust (foldrMay f xs)
where instance _ = foldrMay-nonEmpty f xs xsne
|
{
"alphanum_fraction": 0.5207833733,
"avg_line_length": 34.993006993,
"ext": "agda",
"hexsha": "1b8027e662980b6c5ada3e8b74f33d24ee36ab61",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "oisdk/agda-playground",
"max_forks_repo_path": "Data/List/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "oisdk/agda-playground",
"max_issues_repo_path": "Data/List/Properties.agda",
"max_line_length": 148,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "oisdk/agda-playground",
"max_stars_repo_path": "Data/List/Properties.agda",
"max_stars_repo_stars_event_max_datetime": "2021-11-16T08:11:34.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-09-11T17:45:41.000Z",
"num_tokens": 2126,
"size": 5004
}
|
{-# OPTIONS --cubical --rewriting #-}
open import Agda.Primitive.Cubical public
postulate
Int : Set
_↦_ : {A : Set} → A → A → Set
id↦ : {A : Set} {a : A} → a ↦ a
{-# BUILTIN REWRITE _↦_ #-}
postulate
hcompIntEmpty : (n : Int) → primHComp (λ _ → isOneEmpty) n ↦ n
{-# REWRITE hcompIntEmpty #-}
test : (n : Int) → primHComp (λ _ → isOneEmpty) n ↦ n
test n = id↦
|
{
"alphanum_fraction": 0.5828877005,
"avg_line_length": 19.6842105263,
"ext": "agda",
"hexsha": "89e250c5bef75d804e1cbe70278325f099787402",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "2fa8ede09451d43647f918dbfb24ff7b27c52edc",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "phadej/agda",
"max_forks_repo_path": "test/Succeed/Issue3382.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "2fa8ede09451d43647f918dbfb24ff7b27c52edc",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "phadej/agda",
"max_issues_repo_path": "test/Succeed/Issue3382.agda",
"max_line_length": 64,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "2fa8ede09451d43647f918dbfb24ff7b27c52edc",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "phadej/agda",
"max_stars_repo_path": "test/Succeed/Issue3382.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 148,
"size": 374
}
|
module Oscar (FunctionName PredicateName VariableName QuantifierName Name : 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
data Formula (n : ℕ) : Set
where
atomic : PredicateName → ∀ {t} → Vec (Term n) t → Formula n
logical : Formula n →
Formula n →
Formula n
quantified : VariableName → Formula (suc n) → Formula 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₁ Term.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₁ Term.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 (Term.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} () _
|
{
"alphanum_fraction": 0.5615530303,
"avg_line_length": 36.5714285714,
"ext": "agda",
"hexsha": "79fb2fb6fe9d5a682b702e92985570bc4cac764b",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_forks_repo_licenses": [
"RSA-MD"
],
"max_forks_repo_name": "m0davis/oscar",
"max_forks_repo_path": "archive/agda-2/Oscar.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_issues_repo_issues_event_max_datetime": "2019-05-11T23:33:04.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-04-29T00:35:04.000Z",
"max_issues_repo_licenses": [
"RSA-MD"
],
"max_issues_repo_name": "m0davis/oscar",
"max_issues_repo_path": "archive/agda-2/Oscar.agda",
"max_line_length": 162,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_stars_repo_licenses": [
"RSA-MD"
],
"max_stars_repo_name": "m0davis/oscar",
"max_stars_repo_path": "archive/agda-2/Oscar.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 3425,
"size": 8448
}
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Lexicographic products of binary relations
------------------------------------------------------------------------
-- The definition of lexicographic product used here is suitable if
-- the left-hand relation is a (non-strict) partial order.
{-# OPTIONS --without-K --safe #-}
module Data.Product.Relation.Binary.Lex.NonStrict where
open import Data.Product using (_×_; _,_; proj₁; proj₂)
open import Data.Sum.Base using (inj₁; inj₂)
open import Level using (Level)
open import Relation.Binary
open import Relation.Binary.Consequences
import Relation.Binary.Construct.NonStrictToStrict as Conv
open import Data.Product.Relation.Binary.Pointwise.NonDependent as Pointwise
using (Pointwise)
import Data.Product.Relation.Binary.Lex.Strict as Strict
private
variable
a b ℓ₁ ℓ₂ ℓ₃ ℓ₄ : Level
A : Set a
B : Set b
------------------------------------------------------------------------
-- Definition
×-Lex : (_≈₁_ : Rel A ℓ₁) (_≤₁_ : Rel A ℓ₂) (_≤₂_ : Rel B ℓ₃) →
Rel (A × B) _
×-Lex _≈₁_ _≤₁_ _≤₂_ = Strict.×-Lex _≈₁_ (Conv._<_ _≈₁_ _≤₁_) _≤₂_
------------------------------------------------------------------------
-- Properties
×-reflexive : (_≈₁_ : Rel A ℓ₁) (_≤₁_ : Rel A ℓ₂)
{_≈₂_ : Rel B ℓ₃} (_≤₂_ : Rel B ℓ₄) →
_≈₂_ ⇒ _≤₂_ →
(Pointwise _≈₁_ _≈₂_) ⇒ (×-Lex _≈₁_ _≤₁_ _≤₂_)
×-reflexive _≈₁_ _≤₁_ _≤₂_ refl₂ =
Strict.×-reflexive _≈₁_ (Conv._<_ _≈₁_ _≤₁_) _≤₂_ refl₂
module _ {_≈₁_ : Rel A ℓ₁} {_≤₁_ : Rel A ℓ₂} {_≤₂_ : Rel B ℓ₃} where
private
_≤ₗₑₓ_ = ×-Lex _≈₁_ _≤₁_ _≤₂_
×-transitive : IsPartialOrder _≈₁_ _≤₁_ → Transitive _≤₂_ →
Transitive _≤ₗₑₓ_
×-transitive po₁ trans₂ =
Strict.×-transitive {_≈₁_ = _≈₁_} {_<₂_ = _≤₂_}
isEquivalence (Conv.<-resp-≈ _ _ isEquivalence ≤-resp-≈)
(Conv.<-trans _ _ po₁)
trans₂
where open IsPartialOrder po₁
×-total : Symmetric _≈₁_ → Decidable _≈₁_ → Antisymmetric _≈₁_ _≤₁_ →
Total _≤₁_ → Total _≤₂_ → Total _≤ₗₑₓ_
×-total sym₁ dec₁ antisym₁ total₁ total₂ =
total
where
tri₁ : Trichotomous _≈₁_ (Conv._<_ _≈₁_ _≤₁_)
tri₁ = Conv.<-trichotomous _ _ sym₁ dec₁ antisym₁ total₁
total : Total _≤ₗₑₓ_
total x y with tri₁ (proj₁ x) (proj₁ y)
... | tri< x₁<y₁ x₁≉y₁ x₁≯y₁ = inj₁ (inj₁ x₁<y₁)
... | tri> x₁≮y₁ x₁≉y₁ x₁>y₁ = inj₂ (inj₁ x₁>y₁)
... | tri≈ x₁≮y₁ x₁≈y₁ x₁≯y₁ with total₂ (proj₂ x) (proj₂ y)
... | inj₁ x₂≤y₂ = inj₁ (inj₂ (x₁≈y₁ , x₂≤y₂))
... | inj₂ x₂≥y₂ = inj₂ (inj₂ (sym₁ x₁≈y₁ , x₂≥y₂))
×-decidable : Decidable _≈₁_ → Decidable _≤₁_ → Decidable _≤₂_ →
Decidable _≤ₗₑₓ_
×-decidable dec-≈₁ dec-≤₁ dec-≤₂ =
Strict.×-decidable dec-≈₁ (Conv.<-decidable _ _ dec-≈₁ dec-≤₁)
dec-≤₂
module _ {_≈₁_ : Rel A ℓ₁} {_≤₁_ : Rel A ℓ₂}
{_≈₂_ : Rel B ℓ₃} {_≤₂_ : Rel B ℓ₄}
where
private
_≤ₗₑₓ_ = ×-Lex _≈₁_ _≤₁_ _≤₂_
_≋_ = Pointwise _≈₁_ _≈₂_
×-antisymmetric : IsPartialOrder _≈₁_ _≤₁_ → Antisymmetric _≈₂_ _≤₂_ →
Antisymmetric _≋_ _≤ₗₑₓ_
×-antisymmetric po₁ antisym₂ =
Strict.×-antisymmetric {_≈₁_ = _≈₁_} {_<₂_ = _≤₂_}
≈-sym₁ irrefl₁ asym₁ antisym₂
where
open IsPartialOrder po₁
open Eq renaming (refl to ≈-refl₁; sym to ≈-sym₁)
irrefl₁ : Irreflexive _≈₁_ (Conv._<_ _≈₁_ _≤₁_)
irrefl₁ = Conv.<-irrefl _≈₁_ _≤₁_
asym₁ : Asymmetric (Conv._<_ _≈₁_ _≤₁_)
asym₁ = trans∧irr⟶asym {_≈_ = _≈₁_}
≈-refl₁ (Conv.<-trans _ _ po₁) irrefl₁
×-respects₂ : IsEquivalence _≈₁_ →
_≤₁_ Respects₂ _≈₁_ → _≤₂_ Respects₂ _≈₂_ →
_≤ₗₑₓ_ Respects₂ _≋_
×-respects₂ eq₁ resp₁ resp₂ =
Strict.×-respects₂ eq₁ (Conv.<-resp-≈ _ _ eq₁ resp₁) resp₂
------------------------------------------------------------------------
-- Structures
×-isPartialOrder : IsPartialOrder _≈₁_ _≤₁_ →
IsPartialOrder _≈₂_ _≤₂_ →
IsPartialOrder _≋_ _≤ₗₑₓ_
×-isPartialOrder po₁ po₂ = record
{ isPreorder = record
{ isEquivalence = Pointwise.×-isEquivalence
(isEquivalence po₁)
(isEquivalence po₂)
; reflexive = ×-reflexive _≈₁_ _≤₁_ _≤₂_ (reflexive po₂)
; trans = ×-transitive {_≤₂_ = _≤₂_} po₁ (trans po₂)
}
; antisym = ×-antisymmetric po₁ (antisym po₂)
}
where open IsPartialOrder
×-isTotalOrder : Decidable _≈₁_ →
IsTotalOrder _≈₁_ _≤₁_ →
IsTotalOrder _≈₂_ _≤₂_ →
IsTotalOrder _≋_ _≤ₗₑₓ_
×-isTotalOrder ≈₁-dec to₁ to₂ = record
{ isPartialOrder = ×-isPartialOrder
(isPartialOrder to₁) (isPartialOrder to₂)
; total = ×-total (Eq.sym to₁) ≈₁-dec
(antisym to₁) (total to₁)
(total to₂)
}
where open IsTotalOrder
×-isDecTotalOrder : IsDecTotalOrder _≈₁_ _≤₁_ →
IsDecTotalOrder _≈₂_ _≤₂_ →
IsDecTotalOrder _≋_ _≤ₗₑₓ_
×-isDecTotalOrder to₁ to₂ = record
{ isTotalOrder = ×-isTotalOrder (_≟_ to₁)
(isTotalOrder to₁)
(isTotalOrder to₂)
; _≟_ = Pointwise.×-decidable (_≟_ to₁) (_≟_ to₂)
; _≤?_ = ×-decidable (_≟_ to₁) (_≤?_ to₁) (_≤?_ to₂)
}
where open IsDecTotalOrder
------------------------------------------------------------------------
-- Bundles
×-poset : Poset a ℓ₁ ℓ₂ → Poset b ℓ₃ ℓ₄ → Poset _ _ _
×-poset p₁ p₂ = record
{ isPartialOrder = ×-isPartialOrder O₁.isPartialOrder O₂.isPartialOrder
} where module O₁ = Poset p₁; module O₂ = Poset p₂
×-totalOrder : DecTotalOrder a ℓ₁ ℓ₂ →
TotalOrder b ℓ₃ ℓ₄ →
TotalOrder _ _ _
×-totalOrder t₁ t₂ = record
{ isTotalOrder = ×-isTotalOrder T₁._≟_ T₁.isTotalOrder T₂.isTotalOrder
} where module T₁ = DecTotalOrder t₁; module T₂ = TotalOrder t₂
×-decTotalOrder : DecTotalOrder a ℓ₁ ℓ₂ →
DecTotalOrder b ℓ₃ ℓ₄ →
DecTotalOrder _ _ _
×-decTotalOrder t₁ t₂ = record
{ isDecTotalOrder = ×-isDecTotalOrder O₁.isDecTotalOrder O₂.isDecTotalOrder
} where module O₁ = DecTotalOrder t₁; module O₂ = DecTotalOrder t₂
------------------------------------------------------------------------
-- DEPRECATED NAMES
------------------------------------------------------------------------
-- Please use the new names as continuing support for the old names is
-- not guaranteed.
-- Version 0.15
_×-isPartialOrder_ = ×-isPartialOrder
{-# WARNING_ON_USAGE _×-isPartialOrder_
"Warning: _×-isPartialOrder_ was deprecated in v0.15.
Please use ×-isPartialOrder instead."
#-}
_×-isDecTotalOrder_ = ×-isDecTotalOrder
{-# WARNING_ON_USAGE _×-isDecTotalOrder_
"Warning: _×-isDecTotalOrder_ was deprecated in v0.15.
Please use ×-isDecTotalOrder instead."
#-}
_×-poset_ = ×-poset
{-# WARNING_ON_USAGE _×-poset_
"Warning: _×-poset_ was deprecated in v0.15.
Please use ×-poset instead."
#-}
_×-totalOrder_ = ×-totalOrder
{-# WARNING_ON_USAGE _×-totalOrder_
"Warning: _×-totalOrder_ was deprecated in v0.15.
Please use ×-totalOrder instead."
#-}
_×-decTotalOrder_ = ×-decTotalOrder
{-# WARNING_ON_USAGE _×-decTotalOrder_
"Warning: _×-decTotalOrder_ was deprecated in v0.15.
Please use ×-decTotalOrder instead."
#-}
×-≈-respects₂ = ×-respects₂
{-# WARNING_ON_USAGE ×-≈-respects₂
"Warning: ×-≈-respects₂ was deprecated in v0.15.
Please use ×-respects₂ instead."
#-}
|
{
"alphanum_fraction": 0.5596927483,
"avg_line_length": 35.3963133641,
"ext": "agda",
"hexsha": "4c9cf1d28584d15a6cfe2ae2ecc074c5bfa71bf5",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-04T06:54:45.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-04T06:54:45.000Z",
"max_forks_repo_head_hexsha": "fb380f2e67dcb4a94f353dbaec91624fcb5b8933",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "DreamLinuxer/popl21-artifact",
"max_forks_repo_path": "agda-stdlib/src/Data/Product/Relation/Binary/Lex/NonStrict.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "fb380f2e67dcb4a94f353dbaec91624fcb5b8933",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "DreamLinuxer/popl21-artifact",
"max_issues_repo_path": "agda-stdlib/src/Data/Product/Relation/Binary/Lex/NonStrict.agda",
"max_line_length": 77,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "fb380f2e67dcb4a94f353dbaec91624fcb5b8933",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "DreamLinuxer/popl21-artifact",
"max_stars_repo_path": "agda-stdlib/src/Data/Product/Relation/Binary/Lex/NonStrict.agda",
"max_stars_repo_stars_event_max_datetime": "2020-10-10T21:41:32.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-10-07T12:07:53.000Z",
"num_tokens": 2801,
"size": 7681
}
|
-- Andreas, 2016-10-10, AIM XXIV
{-# REWRITE #-} -- This should yield a warning.
|
{
"alphanum_fraction": 0.619047619,
"avg_line_length": 16.8,
"ext": "agda",
"hexsha": "bd50d832bc9642a6efe2234ecb1b2378bab09b7d",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/RewritingEmptyPragma.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/RewritingEmptyPragma.agda",
"max_line_length": 48,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/RewritingEmptyPragma.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 28,
"size": 84
}
|
-- Andreas, 2016-12-31, issue #2371 reported by subttle
-- Module parameter Nat shadowed by import
module Issue2371 (Nat : Set) where
open import Agda.Builtin.Nat
-- C-c C-n zero RET
-- ERROR WAS:
-- An internal error has occurred. Please report this as a bug.
-- Location of the error: src/full/Agda/Utils/List.hs:304
-- Should succeed.
-- C-c C-n Nat RET will report an ambiguous name
|
{
"alphanum_fraction": 0.7201017812,
"avg_line_length": 23.1176470588,
"ext": "agda",
"hexsha": "f0d115ed1bf0b584d15396859851c23e3af19874",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/interaction/Issue2371.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/interaction/Issue2371.agda",
"max_line_length": 63,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/interaction/Issue2371.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 111,
"size": 393
}
|
{-# OPTIONS --sized-types #-}
module Rose where
postulate
Size : Set
_^ : Size -> Size
∞ : Size
{-# BUILTIN SIZE Size #-}
{-# BUILTIN SIZESUC _^ #-}
{-# BUILTIN SIZEINF ∞ #-}
data List (A : Set) : {_ : Size} -> Set where
[] : {size : Size} -> List A {size ^}
_::_ : {size : Size} -> A -> List A {size} -> List A {size ^}
map : {A B : Set} -> (A -> B) ->
{size : Size} -> List A {size} -> List B {size}
map f [] = []
map f (x :: xs) = f x :: map f xs
data Rose (A : Set) : {_ : Size} -> Set where
rose : {size : Size} -> A -> List (Rose A {size}) {∞} -> Rose A {size ^}
{-
mapRose : {A B : Set} -> (A -> B) ->
{size : Size} -> Rose A {size} -> Rose B {size}
mapRose {A} {B} f .{size ^} (rose {size} a l) =
rose (f a) (map (\ r -> mapRose {A} {B} f {size} r) l)
-}
mapRose : {A B : Set} -> (A -> B) ->
{size : Size} -> Rose A {size} -> Rose B {size}
mapRose f (rose a l) = rose (f a) (map (mapRose f) l)
|
{
"alphanum_fraction": 0.471383975,
"avg_line_length": 25.972972973,
"ext": "agda",
"hexsha": "b877c4f8a73ed89c84d8867469c8d47ac24a5dea",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_head_hexsha": "477c8c37f948e6038b773409358fd8f38395f827",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "larrytheliquid/agda",
"max_forks_repo_path": "test/succeed/Rose.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "477c8c37f948e6038b773409358fd8f38395f827",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "larrytheliquid/agda",
"max_issues_repo_path": "test/succeed/Rose.agda",
"max_line_length": 74,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "477c8c37f948e6038b773409358fd8f38395f827",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "larrytheliquid/agda",
"max_stars_repo_path": "test/succeed/Rose.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 359,
"size": 961
}
|
module Terms where
open import Library
-- * Variables
------------------------------------------------------------------------
data Ty : Set where
base : Ty
_→̂_ : (a b : Ty) → Ty
-- Typing contexts.
Cxt = List Ty
-- Variables.
data Var : (Γ : Cxt) (a : Ty) → Set where
zero : ∀{Γ a} → Var (a ∷ Γ) a
suc : ∀{Γ a b} (x : Var Γ a) → Var (b ∷ Γ) a
-- De Bruijn index 0.
v₀ : ∀ {a Γ} → Var (a ∷ Γ) a
v₀ = zero
-- * Terms
------------------------------------------------------------------------
-- Well-typed terms.
data Tm (Γ : Cxt) : (a : Ty) → Set where
var : ∀{a} (x : Var Γ a) → Tm Γ a
abs : ∀{a b} (t : Tm (a ∷ Γ) b) → Tm Γ (a →̂ b)
app : ∀{a b} (t : Tm Γ (a →̂ b)) (u : Tm Γ a) → Tm Γ b
|
{
"alphanum_fraction": 0.3472750317,
"avg_line_length": 21.9166666667,
"ext": "agda",
"hexsha": "11ce4ec11936a68ac21327c8a64c9fc6340c635d",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2018-02-23T18:22:17.000Z",
"max_forks_repo_forks_event_min_datetime": "2017-11-10T16:44:52.000Z",
"max_forks_repo_head_hexsha": "79d97481f3312c2d30a823c3b1bcb8ae871c2fe2",
"max_forks_repo_licenses": [
"Unlicense"
],
"max_forks_repo_name": "ryanakca/strong-normalization",
"max_forks_repo_path": "agda-aplas14/Terms.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "79d97481f3312c2d30a823c3b1bcb8ae871c2fe2",
"max_issues_repo_issues_event_max_datetime": "2018-02-20T14:54:18.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-02-14T16:42:36.000Z",
"max_issues_repo_licenses": [
"Unlicense"
],
"max_issues_repo_name": "ryanakca/strong-normalization",
"max_issues_repo_path": "agda-aplas14/Terms.agda",
"max_line_length": 72,
"max_stars_count": 32,
"max_stars_repo_head_hexsha": "79d97481f3312c2d30a823c3b1bcb8ae871c2fe2",
"max_stars_repo_licenses": [
"Unlicense"
],
"max_stars_repo_name": "ryanakca/strong-normalization",
"max_stars_repo_path": "agda-aplas14/Terms.agda",
"max_stars_repo_stars_event_max_datetime": "2021-03-05T12:12:03.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-05-22T14:33:27.000Z",
"num_tokens": 281,
"size": 789
}
|
{-# BUILTIN CUBEINTERVALUNIV IUniv #-}
|
{
"alphanum_fraction": 0.7179487179,
"avg_line_length": 19.5,
"ext": "agda",
"hexsha": "ace5589dfd712d05a96682094cb4f1dd79713168",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "cc026a6a97a3e517bb94bafa9d49233b067c7559",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "cagix/agda",
"max_forks_repo_path": "test/Fail/IUnivWithoutCubical.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "cc026a6a97a3e517bb94bafa9d49233b067c7559",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "cagix/agda",
"max_issues_repo_path": "test/Fail/IUnivWithoutCubical.agda",
"max_line_length": 38,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "cc026a6a97a3e517bb94bafa9d49233b067c7559",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "cagix/agda",
"max_stars_repo_path": "test/Fail/IUnivWithoutCubical.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 13,
"size": 39
}
|
{-# OPTIONS --cubical --safe #-}
-- | Quotient integer
module QuoInt where
open import Cubical.Core.Everything
open import Cubical.HITs.Ints.QuoInt renaming (_+ℤ_ to _+_; ℤ to Z)
open import Cubical.Data.Nat hiding (_+_)
open import Cubical.Foundations.Prelude
+-i-zero : ∀ a i → posneg i + a ≡ a
+-i-zero a i =
cong (_+ a) (lemma₁ i)
∙ -- x ≡ y → y ≡ z → x ≡ z
lemma₀ a
where
lemma₀ : ∀ a → pos 0 + a ≡ a
lemma₀ (pos zero) = refl
lemma₀ (pos (suc n)) = cong sucℤ (lemma₀ (pos n))
lemma₀ (neg zero) = posneg
lemma₀ (neg (suc n)) = cong predℤ (lemma₀ (neg n))
lemma₀ (posneg i) j = posneg (i ∧ j)
lemma₁ : ∀ i → posneg i ≡ pos 0
lemma₁ i j = posneg (i ∧ ~ j)
|
{
"alphanum_fraction": 0.5974395448,
"avg_line_length": 26.037037037,
"ext": "agda",
"hexsha": "15f59ea5068efed89524500ca4258a9b6471630a",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "9576d5b76e6a868992dbe52930712ac67697bed2",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "anqurvanillapy/fpl",
"max_forks_repo_path": "agda/QuoInt.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "9576d5b76e6a868992dbe52930712ac67697bed2",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "anqurvanillapy/fpl",
"max_issues_repo_path": "agda/QuoInt.agda",
"max_line_length": 67,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "9576d5b76e6a868992dbe52930712ac67697bed2",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "anqurvanillapy/fpl",
"max_stars_repo_path": "agda/QuoInt.agda",
"max_stars_repo_stars_event_max_datetime": "2019-08-24T22:47:47.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-08-24T22:47:47.000Z",
"num_tokens": 268,
"size": 703
}
|
module Categories.Monoidal.CartesianClosed where
|
{
"alphanum_fraction": 0.8979591837,
"avg_line_length": 24.5,
"ext": "agda",
"hexsha": "6805d837383d9abd4f8bdb9ab0ce98358342eb07",
"lang": "Agda",
"max_forks_count": 23,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T13:50:56.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-02-05T13:03:09.000Z",
"max_forks_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "p-pavel/categories",
"max_forks_repo_path": "Categories/Monoidal/CartesianClosed.agda",
"max_issues_count": 19,
"max_issues_repo_head_hexsha": "e41aef56324a9f1f8cf3cd30b2db2f73e01066f2",
"max_issues_repo_issues_event_max_datetime": "2019-08-09T16:31:40.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-05-23T06:47:10.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "p-pavel/categories",
"max_issues_repo_path": "Categories/Monoidal/CartesianClosed.agda",
"max_line_length": 48,
"max_stars_count": 98,
"max_stars_repo_head_hexsha": "36f4181d751e2ecb54db219911d8c69afe8ba892",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "copumpkin/categories",
"max_stars_repo_path": "Categories/Monoidal/CartesianClosed.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-08T05:20:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-04-15T14:57:33.000Z",
"num_tokens": 9,
"size": 49
}
|
{-# OPTIONS --safe #-}
module Cubical.Algebra.Monoid.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.Transport
open import Cubical.Foundations.SIP
open import Cubical.Data.Sigma
open import Cubical.Algebra.Semigroup
open import Cubical.Displayed.Base
open import Cubical.Displayed.Auto
open import Cubical.Displayed.Record
open import Cubical.Displayed.Universe
open import Cubical.Reflection.RecordEquiv
open Iso
private
variable
ℓ : Level
record IsMonoid {A : Type ℓ} (ε : A) (_·_ : A → A → A) : Type ℓ where
constructor ismonoid
field
isSemigroup : IsSemigroup _·_
identity : (x : A) → (x · ε ≡ x) × (ε · x ≡ x)
open IsSemigroup isSemigroup public
lid : (x : A) → ε · x ≡ x
lid x = identity x .snd
rid : (x : A) → x · ε ≡ x
rid x = identity x .fst
unquoteDecl IsMonoidIsoΣ = declareRecordIsoΣ IsMonoidIsoΣ (quote IsMonoid)
record MonoidStr (A : Type ℓ) : Type ℓ where
constructor monoidstr
field
ε : A
_·_ : A → A → A
isMonoid : IsMonoid ε _·_
infixl 7 _·_
open IsMonoid isMonoid public
Monoid : ∀ ℓ → Type (ℓ-suc ℓ)
Monoid ℓ = TypeWithStr ℓ MonoidStr
monoid : (A : Type ℓ) (ε : A) (_·_ : A → A → A) (h : IsMonoid ε _·_) → Monoid ℓ
monoid A ε _·_ h = A , monoidstr ε _·_ h
-- Easier to use constructors
makeIsMonoid : {M : Type ℓ} {ε : M} {_·_ : M → M → M}
(is-setM : isSet M)
(assoc : (x y z : M) → x · (y · z) ≡ (x · y) · z)
(rid : (x : M) → x · ε ≡ x)
(lid : (x : M) → ε · x ≡ x)
→ IsMonoid ε _·_
IsMonoid.isSemigroup (makeIsMonoid is-setM assoc rid lid) = issemigroup is-setM assoc
IsMonoid.identity (makeIsMonoid is-setM assoc rid lid) = λ x → rid x , lid x
makeMonoid : {M : Type ℓ} (ε : M) (_·_ : M → M → M)
(is-setM : isSet M)
(assoc : (x y z : M) → x · (y · z) ≡ (x · y) · z)
(rid : (x : M) → x · ε ≡ x)
(lid : (x : M) → ε · x ≡ x)
→ Monoid ℓ
makeMonoid ε _·_ is-setM assoc rid lid =
monoid _ ε _·_ (makeIsMonoid is-setM assoc rid lid)
record IsMonoidEquiv {A : Type ℓ} {B : Type ℓ}
(M : MonoidStr A) (e : A ≃ B) (N : MonoidStr B)
: Type ℓ
where
constructor monoidequiv
-- Shorter qualified names
private
module M = MonoidStr M
module N = MonoidStr N
field
presε : equivFun e M.ε ≡ N.ε
isHom : (x y : A) → equivFun e (x M.· y) ≡ equivFun e x N.· equivFun e y
MonoidEquiv : (M N : Monoid ℓ) → Type ℓ
MonoidEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsMonoidEquiv (M .snd) e (N .snd)
-- We now extract the important results from the above module
isPropIsMonoid : {M : Type ℓ} (ε : M) (_·_ : M → M → M) → isProp (IsMonoid ε _·_)
isPropIsMonoid ε _·_ =
isOfHLevelRetractFromIso 1 IsMonoidIsoΣ
(isPropΣ
(isPropIsSemigroup _·_)
(λ semi → isPropΠ λ _ → isProp× (semi .is-set _ _) (semi .is-set _ _)))
where
open IsSemigroup
𝒮ᴰ-Monoid : DUARel (𝒮-Univ ℓ) MonoidStr ℓ
𝒮ᴰ-Monoid =
𝒮ᴰ-Record (𝒮-Univ _) IsMonoidEquiv
(fields:
data[ ε ∣ autoDUARel _ _ ∣ presε ]
data[ _·_ ∣ autoDUARel _ _ ∣ isHom ]
prop[ isMonoid ∣ (λ _ _ → isPropIsMonoid _ _) ])
where
open MonoidStr
open IsMonoidEquiv
MonoidPath : (M N : Monoid ℓ) → MonoidEquiv M N ≃ (M ≡ N)
MonoidPath = ∫ 𝒮ᴰ-Monoid .UARel.ua
module MonoidTheory {ℓ} (M : Monoid ℓ) where
open MonoidStr (snd M)
-- Added for its use in groups
-- If there exists a inverse of an element it is unique
inv-lemma : (x y z : ⟨ M ⟩) → y · x ≡ ε → x · z ≡ ε → y ≡ z
inv-lemma x y z left-inverse right-inverse =
y ≡⟨ sym (rid y) ⟩
y · ε ≡⟨ cong (λ - → y · -) (sym right-inverse) ⟩
y · (x · z) ≡⟨ assoc y x z ⟩
(y · x) · z ≡⟨ cong (λ - → - · z) left-inverse ⟩
ε · z ≡⟨ lid z ⟩
z ∎
|
{
"alphanum_fraction": 0.6035415642,
"avg_line_length": 28.0413793103,
"ext": "agda",
"hexsha": "6214c65b566b9664893533e1207c0343680d6a58",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-03-12T20:08:45.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-03-12T20:08:45.000Z",
"max_forks_repo_head_hexsha": "94b474af2909727d04706d562d949928c19faf7b",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "jespercockx/cubical",
"max_forks_repo_path": "Cubical/Algebra/Monoid/Base.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "94b474af2909727d04706d562d949928c19faf7b",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "jespercockx/cubical",
"max_issues_repo_path": "Cubical/Algebra/Monoid/Base.agda",
"max_line_length": 85,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "94b474af2909727d04706d562d949928c19faf7b",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "jespercockx/cubical",
"max_stars_repo_path": "Cubical/Algebra/Monoid/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1547,
"size": 4066
}
|
module Numeral.Matrix where
import Lvl
open import Syntax.Number
open import Data
open import Data.Boolean
open import Data.Tuple as Tuple using (_⨯_ ; _,_)
open import Functional using (const)
open import Numeral.Finite
open import Numeral.Finite.Bound
open import Numeral.Finite.Oper
open import Numeral.Finite.Oper.Comparisons
open import Numeral.Natural
open import Numeral.CoordinateVector as Vector using (Vector)
open import Type
-- Accessor of data in 2-dimensional finite space (Implies bounded).
-- Like a data table.
record Matrix {ℓ} (s : ℕ ⨯ ℕ) (T : Type{ℓ}) : Type{ℓ} where
constructor mat
-- Type of elements in the matrix.
Element : Type
Element = T
-- Width of the matrix (Number of columns).
width : ℕ
width = Tuple.left(s)
-- Height of the matrix (Number of rows).
height : ℕ
height = Tuple.right(s)
field
-- Projection of a matrix.
-- A cell in the matrix.
proj : (𝕟(width) ⨯ 𝕟(height)) → T
-- Vector of a row in the matrix.
row : 𝕟(height) → Vector(width)(T)
(row(y))(x) = proj(x , y)
-- Vector of a column in the matrix.
col : 𝕟(width) → Vector(height)(T)
(col(x))(y) = proj(x , y)
-- Transpose (Reflection on main diagonal).
⬔_ : Matrix(height , width)(T)
proj(⬔_)(x , y) = proj(y , x)
module Rows where
module _ {ℓ} {w}{h} {T : Type{ℓ}} where
-- A matrix with two rows swapped.
swap : 𝕟(h) → 𝕟(h) → Matrix(w , h)(T) → Matrix(w , h)(T)
Matrix.proj(swap(y₁)(y₂)(M))(x , y) =
if (y ≡? y₁) then Matrix.proj(M)(x , y₂)
else if (y ≡? y₂) then Matrix.proj(M)(x , y₁)
else Matrix.proj(M)(x , y)
module _ {ℓ₁ ℓ₂} {w₁ w₂}{h} {A : Type{ℓ₁}} {B : Type{ℓ₂}} where
-- A matrix where a function has been applied to every row.
map : (Vector(w₁)(A) → Vector(w₂)(B)) → Matrix(w₁ , h)(A) → Matrix(w₂ , h)(B)
Matrix.proj(map f(M))(x , y) = Vector.proj(f(Matrix.row(M)(y)))(x)
module _ {ℓ} {w}{h} {T : Type{ℓ}} where
-- A matrix where a function has been applied to every element of the specified row.
mapSingle : 𝕟(h) → (T → T) → Matrix(w , h)(T) → Matrix(w , h)(T)
Matrix.proj(mapSingle target f(M))(x , y) =
if (y ≡? target) then f(Matrix.proj(M)(x , y))
else Matrix.proj(M)(x , y)
-- A matrix where a function has been applied to the specified row.
applyOn : 𝕟(h) → (Vector(w)(T) → Vector(w)(T)) → Matrix(w , h)(T) → Matrix(w , h)(T)
Matrix.proj(applyOn target f(M))(x , y) =
if (y ≡? target) then Vector.proj(f(Matrix.row(M)(y)))(x)
else Matrix.proj(M)(x , y)
module Cols where
module _ {ℓ} {w}{h} {T : Type{ℓ}} where
-- A matrix with two columns swapped.
swap : 𝕟(w) → 𝕟(w) → Matrix(w , h)(T) → Matrix(w , h)(T)
Matrix.proj(swap(x₁)(x₂)(M))(x , y) =
if (x ≡? x₁) then Matrix.proj(M)(x₂ , y)
else if (x ≡? x₂) then Matrix.proj(M)(x₁ , y)
else Matrix.proj(M)(x , y)
module _ {ℓ₁ ℓ₂} {w}{h₁ h₂} {A : Type{ℓ₁}} {B : Type{ℓ₂}} where
-- A matrix where a function has been applied to every column.
map : (Vector(h₁)(A) → Vector(h₂)(B)) → Matrix(w , h₁)(A) → Matrix(w , h₂)(B)
Matrix.proj(map f(M))(x , y) = Vector.proj(f(Matrix.col(M)(x)))(y)
module _ {ℓ} {w}{h} {T : Type{ℓ}} where
-- A matrix where a function has been applied to every element of the specified column.
mapSingle : 𝕟(w) → (T → T) → Matrix(w , h)(T) → Matrix(w , h)(T)
Matrix.proj(mapSingle target f(M))(x , y) =
if (y ≡? target) then f(Matrix.proj(M)(x , y))
else Matrix.proj(M)(x , y)
-- A matrix where a function has been applied to the specified column.
applyOn : 𝕟(w) → (Vector(h)(T) → Vector(h)(T)) → Matrix(w , h)(T) → Matrix(w , h)(T)
Matrix.proj(applyOn target f(M))(x , y) =
if (x ≡? target) then Vector.proj(f(Matrix.col(M)(x)))(y)
else Matrix.proj(M)(x , y)
module _ {ℓ₁ ℓ₂} {s} {A : Type{ℓ₁}} {B : Type{ℓ₂}} where
-- A matrix where a function has been applied to every element.
map : (A → B) → Matrix(s)(A) → Matrix(s)(B) -- TODO: Same implementation in Vector.agda. Generalize. Maybe like in Haskell? With Applicative, Functor and stuff?
Matrix.proj(map f(m))(x , y) = f(Matrix.proj(m)(x , y))
module _ {ℓ₁ ℓ₂ ℓ₃} {s} {A : Type{ℓ₁}} {B : Type{ℓ₂}} {C : Type{ℓ₃}} where
-- A matrix where a binary operator has been pairwise applied to every element of the given matrices at the same positions.
-- This can be used to construct a component-wise operator.
map₂ : (A → B → C) → Matrix(s)(A) → Matrix(s)(B) → Matrix(s)(C)
Matrix.proj(map₂(_▫_) (v₁)(v₂))(x , y) = Matrix.proj(v₁)(x , y) ▫ Matrix.proj(v₂)(x , y)
module _ {ℓ} {w}{h} {T : Type{ℓ}} where
-- A matrix from a vector of vectors. The inner vectors becomes rows.
rowMat : Vector(h)(Vector(w)(T)) → Matrix(w , h)(T)
Matrix.proj(rowMat(vs))(x , y) = Vector.proj(Vector.proj(vs)(y))(x)
-- A matrix from a vector of vectors. The inner vectors becomes columns.
colMat : Vector(w)(Vector(h)(T)) → Matrix(w , h)(T)
Matrix.proj(colMat(vs))(x , y) = Vector.proj(Vector.proj(vs)(x))(y)
-- A matrix represented as a vector of vectors where the inner vectors are the rows of the matrix.
rows : Matrix(w , h)(T) → Vector(h)(Vector(w)(T))
((rows(M))(y))(x) = Matrix.proj(M)(x , y)
-- A matrix represented as a vector of vectors where the inner vectors are the columns of the matrix.
cols : Matrix(w , h)(T) → Vector(w)(Vector(h)(T))
((cols(M))(x))(y) = Matrix.proj(M)(x , y)
-- Matrix with one row and one column removed.
minor : Matrix(𝐒(w) , 𝐒(h))(T) → (𝕟(𝐒(w)) ⨯ 𝕟(𝐒(h))) → Matrix(w , h)(T)
Matrix.proj(minor(M)(X , Y))(x , y) = Matrix.proj(M)(new-x , new-y) where
new-x = if(x <? X) then bound-𝐒(x) else 𝐒(x)
new-y = if(y <? Y) then bound-𝐒(y) else 𝐒(y)
module _ {ℓ} {s} {T : Type{ℓ}} where
-- A matrix filled with a single element.
fill : T → Matrix(s)(T)
Matrix.proj(fill(elem)) = const(elem)
-- submatrix : Matrix(w , h)(T) → ((X , Y) : (𝕟(w) ⨯ 𝕟(h))) → ((W , H) : (𝕟(w −₀ X) ⨯ 𝕟(h −₀ Y))) → Matrix(W −₀ X , H −₀ Y)(T)
-- A square matrix is a matrix with equal length in both directions.
SquareMatrix : ∀{ℓ} → ℕ → Type{ℓ} → Type{ℓ}
SquareMatrix(d)(T) = Matrix(d , d)(T)
module SquareMatrix {ℓ} {d} {T : Type{ℓ}} where
module _ (m : SquareMatrix(d)(T)) where
-- The diagonal vector.
-- The vector consisting of the elements in the main diagonal of the matrix.
diag : Vector(d)(T)
(diag)(i) = Matrix.proj(m)(i , i)
-- The maximum number of dimensions of a space that the matrix can describe linear transformations in.
-- The width/height of the matrix.
dim : ℕ
dim = d
-- The diagonal matrix from a vector.
-- The matrix consisting of the elements from the vector in the main diagonal and a default element (zero) in the rest of the positions.
diagMat : T → Vector(d)(T) → SquareMatrix(d)(T)
Matrix.proj(diagMat(zero)(v))(x , y) = if (x ≡? y) then Vector.proj(v)(x) else zero
-- Scalar matrix.
-- The matrix consisting of a constant element in the main diagonal and a default element (zero) in the rest of the positions.
scalarMat : T → T → SquareMatrix(d)(T)
scalarMat(zero)(elem) = diagMat(zero)(Vector.fill(elem))
module _ {ℓ} where
RowVector : ℕ → Type{ℓ} → Type{ℓ}
RowVector(d)(T) = Matrix(d , 1)(T)
module RowVector {d}{T} where
rowVecMat : Vector(d)(T) → RowVector(d)(T)
Matrix.proj(rowVecMat(v))(x , _) = Vector.proj(v)(x)
ColVector : ℕ → Type{ℓ} → Type{ℓ}
ColVector(d)(T) = Matrix(1 , d)(T)
module ColVector {d}{T} where
colVecMat : Vector(d)(T) → ColVector(d)(T)
Matrix.proj(colVecMat(v))(_ , y) = Vector.proj(v)(y)
module _ {ℓ₁ ℓ₂ ℓ₃ ℓ₄} {A : Type{ℓ₁}} {B : Type{ℓ₂}} {C : Type{ℓ₃}} {D : Type{ℓ₄}} where
multPattern : ∀{x y z} → (C → D → D) → (A → B → C) → D → Matrix(y , z)(A) → Matrix(x , y)(B) → Matrix(x , z)(D)
Matrix.proj(multPattern (_+_) (_⋅_) (zero) M₁ M₂)(x , y) = Vector.foldᵣ(_+_) zero (Vector.map₂(_⋅_) (Matrix.row(M₁)(y)) (Matrix.col(M₂)(x)))
{-
module _ {ℓ} {T : Type{ℓ}} where
detPatternX : T → ∀{d} → SquareMatrix(d)(T) → 𝕟(d) → T
detPatternX _ {𝐒(𝟎)} M _ = Matrix.proj M(0 , 0)
detPatternX zero {𝐒(𝐒(d))} M y = Vector.foldᵣ {!+_!} zero (Vector.map () (Matrix.row M(y)))
-}
|
{
"alphanum_fraction": 0.5950721154,
"avg_line_length": 42.8865979381,
"ext": "agda",
"hexsha": "6ef3ad03fa8391212ec04db6ec8ebf926f7934ae",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Lolirofle/stuff-in-agda",
"max_forks_repo_path": "Numeral/Matrix.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "Numeral/Matrix.agda",
"max_line_length": 162,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Lolirofle/stuff-in-agda",
"max_stars_repo_path": "Numeral/Matrix.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-05T06:53:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:58:13.000Z",
"num_tokens": 2869,
"size": 8320
}
|
module Data.Fin.Properties.Extra where
open import Data.Nat
renaming (suc to S; zero to Z; _+_ to _ℕ+_; _*_ to _ℕ*_)
open ≤-Reasoning renaming (begin_ to start_; _∎ to _□; _≡⟨_⟩_ to _≈⟨_⟩_)
open import Data.Nat.Properties
open import Data.Nat.Properties.Extra renaming (cancel-suc to S-injective)
open import Data.Nat.Properties.Simple
open import Data.Fin
open import Data.Fin.Extra
open import Data.Fin.Properties
open import Data.Product
open import Function
open import Relation.Nullary.Negation
open import Relation.Binary
open import Relation.Binary.PropositionalEquality
open ≡-Reasoning
open DecTotalOrder decTotalOrder renaming (refl to ≤-refl)
-- start
-- {! !}
-- ≤⟨ {! !} ⟩
-- {! !}
-- ≤⟨ {! !} ⟩
-- {! !}
-- ≤⟨ {! !} ⟩
-- {! !}
-- □
-- begin
-- {! !}
-- ≡⟨ {! !} ⟩
-- {! !}
-- ≡⟨ {! !} ⟩
-- {! !}
-- ≡⟨ {! !} ⟩
-- {! !}
-- ≡⟨ {! !} ⟩
-- {! !}
-- ∎
inject-1-lemma : ∀ {n} → (i : Fin (S n)) → (¬p : toℕ i ≢ n) → toℕ (inject-1 i ¬p) ≡ toℕ i
inject-1-lemma {Z} zero ¬p = contradiction refl ¬p
inject-1-lemma {Z} (suc ()) ¬p
inject-1-lemma {S n} zero ¬p = refl
inject-1-lemma {S n} (suc i) ¬p = cong S (inject-1-lemma i (¬p ∘ cong S))
cancel-suc : ∀ {b} {x y : Fin b} → suc x ≡ suc y → x ≡ y
cancel-suc {b} {x} {.x} refl = refl
some-lemma : ∀ {b} (x y : Fin (S b)) (xs ys : ℕ)
→ toℕ {S b} x ℕ+ xs ℕ* S b ≡ toℕ {S b} y ℕ+ ys ℕ* S b
→ x ≡ y × xs ≡ ys
some-lemma zero zero Z Z p = refl , refl
some-lemma zero (suc n) Z Z ()
some-lemma (suc m) zero Z Z ()
some-lemma (suc m) (suc n) Z Z p =
cong suc (toℕ-injective (cancel-+-right Z (S-injective p)))
, refl
some-lemma zero zero Z (S ns) ()
some-lemma zero (suc n) Z (S ns) ()
some-lemma {b} (suc m) zero Z (S ns) p = contradiction p ¬p
where
¬p : S (toℕ m ℕ+ Z) ≢ S (b ℕ+ ns ℕ* S b)
¬p = <⇒≢ $ s≤s $
start
S (toℕ m ℕ+ Z)
≈⟨ +-right-identity (S (toℕ m)) ⟩
S (toℕ m)
≤⟨ bounded m ⟩
b
≤⟨ m≤m+n b (ns ℕ* S b) ⟩
b ℕ+ ns ℕ* S b
□
some-lemma {b} (suc m) (suc n) Z (S ns) p = contradiction p ¬p
where
¬p : S (toℕ m ℕ+ Z) ≢ S (toℕ n ℕ+ S (b ℕ+ ns ℕ* S b))
¬p = <⇒≢ $ s≤s $
start
S (toℕ m ℕ+ Z)
≈⟨ +-right-identity (S (toℕ m)) ⟩
S (toℕ m)
≤⟨ bounded m ⟩
b
≤⟨ ≤-step ≤-refl ⟩
S b
≤⟨ m≤m+n (S b) (ns ℕ* S b) ⟩
S (b ℕ+ ns ℕ* S b)
≤⟨ n≤m+n (toℕ n) (S (b ℕ+ ns ℕ* S b)) ⟩
toℕ n ℕ+ S (b ℕ+ ns ℕ* S b)
□
some-lemma {b} zero zero (S ms) Z ()
some-lemma {b} zero (suc n) (S ms) Z p = contradiction p ¬p
where
¬p : S (b ℕ+ ms ℕ* S b) ≢ S (toℕ n ℕ+ Z)
¬p = >⇒≢ $ s≤s $
start
S (toℕ n ℕ+ Z)
≈⟨ +-right-identity (S (toℕ n)) ⟩
S (toℕ n)
≤⟨ bounded n ⟩
b
≤⟨ m≤m+n b (ms ℕ* S b) ⟩
b ℕ+ ms ℕ* S b
□
some-lemma {b} (suc m) zero (S ms) Z ()
some-lemma {b} (suc m) (suc n) (S ms) Z p = contradiction p ¬p
where
¬p : S (toℕ m ℕ+ S (b ℕ+ ms ℕ* S b)) ≢ S (toℕ n ℕ+ Z)
¬p = >⇒≢ $ s≤s $
start
S (toℕ n ℕ+ Z)
≈⟨ +-right-identity (S (toℕ n)) ⟩
S (toℕ n)
≤⟨ bounded n ⟩
b
≤⟨ ≤-step ≤-refl ⟩
S b
≤⟨ m≤m+n (S b) (ms ℕ* S b) ⟩
S (b ℕ+ ms ℕ* S b)
≤⟨ n≤m+n (toℕ m) (S (b ℕ+ ms ℕ* S b)) ⟩
toℕ m ℕ+ S (b ℕ+ ms ℕ* S b)
□
some-lemma {b} zero zero (S ms) (S ns) p =
refl
, (cong S (cancel-*-right ms ns {b} (cancel-+-left b (S-injective p))))
some-lemma {b} zero (suc n) (S ms) (S ns) p = (proj₁ ind) , cong S (proj₂ ind)
where
p' : S b ℕ+ ms ℕ* S b ≡ S b ℕ+ S (toℕ n ℕ+ ns ℕ* S b)
p' = begin
S (b ℕ+ ms ℕ* S b)
≡⟨ p ⟩
S (toℕ n ℕ+ S (b ℕ+ ns ℕ* S b))
≡⟨ sym (+-assoc (S (toℕ n)) (S b) (ns ℕ* S b)) ⟩
(S (toℕ n) ℕ+ S b) ℕ+ ns ℕ* S b
≡⟨ cong (λ x → x ℕ+ ns ℕ* S b) (+-comm (S (toℕ n)) (S b)) ⟩
S (b ℕ+ S (toℕ n) ℕ+ ns ℕ* S b)
≡⟨ +-assoc (S b) (S (toℕ n)) (ns ℕ* S b) ⟩
S (b ℕ+ S (toℕ n ℕ+ ns ℕ* S b))
∎
ind : zero ≡ suc n × ms ≡ ns
ind = some-lemma {b} zero (suc n) ms ns (cancel-+-left (S b) p')
some-lemma {b} (suc m) zero (S ms) (S ns) p = (proj₁ ind) , (cong S (proj₂ ind))
where
p' : S b ℕ+ (S (toℕ m) ℕ+ ms ℕ* S b) ≡ S b ℕ+ ns ℕ* S b
p' = begin
S b ℕ+ S (toℕ m ℕ+ ms ℕ* S b)
≡⟨ sym (+-assoc (S b) (S (toℕ m)) (ms ℕ* S b)) ⟩
S (b ℕ+ S (toℕ m) ℕ+ ms ℕ* S b)
≡⟨ cong (λ x → x ℕ+ ms ℕ* S b) (+-comm (S b) (S (toℕ m))) ⟩
S (toℕ m ℕ+ S b ℕ+ ms ℕ* S b)
≡⟨ +-assoc (S (toℕ m)) (S b) (ms ℕ* S b) ⟩
S (toℕ m ℕ+ S (b ℕ+ ms ℕ* S b))
≡⟨ p ⟩
S (b ℕ+ ns ℕ* S b)
∎
ind : suc m ≡ zero × ms ≡ ns
ind = some-lemma {b} (suc m) zero ms ns (cancel-+-left (S b) p')
some-lemma {b} (suc m) (suc n) (S ms) (S ns) p = (proj₁ ind) , (cong S (proj₂ ind))
where
p' : S (b ℕ+ S (toℕ m ℕ+ ms ℕ* S b)) ≡ S (b ℕ+ S (toℕ n ℕ+ ns ℕ* S b))
p' = begin
S (b ℕ+ S (toℕ m ℕ+ ms ℕ* S b))
≡⟨ sym (+-assoc (S b) (S (toℕ m)) (ms ℕ* S b)) ⟩
S (b ℕ+ S (toℕ m) ℕ+ ms ℕ* S b)
≡⟨ cong (λ x → x ℕ+ ms ℕ* S b) (+-comm (S b) (S (toℕ m))) ⟩
S (toℕ m ℕ+ S b ℕ+ ms ℕ* S b)
≡⟨ +-assoc (S (toℕ m)) (S b) (ms ℕ* S b) ⟩
S (toℕ m ℕ+ S (b ℕ+ ms ℕ* S b))
≡⟨ p ⟩
S (toℕ n ℕ+ S (b ℕ+ ns ℕ* S b))
≡⟨ sym (+-assoc (S (toℕ n)) (S b) (ns ℕ* S b)) ⟩
S (toℕ n ℕ+ S b ℕ+ ns ℕ* S b)
≡⟨ cong (λ x → x ℕ+ ns ℕ* S b) (+-comm (S (toℕ n)) (S b)) ⟩
S (b ℕ+ S (toℕ n) ℕ+ ns ℕ* S b)
≡⟨ +-assoc (S b) (S (toℕ n)) (ns ℕ* S b) ⟩
S (b ℕ+ S (toℕ n ℕ+ ns ℕ* S b))
∎
ind : suc m ≡ suc n × ms ≡ ns
ind = some-lemma {b} (suc m) (suc n) ms ns (cancel-+-left (S b) p')
|
{
"alphanum_fraction": 0.3680034622,
"avg_line_length": 37.8797814208,
"ext": "agda",
"hexsha": "9c93eba66c323f9dc53b75992e248e73b27d0d3b",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2015-05-30T05:50:50.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-05-30T05:50:50.000Z",
"max_forks_repo_head_hexsha": "aae093cc9bf21f11064e7f7b12049448cd6449f1",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "banacorn/numeral",
"max_forks_repo_path": "Data/Fin/Properties/Extra.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "aae093cc9bf21f11064e7f7b12049448cd6449f1",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "banacorn/numeral",
"max_issues_repo_path": "Data/Fin/Properties/Extra.agda",
"max_line_length": 89,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "aae093cc9bf21f11064e7f7b12049448cd6449f1",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "banacorn/numeral",
"max_stars_repo_path": "Data/Fin/Properties/Extra.agda",
"max_stars_repo_stars_event_max_datetime": "2015-04-23T15:58:28.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-04-23T15:58:28.000Z",
"num_tokens": 2762,
"size": 6932
}
|
-- Martin-Löf identity type without the K axiom
-- (we do not assume uniqueness of identity proofs).
{-# OPTIONS --without-K --safe #-}
module Tools.PropositionalEquality where
-- We reexport Agda's builtin equality type.
open import Tools.Empty public
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; _≢_; refl; sym; trans; cong; cong₂; subst; subst₂) public
open Eq.≡-Reasoning public
-- Non-dependent congruence rules.
cong₃ : ∀ {A B C D : Set} {a a′ b b′ c c′}
(f : A → B → C → D) → a ≡ a′ → b ≡ b′ → c ≡ c′
→ f a b c ≡ f a′ b′ c′
cong₃ f refl refl refl = refl
cong₄ : ∀ {A B C D E : Set} {a a′ b b′ c c′ d d′}
(f : A → B → C → D → E) → a ≡ a′ → b ≡ b′ → c ≡ c′ → d ≡ d′
→ f a b c d ≡ f a′ b′ c′ d′
cong₄ f refl refl refl refl = refl
-- Substitution (type-cast).
-- Three substitutions simultaneously.
subst₃ : ∀ {A B C : Set} {a a′ b b′ c c′} (F : A → B → C → Set)
→ a ≡ a′ → b ≡ b′ → c ≡ c′ → F a b c → F a′ b′ c′
subst₃ F refl refl refl f = f
|
{
"alphanum_fraction": 0.5703048181,
"avg_line_length": 29.9117647059,
"ext": "agda",
"hexsha": "70116308745733630fd83a93c05124e6e595304a",
"lang": "Agda",
"max_forks_count": 8,
"max_forks_repo_forks_event_max_datetime": "2021-11-27T15:58:33.000Z",
"max_forks_repo_forks_event_min_datetime": "2017-10-18T14:18:20.000Z",
"max_forks_repo_head_hexsha": "ea83fc4f618d1527d64ecac82d7d17e2f18ac391",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "fhlkfy/logrel-mltt",
"max_forks_repo_path": "Tools/PropositionalEquality.agda",
"max_issues_count": 4,
"max_issues_repo_head_hexsha": "ea83fc4f618d1527d64ecac82d7d17e2f18ac391",
"max_issues_repo_issues_event_max_datetime": "2021-02-22T10:37:24.000Z",
"max_issues_repo_issues_event_min_datetime": "2017-06-22T12:49:23.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "fhlkfy/logrel-mltt",
"max_issues_repo_path": "Tools/PropositionalEquality.agda",
"max_line_length": 77,
"max_stars_count": 30,
"max_stars_repo_head_hexsha": "ea83fc4f618d1527d64ecac82d7d17e2f18ac391",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "fhlkfy/logrel-mltt",
"max_stars_repo_path": "Tools/PropositionalEquality.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:01:07.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-05-20T03:05:21.000Z",
"num_tokens": 386,
"size": 1017
}
|
{-# OPTIONS --without-K #-}
module sets.fin where
open import sets.fin.core public
open import sets.fin.properties public
open import sets.fin.ordering public
open import sets.fin.universe public
|
{
"alphanum_fraction": 0.7828282828,
"avg_line_length": 24.75,
"ext": "agda",
"hexsha": "f9fcf55d84ae563886eeb47f35dc04758b5e051a",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2019-05-04T19:31:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-02-02T12:17:00.000Z",
"max_forks_repo_head_hexsha": "bbbc3bfb2f80ad08c8e608cccfa14b83ea3d258c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "pcapriotti/agda-base",
"max_forks_repo_path": "src/sets/fin.agda",
"max_issues_count": 4,
"max_issues_repo_head_hexsha": "bbbc3bfb2f80ad08c8e608cccfa14b83ea3d258c",
"max_issues_repo_issues_event_max_datetime": "2016-10-26T11:57:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-02-02T14:32:16.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "pcapriotti/agda-base",
"max_issues_repo_path": "src/sets/fin.agda",
"max_line_length": 38,
"max_stars_count": 20,
"max_stars_repo_head_hexsha": "bbbc3bfb2f80ad08c8e608cccfa14b83ea3d258c",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "pcapriotti/agda-base",
"max_stars_repo_path": "src/sets/fin.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-01T11:25:54.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-06-12T12:20:17.000Z",
"num_tokens": 42,
"size": 198
}
|
{-# OPTIONS --without-K #-}
open import Base
open import Homotopy.TruncatedHIT
{-
The idea is that if [n : ℕ] and [A : Set i], then [τ n A] is defined by the
following n-truncated higher inductive type:
module Homotopy.TruncationHIT {i} (n : ℕ) (A : Set i) where
(n)data τ : Set i where
proj : A → τ
More explanations on the way this is done can be found in TruncatedHIT.agda.
This file contains nothing but stuff that could (should) be autogenerated from
the three lines above.
-}
module Homotopy.TruncationHIT {i} (n : ℕ₋₂) (A : Set i) where
private
data #τ : Set i where
#proj : A → #τ
#top : (f : hSⁿ n → #τ) → #τ
τ : Set i
τ = #τ
proj : A → τ
proj = #proj
top : (f : hSⁿ n → τ) → τ
top = #top
postulate -- HIT
rays : (f : hSⁿ n → τ) (x : hSⁿ n) → top f ≡ f x
hack-prop : (p : n ≡ ⟨-2⟩) (x y : τ) → (x ≡ y)
#τ-rec : ∀ {j} (P : τ → Set j)
(proj* : (x : A) → P (proj x))
{top* : (f : hSⁿ n → τ) (p : (x : hSⁿ n) → P (f x)) → P (top f)}
{rays* : (f : hSⁿ n → τ) (p : (x : hSⁿ n) → P (f x)) (x : hSⁿ n)
→ transport P (rays f x) (top* f p) ≡ p x}
{hack-prop* : (p : n ≡ ⟨-2⟩) (x y : τ) (x* : P x) (y* : P y)
→ (transport P (hack-prop p x y) x* ≡ y* )}
→ ((x : τ) → P x)
#τ-rec P proj* {top*} {rays*} {hack-prop*} (#proj u) = proj* u
#τ-rec P proj* {top*} {rays*} {hack-prop*} (#top f) =
top* f (λ x → #τ-rec P proj* {top*} {rays*} {hack-prop*} (f x))
#τ-rec-nondep : ∀ {j} (C : Set j)
(proj* : A → C)
{top* : (f : hSⁿ n → τ) (p : hSⁿ n → C) → C}
{rays* : (f : hSⁿ n → τ) (p : hSⁿ n → C) (x : hSⁿ n) → top* f p ≡ p x}
{hack-prop* : (p : n ≡ ⟨-2⟩) (x y : τ) (x* y* : C) → x* ≡ y*}
→ (τ → C)
#τ-rec-nondep C proj* {top*} {rays*} {hack-prop*} (#proj u) = proj* u
#τ-rec-nondep C proj* {top*} {rays*} {hack-prop*} (#top f) =
top* f (λ x → #τ-rec-nondep C proj* {top*} {rays*} {hack-prop*} (f x))
private
contr : (n ≡ ⟨-2⟩) → is-contr τ
abstract
contr p = inhab-prop-is-contr (top (λ x → abort-nondep (transport hSⁿ p x)))
(all-paths-is-prop (hack-prop p))
-- Computation rules for [rays] are not needed
τ-rec : ∀ {j} (P : τ → Set j)
(proj* : (x : A) → P (proj x))
{hack-prop* : (p : n ≡ ⟨-2⟩) (x y : τ) (x* : P x) (y* : P y)
→ (transport P (hack-prop p x y) x* ≡ y* )}
(trunc : (x : τ) → is-truncated n (P x))
→ ((x : τ) → P x)
τ-rec P proj* {hack-prop*} trunc =
#τ-rec P proj* {x₁} {x₂} {hack-prop*} where
abstract
u : (f : hSⁿ n → τ) (p : (x : hSⁿ n) → P (f x))
→ filling-dep n P f (top f , rays f) p
u = truncated-has-filling-dep τ P n contr (λ f → (top f , rays f))
x₁ : (f : hSⁿ n → τ) (p : (x : hSⁿ n) → P (f x)) → P (top f)
x₁ = λ f p → π₁ (u f p)
x₂ : (f : hSⁿ n → τ) (p : (x : hSⁿ n) → P (f x)) (x : hSⁿ n)
→ transport P (rays f x) (x₁ f p) ≡ p x
x₂ = λ f p → π₂ (u f p)
τ-rec-nondep : ∀ {j} (C : Set j)
(proj* : A → C)
{hack-prop* : (p : n ≡ ⟨-2⟩) (x y : τ) (x* y* : C) → x* ≡ y*}
(trunc : is-truncated n C)
→ (τ → C)
τ-rec-nondep C proj* {hack-prop*} trunc =
#τ-rec-nondep C proj* {λ _ p → π₁ (u p)}
{λ _ p → π₂ (u p)} {hack-prop*} where
u : _
u = truncated-has-spheres-filled n _ trunc
-- The nth truncation is of h-level [n]
abstract
τ-is-truncated : is-truncated n τ
τ-is-truncated =
spheres-filled-is-truncated n τ contr (λ f → (top f , rays f))
|
{
"alphanum_fraction": 0.4982206406,
"avg_line_length": 31.5140186916,
"ext": "agda",
"hexsha": "dce14b2fa54b1c2fcd42ca0a6f2e02074b38b5e4",
"lang": "Agda",
"max_forks_count": 50,
"max_forks_repo_forks_event_max_datetime": "2022-02-14T03:03:25.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-10T01:48:08.000Z",
"max_forks_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nicolaikraus/HoTT-Agda",
"max_forks_repo_path": "old/Homotopy/TruncationHIT.agda",
"max_issues_count": 31,
"max_issues_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_issues_repo_issues_event_max_datetime": "2021-10-03T19:15:25.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-03-05T20:09:00.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nicolaikraus/HoTT-Agda",
"max_issues_repo_path": "old/Homotopy/TruncationHIT.agda",
"max_line_length": 78,
"max_stars_count": 294,
"max_stars_repo_head_hexsha": "f8fa68bf753d64d7f45556ca09d0da7976709afa",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "UlrikBuchholtz/HoTT-Agda",
"max_stars_repo_path": "old/Homotopy/TruncationHIT.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-20T13:54:45.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T16:23:23.000Z",
"num_tokens": 1473,
"size": 3372
}
|
-- Andreas, 2016-07-17
record R : Set₁ where
abstract
field T : Set
-- Expected error:
--
-- Using abstract here has no effect. Abstract applies only
-- definitions like data definitions, record type definitions and
-- function clauses.
|
{
"alphanum_fraction": 0.7224489796,
"avg_line_length": 20.4166666667,
"ext": "agda",
"hexsha": "0618751cb8ce3ae092a085b160e5ea70622dce2f",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "pthariensflame/agda",
"max_forks_repo_path": "test/Fail/UselessAbstractField.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "pthariensflame/agda",
"max_issues_repo_path": "test/Fail/UselessAbstractField.agda",
"max_line_length": 65,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "pthariensflame/agda",
"max_stars_repo_path": "test/Fail/UselessAbstractField.agda",
"max_stars_repo_stars_event_max_datetime": "2015-12-07T20:14:00.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-03-28T14:51:03.000Z",
"num_tokens": 59,
"size": 245
}
|
module Prelude.Unit where
open import Agda.Builtin.Unit public
record ⊤′ {a} : Set a where
instance constructor tt
-- To keep changes from compat-2.4.0 to a minimum.
Unit = ⊤
pattern unit = tt
|
{
"alphanum_fraction": 0.7185929648,
"avg_line_length": 16.5833333333,
"ext": "agda",
"hexsha": "6d6bf86494e0ad7429b02ea6215acde58dbff2ba",
"lang": "Agda",
"max_forks_count": 24,
"max_forks_repo_forks_event_max_datetime": "2021-04-22T06:10:41.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-03-12T18:03:45.000Z",
"max_forks_repo_head_hexsha": "158d299b1b365e186f00d8ef5b8c6844235ee267",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "L-TChen/agda-prelude",
"max_forks_repo_path": "src/Prelude/Unit.agda",
"max_issues_count": 59,
"max_issues_repo_head_hexsha": "158d299b1b365e186f00d8ef5b8c6844235ee267",
"max_issues_repo_issues_event_max_datetime": "2022-01-14T07:32:36.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-02-09T05:36:44.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "L-TChen/agda-prelude",
"max_issues_repo_path": "src/Prelude/Unit.agda",
"max_line_length": 50,
"max_stars_count": 111,
"max_stars_repo_head_hexsha": "158d299b1b365e186f00d8ef5b8c6844235ee267",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "L-TChen/agda-prelude",
"max_stars_repo_path": "src/Prelude/Unit.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-12T23:29:26.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-05T11:28:15.000Z",
"num_tokens": 58,
"size": 199
}
|
{-# OPTIONS --without-K --safe #-}
module Categories.Kan where
-- Left and Right Kan extensions (known as Lan and Ran)
open import Level
open import Categories.Category using (Category)
open import Categories.Functor
open import Categories.NaturalTransformation using (NaturalTransformation; _∘ʳ_; _∘ᵥ_)
open import Categories.NaturalTransformation.Equivalence using (_≃_)
private
variable
o₀ ℓ₀ e₀ o₁ ℓ₁ e₁ o₂ ℓ₂ e₂ : Level
module _ {A : Category o₀ ℓ₀ e₀} {B : Category o₁ ℓ₁ e₁} {C : Category o₂ ℓ₂ e₂}
(F : Functor A B) (X : Functor A C) where
record Lan : Set (o₀ ⊔ ℓ₀ ⊔ e₀ ⊔ o₁ ⊔ ℓ₁ ⊔ e₁ ⊔ o₂ ⊔ ℓ₂ ⊔ e₂) where
field
L : Functor B C
η : NaturalTransformation X (L ∘F F)
σ : (M : Functor B C) → (α : NaturalTransformation X (M ∘F F)) → NaturalTransformation L M
σ-unique : {M : Functor B C} → {α : NaturalTransformation X (M ∘F F)} →
(σ′ : NaturalTransformation L M) → α ≃ (σ′ ∘ʳ F) ∘ᵥ η → σ′ ≃ σ M α
commutes : (M : Functor B C) → (α : NaturalTransformation X (M ∘F F)) → α ≃ (σ M α ∘ʳ F) ∘ᵥ η
module L = Functor L
module η = NaturalTransformation η
record Ran : Set (o₀ ⊔ ℓ₀ ⊔ e₀ ⊔ o₁ ⊔ ℓ₁ ⊔ e₁ ⊔ o₂ ⊔ ℓ₂ ⊔ e₂) where
field
R : Functor B C
ε : NaturalTransformation (R ∘F F) X
δ : (M : Functor B C) → (α : NaturalTransformation (M ∘F F) X) → NaturalTransformation M R
δ-unique : {M : Functor B C} → {α : NaturalTransformation (M ∘F F) X} →
(δ′ : NaturalTransformation M R) → α ≃ ε ∘ᵥ (δ′ ∘ʳ F) → δ′ ≃ δ M α
commutes : (M : Functor B C) → (α : NaturalTransformation (M ∘F F) X) → α ≃ ε ∘ᵥ (δ M α ∘ʳ F)
module R = Functor R
module ε = NaturalTransformation ε
|
{
"alphanum_fraction": 0.6017492711,
"avg_line_length": 37.2826086957,
"ext": "agda",
"hexsha": "5d0c748730f6a27a16f6bd09a67abfd0239f65db",
"lang": "Agda",
"max_forks_count": 64,
"max_forks_repo_forks_event_max_datetime": "2022-03-14T02:00:59.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-06-02T16:58:15.000Z",
"max_forks_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Code-distancing/agda-categories",
"max_forks_repo_path": "src/Categories/Kan.agda",
"max_issues_count": 236,
"max_issues_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_issues_repo_issues_event_max_datetime": "2022-03-28T14:31:43.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-06-01T14:53:54.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Code-distancing/agda-categories",
"max_issues_repo_path": "src/Categories/Kan.agda",
"max_line_length": 99,
"max_stars_count": 279,
"max_stars_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Trebor-Huang/agda-categories",
"max_stars_repo_path": "src/Categories/Kan.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-22T00:40:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-06-01T14:36:40.000Z",
"num_tokens": 630,
"size": 1715
}
|
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Category.Complete.Finitely
module Categories.Category.Complete.Finitely.Properties {o ℓ e} {C : Category o ℓ e} (finite : FinitelyComplete C) where
open import Level using (Level)
open import Data.Nat using (ℕ)
open import Data.Product using (Σ; _,_; proj₁; ∃₂) renaming (_×_ to _&_)
open import Data.Fin
open import Data.Fin.Properties
open import Data.Sum using (inj₁; inj₂)
open import Data.List hiding ([_])
open import Data.List.Relation.Unary.Any as Any using (here; there)
open import Data.List.Relation.Unary.Any.Properties
open import Data.List.Relation.Unary.Unique.Propositional
open import Data.List.Membership.Propositional
open import Relation.Binary.PropositionalEquality as ≡ using (refl; _≡_; cong)
open import Function renaming (_∘_ to _∙_)
import Data.List.Relation.Unary.Unique.Propositional.Properties as Uₚ
import Data.List.Membership.Propositional.Properties as ∈ₚ
import Data.List.Membership.Setoid.Properties as S∈ₚ
open import Categories.Category
open import Categories.Category.Cartesian.Properties C
open import Categories.Category.Finite.Fin
open import Categories.Diagram.Equalizer C
open import Categories.Morphism.Reasoning C
open import Categories.Functor
import Categories.Category.Construction.Cones as Co
import Categories.Diagram.Limit as Lim
open FinitelyComplete finite
module GeneralProperties where
module _ {a} {A : Set a} where
concatMap-∈ : ∀ {b} {B : Set b} (f : A → List B) {l : List A} →
∀ {x y} → x ∈ l → y ∈ f x → y ∈ concatMap f l
concatMap-∈ f (here refl) y∈fx = ++⁺ˡ y∈fx
concatMap-∈ f (there {z} x∈l) y∈fx = ++⁺ʳ (f z) (concatMap-∈ f x∈l y∈fx)
module _ {a} {A : Set a} where
concatMap²-∈ : ∀ {m n} {ms : List (Fin m)} {ns : List (Fin n)}
(f : Fin m → Fin n → List A) →
∀ {x y k} → x ∈ ms → y ∈ ns → k ∈ f x y →
k ∈ concatMap (λ z → concatMap (λ w → f z w) ns) ms
concatMap²-∈ {m} {n} {ms} {ns} f {x} {y} {k} x∈ms y∈ns k∈fxy = concatMap-∈ _ x∈ms k∈ns
where k∈ns : k ∈ concatMap (λ w → f x w) ns
k∈ns = concatMap-∈ _ y∈ns k∈fxy
module _ {b} {B : Set b} where
concatMap²-map-∈ : ∀ {m n} {ms : List (Fin m)} {ns : List (Fin n)}
(f : Fin m → Fin n → List A) →
(g : A → B) →
∀ {x y k} → x ∈ ms → y ∈ ns → k ∈ f x y →
g k ∈ map g (concatMap (λ z → concatMap (λ w → f z w) ns) ms)
concatMap²-map-∈ f g x∈ms y∈ns k∈fxy = map⁺ (Any.map (cong g) (concatMap²-∈ f x∈ms y∈ns k∈fxy))
open GeneralProperties
open Prods cartesian
-- construct a finite limit from cartesian products and equalizer
--
-- c.f. Awodey 5.21
module _ (shape : FinCatShape) (F : Functor (FinCategory shape) C) where
private
module C = Category C
open C
open HomReasoning
S = FinCategory shape
open Co F
open Lim F
open FinCatShape shape using (size; ∣_⇒_∣; objects; morphisms; wrap-arr; Obj-UIP)
module S = Category S
module F = Functor F
obj∈-irr : ∀ {x} → (p q : x ∈ objects) → p ≡ q
obj∈-irr = S∈ₚ.unique⇒irrelevant (≡.setoid _) Obj-UIP (Uₚ.allFin⁺ size)
prods-gen : List (Fin size) → Obj
prods-gen ns = prod (map F.₀ ns)
prods : Obj
prods = prods-gen objects
cods : List Obj
cods = map (λ n → F.₀ (Arrow.cod n)) morphisms
arrs : Obj
arrs = prod cods
∈-objects : ∀ n → n ∈ objects
∈-objects n = ∈ₚ.∈-allFin n
Fn∈obj : ∀ n → F.₀ n ∈ map F.₀ objects
Fn∈obj n = ∈ₚ.∈-map⁺ F.₀ (∈-objects n)
π : ∀ n → prods ⇒ F.₀ n
π n = π[ Fn∈obj n ]
ϕ⇒ : ∀ (a : Arrow size ∣_⇒_∣) → prods ⇒ F.F₀ (Arrow.cod a)
ϕ⇒ a = π (Arrow.cod a)
ϕπ : prods ⇒ cods *
ϕπ = build-mors _ ϕ⇒ morphisms
ϕ : prods ⇒ arrs
ϕ = ⟨ ϕπ ⟩*
ψ⇒ : ∀ a → prods ⇒ F.F₀ (Arrow.cod a)
ψ⇒ a = F.₁ (Arrow.arr a) ∘ π (Arrow.dom a)
ψπ : prods ⇒ cods *
ψπ = build-mors _ ψ⇒ morphisms
ψ : prods ⇒ arrs
ψ = ⟨ ψπ ⟩*
∈-morphisms : ∀ {d c} (f : Fin ∣ d ⇒ c ∣) → record { arr = f } ∈ morphisms
∈-morphisms {d} {c} f = concatMap²-∈ (λ _ _ → tabulate wrap-arr) (∈-objects d) (∈-objects c) (∈ₚ.∈-tabulate⁺ f)
Fc∈cods : ∀ {d c} (f : Fin ∣ d ⇒ c ∣) → F.₀ c ∈ cods
Fc∈cods f = ∈ₚ.∈-map⁺ (λ a → F.₀ (Arrow.cod a)) (∈-morphisms f)
π′ : ∀ {d c} (f : Fin ∣ d ⇒ c ∣) → arrs ⇒ F.₀ c
π′ f = π[ Fc∈cods f ]
ψπ-proj : ∀ {d c} (f : Fin ∣ d ⇒ c ∣) →
F.₁ f ∘ π d ≈ π[ Fc∈cods f ] ∘ ψ
ψπ-proj f = build-proj (λ a → F.₀ (Arrow.cod a))
(λ a → F.₁ (Arrow.arr a) ∘ π (Arrow.dom a))
(∈-morphisms f)
ϕπ-proj : ∀ {d c} (f : Fin ∣ d ⇒ c ∣) →
π c ≈ π[ Fc∈cods f ] ∘ ϕ
ϕπ-proj f = build-proj (λ a → F.₀ (Arrow.cod a))
(λ a → π (Arrow.cod a))
(∈-morphisms f)
e⇒prods : Equalizer ψ ϕ
e⇒prods = equalizer ψ ϕ
module e⇒prods = Equalizer e⇒prods
open e⇒prods
⊤cone : Cone
⊤cone = record
{ N = obj
; apex = record
{ ψ = λ n → π n ∘ arr
; commute = λ {m n} f → begin
F.₁ f ∘ π m ∘ arr ≈⟨ pullˡ (ψπ-proj f) ⟩
(π′ f ∘ ψ) ∘ arr ≈⟨ pullʳ equality ⟩
π′ f ∘ ϕ ∘ arr ≈˘⟨ pushˡ (ϕπ-proj f) ⟩
π n ∘ arr ∎
}
}
module _ {K : Cone} where
private
module K = Cone K
N⇒* : K.N ⇒ map F.₀ objects *
N⇒* = build-mors F.₀ K.ψ objects
Kmor : K.N ⇒ prods
Kmor = ⟨ N⇒* ⟩*
ψ∘Kmor≈ϕ∘Kmor : ∀ a → ψ⇒ a ∘ Kmor ≈ ϕ⇒ a ∘ Kmor
ψ∘Kmor≈ϕ∘Kmor a = begin
ψ⇒ a ∘ Kmor ≈˘⟨ pushʳ (build-proj F.₀ K.ψ (∈-objects (Arrow.dom a))) ⟩
F.₁ (Arrow.arr a) ∘ K.ψ (Arrow.dom a) ≈⟨ K.commute (Arrow.arr a) ⟩
K.ψ (Arrow.cod a) ≈⟨ build-proj F.₀ K.ψ (∈-objects (Arrow.cod a)) ⟩
ϕ⇒ a ∘ Kmor ∎
equalize-eq : ψ ∘ Kmor ≈ ϕ ∘ Kmor
equalize-eq = begin
ψ ∘ Kmor ≈⟨ build-⟨⟩*∘ _ ψ⇒ Kmor morphisms ⟩
⟨ build-mors _ (λ a → ψ⇒ a ∘ Kmor) morphisms ⟩* ≈⟨ build-uniqueness* _ ψ∘Kmor≈ϕ∘Kmor morphisms ⟩
⟨ build-mors _ (λ a → ϕ⇒ a ∘ Kmor) morphisms ⟩* ≈˘⟨ build-⟨⟩*∘ _ ϕ⇒ Kmor morphisms ⟩
ϕ ∘ Kmor ∎
!cone : Cone⇒ K ⊤cone
!cone = record
{ arr = equalize equalize-eq
; commute = commute _
}
where commute : ∀ n → (π n ∘ arr) ∘ equalize equalize-eq ≈ K.ψ n
commute n = begin
(π n ∘ arr) ∘ equalize equalize-eq ≈˘⟨ pushʳ universal ⟩
π n ∘ Kmor ≈˘⟨ build-proj _ K.ψ (∈-objects n) ⟩
K.ψ n ∎
module _ {K : Cone} (f : Cones [ K , ⊤cone ]) where
private
module K = Cone K
module f = Cone⇒ f
!cone-unique : Cones [ !cone ≈ f ]
!cone-unique = begin
equalize equalize-eq ≈˘⟨ e⇒prods.unique eq ⟩
f.arr ∎
where eq″ : ∀ y → π y ∘ arr ∘ f.arr ≈ π y ∘ Kmor {K}
eq″ y = begin
π y ∘ arr ∘ f.arr ≈⟨ sym-assoc ⟩
(π y ∘ arr) ∘ f.arr ≈⟨ f.commute ⟩
K.ψ y ≈⟨ build-proj _ K.ψ (∈-objects y) ⟩
π y ∘ Kmor {K} ∎
eq′ : ∀ {y : Fin size} (y∈ys : y ∈ objects) →
π[ ∈ₚ.∈-map⁺ F.₀ y∈ys ] ∘ arr ∘ f.arr ≈ π[ ∈ₚ.∈-map⁺ F.₀ y∈ys ] ∘ Kmor {K}
eq′ {y} y∈ys with obj∈-irr y∈ys (∈-objects y)
... | refl = eq″ y
eq : Kmor {K} ≈ arr ∘ f.arr
eq = sym (uniqueness*′ F.₀ {K.N} {objects} eq′)
finiteLimit : Limit
finiteLimit = record
{ terminal = record
{ ⊤ = ⊤cone
; ! = !cone
; !-unique = !cone-unique
}
}
|
{
"alphanum_fraction": 0.5022460694,
"avg_line_length": 34.2478632479,
"ext": "agda",
"hexsha": "e7e8f1302bb56541a5074a1d141c0dc3d4dbf8da",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "58e5ec015781be5413bdf968f7ec4fdae0ab4b21",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "MirceaS/agda-categories",
"max_forks_repo_path": "src/Categories/Category/Complete/Finitely/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "58e5ec015781be5413bdf968f7ec4fdae0ab4b21",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "MirceaS/agda-categories",
"max_issues_repo_path": "src/Categories/Category/Complete/Finitely/Properties.agda",
"max_line_length": 120,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "58e5ec015781be5413bdf968f7ec4fdae0ab4b21",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "MirceaS/agda-categories",
"max_stars_repo_path": "src/Categories/Category/Complete/Finitely/Properties.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 3084,
"size": 8014
}
|
{-# OPTIONS --prop --type-in-type #-}
record × (A B : Prop) : Prop where
field
fst : A
snd : B
|
{
"alphanum_fraction": 0.5188679245,
"avg_line_length": 15.1428571429,
"ext": "agda",
"hexsha": "2a58554170eff11d6cc6868e09f5142054722696",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Succeed/Issue3326.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Succeed/Issue3326.agda",
"max_line_length": 37,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Succeed/Issue3326.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 34,
"size": 106
}
|
{-# OPTIONS --safe #-}
postulate F : Set → Set
{-# POLARITY F ++ #-}
|
{
"alphanum_fraction": 0.5070422535,
"avg_line_length": 11.8333333333,
"ext": "agda",
"hexsha": "14f7bb99556a4e68323b4b8a39a4382b135db707",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Fail/Polarity-pragma-in-safe-mode.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Fail/Polarity-pragma-in-safe-mode.agda",
"max_line_length": 23,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Fail/Polarity-pragma-in-safe-mode.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 20,
"size": 71
}
|
{-# OPTIONS --no-termination-check #-}
module Data.Bin.DivModTests where
open import Data.Bin.DivMod
open Everything using (BinFin; _divMod_; result)
open import IO
open import Data.Bin hiding (suc; fromℕ)
open import Data.String hiding (_≟_)
open import Data.Unit hiding (_≟_)
open import Coinduction
open import Data.List
open import Data.Char hiding (_≟_)
open import Data.Digit hiding (toDigits)
open import Data.Fin hiding (_+_; fromℕ; _≟_)
open import Data.Bin.Bijection using (fromℕ)
showBits : Bin → String
showBits x = fromList (Data.List.reverse (Data.List.map showDigit (toBits x)))
open import Relation.Nullary.Decidable
import Data.Bin.Properties
-- eq = Data.Bin.Properties._≟_
open import Relation.Binary
open import Data.Bin.Properties using (<-strictTotalOrder)
open StrictTotalOrder <-strictTotalOrder using (_≟_)
toDigits : (base : Bin) → {≢0 : False (base ≟ (fromℕ 0))} → Bin → List (BinFin base)
toDigits _ 0# = []
toDigits base {≢0} x with (x divMod base) {≢0}
... | result q r _ = r ∷ toDigits base {≢0} q -- still need to prove termination of this
showBinDigit : Bin → Char
showBinDigit 0# = '0'
showBinDigit ([] 1#) = '1'
showBinDigit ((zero ∷ []) 1#) = '2'
showBinDigit ((suc zero ∷ []) 1#) = '3'
showBinDigit ((zero ∷ zero ∷ []) 1#) = '4'
showBinDigit ((suc zero ∷ zero ∷ []) 1#) = '5'
showBinDigit ((zero ∷ suc zero ∷ []) 1#) = '6'
showBinDigit ((suc zero ∷ suc zero ∷ []) 1#) = '7'
showBinDigit ((zero ∷ zero ∷ zero ∷ []) 1#) = '8'
showBinDigit ((suc zero ∷ zero ∷ zero ∷ []) 1#) = '9'
showBinDigit _ = 'x'
open import Function
open import Data.Product
showDigits : Bin → String
showDigits x = fromList (Data.List.reverse (Data.List.map (showBinDigit ∘ proj₁) (toDigits (fromℕ 10) x)))
test : Bin → String
test x = showDigits x
go : Bin → IO ⊤
go n = ♯ putStrLn (test n) >> ♯ go (n + (fromℕ 1))
main = run (go (fromℕ 0))
|
{
"alphanum_fraction": 0.6766917293,
"avg_line_length": 32.1034482759,
"ext": "agda",
"hexsha": "ee9d538c8abfb121a1111b02c0600b9c758c0f98",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "09cc5104421e88da82f9fead5a43f0028f77810d",
"max_forks_repo_licenses": [
"Unlicense"
],
"max_forks_repo_name": "Rotsor/BinDivMod",
"max_forks_repo_path": "Data/Bin/DivModTests.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "09cc5104421e88da82f9fead5a43f0028f77810d",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Unlicense"
],
"max_issues_repo_name": "Rotsor/BinDivMod",
"max_issues_repo_path": "Data/Bin/DivModTests.agda",
"max_line_length": 106,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "09cc5104421e88da82f9fead5a43f0028f77810d",
"max_stars_repo_licenses": [
"Unlicense"
],
"max_stars_repo_name": "Rotsor/BinDivMod",
"max_stars_repo_path": "Data/Bin/DivModTests.agda",
"max_stars_repo_stars_event_max_datetime": "2019-11-18T13:58:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-11-18T13:58:14.000Z",
"num_tokens": 623,
"size": 1862
}
|
open import Nat
open import Prelude
open import List
open import judgemental-erase
open import statics-checks
open import statics-core
module constructability where
-- we construct expressions and types by induction on their
-- structure. for each sub term, we call the relevant theorem, then
-- assemble the results with carefully chosen lists of actions that allow
-- us to call the appropriate zipper lemmas and maintain well-typedness
-- at every stage of the contruction.
--
-- the proof term at each stage except subsumption is, morally, just the
-- mapping of the fragment of the action semantics used by the constructs
-- in the list in the current formation context into the list monoid.
-- if the name of the given hole is irrelevant
irr-hole : Nat
irr-hole = 0
-- construction of types
construct-type : (t : htyp) → Σ[ L ∈ List action ] runtype (▹ ⦇-⦈ ◃) L (▹ t ◃)
construct-type num = [ construct num ] , DoType TMConNum DoRefl
construct-type ⦇-⦈ = [ del irr-hole ] , DoType TMDel DoRefl
construct-type (t1 ==> t2) with construct-type t1 | construct-type t2
... | (l1 , ih1) | (l2 , ih2) = l1 ++ construct arrow :: l2 ++ [ move parent ] ,
runtype++ ih1
(DoType TMConArrow
(runtype++ (ziplem-tmarr2 ih2)
(DoType TMArrParent2 DoRefl)))
construct-type (t1 ⊕ t2) with construct-type t1 | construct-type t2
... | (l1 , ih1) | (l2 , ih2) = l1 ++ construct sum :: l2 ++ [ move parent ] ,
runtype++ ih1
(DoType TMConPlus
(runtype++ (ziplem-tmplus2 ih2)
(DoType TMPlusParent2 DoRefl)))
construct-type (t1 ⊠ t2) with construct-type t1 | construct-type t2
... | (l1 , ih1) | (l2 , ih2) = l1 ++ construct prod :: l2 ++ [ move parent ] ,
runtype++ ih1
(DoType TMConProd
(runtype++ (ziplem-tmprod2 ih2)
(DoType TMProdParent2 DoRefl)))
mutual
-- construction of expressions in synthetic positions
construct-synth : {Γ : tctx} {u : Nat} {t : htyp} {e : hexp} →
(Γ ⊢ e => t) →
Σ[ L ∈ List action ]
runsynth Γ ▹ ⦇-⦈[ u ] ◃ ⦇-⦈ L ▹ e ◃ t
-- the three base cases
construct-synth (SVar x) = [ construct (var _ irr-hole) ] , DoSynth (SAConVar x) DoRefl
construct-synth SNum = [ construct (numlit _ irr-hole) ] , DoSynth SAConNumlit DoRefl
construct-synth SEHole = [ del _ ] , DoSynth SADel DoRefl
-- the inductive cases
construct-synth (SPlus e1 e2 ) with construct-ana e1 | construct-ana e2
... | (l1 , ih1) | (l2 , ih2) =
construct (plus irr-hole irr-hole) :: (l2 ++ move parent ::
move (child 1) :: (l1 ++ [ move parent ])) ,
DoSynth (SAConPlus1 TCHole2)
(runsynth++ (ziplem-plus2 ih2)
(DoSynth (SAMove EMPlusParent2)
(DoSynth (SAMove EMPlusChild1)
(runsynth++ (ziplem-plus1 ih1)
(DoSynth (SAMove EMPlusParent1) DoRefl)))))
construct-synth {t = t} (SAsc x) with construct-type t | construct-ana x
... | (l1 , ih1) | (l2 , ih2) =
construct asc :: (l1 ++ move parent :: move (child 1) :: (l2 ++ [ move parent ])) ,
DoSynth SAConAsc
(runsynth++ (ziplem-asc2 ETTop ETTop ih1)
(DoSynth (SAMove EMAscParent2)
(DoSynth (SAMove EMAscChild1)
(runsynth++ (ziplem-asc1 ih2)
(DoSynth (SAMove EMAscParent1) DoRefl)))))
construct-synth {t = t1 ==> t2} (SLam x wt) with construct-type t1 | construct-synth wt
... | l1 , ih1 | l2 , ih2 =
construct (lam _ irr-hole irr-hole) ::
(l1 ++ (move parent :: move (child 2) :: (l2 ++ [ move parent ]))) ,
DoSynth (SAConLam x)
(runsynth++ (ziplem-halflam1 x ETTop (rel◆t _) ih1)
(DoSynth (SAMove EMHalfLamParent1)
(DoSynth (SAMove EMHalfLamChild2)
(runsynth++ (ziplem-halflam2 x EETop SEHole ih2)
(DoSynth (SAMove EMHalfLamParent2) DoRefl)))))
construct-synth (SAp e1 m e2) with construct-synth e1 | construct-ana e2
... | l1 , ih1 | l2 , ih2 =
l1 ++ construct (ap irr-hole irr-hole) :: (l2 ++ [ move parent ]) ,
runsynth++ ih1
(DoSynth (SAConApArr m)
(runsynth++ (ziplem-ap2 e1 m ih2)
(DoSynth (SAMove EMApParent2) DoRefl)))
construct-synth (SNEHole {u = u} wt) with construct-synth wt
... | l , ih = l ++ construct (nehole u) :: move parent :: [] ,
runsynth++ ih
(DoSynth SAConNEHole
(DoSynth (SAMove EMNEHoleParent) DoRefl))
construct-synth (SPair e1 e2) with construct-synth e1 | construct-synth e2
... | l1 , ih1 | l2 , ih2 =
construct (pair irr-hole irr-hole) :: (l1 ++ move parent :: move (child 2)
:: l2 ++ [ move parent ]) ,
DoSynth SAConPair
(runsynth++ (ziplem-pair1 EETop SEHole ih1 SEHole)
(DoSynth (SAMove EMPairParent1)
(DoSynth (SAMove EMPairChild2)
(runsynth++ (ziplem-pair2 e1 EETop SEHole ih2)
(DoSynth (SAMove EMPairParent2) DoRefl)))))
construct-synth (SFst e pr) with construct-synth e
... | l , ih = l ++ [ construct (fst irr-hole) ] ,
runsynth++ ih (DoSynth (SAConFst1 pr) DoRefl)
construct-synth (SSnd e pr) with construct-synth e
... | l , ih = l ++ [ construct (snd irr-hole) ] ,
runsynth++ ih (DoSynth (SAConSnd1 pr) DoRefl)
-- construction of expressions in analytic positions
construct-ana : {Γ : tctx} {u : Nat} {t : htyp} {e : hexp} →
(Γ ⊢ e <= t) →
Σ[ L ∈ List action ]
runana Γ ▹ ⦇-⦈[ u ] ◃ L ▹ e ◃ t
construct-ana (ASubsume x c) with construct-synth x
... | l , ih = construct (nehole irr-hole) :: l ++ (move parent :: finish :: []) ,
DoAna (AASubsume EETop SEHole SAConNEHole TCHole1)
(runana++ (ziplem-nehole-b SEHole c ih)
(DoAna (AAMove EMNEHoleParent)
(DoAna (AAFinish (ASubsume x c)) DoRefl)))
construct-ana (ALam a m e) with construct-ana e
... | l , ih = construct (lam _ irr-hole irr-hole) :: (l ++ [ move parent ]) ,
DoAna (AAConLam1 a m)
(runana++ (ziplem-lam a m ih)
(DoAna (AAMove EMLamParent) DoRefl))
construct-ana (AInl m wt) with construct-ana wt
... | l , ih = construct (inl irr-hole irr-hole) :: l ++ [ move parent ] ,
DoAna (AAConInl1 m)
(runana++ (ziplem-inl m ih)
(DoAna (AAMove EMInlParent) DoRefl))
construct-ana (AInr m wt) with construct-ana wt
... | l , ih = construct (inr irr-hole irr-hole) :: l ++ [ move parent ] ,
DoAna (AAConInr1 m)
(runana++ (ziplem-inr m ih)
(DoAna (AAMove EMInrParent) DoRefl))
construct-ana (ACase {x = x} {y = y} x# y# m wt0 wt1 wt2)
with construct-synth wt0
| construct-ana wt1
| construct-ana wt2
... | l0 , ih0 | l1 , ih1 | l2 , ih2 =
construct (case x y irr-hole irr-hole irr-hole) :: construct (nehole irr-hole) ::
l0 ++ (move parent :: finish :: move parent :: move (child 2) ::
l1 ++ (move parent :: move (child 3) ::
l2 ++ [ move parent ])) ,
DoAna (AAConCase x# y#)
(DoAna (AAZipCase1 x# y# EETop SEHole SAConNEHole MSHole
(ASubsume SEHole TCHole1) (ASubsume SEHole TCHole1))
(runana++ (ziplem-case1b x# y# EETop SEHole ih0)
(DoAna (AAZipCase1 x# y# (EENEHole EETop)
(SNEHole wt0) (SAMove EMNEHoleParent) MSHole (ASubsume SEHole TCHole1)
(ASubsume SEHole TCHole1))
(DoAna (AAZipCase1 x# y# EETop (SNEHole wt0) (SAFinish wt0) m
(ASubsume SEHole TCHole1) (ASubsume SEHole TCHole1))
(DoAna (AAMove EMCaseParent1)
(DoAna (AAMove EMCaseChild2)
(runana++ (ziplem-case2 x# y# wt0 (ASubsume SEHole TCHole1) m ih1)
(DoAna (AAMove EMCaseParent2)
(DoAna (AAMove EMCaseChild3)
(runana++ (ziplem-case3 x# y# wt0 wt1 m ih2)
(DoAna (AAMove EMCaseParent3) DoRefl)))))))))))
|
{
"alphanum_fraction": 0.5444856348,
"avg_line_length": 48.7683615819,
"ext": "agda",
"hexsha": "ad9ff9a638bda48dcb778a996a4a57700a886cb5",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "a3640d7b0f76cdac193afd382694197729ed6d57",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "hazelgrove/hazelnut-agda",
"max_forks_repo_path": "constructability.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "a3640d7b0f76cdac193afd382694197729ed6d57",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "hazelgrove/hazelnut-agda",
"max_issues_repo_path": "constructability.agda",
"max_line_length": 91,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "a3640d7b0f76cdac193afd382694197729ed6d57",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "hazelgrove/hazelnut-agda",
"max_stars_repo_path": "constructability.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2693,
"size": 8632
}
|
-- Andreas, 2017-01-12, issue #2386
postulate
B : Set
data _≡_ {A B : Set} (x : A) : A → Set where
refl : (b : B) → x ≡ x
{-# BUILTIN EQUALITY _≡_ #-}
-- Wrong type of _≡_
|
{
"alphanum_fraction": 0.5388888889,
"avg_line_length": 15,
"ext": "agda",
"hexsha": "922214fe39022b13943b73cbfc522fa7749f2eaa",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Fail/Issue2386BuiltinEqualityExtraArg.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Fail/Issue2386BuiltinEqualityExtraArg.agda",
"max_line_length": 44,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Fail/Issue2386BuiltinEqualityExtraArg.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 78,
"size": 180
}
|
open import Prelude
module Implicits.Substitutions.Context where
open import Implicits.Syntax.Type
open import Implicits.Syntax.Context
open import Implicits.Substitutions.Type as TS using ()
open import Data.Fin.Substitution
open import Data.Star as Star hiding (map)
open import Data.Star.Properties
open import Data.Vec
open import Data.List as List using ()
ktx-map : ∀ {ν μ n} → (Type ν → Type μ) → Ktx ν n → Ktx μ n
ktx-map f (Γ , Δ) = map f Γ , List.map f Δ
_/_ : ∀ {ν μ n} → Ktx ν n → Sub Type ν μ → Ktx μ n
K / σ = ktx-map (λ t → t TS./ σ) K
_/Var_ : ∀ {ν m n} → Sub Fin n m → Ktx ν m → Ktx ν n
σ /Var (Γ , Δ) = map (λ x → lookup x Γ) σ , Δ
ictx-weaken : ∀ {ν} → ICtx ν → ICtx (suc ν)
ictx-weaken Δ = List.map (flip TS._/_ TS.wk) Δ
ctx-weaken : ∀ {ν n} → Ctx ν n → Ctx (suc ν) n
ctx-weaken Γ = map (flip TS._/_ TS.wk) Γ
weaken : ∀ {ν n} → Ktx ν n → Ktx (suc ν) n
weaken K = K / TS.wk
|
{
"alphanum_fraction": 0.6367663344,
"avg_line_length": 28.21875,
"ext": "agda",
"hexsha": "ba80ddcf724bd50875674da760d84939f87f52ed",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7fe638b87de26df47b6437f5ab0a8b955384958d",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "metaborg/ts.agda",
"max_forks_repo_path": "src/Implicits/Substitutions/Context.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7fe638b87de26df47b6437f5ab0a8b955384958d",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "metaborg/ts.agda",
"max_issues_repo_path": "src/Implicits/Substitutions/Context.agda",
"max_line_length": 60,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "7fe638b87de26df47b6437f5ab0a8b955384958d",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "metaborg/ts.agda",
"max_stars_repo_path": "src/Implicits/Substitutions/Context.agda",
"max_stars_repo_stars_event_max_datetime": "2021-05-07T04:08:41.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-04-05T17:57:11.000Z",
"num_tokens": 337,
"size": 903
}
|
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.cubical.Square
open import lib.types.Group
open import lib.types.EilenbergMacLane1.Core
module lib.types.EilenbergMacLane1.PathElim where
module _ {i} (G : Group i) where
private
module G = Group G
module EM₁Level₂PathElim {k} {C : Type k}
{{C-level : has-level 2 C}}
(f₁ f₂ : EM₁ G → C)
(embase* : f₁ embase == f₂ embase)
(emloop* : ∀ g →
Square embase* (ap f₁ (emloop g))
(ap f₂ (emloop g)) embase*)
(emloop-comp* : ∀ g₁ g₂ →
emloop* (G.comp g₁ g₂) ⊡v∙
ap (ap f₂) (emloop-comp' G g₁ g₂)
==
ap (ap f₁) (emloop-comp' G g₁ g₂) ∙v⊡
↓-='-square-comp (emloop* g₁) (emloop* g₂))
where
private
module M =
EM₁Level₁Elim {i} {G}
{P = λ x → f₁ x == f₂ x}
{{λ x → has-level-apply C-level _ _}}
embase*
(λ g → ↓-='-from-square (emloop* g))
(λ g₁ g₂ →
↓-='-from-square-comp-path (emloop-comp g₁ g₂)
(emloop* g₁)
(emloop* g₂)
(emloop* (G.comp g₁ g₂))
(emloop-comp* g₁ g₂))
open M public
module EM₁Level₂PathConstElim {k} {C : Type k}
{{C-level : has-level 2 C}}
(f : EM₁ G → C) (c : C)
(embase* : f embase == c)
(emloop* : ∀ g →
Square embase* (ap f (emloop g))
idp embase*)
(emloop-comp* : ∀ g₁ g₂ →
emloop* (G.comp g₁ g₂)
==
(ap (ap f) (emloop-comp' G g₁ g₂) ∙
ap-∙ f (emloop g₁) (emloop g₂)) ∙v⊡
(emloop* g₁ ⊡h emloop* g₂))
where
emloop** : ∀ g → Square embase* (ap f (emloop g))
(ap (cst c) (emloop' G g)) embase*
emloop** g = emloop* g ⊡v∙ ! (ap-cst c (emloop g))
private
emloop-comp** : ∀ g₁ g₂ →
emloop** (G.comp g₁ g₂) ⊡v∙ ap (ap (cst c)) (emloop-comp' G g₁ g₂)
==
ap (ap f) (emloop-comp g₁ g₂) ∙v⊡
↓-='-square-comp (emloop** g₁) (emloop** g₂)
emloop-comp** g₁ g₂ =
(emloop* (G.comp g₁ g₂) ⊡v∙ ! (ap-cst c (emloop (G.comp g₁ g₂)))) ⊡v∙ ap (ap (cst c)) (emloop-comp g₁ g₂)
=⟨ ⊡v∙-assoc (emloop* (G.comp g₁ g₂))
(! (ap-cst c (emloop (G.comp g₁ g₂))))
(ap (ap (cst c)) (emloop-comp g₁ g₂)) ⟩
emloop* (G.comp g₁ g₂) ⊡v∙
(! (ap-cst c (emloop (G.comp g₁ g₂))) ∙
ap (ap (cst c)) (emloop-comp g₁ g₂))
=⟨ ap (emloop* (G.comp g₁ g₂) ⊡v∙_) $ =ₛ-out $
! (ap-cst c (emloop (G.comp g₁ g₂))) ◃∙
ap (ap (cst c)) (emloop-comp g₁ g₂) ◃∎
=ₛ⟨ pre-rotate'-in $
post-rotate-in {p = _ ◃∎} $
homotopy-naturality-to-cst (ap (cst c)) idp (ap-cst c) (emloop-comp g₁ g₂) ⟩
! (ap-cst c (emloop g₁ ∙ emloop g₂)) ◃∎
=ₛ⟨ !-=ₛ (ap-cst-coh c (emloop g₁) (emloop g₂)) ⟩
! (ap2 _∙_ (ap-cst c (emloop g₁)) (ap-cst c (emloop g₂))) ◃∙
! (ap-∙ (cst c) (emloop g₁) (emloop g₂)) ◃∎
=ₛ₁⟨ 0 & 1 & !-ap2 _∙_ (ap-cst c (emloop g₁)) (ap-cst c (emloop g₂)) ⟩
ap2 _∙_ (! (ap-cst c (emloop g₁))) (! (ap-cst c (emloop g₂))) ◃∙
! (ap-∙ (cst c) (emloop g₁) (emloop g₂)) ◃∎
=ₛ₁⟨ 1 & 1 & !ap-∙=∙-ap (cst c) (emloop g₁) (emloop g₂) ⟩
ap2 _∙_ (! (ap-cst c (emloop g₁))) (! (ap-cst c (emloop g₂))) ◃∙
∙-ap (cst c) (emloop g₁) (emloop g₂) ◃∎ ∎ₛ
⟩
emloop* (G.comp g₁ g₂) ⊡v∙
(ap2 _∙_ (! (ap-cst c (emloop g₁))) (! (ap-cst c (emloop g₂))) ∙
∙-ap (cst c) (emloop g₁) (emloop g₂))
=⟨ ! $ ⊡v∙-assoc (emloop* (G.comp g₁ g₂))
(ap2 _∙_ (! (ap-cst c (emloop g₁))) (! (ap-cst c (emloop g₂))))
(∙-ap (cst c) (emloop g₁) (emloop g₂)) ⟩
(emloop* (G.comp g₁ g₂) ⊡v∙
ap2 _∙_ (! (ap-cst c (emloop g₁))) (! (ap-cst c (emloop g₂)))) ⊡v∙
∙-ap (cst c) (emloop g₁) (emloop g₂)
=⟨ ap (λ s → (s ⊡v∙
ap2 _∙_ (! (ap-cst c (emloop g₁))) (! (ap-cst c (emloop g₂)))) ⊡v∙
∙-ap (cst c) (emloop g₁) (emloop g₂))
(emloop-comp* g₁ g₂) ⟩
(((ap (ap f) (emloop-comp' G g₁ g₂) ∙
ap-∙ f (emloop g₁) (emloop g₂)) ∙v⊡
emloop* g₁ ⊡h emloop* g₂) ⊡v∙
ap2 _∙_ (! (ap-cst c (emloop g₁))) (! (ap-cst c (emloop g₂)))) ⊡v∙
∙-ap (cst c) (emloop g₁) (emloop g₂)
=⟨ ap (_⊡v∙ ∙-ap (cst c) (emloop g₁) (emloop g₂)) $
((ap (ap f) (emloop-comp' G g₁ g₂) ∙
ap-∙ f (emloop g₁) (emloop g₂)) ∙v⊡
emloop* g₁ ⊡h emloop* g₂) ⊡v∙
ap2 _∙_ (! (ap-cst c (emloop g₁))) (! (ap-cst c (emloop g₂)))
=⟨ ∙v⊡-⊡v∙-comm
(ap (ap f) (emloop-comp' G g₁ g₂) ∙ ap-∙ f (emloop g₁) (emloop g₂))
(emloop* g₁ ⊡h emloop* g₂)
(ap2 _∙_ (! (ap-cst c (emloop g₁))) (! (ap-cst c (emloop g₂)))) ⟩
(ap (ap f) (emloop-comp' G g₁ g₂) ∙
ap-∙ f (emloop g₁) (emloop g₂)) ∙v⊡
((emloop* g₁ ⊡h emloop* g₂) ⊡v∙
ap2 _∙_ (! (ap-cst c (emloop g₁))) (! (ap-cst c (emloop g₂))))
=⟨ ap ((ap (ap f) (emloop-comp' G g₁ g₂) ∙
ap-∙ f (emloop g₁) (emloop g₂)) ∙v⊡_) $
⊡h-⊡v∙-comm (emloop* g₁) (emloop* g₂)
(! (ap-cst c (emloop g₁))) (! (ap-cst c (emloop g₂))) ⟩
(ap (ap f) (emloop-comp' G g₁ g₂) ∙
ap-∙ f (emloop g₁) (emloop g₂)) ∙v⊡
(emloop** g₁ ⊡h emloop** g₂)
=⟨ ∙v⊡-assoc (ap (ap f) (emloop-comp' G g₁ g₂))
(ap-∙ f (emloop g₁) (emloop g₂))
(emloop** g₁ ⊡h emloop** g₂) ⟩
ap (ap f) (emloop-comp' G g₁ g₂) ∙v⊡
(ap-∙ f (emloop g₁) (emloop g₂) ∙v⊡
(emloop** g₁ ⊡h emloop** g₂)) =∎
⟩
(ap (ap f) (emloop-comp' G g₁ g₂) ∙v⊡
(ap-∙ f (emloop g₁) (emloop g₂) ∙v⊡
(emloop** g₁ ⊡h emloop** g₂))) ⊡v∙
∙-ap (cst c) (emloop g₁) (emloop g₂)
=⟨ ∙v⊡-⊡v∙-comm (ap (ap f) (emloop-comp' G g₁ g₂))
(ap-∙ f (emloop g₁) (emloop g₂) ∙v⊡ (emloop** g₁ ⊡h emloop** g₂))
(∙-ap (cst c) (emloop g₁) (emloop g₂)) ⟩
ap (ap f) (emloop-comp' G g₁ g₂) ∙v⊡
(ap-∙ f (emloop g₁) (emloop g₂) ∙v⊡ emloop** g₁ ⊡h emloop** g₂) ⊡v∙ ∙-ap (cst c) (emloop g₁) (emloop g₂)
=⟨ ap (ap (ap f) (emloop-comp' G g₁ g₂) ∙v⊡_) $
∙v⊡-⊡v∙-comm (ap-∙ f (emloop g₁) (emloop g₂))
(emloop** g₁ ⊡h emloop** g₂)
(∙-ap (cst c) (emloop g₁) (emloop g₂)) ⟩
ap (ap f) (emloop-comp' G g₁ g₂) ∙v⊡
↓-='-square-comp' (emloop** g₁) (emloop** g₂)
=⟨ ap (ap (ap f) (emloop-comp' G g₁ g₂) ∙v⊡_) $
↓-='-square-comp'=↓-='-square-comp {f = f} {g = cst c}
(emloop** g₁) (emloop** g₂) ⟩
ap (ap f) (emloop-comp g₁ g₂) ∙v⊡
↓-='-square-comp (emloop** g₁) (emloop** g₂) =∎
module M =
EM₁Level₂PathElim {k} {C}
{{C-level}}
f (cst c)
embase*
emloop**
emloop-comp**
open M public
|
{
"alphanum_fraction": 0.426804678,
"avg_line_length": 43.25,
"ext": "agda",
"hexsha": "f8eb7a52dcbb65016b20f45e5053bf9d60b27613",
"lang": "Agda",
"max_forks_count": 50,
"max_forks_repo_forks_event_max_datetime": "2022-02-14T03:03:25.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-10T01:48:08.000Z",
"max_forks_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "AntoineAllioux/HoTT-Agda",
"max_forks_repo_path": "core/lib/types/EilenbergMacLane1/PathElim.agda",
"max_issues_count": 31,
"max_issues_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_issues_repo_issues_event_max_datetime": "2021-10-03T19:15:25.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-03-05T20:09:00.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "AntoineAllioux/HoTT-Agda",
"max_issues_repo_path": "core/lib/types/EilenbergMacLane1/PathElim.agda",
"max_line_length": 113,
"max_stars_count": 294,
"max_stars_repo_head_hexsha": "1037d82edcf29b620677a311dcfd4fc2ade2faa6",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "AntoineAllioux/HoTT-Agda",
"max_stars_repo_path": "core/lib/types/EilenbergMacLane1/PathElim.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-20T13:54:45.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T16:23:23.000Z",
"num_tokens": 3119,
"size": 7439
}
|
postulate
ANY : ∀{a}{A : Set a} → A
data Ty : Set where
_⇒_ : (a b : Ty) → Ty
data Tm : (b : Ty) → Set where
S : ∀{c a b} → Tm ((c ⇒ (a ⇒ b)) ⇒ ((c ⇒ a) ⇒ (c ⇒ b)))
_∙_ : ∀{a b} (t : Tm (a ⇒ b)) (u : Tm a) → Tm b
data _↦_ : ∀{a} (t t' : Tm a) → Set where
↦S : ∀{c a b} {t : Tm (c ⇒ (a ⇒ b))} {u : Tm (c ⇒ a)} {v : Tm c}
→ (((S ∙ t) ∙ u) ∙ v) ↦ ((t ∙ v) ∙ (u ∙ v))
↦r : ∀{a b} {u u' : Tm a} {t : Tm (a ⇒ b)}
→ (t ∙ u) ↦ (t ∙ u')
data SN {a} (t : Tm a) : Set where
acc : (h : ∀{t'} (r : t ↦ t') → SN t') → SN t
test : ∀{a b} {t : Tm (a ⇒ b)} {u : Tm a} → SN t → SN u → SN (t ∙ u)
test snt snu = acc λ{ (↦S) → ANY ; (↦r) → {!test snt ?!} }
-- Refine with (test snt)
-- or give (test snt ?)
-- An internal error has occurred. Please report this as a bug.
-- Location of the error: src/full/Agda/TypeChecking/Substitute.hs:456
|
{
"alphanum_fraction": 0.4280742459,
"avg_line_length": 27.8064516129,
"ext": "agda",
"hexsha": "e8355bba18c8dbc990f5da4e297efff1ebbe2705",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "4c5c237f39c1b2ad7ae40e873f427b51e6a438e3",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "andreas-roehler/agda",
"max_forks_repo_path": "test/interaction/Issue4929.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "4c5c237f39c1b2ad7ae40e873f427b51e6a438e3",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "andreas-roehler/agda",
"max_issues_repo_path": "test/interaction/Issue4929.agda",
"max_line_length": 70,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "4c5c237f39c1b2ad7ae40e873f427b51e6a438e3",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "andreas-roehler/agda",
"max_stars_repo_path": "test/interaction/Issue4929.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 427,
"size": 862
}
|
-- The error on Agda 2.5.3 was:
-- An internal error has occurred. Please report this as a bug.
-- Location of the error: src/full/Agda/TypeChecking/Substitute/Class.hs:209
open import Agda.Primitive using (_⊔_ ; Level ; lsuc)
record Unit {U : Level} : Set U where
-- error still occurs with no constructors or fields in these types
constructor unit
record _×_ {U V : Level} (A : Set U) (B : Set V) : Set (U ⊔ V) where
constructor _,,_
field
x : A
y : B
infixr 25 _×_
data _⇔_ {U V : Level} : (A : Set U) → (B : Set V) → Set (U ⊔ V) where
unitIL : {A : Set U} → A ⇔ A × Unit
|
{
"alphanum_fraction": 0.634840871,
"avg_line_length": 27.1363636364,
"ext": "agda",
"hexsha": "143031e3d527d256cfdf18f1c634721e5b7ed3fd",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Fail/Issue3044.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Fail/Issue3044.agda",
"max_line_length": 76,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Fail/Issue3044.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 210,
"size": 597
}
|
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020, 2021, 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 #-}
-- This module proves the two "VotesOnce" proof obligations for our fake handler
open import Optics.All
open import LibraBFT.Prelude
open import LibraBFT.Lemmas
open import LibraBFT.Base.PKCS
import LibraBFT.Concrete.Properties.VotesOnce as VO
open import LibraBFT.Impl.Consensus.Types hiding (EpochConfigFor)
open import LibraBFT.Impl.Util.Crypto
open import LibraBFT.Impl.Handle.Properties sha256 sha256-cr
open import LibraBFT.Impl.Properties.Aux
open import LibraBFT.Concrete.System impl-sps-avp
open import LibraBFT.Concrete.System.Parameters
open EpochConfig
open import LibraBFT.Yasm.Yasm (ℓ+1 0ℓ) EpochConfig epochId authorsN ConcSysParms NodeId-PK-OK
open Structural impl-sps-avp
open import LibraBFT.Impl.Properties.VotesOnce
-- In this module, we (will) prove the two implementation obligations for the VotesOnce rule. Note
-- that it is not yet 100% clear that the obligations are the best definitions to use. See comments
-- in Concrete.VotesOnce. We will want to prove these obligations for the fake/simple
-- implementation (or some variant on it) and streamline the proof before we proceed to tacke more
-- ambitious properties.
module LibraBFT.Impl.Properties.VotesOnceDirect where
oldVoteRound≤lvr : ∀ {e pid pk v}{pre : SystemState e}
→ (r : ReachableSystemState pre)
→ initialised pre pid ≡ initd
→ Meta-Honest-PK pk → (sig : WithVerSig pk v)
→ MsgWithSig∈ pk (ver-signature sig) (msgPool pre)
→ ValidSenderForPK (availEpochs pre) v pid pk
→ (₋epEC (peerStates pre pid)) ^∙ epEpoch ≡ (v ^∙ vEpoch)
→ v ^∙ vRound ≤ (₋epEC (peerStates pre pid)) ^∙ epLastVotedRound
oldVoteRound≤lvr (step-s r (step-epoch _)) pidIn pkH sig msv vspk ep≡ = {!!}
oldVoteRound≤lvr {pid = pid'} {pre = pre} (step-s r (step-peer {pid = pid} cheat@(step-cheat f c)))
pidIn pkH sig msv vspk ep≡
with ¬cheatForgeNew cheat refl unit pkH msv
...| msb4
rewrite cheatStepDNMPeerStates₁ {pid = pid} {pid' = pid'} cheat unit
= oldVoteRound≤lvr r pidIn pkH sig msb4 vspk ep≡
oldVoteRound≤lvr {pid = pid'} {pre = pre}
step@(step-s r (step-peer {pid = pid} stHon@(step-honest stPeer)))
pidIn pkH sig msv vspk ep≡
with newMsg⊎msgSentB4 r stHon pkH (msgSigned msv) (msg⊆ msv) (msg∈pool msv)
...| inj₂ msb4 rewrite msgSameSig msv
with pid ≟ pid'
...| no imp = oldVoteRound≤lvr r pidIn pkH sig msb4 vspk ep≡
...| yes refl = let ep≡st = noEpochChangeYet r refl stPeer
lvr≤ = lastVoteRound-mono r refl stPeer ep≡st
ep≡v = trans ep≡st ep≡
in ≤-trans (oldVoteRound≤lvr r pidIn pkH sig msb4 vspk ep≡v) lvr≤
oldVoteRound≤lvr {pid = pid'} {pre = pre}
step@(step-s r (step-peer {pid = pid} stHon@(step-honest stPeer)))
pidIn pkH sig msv vspk ep≡
| inj₁ (m∈outs , vspkN , newV)
with sameHonestSig⇒sameVoteData pkH (msgSigned msv) sig (msgSameSig msv)
...| inj₁ hb = ⊥-elim (PerState.meta-sha256-cr pre step hb)
...| inj₂ refl
with sameEpoch⇒sameEC vspk vspkN refl
-- Both peers are allowed to sign for the same PK in the same epoch,
-- so they are the same peer
...| refl
with NodeId-PK-OK-injective (vp-ec vspk) (vp-sender-ok vspk) (vp-sender-ok vspkN)
...| refl rewrite eventProcessorPostSt r stPeer refl
= let nvr = newVoteSameEpochGreaterRound r stPeer (msg⊆ msv) m∈outs (msgSigned msv) newV
in ≡⇒≤ ((proj₂ ∘ proj₂) nvr)
votesOnce₁ : VO.ImplObligation₁
votesOnce₁ {pid' = pid'} r (step-msg {_ , P m} _ psI) {v' = v'} {m' = m'}
pkH v⊂m (here refl) sv ¬msb vspkv v'⊂m' m'∈pool sv' ep≡ r≡
with v⊂m
...| vote∈vm = let m'mwsb = mkMsgWithSig∈ m' v' v'⊂m' pid' m'∈pool sv' refl
vspkv' = ValidSenderForPK⇒ep≡ sv sv' ep≡ vspkv
rv'<rv = oldVoteRound≤lvr r psI pkH sv' m'mwsb vspkv' ep≡
in ⊥-elim (<⇒≢ (s≤s rv'<rv) (sym r≡))
...| vote∈qc vs∈qc v≈rbld (inV qc∈m) rewrite cong ₋vSignature v≈rbld
= ⊥-elim (¬msb (qcVotesSentB4 r psI refl qc∈m refl vs∈qc))
votesOnce₂ : VO.ImplObligation₂
votesOnce₂ {pk = pk} {st} r (step-msg {_ , P m} _ psI) hpk v⊂m m∈outs sig vnew
vpk v'⊂m' m'∈outs sig' v'new vpk' es≡ rnds≡
with m∈outs | m'∈outs
...| here refl | here refl
with v⊂m | v'⊂m'
...| vote∈vm | vote∈vm = refl
...| vote∈vm | vote∈qc vs∈qc' v≈rbld' (inV qc∈m')
rewrite cong ₋vSignature v≈rbld'
= ⊥-elim (v'new (qcVotesSentB4 r psI refl qc∈m' refl vs∈qc'))
...| vote∈qc vs∈qc v≈rbld (inV qc∈m) | _
rewrite cong ₋vSignature v≈rbld
= ⊥-elim (vnew (qcVotesSentB4 r psI refl qc∈m refl vs∈qc))
|
{
"alphanum_fraction": 0.624042879,
"avg_line_length": 50.2307692308,
"ext": "agda",
"hexsha": "82e0bbcbb7d4cc70f4cb3516e33ccec1717e2ad3",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "34e4627855fb198665d0c98f377403a906ba75d7",
"max_forks_repo_licenses": [
"UPL-1.0"
],
"max_forks_repo_name": "haroldcarr/bft-consensus-agda",
"max_forks_repo_path": "LibraBFT/Impl/Properties/VotesOnceDirect.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "34e4627855fb198665d0c98f377403a906ba75d7",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"UPL-1.0"
],
"max_issues_repo_name": "haroldcarr/bft-consensus-agda",
"max_issues_repo_path": "LibraBFT/Impl/Properties/VotesOnceDirect.agda",
"max_line_length": 111,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "34e4627855fb198665d0c98f377403a906ba75d7",
"max_stars_repo_licenses": [
"UPL-1.0"
],
"max_stars_repo_name": "haroldcarr/bft-consensus-agda",
"max_stars_repo_path": "LibraBFT/Impl/Properties/VotesOnceDirect.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1809,
"size": 5224
}
|
open import Data.Product using ( _,_ )
open import Data.Sum using ( inj₁ ; inj₂ )
open import Web.Semantic.DL.ABox.Interp using ( _*_ )
open import Web.Semantic.DL.ABox.Model using ( *-resp-⟨ABox⟩ )
open import Web.Semantic.DL.Category.Object using ( Object ; iface )
open import Web.Semantic.DL.Category.Morphism using ( _⇒_ ; _≣_ ; _⊑_ ; _,_ )
open import Web.Semantic.DL.Category.Tensor using ( _⟨⊗⟩_ )
open import Web.Semantic.DL.Category.Properties.Tensor.Lemmas using
( tensor-up ; tensor-down ; tensor-resp-⊨b )
open import Web.Semantic.DL.Signature using ( Signature )
open import Web.Semantic.DL.TBox using ( TBox )
open import Web.Semantic.Util using ( inode ; up ; down )
module Web.Semantic.DL.Category.Properties.Tensor.RespectsEquiv
{Σ : Signature} {S T : TBox Σ} where
tensor-resp-⊑ : ∀ {A₁ A₂ B₁ B₂ : Object S T}
(F₁ G₁ : A₁ ⇒ B₁) (F₂ G₂ : A₂ ⇒ B₂) →
(F₁ ⊑ G₁) → (F₂ ⊑ G₂) → (F₁ ⟨⊗⟩ F₂ ⊑ G₁ ⟨⊗⟩ G₂)
tensor-resp-⊑ {A₁} {A₂} F₁ G₁ F₂ G₂ F₁⊑G₁ F₂⊑G₂
I (I⊨ST , (I⊨A₁ , I⊨A₂)) I⊨F₁F₂ =
tensor-resp-⊨b G₁ G₂ I
(F₁⊑G₁ (up * I)
(I⊨ST , *-resp-⟨ABox⟩ inj₁ (inode * I) (iface A₁) I⊨A₁)
(tensor-up F₁ F₂ I I⊨F₁F₂))
(F₂⊑G₂ (down * I)
(I⊨ST , *-resp-⟨ABox⟩ inj₂ (inode * I) (iface A₂) I⊨A₂)
(tensor-down F₁ F₂ I I⊨F₁F₂))
tensor-resp-≣ : ∀ {A₁ A₂ B₁ B₂ : Object S T}
{F₁ G₁ : A₁ ⇒ B₁} {F₂ G₂ : A₂ ⇒ B₂} →
(F₁ ≣ G₁) → (F₂ ≣ G₂) → (F₁ ⟨⊗⟩ F₂ ≣ G₁ ⟨⊗⟩ G₂)
tensor-resp-≣ {A₁} {A₂} {B₁} {B₂} {F₁} {G₁} {F₂} {G₂}
(F₁⊑G₁ , G₁⊑F₁) (F₂⊑G₂ , G₂⊑F₂) =
( tensor-resp-⊑ F₁ G₁ F₂ G₂ F₁⊑G₁ F₂⊑G₂
, tensor-resp-⊑ G₁ F₁ G₂ F₂ G₁⊑F₁ G₂⊑F₂ )
|
{
"alphanum_fraction": 0.5983910891,
"avg_line_length": 43.6756756757,
"ext": "agda",
"hexsha": "1dbaa30924a3c02e202f4a3b6d7c83b8c0334272",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:40:03.000Z",
"max_forks_repo_forks_event_min_datetime": "2017-12-03T14:52:09.000Z",
"max_forks_repo_head_hexsha": "38fbc3af7062ba5c3d7d289b2b4bcfb995d99057",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "bblfish/agda-web-semantic",
"max_forks_repo_path": "src/Web/Semantic/DL/Category/Properties/Tensor/RespectsEquiv.agda",
"max_issues_count": 4,
"max_issues_repo_head_hexsha": "38fbc3af7062ba5c3d7d289b2b4bcfb995d99057",
"max_issues_repo_issues_event_max_datetime": "2021-01-04T20:57:19.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-11-14T02:32:28.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "bblfish/agda-web-semantic",
"max_issues_repo_path": "src/Web/Semantic/DL/Category/Properties/Tensor/RespectsEquiv.agda",
"max_line_length": 77,
"max_stars_count": 9,
"max_stars_repo_head_hexsha": "8ddbe83965a616bff6fc7a237191fa261fa78bab",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "agda/agda-web-semantic",
"max_stars_repo_path": "src/Web/Semantic/DL/Category/Properties/Tensor/RespectsEquiv.agda",
"max_stars_repo_stars_event_max_datetime": "2020-03-14T14:21:08.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-13T17:46:41.000Z",
"num_tokens": 790,
"size": 1616
}
|
module Algebra.LabelledGraph where
open import Algebra.Dioid
-- Core graph construction primitives
data LabelledGraph {D eq} (d : Dioid D eq) (A : Set) : Set where
ε : LabelledGraph d A -- Empty graph
v : A -> LabelledGraph d A -- Graph comprising a single vertex
_[_]>_ : LabelledGraph d A -> D -> LabelledGraph d A -> LabelledGraph d A
-- Connect two graphs
_+_ : ∀ {A D eq} {d : Dioid D eq} -> LabelledGraph d A -> LabelledGraph d A -> LabelledGraph d A
_+_ {_} {_} {_} {d} g h = g [ Dioid.zero d ]> h
_*_ : ∀ {A D eq} {d : Dioid D eq} -> LabelledGraph d A -> LabelledGraph d A -> LabelledGraph d A
_*_ {_} {_} {_} {d} g h = g [ Dioid.one d ]> h
infixl 4 _≡_
infixl 8 _+_
infixl 9 _*_
infixl 9 _[_]>_
infix 10 _⊆_
-- Equational theory of graphs
data _≡_ {A D eq} {d : Dioid D eq} : (x y : LabelledGraph d A) -> Set where
-- Equivalence relation
reflexivity : ∀ {x : LabelledGraph d A} -> x ≡ x
symmetry : ∀ {x y : LabelledGraph d A} -> x ≡ y -> y ≡ x
transitivity : ∀ {x y z : LabelledGraph d A} -> x ≡ y -> y ≡ z -> x ≡ z
-- Congruence
left-congruence : ∀ {x y z : LabelledGraph d A} {r : D} -> x ≡ y -> x [ r ]> z ≡ y [ r ]> z
right-congruence : ∀ {x y z : LabelledGraph d A} {r : D} -> x ≡ y -> z [ r ]> x ≡ z [ r ]> y
dioid-congruence : ∀ {x y : LabelledGraph d A} {r s : D} -> eq r s -> x [ r ]> y ≡ x [ s ]> y
-- Axioms
zero-commutativity : ∀ {x y : LabelledGraph d A} -> x + y ≡ y + x
left-identity : ∀ {x : LabelledGraph d A} {r : D} -> ε [ r ]> x ≡ x
right-identity : ∀ {x : LabelledGraph d A} {r : D} -> x [ r ]> ε ≡ x
left-decomposition : ∀ {x y z : LabelledGraph d A} {r s : D} -> x [ r ]> (y [ s ]> z) ≡ (x [ r ]> y) + (x [ r ]> z) + (y [ s ]> z)
right-decomposition : ∀ {x y z : LabelledGraph d A} {r s : D} -> (x [ r ]> y) [ s ]> z ≡ (x [ r ]> y) + (x [ s ]> z) + (y [ s ]> z)
label-addition : ∀ {x y : LabelledGraph d A} {r s : D} -> (x [ r ]> y) + (x [ s ]> y) ≡ (x [ Dioid.plus d r s ]> y)
-- Subgraph relation
_⊆_ : ∀ {A D eq} {d : Dioid D eq} -> LabelledGraph d A -> LabelledGraph d A -> Set
x ⊆ y = x + y ≡ y
|
{
"alphanum_fraction": 0.5047021944,
"avg_line_length": 47.5106382979,
"ext": "agda",
"hexsha": "f82d669d6f7d3139905e5fa0c857c480f98e1197",
"lang": "Agda",
"max_forks_count": 6,
"max_forks_repo_forks_event_max_datetime": "2019-05-09T23:53:28.000Z",
"max_forks_repo_forks_event_min_datetime": "2017-12-17T20:48:20.000Z",
"max_forks_repo_head_hexsha": "0fdb96c0233d9be83eba637f0434d0fd22aefb1d",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "snowleopard/alga-proofs",
"max_forks_repo_path": "src/Algebra/LabelledGraph.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "0fdb96c0233d9be83eba637f0434d0fd22aefb1d",
"max_issues_repo_issues_event_max_datetime": "2018-06-23T13:54:02.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-04-12T16:25:13.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "snowleopard/alga-proofs",
"max_issues_repo_path": "src/Algebra/LabelledGraph.agda",
"max_line_length": 135,
"max_stars_count": 60,
"max_stars_repo_head_hexsha": "0fdb96c0233d9be83eba637f0434d0fd22aefb1d",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "snowleopard/alga-proofs",
"max_stars_repo_path": "src/Algebra/LabelledGraph.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-22T23:05:29.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-12-27T14:57:04.000Z",
"num_tokens": 891,
"size": 2233
}
|
open import Agda.Builtin.Bool
works : Bool → Bool
works b with b | true
... | b′ | _ = b′
fails : Bool → Bool
fails b with b′ ← b | true
... | _ = b′
|
{
"alphanum_fraction": 0.5723684211,
"avg_line_length": 15.2,
"ext": "agda",
"hexsha": "1dc02a9ff5e1f8632e5d03e50e920e86fb78af4f",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Succeed/Issue4088.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Succeed/Issue4088.agda",
"max_line_length": 29,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Succeed/Issue4088.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 54,
"size": 152
}
|
module CS410-Functor where
open import CS410-Prelude
record Functor (T : Set -> Set) : Set1 where
field
-- OPERATIONS ----------------------------------------------
map : forall {X Y} -> (X -> Y) -> T X -> T Y
-- LAWS ----------------------------------------------------
mapid : forall {X}(x : T X) -> map id x == x
mapcomp : forall {X Y Z}(f : Y -> Z)(g : X -> Y)(x : T X) ->
map (f o g) x == map f (map g x)
record Applicative (T : Set -> Set) : Set1 where
field
-- OPERATIONS ----------------------------------------------
pure : forall {X} -> X -> T X
_<*>_ : forall {X Y} -> T (X -> Y) -> T X -> T Y
-- LAWS ----------------------------------------------------
identity : forall {X}(v : T X) ->
pure id <*> v == v
composition : forall {X Y Z}(u : T (Y -> Z))(v : T (X -> Y))(w : T X) ->
pure (\ f g x -> f (g x)) <*> u <*> v <*> w == u <*> (v <*> w)
homomorphism : forall {X Y}(f : X -> Y)(x : X) ->
pure (f x) == pure f <*> pure x
interchange : forall {X Y}(u : T (X -> Y))(y : X) ->
u <*> pure y == pure (\ f -> f y) <*> u
infixl 10 _<*>_
App2Fun : {T : Set -> Set} -> Applicative T -> Functor T
App2Fun {T} app = record {
map = \ f x -> pure f <*> x;
mapid = identity;
mapcomp = lem}
where
open Applicative app
lem : forall {X Y Z}(f : Y -> Z)(g : X -> Y)(x : T X) ->
pure (\ x -> f (g x)) <*> x == pure f <*> (pure g <*> x)
lem {X}{Y}{Z} f g x rewrite
(sym (composition (pure f) (pure g) x))
| (sym (homomorphism (\ (f : Y -> Z)(g : X -> Y) x -> f (g x)) f))
| (sym (homomorphism (\ (g : X -> Y) x -> f (g x)) g))
= refl
record Traversable (T : Set -> Set) : Set1 where
field
-- OPERATIONS ----------------------------------------------
traverse : forall {F} -> Applicative F ->
forall {A B} -> (A -> F B) -> T A -> F (T B)
-- LAWS ----------------------------------------------------
-- maybe later
record Monad (T : Set -> Set) : Set1 where
field
-- OPERATIONS ----------------------------------------------
return : forall {X} -> X -> T X
_>>=_ : forall {X Y} -> T X -> (X -> T Y) -> T Y
-- LAWS ----------------------------------------------------
law1 : forall {X Y}(x : X)(f : X -> T Y) -> return x >>= f == f x
law2 : forall {X}(t : T X) -> t >>= return == t
law3 : forall {X Y Z}(f : X -> T Y)(g : Y -> T Z)(t : T X) ->
(t >>= f) >>= g == t >>= (\ x -> f x >>= g)
-- DERIVED OPERATIONS
_<=<_ : {X Y Z : Set} -> (Y -> T Z) -> (X -> T Y) -> (X -> T Z)
(f <=< g) x = g x >>= f
infixr 5 _>>=_
record Monad-Alg {T : Set -> Set}(M : Monad T) : Set1 where
field
-- OPERATIONS ----------------------------------------------
A : Set
A-map : forall {X} -> (X -> A) -> T X -> A
open Monad M
-- LAWS ----------------------------------------------------
field
A-law1 : forall {X}(f : X -> A)(x : X) -> A-map f (return x) == f x
A-law2 : forall {X Y}(g : X -> T Y)(f : Y -> A)(t : T X) ->
A-map (A-map f o g) t == A-map f (t >>= g)
|
{
"alphanum_fraction": 0.3457575758,
"avg_line_length": 36.6666666667,
"ext": "agda",
"hexsha": "91f4e4b3c55e1e6d8d008c7e66505472c9e3abe5",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "523a8749f49c914bcd28402116dcbe79a78dbbf4",
"max_forks_repo_licenses": [
"CC0-1.0"
],
"max_forks_repo_name": "clarkdm/CS410",
"max_forks_repo_path": "CS410-Functor.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "523a8749f49c914bcd28402116dcbe79a78dbbf4",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"CC0-1.0"
],
"max_issues_repo_name": "clarkdm/CS410",
"max_issues_repo_path": "CS410-Functor.agda",
"max_line_length": 84,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "523a8749f49c914bcd28402116dcbe79a78dbbf4",
"max_stars_repo_licenses": [
"CC0-1.0"
],
"max_stars_repo_name": "clarkdm/CS410",
"max_stars_repo_path": "CS410-Functor.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1021,
"size": 3300
}
|
module DualTail1 where
open import Data.Nat
open import Data.Fin using (Fin; zero; suc)
open import Data.Product
open import Function using (id; _∘_)
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
open import Types.Direction
open import Types.IND1 as IND hiding (GType; Type; SType; _≈_; _≈'_)
import Types.COI as COI
open import Types.Tail1
private
variable
n : ℕ
-- instead of unrolling and substituting, we maintain a stack of bodies of recursive types
data Stack {GType : ℕ → Set} : ℕ → Set where
ε : Stack 0
⟪_,_⟫ : Stack {GType} n → GType (suc n) → Stack (suc n)
-- obtain an entry from the stack
-- technically m = n - i, but we don't need to know
get : ∀ {GType} (i : Fin n) → Stack {GType} n → Σ ℕ λ m → Stack {GType} m × GType (suc m)
get zero ⟪ σ , x ⟫ = _ , (σ , x)
get (suc i) ⟪ σ , x ⟫ = get i σ
-- the dual of a stack
dual-stack : Stack {GType} n → Stack {GType} n
dual-stack ε = ε
dual-stack ⟪ σ , g ⟫ = ⟪ dual-stack σ , dualG g ⟫
-- relate a stack entry to the corresponding entry on the dual stack
get-dual-stack : (x : Fin n) (σ : Stack n) →
get x (dual-stack σ) ≡ map id (map dual-stack dualG) (get x σ)
get-dual-stack zero ⟪ σ , x ⟫ = refl
get-dual-stack (suc x) ⟪ σ , x₁ ⟫ = get-dual-stack x σ
-- stacked version of general mapping of inductive session type to COI
ind2coiS : Stack {IND.GType} n → IND.SType n → COI.SType
ind2coiG : Stack {IND.GType} n → IND.GType n → COI.STypeF COI.SType
ind2coiT : Stack {IND.GType} n → IND.TType n → COI.Type
COI.SType.force (ind2coiS σ (gdd G)) = ind2coiG σ G
COI.SType.force (ind2coiS σ (rec G)) = ind2coiG ⟪ σ , G ⟫ G
COI.SType.force (ind2coiS σ (var x)) with get x σ
... | m , σ' , gxs = ind2coiG ⟪ σ' , gxs ⟫ gxs
ind2coiG σ (transmit d T S) = COI.transmit d (ind2coiT σ T) (ind2coiS σ S)
ind2coiG σ (choice d m alt) = COI.choice d m (ind2coiS σ ∘ alt)
ind2coiG σ end = COI.end
ind2coiT σ TUnit = COI.TUnit
ind2coiT σ TInt = COI.TInt
ind2coiT σ (TPair T T₁) = COI.TPair (ind2coiT σ T) (ind2coiT σ T₁)
ind2coiT σ (TChan S) = COI.TChan (ind2coiS σ S)
-- mapping tail recursive session types to coinductive session types
-- relies on a stack to unfold variables on the fly
tail2coiT : Type → COI.Type
tail2coiS : Stack {GType} n → SType n → COI.SType
tail2coiG : Stack {GType} n → GType n → COI.STypeF COI.SType
tail2coiT TUnit = COI.TUnit
tail2coiT TInt = COI.TInt
tail2coiT (TPair t t₁) = COI.TPair (tail2coiT t) (tail2coiT t₁)
tail2coiT (TChan s) = COI.TChan (ind2coiS ε s)
COI.SType.force (tail2coiS σ (gdd g)) = tail2coiG σ g
COI.SType.force (tail2coiS σ (rec g)) = tail2coiG ⟪ σ , g ⟫ g
COI.SType.force (tail2coiS σ (var x))
with get x σ
... | m , σ' , gxs = tail2coiG ⟪ σ' , gxs ⟫ gxs
tail2coiG σ (transmit d t s) = COI.transmit d (tail2coiT t) (tail2coiS σ s)
tail2coiG σ (choice d m alt) = COI.choice d m (tail2coiS σ ∘ alt)
tail2coiG σ end = COI.end
-- get coinductive bisimulation in scope
_≈_ = COI._≈_
_≈'_ = COI._≈'_
-- main proposition
dual-tailS : (σ : Stack {GType} n) (s : SType n) →
COI.dual (tail2coiS σ s) ≈ tail2coiS (dual-stack σ) (dualS s)
dual-tailG : (σ : Stack {GType} n) (g : GType n) →
COI.dualF (tail2coiG σ g) ≈' tail2coiG (dual-stack σ) (dualG g)
COI.Equiv.force (dual-tailS σ (gdd g)) = dual-tailG σ g
COI.Equiv.force (dual-tailS σ (rec g)) = dual-tailG ⟪ σ , g ⟫ g
COI.Equiv.force (dual-tailS σ (var x))
rewrite get-dual-stack x σ
with get x σ
... | m , σ' , g = dual-tailG ⟪ σ' , g ⟫ g
dual-tailG σ (transmit d t s) = COI.eq-transmit (dual-dir d) COI.≈ᵗ-refl (dual-tailS σ s)
dual-tailG σ (choice d m alt) = COI.eq-choice (dual-dir d) (dual-tailS σ ∘ alt)
dual-tailG σ end = COI.eq-end
-- corrolary for SType 0
dual-tail : ∀ s → COI.dual (tail2coiS ε s) ≈ tail2coiS ε (dualS s)
dual-tail = dual-tailS ε
|
{
"alphanum_fraction": 0.6637543024,
"avg_line_length": 31.7394957983,
"ext": "agda",
"hexsha": "0461d168c961cea0b06e1cde29d8dc023f9f037c",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-12-07T16:12:50.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-12-07T16:12:50.000Z",
"max_forks_repo_head_hexsha": "7a8bc1f6b2f808bd2a22c592bd482dbcc271979c",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "peterthiemann/dual-session",
"max_forks_repo_path": "src/DualTail1.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7a8bc1f6b2f808bd2a22c592bd482dbcc271979c",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "peterthiemann/dual-session",
"max_issues_repo_path": "src/DualTail1.agda",
"max_line_length": 90,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "7a8bc1f6b2f808bd2a22c592bd482dbcc271979c",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "peterthiemann/dual-session",
"max_stars_repo_path": "src/DualTail1.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-13T05:43:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2022-02-13T05:43:25.000Z",
"num_tokens": 1549,
"size": 3777
}
|
open import Data.Nat
open import Data.Nat.Show
open import IO
module Ackermann where
ack : ℕ -> ℕ -> ℕ
ack zero n = n + 1
ack (suc m) zero = ack m 1
ack (suc m) (suc n) = ack m (ack (suc m) n)
main = run (putStrLn (show (ack 3 9)))
|
{
"alphanum_fraction": 0.6340425532,
"avg_line_length": 18.0769230769,
"ext": "agda",
"hexsha": "1528a75ff43c67a44eaae7745ecdc7d4a6865ec2",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2018-11-09T22:08:40.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-11-09T22:08:40.000Z",
"max_forks_repo_head_hexsha": "9ad63ea473a958506c041077f1d810c0c7c8c18d",
"max_forks_repo_licenses": [
"Info-ZIP"
],
"max_forks_repo_name": "seanwallawalla-forks/RosettaCodeData",
"max_forks_repo_path": "Task/Ackermann-function/Agda/ackermann-function-1.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "9ad63ea473a958506c041077f1d810c0c7c8c18d",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Info-ZIP"
],
"max_issues_repo_name": "seanwallawalla-forks/RosettaCodeData",
"max_issues_repo_path": "Task/Ackermann-function/Agda/ackermann-function-1.agda",
"max_line_length": 43,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "9ad63ea473a958506c041077f1d810c0c7c8c18d",
"max_stars_repo_licenses": [
"Info-ZIP"
],
"max_stars_repo_name": "LaudateCorpus1/RosettaCodeData",
"max_stars_repo_path": "Task/Ackermann-function/Agda/ackermann-function-1.agda",
"max_stars_repo_stars_event_max_datetime": "2018-11-09T22:08:38.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-11-09T22:08:38.000Z",
"num_tokens": 90,
"size": 235
}
|
{-# OPTIONS --type-in-type #-}
module CS410-Categories where
open import CS410-Prelude
postulate
extensionality : {S : Set}{T : S -> Set}
{f g : (x : S) -> T x} ->
((x : S) -> f x == g x) ->
f == g
imp : {S : Set}{T : S -> Set}(f : (x : S) -> T x){x : S} -> T x
imp f {x} = f x
extensionality' : {S : Set}{T : S -> Set}
{f g : {x : S} -> T x} ->
((x : S) -> f {x} == g {x}) ->
_==_ {forall {x : S} -> T x} f g
extensionality' {f = f}{g = g} q =
refl imp =$= extensionality {f = \ x -> f {x}}{g = \ x -> g {x}}
q
_=$'_ : {S : Set}{T : S -> Set}
{f g : {x : S} -> T x} ->
_==_ {forall {x : S} -> T x} f g ->
(x : S) -> f {x} == g {x}
refl f =$' x = refl (f {x})
infixl 2 _=$'_
record Category : Set where
field
-- two types of thing
Obj : Set -- "objects"
_~>_ : Obj -> Obj -> Set -- "arrows" or "morphisms"
-- or "homomorphisms"
-- two operations
id~> : {T : Obj} -> T ~> T
_>~>_ : {R S T : Obj} -> R ~> S -> S ~> T -> R ~> T
-- three laws
law-id~>>~> : {S T : Obj} (f : S ~> T) ->
(id~> >~> f) == f
law->~>id~> : {S T : Obj} (f : S ~> T) ->
(f >~> id~>) == f
law->~>>~> : {Q R S T : Obj} (f : Q ~> R)(g : R ~> S)(h : S ~> T) ->
((f >~> g) >~> h) == (f >~> (g >~> h))
assocn : {Q R R' S T : Obj}
{f : Q ~> R} {g : R ~> S}
{f' : Q ~> R'}{g' : R' ~> S}
{h : S ~> T} ->
(f >~> g) == (f' >~> g') ->
(f >~> g >~> h) == (f' >~> g' >~> h)
assocn {f = f} {g = g} {f' = f'} {g' = g'} {h = h} q =
f >~> g >~> h
=< law->~>>~> _ _ _ ]=
(f >~> g) >~> h
=[ refl _>~>_ =$= q =$= refl h >=
(f' >~> g') >~> h
=[ law->~>>~> _ _ _ >=
f' >~> g' >~> h
[QED]
infixr 3 _>~>_
-- Sets and functions are the classic example of a category.
SET : Category
SET = record
{ Obj = Set
; _~>_ = \ S T -> S -> T
; id~> = id
; _>~>_ = _>>_
; law-id~>>~> = \ f -> refl f
; law->~>id~> = \ f -> refl f
; law->~>>~> = \ f g h -> refl (f >> (g >> h))
}
module FUNCTOR where
open Category
record _=>_ (C D : Category) : Set where -- "Functor from C to D"
field
-- two actions
F-Obj : Obj C -> Obj D
F-map : {S T : Obj C} -> _~>_ C S T -> _~>_ D (F-Obj S) (F-Obj T)
-- two laws
F-map-id~> : {T : Obj C} -> F-map (id~> C {T}) == id~> D {F-Obj T}
F-map->~> : {R S T : Obj C}(f : _~>_ C R S)(g : _~>_ C S T) ->
F-map (_>~>_ C f g) == _>~>_ D (F-map f) (F-map g)
open FUNCTOR public
ID : {C : Category} -> C => C
ID = record
{ F-Obj = id
; F-map = id
; F-map-id~> = refl _
; F-map->~> = \ f g -> refl _
}
module FUNCTOR-CP {C D E : Category} where
open _=>_
open Category
_>=>_ : C => D -> D => E -> C => E
F-Obj (F >=> G) = F-Obj F >> F-Obj G
F-map (F >=> G) = F-map F >> F-map G
F-map-id~> (F >=> G) =
F-map G (F-map F (id~> C))
=[ refl (F-map G) =$= F-map-id~> F >=
F-map G (id~> D)
=[ F-map-id~> G >=
id~> E
[QED]
F-map->~> (F >=> G) f g =
F-map G (F-map F (_>~>_ C f g))
=[ refl (F-map G) =$= F-map->~> F f g >=
F-map G (_>~>_ D (F-map F f) (F-map F g))
=[ F-map->~> G (F-map F f) (F-map F g) >=
_>~>_ E (F-map G (F-map F f)) (F-map G (F-map F g))
[QED]
open FUNCTOR-CP public
module NATURAL-TRANSFORMATION {C D : Category} where
open Category
open _=>_
record _~~>_ (F G : C => D) : Set where
field
-- one operation
xf : {X : Obj C} -> _~>_ D (F-Obj F X) (F-Obj G X)
-- one law
naturality : {X Y : Obj C}(f : _~>_ C X Y) ->
_>~>_ D (F-map F f) (xf {Y})
==
_>~>_ D (xf {X}) (F-map G f)
open NATURAL-TRANSFORMATION public
open _~~>_ public
module MONAD {C : Category}(M : C => C) where
open Category C
open _=>_ M
record Monad : Set where
field
unit : ID ~~> M
mult : (M >=> M) ~~> M
unitMult : {X : Obj} -> (xf unit >~> xf mult) == id~> {F-Obj X}
multUnit : {X : Obj} -> (F-map (xf unit) >~> xf mult) == id~> {F-Obj X}
multMult : {X : Obj} -> (xf mult >~> xf mult) == (F-map (xf mult) >~> xf mult {X})
KLEISLI : Category
KLEISLI = record
{ Obj = Obj
; _~>_ = \ S T -> S ~> F-Obj T
; id~> = xf unit
; _>~>_ = \ f g -> f >~> F-map g >~> xf mult
; law-id~>>~> = \ f ->
xf unit >~> F-map f >~> xf mult
=< law->~>>~> _ _ _ ]=
(xf unit >~> F-map f) >~> xf mult
=< refl (_>~> xf mult) =$= naturality unit f ]=
(f >~> xf unit) >~> xf mult
=[ law->~>>~> _ _ _ >=
f >~> (xf unit >~> xf mult)
=[ refl (f >~>_) =$= unitMult >=
f >~> id~>
=[ law->~>id~> f >=
f [QED]
; law->~>id~> = \ f ->
f >~> (F-map (xf unit) >~> xf mult)
=[ refl (f >~>_) =$= multUnit >=
f >~> id~>
=[ law->~>id~> f >=
f [QED]
; law->~>>~> = \ f g h ->
(f >~> F-map g >~> xf mult) >~> F-map h >~> xf mult
=[ law->~>>~> _ _ _ >=
f >~> (F-map g >~> xf mult) >~> (F-map h >~> xf mult)
=[ refl (\ x -> _ >~> x) =$= law->~>>~> _ _ _ >=
f >~> F-map g >~> xf mult >~> F-map h >~> xf mult
=< refl (\ x -> _ >~> _ >~> x) =$= assocn (naturality mult _) ]=
f >~> F-map g >~> F-map (F-map h) >~> xf mult >~> xf mult
=[ refl (\ x -> _ >~> _ >~> _ >~> x) =$= multMult >=
f >~> F-map g >~> F-map (F-map h) >~> F-map (xf mult) >~> xf mult
=< refl (\ x -> _ >~> _ >~> x) =$= law->~>>~> _ _ _ ]=
f >~> F-map g >~> (F-map (F-map h) >~> F-map (xf mult)) >~> xf mult
=< refl (\ x -> _ >~> _ >~> x >~> _) =$= F-map->~> _ _ ]=
f >~> F-map g >~> F-map (F-map h >~> xf mult) >~> xf mult
=< refl (\ x -> _ >~> x) =$= law->~>>~> _ _ _ ]=
f >~> (F-map g >~> F-map (F-map h >~> xf mult)) >~> xf mult
=< refl (\ x -> _ >~> x >~> _) =$= F-map->~> _ _ ]=
f >~> F-map (g >~> F-map h >~> xf mult) >~> xf mult
[QED]
}
|
{
"alphanum_fraction": 0.3538865709,
"avg_line_length": 30.8142857143,
"ext": "agda",
"hexsha": "a3b6697de9c19e232b0b3ee1ed0e37dffb8d98c4",
"lang": "Agda",
"max_forks_count": 8,
"max_forks_repo_forks_event_max_datetime": "2021-09-21T15:58:10.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-04-13T21:40:15.000Z",
"max_forks_repo_head_hexsha": "5db8e95bbcbe8dc0eec810f3e73130ecd78d207c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "m-schmidt/CS410-17-Exercises",
"max_forks_repo_path": "CS410-Categories.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "5db8e95bbcbe8dc0eec810f3e73130ecd78d207c",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "m-schmidt/CS410-17-Exercises",
"max_issues_repo_path": "CS410-Categories.agda",
"max_line_length": 88,
"max_stars_count": 36,
"max_stars_repo_head_hexsha": "5db8e95bbcbe8dc0eec810f3e73130ecd78d207c",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "m-schmidt/CS410-17-Exercises",
"max_stars_repo_path": "CS410-Categories.agda",
"max_stars_repo_stars_event_max_datetime": "2021-07-30T06:55:03.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-29T14:37:15.000Z",
"num_tokens": 2571,
"size": 6471
}
|
{-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.Pair {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped as U hiding (wk)
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.Weakening as T hiding (wk; wkTerm; wkEqTerm)
open import Definition.Typed.RedSteps
open import Definition.LogicalRelation
open import Definition.LogicalRelation.ShapeView
open import Definition.LogicalRelation.Irrelevance
open import Definition.LogicalRelation.Weakening
open import Definition.LogicalRelation.Properties
open import Definition.LogicalRelation.Application
open import Definition.LogicalRelation.Substitution
open import Definition.LogicalRelation.Substitution.Properties
open import Definition.LogicalRelation.Substitution.Reflexivity
open import Definition.LogicalRelation.Substitution.Introductions.Sigma
open import Definition.LogicalRelation.Substitution.Introductions.Pi
open import Definition.LogicalRelation.Substitution.Introductions.SingleSubst
open import Tools.Product
import Tools.PropositionalEquality as PE
-- Valid pair construction.
⦅⦆ᵛ : ∀ {F G l∃ t u Γ l}
([Γ] : ⊩ᵛ Γ)
([F] : Γ ⊩ᵛ⟨ l ⟩ F ^ [ % , ι l∃ ] / [Γ])
([G] : Γ ∙ F ^ [ % , ι l∃ ] ⊩ᵛ⟨ l ⟩ G ^ [ % , ι l∃ ] / [Γ] ∙ [F])
([t] : Γ ⊩ᵛ⟨ l ⟩ t ∷ F ^ [ % , ι l∃ ] / [Γ] / [F])
([u] : Γ ⊩ᵛ⟨ l ⟩ u ∷ G [ t ] ^ [ % , ι l∃ ] / [Γ] / substS {F} {G} {t} [Γ] [F] [G] [t])
→ Γ ⊩ᵛ⟨ l ⟩ ⦅ G , t , u ⦆ ∷ ∃ F ▹ G ^ [ % , ι l∃ ] / [Γ] / ∃ᵛ {F} {G} [Γ] [F] [G]
⦅⦆ᵛ {F} {G} {l∃} {t} {u} {Γ} {l} [Γ] [F] [G] [t] [u] {Δ = Δ} {σ = σ} ⊢Δ [σ] =
let [G[t]] = substS {F} {G} {t} [Γ] [F] [G] [t]
[ΠFG] = Πᵛ {F = F} {G = G} (≡is≤ PE.refl) (≡is≤ PE.refl) [Γ] [F] [G]
[σF] = proj₁ ([F] ⊢Δ [σ])
⊢F = escape [σF]
[σG] = proj₁ ([G] (⊢Δ ∙ ⊢F) (liftSubstS {F = F} [Γ] ⊢Δ [F] [σ]))
⊢G = escape [σG]
[σt] = proj₁ ([t] (⊢Δ) [σ])
⊢t = escapeTerm [σF] [σt]
[σu] = proj₁ ([u] (⊢Δ) [σ])
[σG[t]] = proj₁ ([G[t]] ⊢Δ [σ])
[σΠFG] = proj₁ ([ΠFG] ⊢Δ [σ])
[σG[t]]′ = irrelevance′ (singleSubstLift G t) [σG[t]]
[σu]′ = irrelevanceTerm′ (singleSubstLift G t) PE.refl PE.refl [σG[t]] [σG[t]]′ [σu]
⊢u = escapeTerm [σG[t]]′ [σu]′
⦅t,u⦆ⱼ = ⦅_,_,_,_⦆ⱼ {F = subst σ F} {G = subst (liftSubst σ) G} {t = subst σ t} {u = subst σ u}
⊢F ⊢G ⊢t ⊢u
in ⦅t,u⦆ⱼ , λ {σ′} [σ′] [σ≡σ′] →
⦅t,u⦆ⱼ ,
let ⊢Γ = wfTerm ⊢t
[σt′] = proj₁ ([t] ⊢Δ [σ′])
[σt≡σt′] = proj₂ ([t] ⊢Δ [σ]) [σ′] [σ≡σ′]
[σF′] = proj₁ ([F] ⊢Δ [σ′])
⊢F′ = escape [σF′]
⊢t′ = escapeTerm [σF′] [σt′]
[σG′] = proj₁ ([G] {σ = liftSubst σ′} (⊢Δ ∙ ⊢F′) (liftSubstS {F = F} [Γ] ⊢Δ [F] [σ′]))
⊢G′ = escape [σG′]
_ , Πᵣ _ _ _ _ _ F′ G′ D′ _ _ A≡A′ [F]₁ [G]₁ G-ext =
extractMaybeEmb (Π-elim (proj₁ ([ΠFG] ⊢Δ [σ′])))
[σ′u] = proj₁ ([u] ⊢Δ [σ′])
[σ′G[t]] = proj₁ ([G[t]] ⊢Δ [σ′])
[σ′G[t]]′ = irrelevance′ (singleSubstLift G t) [σ′G[t]]
[σ′u]′ = irrelevanceTerm′ (singleSubstLift G t) PE.refl PE.refl [σ′G[t]] [σ′G[t]]′ [σ′u]
⊢u′ = escapeTerm [σ′G[t]]′ [σ′u]′
pair' = ⦅_,_,_,_⦆ⱼ {F = subst σ′ F} {G = subst (liftSubst σ′) G} {t = subst σ′ t}
{u = subst σ′ u} ⊢F′ ⊢G′ ⊢t′ ⊢u′
[σ′≡σ] = symS [Γ] ⊢Δ [σ] [σ′] [σ≡σ′]
[σF′≡σF] = proj₂ ([F] ⊢Δ [σ′]) [σ] [σ′≡σ]
σF′≡σF = escapeEq [σF′] [σF′≡σF]
[liftσ] = liftSubstS {F = F} [Γ] ⊢Δ [F] [σ]
[wk1σ′] = wk1SubstS [Γ] ⊢Δ ⊢F′ [σ′]
[wk1σ] = wk1SubstS [Γ] ⊢Δ ⊢F′ [σ]
foo = proj₁ ([F] (⊢Δ ∙ ⊢F′) [wk1σ′])
[liftσ′] : (Δ ∙ subst σ′ F ^ [ % , ι l∃ ]) ⊩ˢ liftSubst σ ∷
Γ ∙ F ^ [ % , ι l∃ ] / [Γ] ∙ [F] / (⊢Δ ∙ escape (proj₁ ([F] ⊢Δ [σ′])))
[liftσ′] = let ⊢F = escape (proj₁ ([F] ⊢Δ [σ]))
[tailσ] = wk1SubstS {F = subst σ′ F} [Γ] ⊢Δ (escape (proj₁ ([F] ⊢Δ [σ′]))) [σ]
var0′ : (Δ ∙ subst σ′ F ^ [ % , ι l∃ ]) ⊢ var 0 ∷ subst (wk1Subst σ′) F ^ [ % , ι l∃ ]
var0′ = var (⊢Δ ∙ ⊢F′) (PE.subst (λ x → 0 ∷ x ^ _ ∈ (Δ ∙ subst σ′ F ^ _))
(wk-subst F) here)
var0 = conv var0′ (≅-eq (escapeEq (proj₁ ([F] (⊢Δ ∙ ⊢F′) [wk1σ′])) (proj₂ ([F] (⊢Δ ∙ ⊢F′) [wk1σ′]) [wk1σ]
(wk1SubstSEq [Γ] ⊢Δ ⊢F′ [σ′] [σ′≡σ]))))
in [tailσ] , neuTerm (proj₁ ([F] (⊢Δ ∙ ⊢F′) [tailσ])) (var 0)
var0 (~-var var0)
[σG′≡σG] = proj₂ ([G] (⊢Δ ∙ ⊢F′) (liftSubstS {F = F} [Γ] ⊢Δ [F] [σ′] )) [liftσ′]
(liftSubstSEq {F = F} [Γ] ⊢Δ [F] [σ′] (symS [Γ] ⊢Δ [σ] [σ′] [σ≡σ′]))
σG′≡σG = escapeEq [σG′] [σG′≡σG]
in conv pair' (univ (∃-cong ⊢F′ (un-univ≡ (≅-eq σF′≡σF)) (un-univ≡ (≅-eq σG′≡σG))) )
|
{
"alphanum_fraction": 0.4454426352,
"avg_line_length": 55.65625,
"ext": "agda",
"hexsha": "d4a52fac6899dc1fbee798bc3ed7bb782cc8702c",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2022-02-15T19:42:19.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-01-26T14:55:51.000Z",
"max_forks_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "CoqHott/logrel-mltt",
"max_forks_repo_path": "Definition/LogicalRelation/Substitution/Introductions/Pair.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "CoqHott/logrel-mltt",
"max_issues_repo_path": "Definition/LogicalRelation/Substitution/Introductions/Pair.agda",
"max_line_length": 138,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "CoqHott/logrel-mltt",
"max_stars_repo_path": "Definition/LogicalRelation/Substitution/Introductions/Pair.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-17T16:13:53.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-06-21T08:39:01.000Z",
"num_tokens": 2347,
"size": 5343
}
|
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Lift
open import lib.types.Paths
open import lib.types.Pointed
module lib.types.Unit where
tt = unit
⊙Unit : Ptd₀
⊙Unit = ⊙[ Unit , unit ]
abstract
-- Unit is contractible
Unit-is-contr : is-contr Unit
Unit-is-contr = (unit , λ y → idp)
Unit-has-level : {n : ℕ₋₂} → has-level n Unit
Unit-has-level = contr-has-level Unit-is-contr
-- [Unit-has-level#instance] produces unsolved metas
Unit-has-level-S#instance : {n : ℕ₋₂} → has-level (S n) Unit
Unit-has-level-S#instance = contr-has-level Unit-is-contr
Unit-is-prop : is-prop Unit
Unit-is-prop = Unit-has-level
Unit-is-set : is-set Unit
Unit-is-set = Unit-has-level
Unit-level = Unit-is-contr
⊤-is-contr = Unit-is-contr
⊤-level = Unit-is-contr
⊤-has-level = Unit-has-level
⊤-is-prop = Unit-is-prop
⊤-is-set = Unit-is-set
LiftUnit-⊙in-level : ∀ {i j} {X : Ptd i}
→ is-contr (fst (X ⊙→ ⊙Lift {j = j} ⊙Unit))
LiftUnit-⊙in-level {X = X} =
(⊙cst {X = X} ,
λ f → pair= idp
(prop-has-all-paths ((Lift-level Unit-is-set) _ _) idp (snd f)))
LiftUnit-⊙out-level : ∀ {i j} {X : Ptd i}
→ is-contr (fst (⊙Lift {j = j} ⊙Unit ⊙→ X))
LiftUnit-⊙out-level {X = X} =
(⊙cst {Y = X} ,
λ f → ⊙λ= (λ _ → ! (snd f)) (! (!-inv-l (snd f))))
|
{
"alphanum_fraction": 0.6117103236,
"avg_line_length": 24.9615384615,
"ext": "agda",
"hexsha": "d9e6603205b4e0194188afd4d29df9ad0aa4610e",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "bc849346a17b33e2679a5b3f2b8efbe7835dc4b6",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cmknapp/HoTT-Agda",
"max_forks_repo_path": "core/lib/types/Unit.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "bc849346a17b33e2679a5b3f2b8efbe7835dc4b6",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cmknapp/HoTT-Agda",
"max_issues_repo_path": "core/lib/types/Unit.agda",
"max_line_length": 75,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "bc849346a17b33e2679a5b3f2b8efbe7835dc4b6",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cmknapp/HoTT-Agda",
"max_stars_repo_path": "core/lib/types/Unit.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 496,
"size": 1298
}
|
module _ where
-- Should not be able to give by name
id : {_ = A : Set} → A → A
id x = x
works : (X : Set) → X → X
works X = id {X}
fails : (X : Set) → X → X
fails X = id {A = X}
|
{
"alphanum_fraction": 0.5081967213,
"avg_line_length": 14.0769230769,
"ext": "agda",
"hexsha": "dcf58ec8c796fc35403e8bd6ff989282b3d03938",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Fail/Issue952-unnamed.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Fail/Issue952-unnamed.agda",
"max_line_length": 37,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Fail/Issue952-unnamed.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 73,
"size": 183
}
|
module Text.Greek.SBLGNT.2Pet where
open import Data.List
open import Text.Greek.Bible
open import Text.Greek.Script
open import Text.Greek.Script.Unicode
ΠΕΤΡΟΥ-Β : List (Word)
ΠΕΤΡΟΥ-Β =
word (Σ ∷ υ ∷ μ ∷ ε ∷ ὼ ∷ ν ∷ []) "2Pet.1.1"
∷ word (Π ∷ έ ∷ τ ∷ ρ ∷ ο ∷ ς ∷ []) "2Pet.1.1"
∷ word (δ ∷ ο ∷ ῦ ∷ ∙λ ∷ ο ∷ ς ∷ []) "2Pet.1.1"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.1"
∷ word (ἀ ∷ π ∷ ό ∷ σ ∷ τ ∷ ο ∷ ∙λ ∷ ο ∷ ς ∷ []) "2Pet.1.1"
∷ word (Ἰ ∷ η ∷ σ ∷ ο ∷ ῦ ∷ []) "2Pet.1.1"
∷ word (Χ ∷ ρ ∷ ι ∷ σ ∷ τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.1"
∷ word (τ ∷ ο ∷ ῖ ∷ ς ∷ []) "2Pet.1.1"
∷ word (ἰ ∷ σ ∷ ό ∷ τ ∷ ι ∷ μ ∷ ο ∷ ν ∷ []) "2Pet.1.1"
∷ word (ἡ ∷ μ ∷ ῖ ∷ ν ∷ []) "2Pet.1.1"
∷ word (∙λ ∷ α ∷ χ ∷ ο ∷ ῦ ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.1.1"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "2Pet.1.1"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.1"
∷ word (δ ∷ ι ∷ κ ∷ α ∷ ι ∷ ο ∷ σ ∷ ύ ∷ ν ∷ ῃ ∷ []) "2Pet.1.1"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.1"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "2Pet.1.1"
∷ word (ἡ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.1.1"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.1"
∷ word (σ ∷ ω ∷ τ ∷ ῆ ∷ ρ ∷ ο ∷ ς ∷ []) "2Pet.1.1"
∷ word (Ἰ ∷ η ∷ σ ∷ ο ∷ ῦ ∷ []) "2Pet.1.1"
∷ word (Χ ∷ ρ ∷ ι ∷ σ ∷ τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.1"
∷ word (χ ∷ ά ∷ ρ ∷ ι ∷ ς ∷ []) "2Pet.1.2"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "2Pet.1.2"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.2"
∷ word (ε ∷ ἰ ∷ ρ ∷ ή ∷ ν ∷ η ∷ []) "2Pet.1.2"
∷ word (π ∷ ∙λ ∷ η ∷ θ ∷ υ ∷ ν ∷ θ ∷ ε ∷ ί ∷ η ∷ []) "2Pet.1.2"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.2"
∷ word (ἐ ∷ π ∷ ι ∷ γ ∷ ν ∷ ώ ∷ σ ∷ ε ∷ ι ∷ []) "2Pet.1.2"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.2"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "2Pet.1.2"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.2"
∷ word (Ἰ ∷ η ∷ σ ∷ ο ∷ ῦ ∷ []) "2Pet.1.2"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.2"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "2Pet.1.2"
∷ word (ἡ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.1.2"
∷ word (Ὡ ∷ ς ∷ []) "2Pet.1.3"
∷ word (π ∷ ά ∷ ν ∷ τ ∷ α ∷ []) "2Pet.1.3"
∷ word (ἡ ∷ μ ∷ ῖ ∷ ν ∷ []) "2Pet.1.3"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.1.3"
∷ word (θ ∷ ε ∷ ί ∷ α ∷ ς ∷ []) "2Pet.1.3"
∷ word (δ ∷ υ ∷ ν ∷ ά ∷ μ ∷ ε ∷ ω ∷ ς ∷ []) "2Pet.1.3"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.3"
∷ word (τ ∷ ὰ ∷ []) "2Pet.1.3"
∷ word (π ∷ ρ ∷ ὸ ∷ ς ∷ []) "2Pet.1.3"
∷ word (ζ ∷ ω ∷ ὴ ∷ ν ∷ []) "2Pet.1.3"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.3"
∷ word (ε ∷ ὐ ∷ σ ∷ έ ∷ β ∷ ε ∷ ι ∷ α ∷ ν ∷ []) "2Pet.1.3"
∷ word (δ ∷ ε ∷ δ ∷ ω ∷ ρ ∷ η ∷ μ ∷ έ ∷ ν ∷ η ∷ ς ∷ []) "2Pet.1.3"
∷ word (δ ∷ ι ∷ ὰ ∷ []) "2Pet.1.3"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.1.3"
∷ word (ἐ ∷ π ∷ ι ∷ γ ∷ ν ∷ ώ ∷ σ ∷ ε ∷ ω ∷ ς ∷ []) "2Pet.1.3"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.3"
∷ word (κ ∷ α ∷ ∙λ ∷ έ ∷ σ ∷ α ∷ ν ∷ τ ∷ ο ∷ ς ∷ []) "2Pet.1.3"
∷ word (ἡ ∷ μ ∷ ᾶ ∷ ς ∷ []) "2Pet.1.3"
∷ word (ἰ ∷ δ ∷ ί ∷ ᾳ ∷ []) "2Pet.1.3"
∷ word (δ ∷ ό ∷ ξ ∷ ῃ ∷ []) "2Pet.1.3"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.3"
∷ word (ἀ ∷ ρ ∷ ε ∷ τ ∷ ῇ ∷ []) "2Pet.1.3"
∷ word (δ ∷ ι ∷ []) "2Pet.1.4"
∷ word (ὧ ∷ ν ∷ []) "2Pet.1.4"
∷ word (τ ∷ ὰ ∷ []) "2Pet.1.4"
∷ word (τ ∷ ί ∷ μ ∷ ι ∷ α ∷ []) "2Pet.1.4"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.4"
∷ word (μ ∷ έ ∷ γ ∷ ι ∷ σ ∷ τ ∷ α ∷ []) "2Pet.1.4"
∷ word (ἡ ∷ μ ∷ ῖ ∷ ν ∷ []) "2Pet.1.4"
∷ word (ἐ ∷ π ∷ α ∷ γ ∷ γ ∷ έ ∷ ∙λ ∷ μ ∷ α ∷ τ ∷ α ∷ []) "2Pet.1.4"
∷ word (δ ∷ ε ∷ δ ∷ ώ ∷ ρ ∷ η ∷ τ ∷ α ∷ ι ∷ []) "2Pet.1.4"
∷ word (ἵ ∷ ν ∷ α ∷ []) "2Pet.1.4"
∷ word (δ ∷ ι ∷ ὰ ∷ []) "2Pet.1.4"
∷ word (τ ∷ ο ∷ ύ ∷ τ ∷ ω ∷ ν ∷ []) "2Pet.1.4"
∷ word (γ ∷ έ ∷ ν ∷ η ∷ σ ∷ θ ∷ ε ∷ []) "2Pet.1.4"
∷ word (θ ∷ ε ∷ ί ∷ α ∷ ς ∷ []) "2Pet.1.4"
∷ word (κ ∷ ο ∷ ι ∷ ν ∷ ω ∷ ν ∷ ο ∷ ὶ ∷ []) "2Pet.1.4"
∷ word (φ ∷ ύ ∷ σ ∷ ε ∷ ω ∷ ς ∷ []) "2Pet.1.4"
∷ word (ἀ ∷ π ∷ ο ∷ φ ∷ υ ∷ γ ∷ ό ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.1.4"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.1.4"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.4"
∷ word (τ ∷ ῷ ∷ []) "2Pet.1.4"
∷ word (κ ∷ ό ∷ σ ∷ μ ∷ ῳ ∷ []) "2Pet.1.4"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.4"
∷ word (ἐ ∷ π ∷ ι ∷ θ ∷ υ ∷ μ ∷ ί ∷ ᾳ ∷ []) "2Pet.1.4"
∷ word (φ ∷ θ ∷ ο ∷ ρ ∷ ᾶ ∷ ς ∷ []) "2Pet.1.4"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.5"
∷ word (α ∷ ὐ ∷ τ ∷ ὸ ∷ []) "2Pet.1.5"
∷ word (τ ∷ ο ∷ ῦ ∷ τ ∷ ο ∷ []) "2Pet.1.5"
∷ word (δ ∷ ὲ ∷ []) "2Pet.1.5"
∷ word (σ ∷ π ∷ ο ∷ υ ∷ δ ∷ ὴ ∷ ν ∷ []) "2Pet.1.5"
∷ word (π ∷ ᾶ ∷ σ ∷ α ∷ ν ∷ []) "2Pet.1.5"
∷ word (π ∷ α ∷ ρ ∷ ε ∷ ι ∷ σ ∷ ε ∷ ν ∷ έ ∷ γ ∷ κ ∷ α ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.1.5"
∷ word (ἐ ∷ π ∷ ι ∷ χ ∷ ο ∷ ρ ∷ η ∷ γ ∷ ή ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "2Pet.1.5"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.5"
∷ word (τ ∷ ῇ ∷ []) "2Pet.1.5"
∷ word (π ∷ ί ∷ σ ∷ τ ∷ ε ∷ ι ∷ []) "2Pet.1.5"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.1.5"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.5"
∷ word (ἀ ∷ ρ ∷ ε ∷ τ ∷ ή ∷ ν ∷ []) "2Pet.1.5"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.5"
∷ word (δ ∷ ὲ ∷ []) "2Pet.1.5"
∷ word (τ ∷ ῇ ∷ []) "2Pet.1.5"
∷ word (ἀ ∷ ρ ∷ ε ∷ τ ∷ ῇ ∷ []) "2Pet.1.5"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.5"
∷ word (γ ∷ ν ∷ ῶ ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.1.5"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.6"
∷ word (δ ∷ ὲ ∷ []) "2Pet.1.6"
∷ word (τ ∷ ῇ ∷ []) "2Pet.1.6"
∷ word (γ ∷ ν ∷ ώ ∷ σ ∷ ε ∷ ι ∷ []) "2Pet.1.6"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.6"
∷ word (ἐ ∷ γ ∷ κ ∷ ρ ∷ ά ∷ τ ∷ ε ∷ ι ∷ α ∷ ν ∷ []) "2Pet.1.6"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.6"
∷ word (δ ∷ ὲ ∷ []) "2Pet.1.6"
∷ word (τ ∷ ῇ ∷ []) "2Pet.1.6"
∷ word (ἐ ∷ γ ∷ κ ∷ ρ ∷ α ∷ τ ∷ ε ∷ ί ∷ ᾳ ∷ []) "2Pet.1.6"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.6"
∷ word (ὑ ∷ π ∷ ο ∷ μ ∷ ο ∷ ν ∷ ή ∷ ν ∷ []) "2Pet.1.6"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.6"
∷ word (δ ∷ ὲ ∷ []) "2Pet.1.6"
∷ word (τ ∷ ῇ ∷ []) "2Pet.1.6"
∷ word (ὑ ∷ π ∷ ο ∷ μ ∷ ο ∷ ν ∷ ῇ ∷ []) "2Pet.1.6"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.6"
∷ word (ε ∷ ὐ ∷ σ ∷ έ ∷ β ∷ ε ∷ ι ∷ α ∷ ν ∷ []) "2Pet.1.6"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.7"
∷ word (δ ∷ ὲ ∷ []) "2Pet.1.7"
∷ word (τ ∷ ῇ ∷ []) "2Pet.1.7"
∷ word (ε ∷ ὐ ∷ σ ∷ ε ∷ β ∷ ε ∷ ί ∷ ᾳ ∷ []) "2Pet.1.7"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.7"
∷ word (φ ∷ ι ∷ ∙λ ∷ α ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ί ∷ α ∷ ν ∷ []) "2Pet.1.7"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.7"
∷ word (δ ∷ ὲ ∷ []) "2Pet.1.7"
∷ word (τ ∷ ῇ ∷ []) "2Pet.1.7"
∷ word (φ ∷ ι ∷ ∙λ ∷ α ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ί ∷ ᾳ ∷ []) "2Pet.1.7"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.7"
∷ word (ἀ ∷ γ ∷ ά ∷ π ∷ η ∷ ν ∷ []) "2Pet.1.7"
∷ word (τ ∷ α ∷ ῦ ∷ τ ∷ α ∷ []) "2Pet.1.8"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.1.8"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "2Pet.1.8"
∷ word (ὑ ∷ π ∷ ά ∷ ρ ∷ χ ∷ ο ∷ ν ∷ τ ∷ α ∷ []) "2Pet.1.8"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.8"
∷ word (π ∷ ∙λ ∷ ε ∷ ο ∷ ν ∷ ά ∷ ζ ∷ ο ∷ ν ∷ τ ∷ α ∷ []) "2Pet.1.8"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "2Pet.1.8"
∷ word (ἀ ∷ ρ ∷ γ ∷ ο ∷ ὺ ∷ ς ∷ []) "2Pet.1.8"
∷ word (ο ∷ ὐ ∷ δ ∷ ὲ ∷ []) "2Pet.1.8"
∷ word (ἀ ∷ κ ∷ ά ∷ ρ ∷ π ∷ ο ∷ υ ∷ ς ∷ []) "2Pet.1.8"
∷ word (κ ∷ α ∷ θ ∷ ί ∷ σ ∷ τ ∷ η ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.1.8"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "2Pet.1.8"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.8"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.8"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "2Pet.1.8"
∷ word (ἡ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.1.8"
∷ word (Ἰ ∷ η ∷ σ ∷ ο ∷ ῦ ∷ []) "2Pet.1.8"
∷ word (Χ ∷ ρ ∷ ι ∷ σ ∷ τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.8"
∷ word (ἐ ∷ π ∷ ί ∷ γ ∷ ν ∷ ω ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.1.8"
∷ word (ᾧ ∷ []) "2Pet.1.9"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.1.9"
∷ word (μ ∷ ὴ ∷ []) "2Pet.1.9"
∷ word (π ∷ ά ∷ ρ ∷ ε ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "2Pet.1.9"
∷ word (τ ∷ α ∷ ῦ ∷ τ ∷ α ∷ []) "2Pet.1.9"
∷ word (τ ∷ υ ∷ φ ∷ ∙λ ∷ ό ∷ ς ∷ []) "2Pet.1.9"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "2Pet.1.9"
∷ word (μ ∷ υ ∷ ω ∷ π ∷ ά ∷ ζ ∷ ω ∷ ν ∷ []) "2Pet.1.9"
∷ word (∙λ ∷ ή ∷ θ ∷ η ∷ ν ∷ []) "2Pet.1.9"
∷ word (∙λ ∷ α ∷ β ∷ ὼ ∷ ν ∷ []) "2Pet.1.9"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.9"
∷ word (κ ∷ α ∷ θ ∷ α ∷ ρ ∷ ι ∷ σ ∷ μ ∷ ο ∷ ῦ ∷ []) "2Pet.1.9"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "2Pet.1.9"
∷ word (π ∷ ά ∷ ∙λ ∷ α ∷ ι ∷ []) "2Pet.1.9"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.9"
∷ word (ἁ ∷ μ ∷ α ∷ ρ ∷ τ ∷ η ∷ μ ∷ ά ∷ τ ∷ ω ∷ ν ∷ []) "2Pet.1.9"
∷ word (δ ∷ ι ∷ ὸ ∷ []) "2Pet.1.10"
∷ word (μ ∷ ᾶ ∷ ∙λ ∷ ∙λ ∷ ο ∷ ν ∷ []) "2Pet.1.10"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ο ∷ ί ∷ []) "2Pet.1.10"
∷ word (σ ∷ π ∷ ο ∷ υ ∷ δ ∷ ά ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "2Pet.1.10"
∷ word (β ∷ ε ∷ β ∷ α ∷ ί ∷ α ∷ ν ∷ []) "2Pet.1.10"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.1.10"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.10"
∷ word (κ ∷ ∙λ ∷ ῆ ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.1.10"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.10"
∷ word (ἐ ∷ κ ∷ ∙λ ∷ ο ∷ γ ∷ ὴ ∷ ν ∷ []) "2Pet.1.10"
∷ word (π ∷ ο ∷ ι ∷ ε ∷ ῖ ∷ σ ∷ θ ∷ α ∷ ι ∷ []) "2Pet.1.10"
∷ word (τ ∷ α ∷ ῦ ∷ τ ∷ α ∷ []) "2Pet.1.10"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.1.10"
∷ word (π ∷ ο ∷ ι ∷ ο ∷ ῦ ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.1.10"
∷ word (ο ∷ ὐ ∷ []) "2Pet.1.10"
∷ word (μ ∷ ὴ ∷ []) "2Pet.1.10"
∷ word (π ∷ τ ∷ α ∷ ί ∷ σ ∷ η ∷ τ ∷ έ ∷ []) "2Pet.1.10"
∷ word (π ∷ ο ∷ τ ∷ ε ∷ []) "2Pet.1.10"
∷ word (ο ∷ ὕ ∷ τ ∷ ω ∷ ς ∷ []) "2Pet.1.11"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.1.11"
∷ word (π ∷ ∙λ ∷ ο ∷ υ ∷ σ ∷ ί ∷ ω ∷ ς ∷ []) "2Pet.1.11"
∷ word (ἐ ∷ π ∷ ι ∷ χ ∷ ο ∷ ρ ∷ η ∷ γ ∷ η ∷ θ ∷ ή ∷ σ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "2Pet.1.11"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "2Pet.1.11"
∷ word (ἡ ∷ []) "2Pet.1.11"
∷ word (ε ∷ ἴ ∷ σ ∷ ο ∷ δ ∷ ο ∷ ς ∷ []) "2Pet.1.11"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "2Pet.1.11"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.11"
∷ word (α ∷ ἰ ∷ ώ ∷ ν ∷ ι ∷ ο ∷ ν ∷ []) "2Pet.1.11"
∷ word (β ∷ α ∷ σ ∷ ι ∷ ∙λ ∷ ε ∷ ί ∷ α ∷ ν ∷ []) "2Pet.1.11"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.11"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "2Pet.1.11"
∷ word (ἡ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.1.11"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.11"
∷ word (σ ∷ ω ∷ τ ∷ ῆ ∷ ρ ∷ ο ∷ ς ∷ []) "2Pet.1.11"
∷ word (Ἰ ∷ η ∷ σ ∷ ο ∷ ῦ ∷ []) "2Pet.1.11"
∷ word (Χ ∷ ρ ∷ ι ∷ σ ∷ τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.11"
∷ word (Δ ∷ ι ∷ ὸ ∷ []) "2Pet.1.12"
∷ word (μ ∷ ε ∷ ∙λ ∷ ∙λ ∷ ή ∷ σ ∷ ω ∷ []) "2Pet.1.12"
∷ word (ἀ ∷ ε ∷ ὶ ∷ []) "2Pet.1.12"
∷ word (ὑ ∷ μ ∷ ᾶ ∷ ς ∷ []) "2Pet.1.12"
∷ word (ὑ ∷ π ∷ ο ∷ μ ∷ ι ∷ μ ∷ ν ∷ ῄ ∷ σ ∷ κ ∷ ε ∷ ι ∷ ν ∷ []) "2Pet.1.12"
∷ word (π ∷ ε ∷ ρ ∷ ὶ ∷ []) "2Pet.1.12"
∷ word (τ ∷ ο ∷ ύ ∷ τ ∷ ω ∷ ν ∷ []) "2Pet.1.12"
∷ word (κ ∷ α ∷ ί ∷ π ∷ ε ∷ ρ ∷ []) "2Pet.1.12"
∷ word (ε ∷ ἰ ∷ δ ∷ ό ∷ τ ∷ α ∷ ς ∷ []) "2Pet.1.12"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.12"
∷ word (ἐ ∷ σ ∷ τ ∷ η ∷ ρ ∷ ι ∷ γ ∷ μ ∷ έ ∷ ν ∷ ο ∷ υ ∷ ς ∷ []) "2Pet.1.12"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.12"
∷ word (τ ∷ ῇ ∷ []) "2Pet.1.12"
∷ word (π ∷ α ∷ ρ ∷ ο ∷ ύ ∷ σ ∷ ῃ ∷ []) "2Pet.1.12"
∷ word (ἀ ∷ ∙λ ∷ η ∷ θ ∷ ε ∷ ί ∷ ᾳ ∷ []) "2Pet.1.12"
∷ word (δ ∷ ί ∷ κ ∷ α ∷ ι ∷ ο ∷ ν ∷ []) "2Pet.1.13"
∷ word (δ ∷ ὲ ∷ []) "2Pet.1.13"
∷ word (ἡ ∷ γ ∷ ο ∷ ῦ ∷ μ ∷ α ∷ ι ∷ []) "2Pet.1.13"
∷ word (ἐ ∷ φ ∷ []) "2Pet.1.13"
∷ word (ὅ ∷ σ ∷ ο ∷ ν ∷ []) "2Pet.1.13"
∷ word (ε ∷ ἰ ∷ μ ∷ ὶ ∷ []) "2Pet.1.13"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.13"
∷ word (τ ∷ ο ∷ ύ ∷ τ ∷ ῳ ∷ []) "2Pet.1.13"
∷ word (τ ∷ ῷ ∷ []) "2Pet.1.13"
∷ word (σ ∷ κ ∷ η ∷ ν ∷ ώ ∷ μ ∷ α ∷ τ ∷ ι ∷ []) "2Pet.1.13"
∷ word (δ ∷ ι ∷ ε ∷ γ ∷ ε ∷ ί ∷ ρ ∷ ε ∷ ι ∷ ν ∷ []) "2Pet.1.13"
∷ word (ὑ ∷ μ ∷ ᾶ ∷ ς ∷ []) "2Pet.1.13"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.13"
∷ word (ὑ ∷ π ∷ ο ∷ μ ∷ ν ∷ ή ∷ σ ∷ ε ∷ ι ∷ []) "2Pet.1.13"
∷ word (ε ∷ ἰ ∷ δ ∷ ὼ ∷ ς ∷ []) "2Pet.1.14"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "2Pet.1.14"
∷ word (τ ∷ α ∷ χ ∷ ι ∷ ν ∷ ή ∷ []) "2Pet.1.14"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "2Pet.1.14"
∷ word (ἡ ∷ []) "2Pet.1.14"
∷ word (ἀ ∷ π ∷ ό ∷ θ ∷ ε ∷ σ ∷ ι ∷ ς ∷ []) "2Pet.1.14"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.14"
∷ word (σ ∷ κ ∷ η ∷ ν ∷ ώ ∷ μ ∷ α ∷ τ ∷ ό ∷ ς ∷ []) "2Pet.1.14"
∷ word (μ ∷ ο ∷ υ ∷ []) "2Pet.1.14"
∷ word (κ ∷ α ∷ θ ∷ ὼ ∷ ς ∷ []) "2Pet.1.14"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.14"
∷ word (ὁ ∷ []) "2Pet.1.14"
∷ word (κ ∷ ύ ∷ ρ ∷ ι ∷ ο ∷ ς ∷ []) "2Pet.1.14"
∷ word (ἡ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.1.14"
∷ word (Ἰ ∷ η ∷ σ ∷ ο ∷ ῦ ∷ ς ∷ []) "2Pet.1.14"
∷ word (Χ ∷ ρ ∷ ι ∷ σ ∷ τ ∷ ὸ ∷ ς ∷ []) "2Pet.1.14"
∷ word (ἐ ∷ δ ∷ ή ∷ ∙λ ∷ ω ∷ σ ∷ έ ∷ ν ∷ []) "2Pet.1.14"
∷ word (μ ∷ ο ∷ ι ∷ []) "2Pet.1.14"
∷ word (σ ∷ π ∷ ο ∷ υ ∷ δ ∷ ά ∷ σ ∷ ω ∷ []) "2Pet.1.15"
∷ word (δ ∷ ὲ ∷ []) "2Pet.1.15"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.15"
∷ word (ἑ ∷ κ ∷ ά ∷ σ ∷ τ ∷ ο ∷ τ ∷ ε ∷ []) "2Pet.1.15"
∷ word (ἔ ∷ χ ∷ ε ∷ ι ∷ ν ∷ []) "2Pet.1.15"
∷ word (ὑ ∷ μ ∷ ᾶ ∷ ς ∷ []) "2Pet.1.15"
∷ word (μ ∷ ε ∷ τ ∷ ὰ ∷ []) "2Pet.1.15"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.15"
∷ word (ἐ ∷ μ ∷ ὴ ∷ ν ∷ []) "2Pet.1.15"
∷ word (ἔ ∷ ξ ∷ ο ∷ δ ∷ ο ∷ ν ∷ []) "2Pet.1.15"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.15"
∷ word (τ ∷ ο ∷ ύ ∷ τ ∷ ω ∷ ν ∷ []) "2Pet.1.15"
∷ word (μ ∷ ν ∷ ή ∷ μ ∷ η ∷ ν ∷ []) "2Pet.1.15"
∷ word (π ∷ ο ∷ ι ∷ ε ∷ ῖ ∷ σ ∷ θ ∷ α ∷ ι ∷ []) "2Pet.1.15"
∷ word (Ο ∷ ὐ ∷ []) "2Pet.1.16"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.1.16"
∷ word (σ ∷ ε ∷ σ ∷ ο ∷ φ ∷ ι ∷ σ ∷ μ ∷ έ ∷ ν ∷ ο ∷ ι ∷ ς ∷ []) "2Pet.1.16"
∷ word (μ ∷ ύ ∷ θ ∷ ο ∷ ι ∷ ς ∷ []) "2Pet.1.16"
∷ word (ἐ ∷ ξ ∷ α ∷ κ ∷ ο ∷ ∙λ ∷ ο ∷ υ ∷ θ ∷ ή ∷ σ ∷ α ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.1.16"
∷ word (ἐ ∷ γ ∷ ν ∷ ω ∷ ρ ∷ ί ∷ σ ∷ α ∷ μ ∷ ε ∷ ν ∷ []) "2Pet.1.16"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "2Pet.1.16"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.16"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.16"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "2Pet.1.16"
∷ word (ἡ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.1.16"
∷ word (Ἰ ∷ η ∷ σ ∷ ο ∷ ῦ ∷ []) "2Pet.1.16"
∷ word (Χ ∷ ρ ∷ ι ∷ σ ∷ τ ∷ ο ∷ ῦ ∷ []) "2Pet.1.16"
∷ word (δ ∷ ύ ∷ ν ∷ α ∷ μ ∷ ι ∷ ν ∷ []) "2Pet.1.16"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.16"
∷ word (π ∷ α ∷ ρ ∷ ο ∷ υ ∷ σ ∷ ί ∷ α ∷ ν ∷ []) "2Pet.1.16"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ []) "2Pet.1.16"
∷ word (ἐ ∷ π ∷ ό ∷ π ∷ τ ∷ α ∷ ι ∷ []) "2Pet.1.16"
∷ word (γ ∷ ε ∷ ν ∷ η ∷ θ ∷ έ ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.1.16"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.1.16"
∷ word (ἐ ∷ κ ∷ ε ∷ ί ∷ ν ∷ ο ∷ υ ∷ []) "2Pet.1.16"
∷ word (μ ∷ ε ∷ γ ∷ α ∷ ∙λ ∷ ε ∷ ι ∷ ό ∷ τ ∷ η ∷ τ ∷ ο ∷ ς ∷ []) "2Pet.1.16"
∷ word (∙λ ∷ α ∷ β ∷ ὼ ∷ ν ∷ []) "2Pet.1.17"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.1.17"
∷ word (π ∷ α ∷ ρ ∷ ὰ ∷ []) "2Pet.1.17"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "2Pet.1.17"
∷ word (π ∷ α ∷ τ ∷ ρ ∷ ὸ ∷ ς ∷ []) "2Pet.1.17"
∷ word (τ ∷ ι ∷ μ ∷ ὴ ∷ ν ∷ []) "2Pet.1.17"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.17"
∷ word (δ ∷ ό ∷ ξ ∷ α ∷ ν ∷ []) "2Pet.1.17"
∷ word (φ ∷ ω ∷ ν ∷ ῆ ∷ ς ∷ []) "2Pet.1.17"
∷ word (ἐ ∷ ν ∷ ε ∷ χ ∷ θ ∷ ε ∷ ί ∷ σ ∷ η ∷ ς ∷ []) "2Pet.1.17"
∷ word (α ∷ ὐ ∷ τ ∷ ῷ ∷ []) "2Pet.1.17"
∷ word (τ ∷ ο ∷ ι ∷ ᾶ ∷ σ ∷ δ ∷ ε ∷ []) "2Pet.1.17"
∷ word (ὑ ∷ π ∷ ὸ ∷ []) "2Pet.1.17"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.1.17"
∷ word (μ ∷ ε ∷ γ ∷ α ∷ ∙λ ∷ ο ∷ π ∷ ρ ∷ ε ∷ π ∷ ο ∷ ῦ ∷ ς ∷ []) "2Pet.1.17"
∷ word (δ ∷ ό ∷ ξ ∷ η ∷ ς ∷ []) "2Pet.1.17"
∷ word (Ὁ ∷ []) "2Pet.1.17"
∷ word (υ ∷ ἱ ∷ ό ∷ ς ∷ []) "2Pet.1.17"
∷ word (μ ∷ ο ∷ υ ∷ []) "2Pet.1.17"
∷ word (ὁ ∷ []) "2Pet.1.17"
∷ word (ἀ ∷ γ ∷ α ∷ π ∷ η ∷ τ ∷ ό ∷ ς ∷ []) "2Pet.1.17"
∷ word (μ ∷ ο ∷ υ ∷ []) "2Pet.1.17"
∷ word (ο ∷ ὗ ∷ τ ∷ ό ∷ ς ∷ []) "2Pet.1.17"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "2Pet.1.17"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "2Pet.1.17"
∷ word (ὃ ∷ ν ∷ []) "2Pet.1.17"
∷ word (ἐ ∷ γ ∷ ὼ ∷ []) "2Pet.1.17"
∷ word (ε ∷ ὐ ∷ δ ∷ ό ∷ κ ∷ η ∷ σ ∷ α ∷ []) "2Pet.1.17"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.18"
∷ word (τ ∷ α ∷ ύ ∷ τ ∷ η ∷ ν ∷ []) "2Pet.1.18"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.1.18"
∷ word (φ ∷ ω ∷ ν ∷ ὴ ∷ ν ∷ []) "2Pet.1.18"
∷ word (ἡ ∷ μ ∷ ε ∷ ῖ ∷ ς ∷ []) "2Pet.1.18"
∷ word (ἠ ∷ κ ∷ ο ∷ ύ ∷ σ ∷ α ∷ μ ∷ ε ∷ ν ∷ []) "2Pet.1.18"
∷ word (ἐ ∷ ξ ∷ []) "2Pet.1.18"
∷ word (ο ∷ ὐ ∷ ρ ∷ α ∷ ν ∷ ο ∷ ῦ ∷ []) "2Pet.1.18"
∷ word (ἐ ∷ ν ∷ ε ∷ χ ∷ θ ∷ ε ∷ ῖ ∷ σ ∷ α ∷ ν ∷ []) "2Pet.1.18"
∷ word (σ ∷ ὺ ∷ ν ∷ []) "2Pet.1.18"
∷ word (α ∷ ὐ ∷ τ ∷ ῷ ∷ []) "2Pet.1.18"
∷ word (ὄ ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.1.18"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.18"
∷ word (τ ∷ ῷ ∷ []) "2Pet.1.18"
∷ word (ἁ ∷ γ ∷ ί ∷ ῳ ∷ []) "2Pet.1.18"
∷ word (ὄ ∷ ρ ∷ ε ∷ ι ∷ []) "2Pet.1.18"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.19"
∷ word (ἔ ∷ χ ∷ ο ∷ μ ∷ ε ∷ ν ∷ []) "2Pet.1.19"
∷ word (β ∷ ε ∷ β ∷ α ∷ ι ∷ ό ∷ τ ∷ ε ∷ ρ ∷ ο ∷ ν ∷ []) "2Pet.1.19"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "2Pet.1.19"
∷ word (π ∷ ρ ∷ ο ∷ φ ∷ η ∷ τ ∷ ι ∷ κ ∷ ὸ ∷ ν ∷ []) "2Pet.1.19"
∷ word (∙λ ∷ ό ∷ γ ∷ ο ∷ ν ∷ []) "2Pet.1.19"
∷ word (ᾧ ∷ []) "2Pet.1.19"
∷ word (κ ∷ α ∷ ∙λ ∷ ῶ ∷ ς ∷ []) "2Pet.1.19"
∷ word (π ∷ ο ∷ ι ∷ ε ∷ ῖ ∷ τ ∷ ε ∷ []) "2Pet.1.19"
∷ word (π ∷ ρ ∷ ο ∷ σ ∷ έ ∷ χ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.1.19"
∷ word (ὡ ∷ ς ∷ []) "2Pet.1.19"
∷ word (∙λ ∷ ύ ∷ χ ∷ ν ∷ ῳ ∷ []) "2Pet.1.19"
∷ word (φ ∷ α ∷ ί ∷ ν ∷ ο ∷ ν ∷ τ ∷ ι ∷ []) "2Pet.1.19"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.19"
∷ word (α ∷ ὐ ∷ χ ∷ μ ∷ η ∷ ρ ∷ ῷ ∷ []) "2Pet.1.19"
∷ word (τ ∷ ό ∷ π ∷ ῳ ∷ []) "2Pet.1.19"
∷ word (ἕ ∷ ω ∷ ς ∷ []) "2Pet.1.19"
∷ word (ο ∷ ὗ ∷ []) "2Pet.1.19"
∷ word (ἡ ∷ μ ∷ έ ∷ ρ ∷ α ∷ []) "2Pet.1.19"
∷ word (δ ∷ ι ∷ α ∷ υ ∷ γ ∷ ά ∷ σ ∷ ῃ ∷ []) "2Pet.1.19"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.1.19"
∷ word (φ ∷ ω ∷ σ ∷ φ ∷ ό ∷ ρ ∷ ο ∷ ς ∷ []) "2Pet.1.19"
∷ word (ἀ ∷ ν ∷ α ∷ τ ∷ ε ∷ ί ∷ ∙λ ∷ ῃ ∷ []) "2Pet.1.19"
∷ word (ἐ ∷ ν ∷ []) "2Pet.1.19"
∷ word (τ ∷ α ∷ ῖ ∷ ς ∷ []) "2Pet.1.19"
∷ word (κ ∷ α ∷ ρ ∷ δ ∷ ί ∷ α ∷ ι ∷ ς ∷ []) "2Pet.1.19"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.1.19"
∷ word (τ ∷ ο ∷ ῦ ∷ τ ∷ ο ∷ []) "2Pet.1.20"
∷ word (π ∷ ρ ∷ ῶ ∷ τ ∷ ο ∷ ν ∷ []) "2Pet.1.20"
∷ word (γ ∷ ι ∷ ν ∷ ώ ∷ σ ∷ κ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.1.20"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "2Pet.1.20"
∷ word (π ∷ ᾶ ∷ σ ∷ α ∷ []) "2Pet.1.20"
∷ word (π ∷ ρ ∷ ο ∷ φ ∷ η ∷ τ ∷ ε ∷ ί ∷ α ∷ []) "2Pet.1.20"
∷ word (γ ∷ ρ ∷ α ∷ φ ∷ ῆ ∷ ς ∷ []) "2Pet.1.20"
∷ word (ἰ ∷ δ ∷ ί ∷ α ∷ ς ∷ []) "2Pet.1.20"
∷ word (ἐ ∷ π ∷ ι ∷ ∙λ ∷ ύ ∷ σ ∷ ε ∷ ω ∷ ς ∷ []) "2Pet.1.20"
∷ word (ο ∷ ὐ ∷ []) "2Pet.1.20"
∷ word (γ ∷ ί ∷ ν ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "2Pet.1.20"
∷ word (ο ∷ ὐ ∷ []) "2Pet.1.21"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.1.21"
∷ word (θ ∷ ε ∷ ∙λ ∷ ή ∷ μ ∷ α ∷ τ ∷ ι ∷ []) "2Pet.1.21"
∷ word (ἀ ∷ ν ∷ θ ∷ ρ ∷ ώ ∷ π ∷ ο ∷ υ ∷ []) "2Pet.1.21"
∷ word (ἠ ∷ ν ∷ έ ∷ χ ∷ θ ∷ η ∷ []) "2Pet.1.21"
∷ word (π ∷ ρ ∷ ο ∷ φ ∷ η ∷ τ ∷ ε ∷ ί ∷ α ∷ []) "2Pet.1.21"
∷ word (π ∷ ο ∷ τ ∷ έ ∷ []) "2Pet.1.21"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ ὰ ∷ []) "2Pet.1.21"
∷ word (ὑ ∷ π ∷ ὸ ∷ []) "2Pet.1.21"
∷ word (π ∷ ν ∷ ε ∷ ύ ∷ μ ∷ α ∷ τ ∷ ο ∷ ς ∷ []) "2Pet.1.21"
∷ word (ἁ ∷ γ ∷ ί ∷ ο ∷ υ ∷ []) "2Pet.1.21"
∷ word (φ ∷ ε ∷ ρ ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "2Pet.1.21"
∷ word (ἐ ∷ ∙λ ∷ ά ∷ ∙λ ∷ η ∷ σ ∷ α ∷ ν ∷ []) "2Pet.1.21"
∷ word (ἀ ∷ π ∷ ὸ ∷ []) "2Pet.1.21"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "2Pet.1.21"
∷ word (ἄ ∷ ν ∷ θ ∷ ρ ∷ ω ∷ π ∷ ο ∷ ι ∷ []) "2Pet.1.21"
∷ word (Ἐ ∷ γ ∷ έ ∷ ν ∷ ο ∷ ν ∷ τ ∷ ο ∷ []) "2Pet.2.1"
∷ word (δ ∷ ὲ ∷ []) "2Pet.2.1"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.1"
∷ word (ψ ∷ ε ∷ υ ∷ δ ∷ ο ∷ π ∷ ρ ∷ ο ∷ φ ∷ ῆ ∷ τ ∷ α ∷ ι ∷ []) "2Pet.2.1"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.1"
∷ word (τ ∷ ῷ ∷ []) "2Pet.2.1"
∷ word (∙λ ∷ α ∷ ῷ ∷ []) "2Pet.2.1"
∷ word (ὡ ∷ ς ∷ []) "2Pet.2.1"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.1"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.1"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "2Pet.2.1"
∷ word (ἔ ∷ σ ∷ ο ∷ ν ∷ τ ∷ α ∷ ι ∷ []) "2Pet.2.1"
∷ word (ψ ∷ ε ∷ υ ∷ δ ∷ ο ∷ δ ∷ ι ∷ δ ∷ ά ∷ σ ∷ κ ∷ α ∷ ∙λ ∷ ο ∷ ι ∷ []) "2Pet.2.1"
∷ word (ο ∷ ἵ ∷ τ ∷ ι ∷ ν ∷ ε ∷ ς ∷ []) "2Pet.2.1"
∷ word (π ∷ α ∷ ρ ∷ ε ∷ ι ∷ σ ∷ ά ∷ ξ ∷ ο ∷ υ ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.2.1"
∷ word (α ∷ ἱ ∷ ρ ∷ έ ∷ σ ∷ ε ∷ ι ∷ ς ∷ []) "2Pet.2.1"
∷ word (ἀ ∷ π ∷ ω ∷ ∙λ ∷ ε ∷ ί ∷ α ∷ ς ∷ []) "2Pet.2.1"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.1"
∷ word (τ ∷ ὸ ∷ ν ∷ []) "2Pet.2.1"
∷ word (ἀ ∷ γ ∷ ο ∷ ρ ∷ ά ∷ σ ∷ α ∷ ν ∷ τ ∷ α ∷ []) "2Pet.2.1"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ὺ ∷ ς ∷ []) "2Pet.2.1"
∷ word (δ ∷ ε ∷ σ ∷ π ∷ ό ∷ τ ∷ η ∷ ν ∷ []) "2Pet.2.1"
∷ word (ἀ ∷ ρ ∷ ν ∷ ο ∷ ύ ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "2Pet.2.1"
∷ word (ἐ ∷ π ∷ ά ∷ γ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.2.1"
∷ word (ἑ ∷ α ∷ υ ∷ τ ∷ ο ∷ ῖ ∷ ς ∷ []) "2Pet.2.1"
∷ word (τ ∷ α ∷ χ ∷ ι ∷ ν ∷ ὴ ∷ ν ∷ []) "2Pet.2.1"
∷ word (ἀ ∷ π ∷ ώ ∷ ∙λ ∷ ε ∷ ι ∷ α ∷ ν ∷ []) "2Pet.2.1"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.2"
∷ word (π ∷ ο ∷ ∙λ ∷ ∙λ ∷ ο ∷ ὶ ∷ []) "2Pet.2.2"
∷ word (ἐ ∷ ξ ∷ α ∷ κ ∷ ο ∷ ∙λ ∷ ο ∷ υ ∷ θ ∷ ή ∷ σ ∷ ο ∷ υ ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.2.2"
∷ word (α ∷ ὐ ∷ τ ∷ ῶ ∷ ν ∷ []) "2Pet.2.2"
∷ word (τ ∷ α ∷ ῖ ∷ ς ∷ []) "2Pet.2.2"
∷ word (ἀ ∷ σ ∷ ε ∷ ∙λ ∷ γ ∷ ε ∷ ί ∷ α ∷ ι ∷ ς ∷ []) "2Pet.2.2"
∷ word (δ ∷ ι ∷ []) "2Pet.2.2"
∷ word (ο ∷ ὓ ∷ ς ∷ []) "2Pet.2.2"
∷ word (ἡ ∷ []) "2Pet.2.2"
∷ word (ὁ ∷ δ ∷ ὸ ∷ ς ∷ []) "2Pet.2.2"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.2.2"
∷ word (ἀ ∷ ∙λ ∷ η ∷ θ ∷ ε ∷ ί ∷ α ∷ ς ∷ []) "2Pet.2.2"
∷ word (β ∷ ∙λ ∷ α ∷ σ ∷ φ ∷ η ∷ μ ∷ η ∷ θ ∷ ή ∷ σ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "2Pet.2.2"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.3"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.3"
∷ word (π ∷ ∙λ ∷ ε ∷ ο ∷ ν ∷ ε ∷ ξ ∷ ί ∷ ᾳ ∷ []) "2Pet.2.3"
∷ word (π ∷ ∙λ ∷ α ∷ σ ∷ τ ∷ ο ∷ ῖ ∷ ς ∷ []) "2Pet.2.3"
∷ word (∙λ ∷ ό ∷ γ ∷ ο ∷ ι ∷ ς ∷ []) "2Pet.2.3"
∷ word (ὑ ∷ μ ∷ ᾶ ∷ ς ∷ []) "2Pet.2.3"
∷ word (ἐ ∷ μ ∷ π ∷ ο ∷ ρ ∷ ε ∷ ύ ∷ σ ∷ ο ∷ ν ∷ τ ∷ α ∷ ι ∷ []) "2Pet.2.3"
∷ word (ο ∷ ἷ ∷ ς ∷ []) "2Pet.2.3"
∷ word (τ ∷ ὸ ∷ []) "2Pet.2.3"
∷ word (κ ∷ ρ ∷ ί ∷ μ ∷ α ∷ []) "2Pet.2.3"
∷ word (ἔ ∷ κ ∷ π ∷ α ∷ ∙λ ∷ α ∷ ι ∷ []) "2Pet.2.3"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "2Pet.2.3"
∷ word (ἀ ∷ ρ ∷ γ ∷ ε ∷ ῖ ∷ []) "2Pet.2.3"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.3"
∷ word (ἡ ∷ []) "2Pet.2.3"
∷ word (ἀ ∷ π ∷ ώ ∷ ∙λ ∷ ε ∷ ι ∷ α ∷ []) "2Pet.2.3"
∷ word (α ∷ ὐ ∷ τ ∷ ῶ ∷ ν ∷ []) "2Pet.2.3"
∷ word (ο ∷ ὐ ∷ []) "2Pet.2.3"
∷ word (ν ∷ υ ∷ σ ∷ τ ∷ ά ∷ ζ ∷ ε ∷ ι ∷ []) "2Pet.2.3"
∷ word (Ε ∷ ἰ ∷ []) "2Pet.2.4"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.2.4"
∷ word (ὁ ∷ []) "2Pet.2.4"
∷ word (θ ∷ ε ∷ ὸ ∷ ς ∷ []) "2Pet.2.4"
∷ word (ἀ ∷ γ ∷ γ ∷ έ ∷ ∙λ ∷ ω ∷ ν ∷ []) "2Pet.2.4"
∷ word (ἁ ∷ μ ∷ α ∷ ρ ∷ τ ∷ η ∷ σ ∷ ά ∷ ν ∷ τ ∷ ω ∷ ν ∷ []) "2Pet.2.4"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "2Pet.2.4"
∷ word (ἐ ∷ φ ∷ ε ∷ ί ∷ σ ∷ α ∷ τ ∷ ο ∷ []) "2Pet.2.4"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ ὰ ∷ []) "2Pet.2.4"
∷ word (σ ∷ ε ∷ ι ∷ ρ ∷ α ∷ ῖ ∷ ς ∷ []) "2Pet.2.4"
∷ word (ζ ∷ ό ∷ φ ∷ ο ∷ υ ∷ []) "2Pet.2.4"
∷ word (τ ∷ α ∷ ρ ∷ τ ∷ α ∷ ρ ∷ ώ ∷ σ ∷ α ∷ ς ∷ []) "2Pet.2.4"
∷ word (π ∷ α ∷ ρ ∷ έ ∷ δ ∷ ω ∷ κ ∷ ε ∷ ν ∷ []) "2Pet.2.4"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "2Pet.2.4"
∷ word (κ ∷ ρ ∷ ί ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.2.4"
∷ word (τ ∷ η ∷ ρ ∷ ο ∷ υ ∷ μ ∷ έ ∷ ν ∷ ο ∷ υ ∷ ς ∷ []) "2Pet.2.4"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.5"
∷ word (ἀ ∷ ρ ∷ χ ∷ α ∷ ί ∷ ο ∷ υ ∷ []) "2Pet.2.5"
∷ word (κ ∷ ό ∷ σ ∷ μ ∷ ο ∷ υ ∷ []) "2Pet.2.5"
∷ word (ο ∷ ὐ ∷ κ ∷ []) "2Pet.2.5"
∷ word (ἐ ∷ φ ∷ ε ∷ ί ∷ σ ∷ α ∷ τ ∷ ο ∷ []) "2Pet.2.5"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ ὰ ∷ []) "2Pet.2.5"
∷ word (ὄ ∷ γ ∷ δ ∷ ο ∷ ο ∷ ν ∷ []) "2Pet.2.5"
∷ word (Ν ∷ ῶ ∷ ε ∷ []) "2Pet.2.5"
∷ word (δ ∷ ι ∷ κ ∷ α ∷ ι ∷ ο ∷ σ ∷ ύ ∷ ν ∷ η ∷ ς ∷ []) "2Pet.2.5"
∷ word (κ ∷ ή ∷ ρ ∷ υ ∷ κ ∷ α ∷ []) "2Pet.2.5"
∷ word (ἐ ∷ φ ∷ ύ ∷ ∙λ ∷ α ∷ ξ ∷ ε ∷ ν ∷ []) "2Pet.2.5"
∷ word (κ ∷ α ∷ τ ∷ α ∷ κ ∷ ∙λ ∷ υ ∷ σ ∷ μ ∷ ὸ ∷ ν ∷ []) "2Pet.2.5"
∷ word (κ ∷ ό ∷ σ ∷ μ ∷ ῳ ∷ []) "2Pet.2.5"
∷ word (ἀ ∷ σ ∷ ε ∷ β ∷ ῶ ∷ ν ∷ []) "2Pet.2.5"
∷ word (ἐ ∷ π ∷ ά ∷ ξ ∷ α ∷ ς ∷ []) "2Pet.2.5"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.6"
∷ word (π ∷ ό ∷ ∙λ ∷ ε ∷ ι ∷ ς ∷ []) "2Pet.2.6"
∷ word (Σ ∷ ο ∷ δ ∷ ό ∷ μ ∷ ω ∷ ν ∷ []) "2Pet.2.6"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.6"
∷ word (Γ ∷ ο ∷ μ ∷ ό ∷ ρ ∷ ρ ∷ α ∷ ς ∷ []) "2Pet.2.6"
∷ word (τ ∷ ε ∷ φ ∷ ρ ∷ ώ ∷ σ ∷ α ∷ ς ∷ []) "2Pet.2.6"
∷ word (κ ∷ α ∷ τ ∷ α ∷ σ ∷ τ ∷ ρ ∷ ο ∷ φ ∷ ῇ ∷ []) "2Pet.2.6"
∷ word (κ ∷ α ∷ τ ∷ έ ∷ κ ∷ ρ ∷ ι ∷ ν ∷ ε ∷ ν ∷ []) "2Pet.2.6"
∷ word (ὑ ∷ π ∷ ό ∷ δ ∷ ε ∷ ι ∷ γ ∷ μ ∷ α ∷ []) "2Pet.2.6"
∷ word (μ ∷ ε ∷ ∙λ ∷ ∙λ ∷ ό ∷ ν ∷ τ ∷ ω ∷ ν ∷ []) "2Pet.2.6"
∷ word (ἀ ∷ σ ∷ ε ∷ β ∷ έ ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.2.6"
∷ word (τ ∷ ε ∷ θ ∷ ε ∷ ι ∷ κ ∷ ώ ∷ ς ∷ []) "2Pet.2.6"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.7"
∷ word (δ ∷ ί ∷ κ ∷ α ∷ ι ∷ ο ∷ ν ∷ []) "2Pet.2.7"
∷ word (Λ ∷ ὼ ∷ τ ∷ []) "2Pet.2.7"
∷ word (κ ∷ α ∷ τ ∷ α ∷ π ∷ ο ∷ ν ∷ ο ∷ ύ ∷ μ ∷ ε ∷ ν ∷ ο ∷ ν ∷ []) "2Pet.2.7"
∷ word (ὑ ∷ π ∷ ὸ ∷ []) "2Pet.2.7"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.2.7"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "2Pet.2.7"
∷ word (ἀ ∷ θ ∷ έ ∷ σ ∷ μ ∷ ω ∷ ν ∷ []) "2Pet.2.7"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.7"
∷ word (ἀ ∷ σ ∷ ε ∷ ∙λ ∷ γ ∷ ε ∷ ί ∷ ᾳ ∷ []) "2Pet.2.7"
∷ word (ἀ ∷ ν ∷ α ∷ σ ∷ τ ∷ ρ ∷ ο ∷ φ ∷ ῆ ∷ ς ∷ []) "2Pet.2.7"
∷ word (ἐ ∷ ρ ∷ ρ ∷ ύ ∷ σ ∷ α ∷ τ ∷ ο ∷ []) "2Pet.2.7"
∷ word (β ∷ ∙λ ∷ έ ∷ μ ∷ μ ∷ α ∷ τ ∷ ι ∷ []) "2Pet.2.8"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.2.8"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.8"
∷ word (ἀ ∷ κ ∷ ο ∷ ῇ ∷ []) "2Pet.2.8"
∷ word (ὁ ∷ []) "2Pet.2.8"
∷ word (δ ∷ ί ∷ κ ∷ α ∷ ι ∷ ο ∷ ς ∷ []) "2Pet.2.8"
∷ word (ἐ ∷ γ ∷ κ ∷ α ∷ τ ∷ ο ∷ ι ∷ κ ∷ ῶ ∷ ν ∷ []) "2Pet.2.8"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.8"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῖ ∷ ς ∷ []) "2Pet.2.8"
∷ word (ἡ ∷ μ ∷ έ ∷ ρ ∷ α ∷ ν ∷ []) "2Pet.2.8"
∷ word (ἐ ∷ ξ ∷ []) "2Pet.2.8"
∷ word (ἡ ∷ μ ∷ έ ∷ ρ ∷ α ∷ ς ∷ []) "2Pet.2.8"
∷ word (ψ ∷ υ ∷ χ ∷ ὴ ∷ ν ∷ []) "2Pet.2.8"
∷ word (δ ∷ ι ∷ κ ∷ α ∷ ί ∷ α ∷ ν ∷ []) "2Pet.2.8"
∷ word (ἀ ∷ ν ∷ ό ∷ μ ∷ ο ∷ ι ∷ ς ∷ []) "2Pet.2.8"
∷ word (ἔ ∷ ρ ∷ γ ∷ ο ∷ ι ∷ ς ∷ []) "2Pet.2.8"
∷ word (ἐ ∷ β ∷ α ∷ σ ∷ ά ∷ ν ∷ ι ∷ ζ ∷ ε ∷ ν ∷ []) "2Pet.2.8"
∷ word (ο ∷ ἶ ∷ δ ∷ ε ∷ ν ∷ []) "2Pet.2.9"
∷ word (κ ∷ ύ ∷ ρ ∷ ι ∷ ο ∷ ς ∷ []) "2Pet.2.9"
∷ word (ε ∷ ὐ ∷ σ ∷ ε ∷ β ∷ ε ∷ ῖ ∷ ς ∷ []) "2Pet.2.9"
∷ word (ἐ ∷ κ ∷ []) "2Pet.2.9"
∷ word (π ∷ ε ∷ ι ∷ ρ ∷ α ∷ σ ∷ μ ∷ ο ∷ ῦ ∷ []) "2Pet.2.9"
∷ word (ῥ ∷ ύ ∷ ε ∷ σ ∷ θ ∷ α ∷ ι ∷ []) "2Pet.2.9"
∷ word (ἀ ∷ δ ∷ ί ∷ κ ∷ ο ∷ υ ∷ ς ∷ []) "2Pet.2.9"
∷ word (δ ∷ ὲ ∷ []) "2Pet.2.9"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "2Pet.2.9"
∷ word (ἡ ∷ μ ∷ έ ∷ ρ ∷ α ∷ ν ∷ []) "2Pet.2.9"
∷ word (κ ∷ ρ ∷ ί ∷ σ ∷ ε ∷ ω ∷ ς ∷ []) "2Pet.2.9"
∷ word (κ ∷ ο ∷ ∙λ ∷ α ∷ ζ ∷ ο ∷ μ ∷ έ ∷ ν ∷ ο ∷ υ ∷ ς ∷ []) "2Pet.2.9"
∷ word (τ ∷ η ∷ ρ ∷ ε ∷ ῖ ∷ ν ∷ []) "2Pet.2.9"
∷ word (μ ∷ ά ∷ ∙λ ∷ ι ∷ σ ∷ τ ∷ α ∷ []) "2Pet.2.10"
∷ word (δ ∷ ὲ ∷ []) "2Pet.2.10"
∷ word (τ ∷ ο ∷ ὺ ∷ ς ∷ []) "2Pet.2.10"
∷ word (ὀ ∷ π ∷ ί ∷ σ ∷ ω ∷ []) "2Pet.2.10"
∷ word (σ ∷ α ∷ ρ ∷ κ ∷ ὸ ∷ ς ∷ []) "2Pet.2.10"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.10"
∷ word (ἐ ∷ π ∷ ι ∷ θ ∷ υ ∷ μ ∷ ί ∷ ᾳ ∷ []) "2Pet.2.10"
∷ word (μ ∷ ι ∷ α ∷ σ ∷ μ ∷ ο ∷ ῦ ∷ []) "2Pet.2.10"
∷ word (π ∷ ο ∷ ρ ∷ ε ∷ υ ∷ ο ∷ μ ∷ έ ∷ ν ∷ ο ∷ υ ∷ ς ∷ []) "2Pet.2.10"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.10"
∷ word (κ ∷ υ ∷ ρ ∷ ι ∷ ό ∷ τ ∷ η ∷ τ ∷ ο ∷ ς ∷ []) "2Pet.2.10"
∷ word (κ ∷ α ∷ τ ∷ α ∷ φ ∷ ρ ∷ ο ∷ ν ∷ ο ∷ ῦ ∷ ν ∷ τ ∷ α ∷ ς ∷ []) "2Pet.2.10"
∷ word (Τ ∷ ο ∷ ∙λ ∷ μ ∷ η ∷ τ ∷ α ∷ ὶ ∷ []) "2Pet.2.10"
∷ word (α ∷ ὐ ∷ θ ∷ ά ∷ δ ∷ ε ∷ ι ∷ ς ∷ []) "2Pet.2.10"
∷ word (δ ∷ ό ∷ ξ ∷ α ∷ ς ∷ []) "2Pet.2.10"
∷ word (ο ∷ ὐ ∷ []) "2Pet.2.10"
∷ word (τ ∷ ρ ∷ έ ∷ μ ∷ ο ∷ υ ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.2.10"
∷ word (β ∷ ∙λ ∷ α ∷ σ ∷ φ ∷ η ∷ μ ∷ ο ∷ ῦ ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.2.10"
∷ word (ὅ ∷ π ∷ ο ∷ υ ∷ []) "2Pet.2.11"
∷ word (ἄ ∷ γ ∷ γ ∷ ε ∷ ∙λ ∷ ο ∷ ι ∷ []) "2Pet.2.11"
∷ word (ἰ ∷ σ ∷ χ ∷ ύ ∷ ϊ ∷ []) "2Pet.2.11"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.11"
∷ word (δ ∷ υ ∷ ν ∷ ά ∷ μ ∷ ε ∷ ι ∷ []) "2Pet.2.11"
∷ word (μ ∷ ε ∷ ί ∷ ζ ∷ ο ∷ ν ∷ ε ∷ ς ∷ []) "2Pet.2.11"
∷ word (ὄ ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.2.11"
∷ word (ο ∷ ὐ ∷ []) "2Pet.2.11"
∷ word (φ ∷ έ ∷ ρ ∷ ο ∷ υ ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.2.11"
∷ word (κ ∷ α ∷ τ ∷ []) "2Pet.2.11"
∷ word (α ∷ ὐ ∷ τ ∷ ῶ ∷ ν ∷ []) "2Pet.2.11"
∷ word (β ∷ ∙λ ∷ ά ∷ σ ∷ φ ∷ η ∷ μ ∷ ο ∷ ν ∷ []) "2Pet.2.11"
∷ word (κ ∷ ρ ∷ ί ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.2.11"
∷ word (ο ∷ ὗ ∷ τ ∷ ο ∷ ι ∷ []) "2Pet.2.12"
∷ word (δ ∷ έ ∷ []) "2Pet.2.12"
∷ word (ὡ ∷ ς ∷ []) "2Pet.2.12"
∷ word (ἄ ∷ ∙λ ∷ ο ∷ γ ∷ α ∷ []) "2Pet.2.12"
∷ word (ζ ∷ ῷ ∷ α ∷ []) "2Pet.2.12"
∷ word (γ ∷ ε ∷ γ ∷ ε ∷ ν ∷ ν ∷ η ∷ μ ∷ έ ∷ ν ∷ α ∷ []) "2Pet.2.12"
∷ word (φ ∷ υ ∷ σ ∷ ι ∷ κ ∷ ὰ ∷ []) "2Pet.2.12"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "2Pet.2.12"
∷ word (ἅ ∷ ∙λ ∷ ω ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.2.12"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.12"
∷ word (φ ∷ θ ∷ ο ∷ ρ ∷ ά ∷ ν ∷ []) "2Pet.2.12"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.12"
∷ word (ο ∷ ἷ ∷ ς ∷ []) "2Pet.2.12"
∷ word (ἀ ∷ γ ∷ ν ∷ ο ∷ ο ∷ ῦ ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.2.12"
∷ word (β ∷ ∙λ ∷ α ∷ σ ∷ φ ∷ η ∷ μ ∷ ο ∷ ῦ ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.2.12"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.12"
∷ word (τ ∷ ῇ ∷ []) "2Pet.2.12"
∷ word (φ ∷ θ ∷ ο ∷ ρ ∷ ᾷ ∷ []) "2Pet.2.12"
∷ word (α ∷ ὐ ∷ τ ∷ ῶ ∷ ν ∷ []) "2Pet.2.12"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.12"
∷ word (φ ∷ θ ∷ α ∷ ρ ∷ ή ∷ σ ∷ ο ∷ ν ∷ τ ∷ α ∷ ι ∷ []) "2Pet.2.12"
∷ word (ἀ ∷ δ ∷ ι ∷ κ ∷ ο ∷ ύ ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "2Pet.2.13"
∷ word (μ ∷ ι ∷ σ ∷ θ ∷ ὸ ∷ ν ∷ []) "2Pet.2.13"
∷ word (ἀ ∷ δ ∷ ι ∷ κ ∷ ί ∷ α ∷ ς ∷ []) "2Pet.2.13"
∷ word (ἡ ∷ δ ∷ ο ∷ ν ∷ ὴ ∷ ν ∷ []) "2Pet.2.13"
∷ word (ἡ ∷ γ ∷ ο ∷ ύ ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "2Pet.2.13"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.2.13"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.13"
∷ word (ἡ ∷ μ ∷ έ ∷ ρ ∷ ᾳ ∷ []) "2Pet.2.13"
∷ word (τ ∷ ρ ∷ υ ∷ φ ∷ ή ∷ ν ∷ []) "2Pet.2.13"
∷ word (σ ∷ π ∷ ί ∷ ∙λ ∷ ο ∷ ι ∷ []) "2Pet.2.13"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.13"
∷ word (μ ∷ ῶ ∷ μ ∷ ο ∷ ι ∷ []) "2Pet.2.13"
∷ word (ἐ ∷ ν ∷ τ ∷ ρ ∷ υ ∷ φ ∷ ῶ ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.2.13"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.13"
∷ word (τ ∷ α ∷ ῖ ∷ ς ∷ []) "2Pet.2.13"
∷ word (ἀ ∷ π ∷ ά ∷ τ ∷ α ∷ ι ∷ ς ∷ []) "2Pet.2.13"
∷ word (α ∷ ὐ ∷ τ ∷ ῶ ∷ ν ∷ []) "2Pet.2.13"
∷ word (σ ∷ υ ∷ ν ∷ ε ∷ υ ∷ ω ∷ χ ∷ ο ∷ ύ ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "2Pet.2.13"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "2Pet.2.13"
∷ word (ὀ ∷ φ ∷ θ ∷ α ∷ ∙λ ∷ μ ∷ ο ∷ ὺ ∷ ς ∷ []) "2Pet.2.14"
∷ word (ἔ ∷ χ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.2.14"
∷ word (μ ∷ ε ∷ σ ∷ τ ∷ ο ∷ ὺ ∷ ς ∷ []) "2Pet.2.14"
∷ word (μ ∷ ο ∷ ι ∷ χ ∷ α ∷ ∙λ ∷ ί ∷ δ ∷ ο ∷ ς ∷ []) "2Pet.2.14"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.14"
∷ word (ἀ ∷ κ ∷ α ∷ τ ∷ α ∷ π ∷ α ∷ ύ ∷ σ ∷ τ ∷ ο ∷ υ ∷ ς ∷ []) "2Pet.2.14"
∷ word (ἁ ∷ μ ∷ α ∷ ρ ∷ τ ∷ ί ∷ α ∷ ς ∷ []) "2Pet.2.14"
∷ word (δ ∷ ε ∷ ∙λ ∷ ε ∷ ά ∷ ζ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.2.14"
∷ word (ψ ∷ υ ∷ χ ∷ ὰ ∷ ς ∷ []) "2Pet.2.14"
∷ word (ἀ ∷ σ ∷ τ ∷ η ∷ ρ ∷ ί ∷ κ ∷ τ ∷ ο ∷ υ ∷ ς ∷ []) "2Pet.2.14"
∷ word (κ ∷ α ∷ ρ ∷ δ ∷ ί ∷ α ∷ ν ∷ []) "2Pet.2.14"
∷ word (γ ∷ ε ∷ γ ∷ υ ∷ μ ∷ ν ∷ α ∷ σ ∷ μ ∷ έ ∷ ν ∷ η ∷ ν ∷ []) "2Pet.2.14"
∷ word (π ∷ ∙λ ∷ ε ∷ ο ∷ ν ∷ ε ∷ ξ ∷ ί ∷ α ∷ ς ∷ []) "2Pet.2.14"
∷ word (ἔ ∷ χ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.2.14"
∷ word (κ ∷ α ∷ τ ∷ ά ∷ ρ ∷ α ∷ ς ∷ []) "2Pet.2.14"
∷ word (τ ∷ έ ∷ κ ∷ ν ∷ α ∷ []) "2Pet.2.14"
∷ word (κ ∷ α ∷ τ ∷ α ∷ ∙λ ∷ ι ∷ π ∷ ό ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.2.15"
∷ word (ε ∷ ὐ ∷ θ ∷ ε ∷ ῖ ∷ α ∷ ν ∷ []) "2Pet.2.15"
∷ word (ὁ ∷ δ ∷ ὸ ∷ ν ∷ []) "2Pet.2.15"
∷ word (ἐ ∷ π ∷ ∙λ ∷ α ∷ ν ∷ ή ∷ θ ∷ η ∷ σ ∷ α ∷ ν ∷ []) "2Pet.2.15"
∷ word (ἐ ∷ ξ ∷ α ∷ κ ∷ ο ∷ ∙λ ∷ ο ∷ υ ∷ θ ∷ ή ∷ σ ∷ α ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.2.15"
∷ word (τ ∷ ῇ ∷ []) "2Pet.2.15"
∷ word (ὁ ∷ δ ∷ ῷ ∷ []) "2Pet.2.15"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.2.15"
∷ word (Β ∷ α ∷ ∙λ ∷ α ∷ ὰ ∷ μ ∷ []) "2Pet.2.15"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.2.15"
∷ word (Β ∷ ο ∷ σ ∷ ὸ ∷ ρ ∷ []) "2Pet.2.15"
∷ word (ὃ ∷ ς ∷ []) "2Pet.2.15"
∷ word (μ ∷ ι ∷ σ ∷ θ ∷ ὸ ∷ ν ∷ []) "2Pet.2.15"
∷ word (ἀ ∷ δ ∷ ι ∷ κ ∷ ί ∷ α ∷ ς ∷ []) "2Pet.2.15"
∷ word (ἠ ∷ γ ∷ ά ∷ π ∷ η ∷ σ ∷ ε ∷ ν ∷ []) "2Pet.2.15"
∷ word (ἔ ∷ ∙λ ∷ ε ∷ γ ∷ ξ ∷ ι ∷ ν ∷ []) "2Pet.2.16"
∷ word (δ ∷ ὲ ∷ []) "2Pet.2.16"
∷ word (ἔ ∷ σ ∷ χ ∷ ε ∷ ν ∷ []) "2Pet.2.16"
∷ word (ἰ ∷ δ ∷ ί ∷ α ∷ ς ∷ []) "2Pet.2.16"
∷ word (π ∷ α ∷ ρ ∷ α ∷ ν ∷ ο ∷ μ ∷ ί ∷ α ∷ ς ∷ []) "2Pet.2.16"
∷ word (ὑ ∷ π ∷ ο ∷ ζ ∷ ύ ∷ γ ∷ ι ∷ ο ∷ ν ∷ []) "2Pet.2.16"
∷ word (ἄ ∷ φ ∷ ω ∷ ν ∷ ο ∷ ν ∷ []) "2Pet.2.16"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.16"
∷ word (ἀ ∷ ν ∷ θ ∷ ρ ∷ ώ ∷ π ∷ ο ∷ υ ∷ []) "2Pet.2.16"
∷ word (φ ∷ ω ∷ ν ∷ ῇ ∷ []) "2Pet.2.16"
∷ word (φ ∷ θ ∷ ε ∷ γ ∷ ξ ∷ ά ∷ μ ∷ ε ∷ ν ∷ ο ∷ ν ∷ []) "2Pet.2.16"
∷ word (ἐ ∷ κ ∷ ώ ∷ ∙λ ∷ υ ∷ σ ∷ ε ∷ ν ∷ []) "2Pet.2.16"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.2.16"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.2.16"
∷ word (π ∷ ρ ∷ ο ∷ φ ∷ ή ∷ τ ∷ ο ∷ υ ∷ []) "2Pet.2.16"
∷ word (π ∷ α ∷ ρ ∷ α ∷ φ ∷ ρ ∷ ο ∷ ν ∷ ί ∷ α ∷ ν ∷ []) "2Pet.2.16"
∷ word (Ο ∷ ὗ ∷ τ ∷ ο ∷ ί ∷ []) "2Pet.2.17"
∷ word (ε ∷ ἰ ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.2.17"
∷ word (π ∷ η ∷ γ ∷ α ∷ ὶ ∷ []) "2Pet.2.17"
∷ word (ἄ ∷ ν ∷ υ ∷ δ ∷ ρ ∷ ο ∷ ι ∷ []) "2Pet.2.17"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.17"
∷ word (ὁ ∷ μ ∷ ί ∷ χ ∷ ∙λ ∷ α ∷ ι ∷ []) "2Pet.2.17"
∷ word (ὑ ∷ π ∷ ὸ ∷ []) "2Pet.2.17"
∷ word (∙λ ∷ α ∷ ί ∷ ∙λ ∷ α ∷ π ∷ ο ∷ ς ∷ []) "2Pet.2.17"
∷ word (ἐ ∷ ∙λ ∷ α ∷ υ ∷ ν ∷ ό ∷ μ ∷ ε ∷ ν ∷ α ∷ ι ∷ []) "2Pet.2.17"
∷ word (ο ∷ ἷ ∷ ς ∷ []) "2Pet.2.17"
∷ word (ὁ ∷ []) "2Pet.2.17"
∷ word (ζ ∷ ό ∷ φ ∷ ο ∷ ς ∷ []) "2Pet.2.17"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.2.17"
∷ word (σ ∷ κ ∷ ό ∷ τ ∷ ο ∷ υ ∷ ς ∷ []) "2Pet.2.17"
∷ word (τ ∷ ε ∷ τ ∷ ή ∷ ρ ∷ η ∷ τ ∷ α ∷ ι ∷ []) "2Pet.2.17"
∷ word (ὑ ∷ π ∷ έ ∷ ρ ∷ ο ∷ γ ∷ κ ∷ α ∷ []) "2Pet.2.18"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.2.18"
∷ word (μ ∷ α ∷ τ ∷ α ∷ ι ∷ ό ∷ τ ∷ η ∷ τ ∷ ο ∷ ς ∷ []) "2Pet.2.18"
∷ word (φ ∷ θ ∷ ε ∷ γ ∷ γ ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "2Pet.2.18"
∷ word (δ ∷ ε ∷ ∙λ ∷ ε ∷ ά ∷ ζ ∷ ο ∷ υ ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.2.18"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.18"
∷ word (ἐ ∷ π ∷ ι ∷ θ ∷ υ ∷ μ ∷ ί ∷ α ∷ ι ∷ ς ∷ []) "2Pet.2.18"
∷ word (σ ∷ α ∷ ρ ∷ κ ∷ ὸ ∷ ς ∷ []) "2Pet.2.18"
∷ word (ἀ ∷ σ ∷ ε ∷ ∙λ ∷ γ ∷ ε ∷ ί ∷ α ∷ ι ∷ ς ∷ []) "2Pet.2.18"
∷ word (τ ∷ ο ∷ ὺ ∷ ς ∷ []) "2Pet.2.18"
∷ word (ὀ ∷ ∙λ ∷ ί ∷ γ ∷ ω ∷ ς ∷ []) "2Pet.2.18"
∷ word (ἀ ∷ π ∷ ο ∷ φ ∷ ε ∷ ύ ∷ γ ∷ ο ∷ ν ∷ τ ∷ α ∷ ς ∷ []) "2Pet.2.18"
∷ word (τ ∷ ο ∷ ὺ ∷ ς ∷ []) "2Pet.2.18"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.18"
∷ word (π ∷ ∙λ ∷ ά ∷ ν ∷ ῃ ∷ []) "2Pet.2.18"
∷ word (ἀ ∷ ν ∷ α ∷ σ ∷ τ ∷ ρ ∷ ε ∷ φ ∷ ο ∷ μ ∷ έ ∷ ν ∷ ο ∷ υ ∷ ς ∷ []) "2Pet.2.18"
∷ word (ἐ ∷ ∙λ ∷ ε ∷ υ ∷ θ ∷ ε ∷ ρ ∷ ί ∷ α ∷ ν ∷ []) "2Pet.2.19"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῖ ∷ ς ∷ []) "2Pet.2.19"
∷ word (ἐ ∷ π ∷ α ∷ γ ∷ γ ∷ ε ∷ ∙λ ∷ ∙λ ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "2Pet.2.19"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ὶ ∷ []) "2Pet.2.19"
∷ word (δ ∷ ο ∷ ῦ ∷ ∙λ ∷ ο ∷ ι ∷ []) "2Pet.2.19"
∷ word (ὑ ∷ π ∷ ά ∷ ρ ∷ χ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.2.19"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.2.19"
∷ word (φ ∷ θ ∷ ο ∷ ρ ∷ ᾶ ∷ ς ∷ []) "2Pet.2.19"
∷ word (ᾧ ∷ []) "2Pet.2.19"
∷ word (γ ∷ ά ∷ ρ ∷ []) "2Pet.2.19"
∷ word (τ ∷ ι ∷ ς ∷ []) "2Pet.2.19"
∷ word (ἥ ∷ τ ∷ τ ∷ η ∷ τ ∷ α ∷ ι ∷ []) "2Pet.2.19"
∷ word (τ ∷ ο ∷ ύ ∷ τ ∷ ῳ ∷ []) "2Pet.2.19"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.19"
∷ word (δ ∷ ε ∷ δ ∷ ο ∷ ύ ∷ ∙λ ∷ ω ∷ τ ∷ α ∷ ι ∷ []) "2Pet.2.19"
∷ word (ε ∷ ἰ ∷ []) "2Pet.2.20"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.2.20"
∷ word (ἀ ∷ π ∷ ο ∷ φ ∷ υ ∷ γ ∷ ό ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.2.20"
∷ word (τ ∷ ὰ ∷ []) "2Pet.2.20"
∷ word (μ ∷ ι ∷ ά ∷ σ ∷ μ ∷ α ∷ τ ∷ α ∷ []) "2Pet.2.20"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.2.20"
∷ word (κ ∷ ό ∷ σ ∷ μ ∷ ο ∷ υ ∷ []) "2Pet.2.20"
∷ word (ἐ ∷ ν ∷ []) "2Pet.2.20"
∷ word (ἐ ∷ π ∷ ι ∷ γ ∷ ν ∷ ώ ∷ σ ∷ ε ∷ ι ∷ []) "2Pet.2.20"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.2.20"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "2Pet.2.20"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.2.20"
∷ word (σ ∷ ω ∷ τ ∷ ῆ ∷ ρ ∷ ο ∷ ς ∷ []) "2Pet.2.20"
∷ word (Ἰ ∷ η ∷ σ ∷ ο ∷ ῦ ∷ []) "2Pet.2.20"
∷ word (Χ ∷ ρ ∷ ι ∷ σ ∷ τ ∷ ο ∷ ῦ ∷ []) "2Pet.2.20"
∷ word (τ ∷ ο ∷ ύ ∷ τ ∷ ο ∷ ι ∷ ς ∷ []) "2Pet.2.20"
∷ word (δ ∷ ὲ ∷ []) "2Pet.2.20"
∷ word (π ∷ ά ∷ ∙λ ∷ ι ∷ ν ∷ []) "2Pet.2.20"
∷ word (ἐ ∷ μ ∷ π ∷ ∙λ ∷ α ∷ κ ∷ έ ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.2.20"
∷ word (ἡ ∷ τ ∷ τ ∷ ῶ ∷ ν ∷ τ ∷ α ∷ ι ∷ []) "2Pet.2.20"
∷ word (γ ∷ έ ∷ γ ∷ ο ∷ ν ∷ ε ∷ ν ∷ []) "2Pet.2.20"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῖ ∷ ς ∷ []) "2Pet.2.20"
∷ word (τ ∷ ὰ ∷ []) "2Pet.2.20"
∷ word (ἔ ∷ σ ∷ χ ∷ α ∷ τ ∷ α ∷ []) "2Pet.2.20"
∷ word (χ ∷ ε ∷ ί ∷ ρ ∷ ο ∷ ν ∷ α ∷ []) "2Pet.2.20"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "2Pet.2.20"
∷ word (π ∷ ρ ∷ ώ ∷ τ ∷ ω ∷ ν ∷ []) "2Pet.2.20"
∷ word (κ ∷ ρ ∷ ε ∷ ῖ ∷ τ ∷ τ ∷ ο ∷ ν ∷ []) "2Pet.2.21"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.2.21"
∷ word (ἦ ∷ ν ∷ []) "2Pet.2.21"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῖ ∷ ς ∷ []) "2Pet.2.21"
∷ word (μ ∷ ὴ ∷ []) "2Pet.2.21"
∷ word (ἐ ∷ π ∷ ε ∷ γ ∷ ν ∷ ω ∷ κ ∷ έ ∷ ν ∷ α ∷ ι ∷ []) "2Pet.2.21"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.2.21"
∷ word (ὁ ∷ δ ∷ ὸ ∷ ν ∷ []) "2Pet.2.21"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.2.21"
∷ word (δ ∷ ι ∷ κ ∷ α ∷ ι ∷ ο ∷ σ ∷ ύ ∷ ν ∷ η ∷ ς ∷ []) "2Pet.2.21"
∷ word (ἢ ∷ []) "2Pet.2.21"
∷ word (ἐ ∷ π ∷ ι ∷ γ ∷ ν ∷ ο ∷ ῦ ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.2.21"
∷ word (ὑ ∷ π ∷ ο ∷ σ ∷ τ ∷ ρ ∷ έ ∷ ψ ∷ α ∷ ι ∷ []) "2Pet.2.21"
∷ word (ἐ ∷ κ ∷ []) "2Pet.2.21"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.2.21"
∷ word (π ∷ α ∷ ρ ∷ α ∷ δ ∷ ο ∷ θ ∷ ε ∷ ί ∷ σ ∷ η ∷ ς ∷ []) "2Pet.2.21"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῖ ∷ ς ∷ []) "2Pet.2.21"
∷ word (ἁ ∷ γ ∷ ί ∷ α ∷ ς ∷ []) "2Pet.2.21"
∷ word (ἐ ∷ ν ∷ τ ∷ ο ∷ ∙λ ∷ ῆ ∷ ς ∷ []) "2Pet.2.21"
∷ word (σ ∷ υ ∷ μ ∷ β ∷ έ ∷ β ∷ η ∷ κ ∷ ε ∷ ν ∷ []) "2Pet.2.22"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῖ ∷ ς ∷ []) "2Pet.2.22"
∷ word (τ ∷ ὸ ∷ []) "2Pet.2.22"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.2.22"
∷ word (ἀ ∷ ∙λ ∷ η ∷ θ ∷ ο ∷ ῦ ∷ ς ∷ []) "2Pet.2.22"
∷ word (π ∷ α ∷ ρ ∷ ο ∷ ι ∷ μ ∷ ί ∷ α ∷ ς ∷ []) "2Pet.2.22"
∷ word (Κ ∷ ύ ∷ ω ∷ ν ∷ []) "2Pet.2.22"
∷ word (ἐ ∷ π ∷ ι ∷ σ ∷ τ ∷ ρ ∷ έ ∷ ψ ∷ α ∷ ς ∷ []) "2Pet.2.22"
∷ word (ἐ ∷ π ∷ ὶ ∷ []) "2Pet.2.22"
∷ word (τ ∷ ὸ ∷ []) "2Pet.2.22"
∷ word (ἴ ∷ δ ∷ ι ∷ ο ∷ ν ∷ []) "2Pet.2.22"
∷ word (ἐ ∷ ξ ∷ έ ∷ ρ ∷ α ∷ μ ∷ α ∷ []) "2Pet.2.22"
∷ word (κ ∷ α ∷ ί ∷ []) "2Pet.2.22"
∷ word (Ὗ ∷ ς ∷ []) "2Pet.2.22"
∷ word (∙λ ∷ ο ∷ υ ∷ σ ∷ α ∷ μ ∷ έ ∷ ν ∷ η ∷ []) "2Pet.2.22"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "2Pet.2.22"
∷ word (κ ∷ υ ∷ ∙λ ∷ ι ∷ σ ∷ μ ∷ ὸ ∷ ν ∷ []) "2Pet.2.22"
∷ word (β ∷ ο ∷ ρ ∷ β ∷ ό ∷ ρ ∷ ο ∷ υ ∷ []) "2Pet.2.22"
∷ word (Τ ∷ α ∷ ύ ∷ τ ∷ η ∷ ν ∷ []) "2Pet.3.1"
∷ word (ἤ ∷ δ ∷ η ∷ []) "2Pet.3.1"
∷ word (ἀ ∷ γ ∷ α ∷ π ∷ η ∷ τ ∷ ο ∷ ί ∷ []) "2Pet.3.1"
∷ word (δ ∷ ε ∷ υ ∷ τ ∷ έ ∷ ρ ∷ α ∷ ν ∷ []) "2Pet.3.1"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "2Pet.3.1"
∷ word (γ ∷ ρ ∷ ά ∷ φ ∷ ω ∷ []) "2Pet.3.1"
∷ word (ἐ ∷ π ∷ ι ∷ σ ∷ τ ∷ ο ∷ ∙λ ∷ ή ∷ ν ∷ []) "2Pet.3.1"
∷ word (ἐ ∷ ν ∷ []) "2Pet.3.1"
∷ word (α ∷ ἷ ∷ ς ∷ []) "2Pet.3.1"
∷ word (δ ∷ ι ∷ ε ∷ γ ∷ ε ∷ ί ∷ ρ ∷ ω ∷ []) "2Pet.3.1"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.3.1"
∷ word (ἐ ∷ ν ∷ []) "2Pet.3.1"
∷ word (ὑ ∷ π ∷ ο ∷ μ ∷ ν ∷ ή ∷ σ ∷ ε ∷ ι ∷ []) "2Pet.3.1"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.3.1"
∷ word (ε ∷ ἰ ∷ ∙λ ∷ ι ∷ κ ∷ ρ ∷ ι ∷ ν ∷ ῆ ∷ []) "2Pet.3.1"
∷ word (δ ∷ ι ∷ ά ∷ ν ∷ ο ∷ ι ∷ α ∷ ν ∷ []) "2Pet.3.1"
∷ word (μ ∷ ν ∷ η ∷ σ ∷ θ ∷ ῆ ∷ ν ∷ α ∷ ι ∷ []) "2Pet.3.2"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "2Pet.3.2"
∷ word (π ∷ ρ ∷ ο ∷ ε ∷ ι ∷ ρ ∷ η ∷ μ ∷ έ ∷ ν ∷ ω ∷ ν ∷ []) "2Pet.3.2"
∷ word (ῥ ∷ η ∷ μ ∷ ά ∷ τ ∷ ω ∷ ν ∷ []) "2Pet.3.2"
∷ word (ὑ ∷ π ∷ ὸ ∷ []) "2Pet.3.2"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "2Pet.3.2"
∷ word (ἁ ∷ γ ∷ ί ∷ ω ∷ ν ∷ []) "2Pet.3.2"
∷ word (π ∷ ρ ∷ ο ∷ φ ∷ η ∷ τ ∷ ῶ ∷ ν ∷ []) "2Pet.3.2"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.2"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.3.2"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "2Pet.3.2"
∷ word (ἀ ∷ π ∷ ο ∷ σ ∷ τ ∷ ό ∷ ∙λ ∷ ω ∷ ν ∷ []) "2Pet.3.2"
∷ word (ὑ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.3.2"
∷ word (ἐ ∷ ν ∷ τ ∷ ο ∷ ∙λ ∷ ῆ ∷ ς ∷ []) "2Pet.3.2"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.3.2"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "2Pet.3.2"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.2"
∷ word (σ ∷ ω ∷ τ ∷ ῆ ∷ ρ ∷ ο ∷ ς ∷ []) "2Pet.3.2"
∷ word (τ ∷ ο ∷ ῦ ∷ τ ∷ ο ∷ []) "2Pet.3.3"
∷ word (π ∷ ρ ∷ ῶ ∷ τ ∷ ο ∷ ν ∷ []) "2Pet.3.3"
∷ word (γ ∷ ι ∷ ν ∷ ώ ∷ σ ∷ κ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.3.3"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "2Pet.3.3"
∷ word (ἐ ∷ ∙λ ∷ ε ∷ ύ ∷ σ ∷ ο ∷ ν ∷ τ ∷ α ∷ ι ∷ []) "2Pet.3.3"
∷ word (ἐ ∷ π ∷ []) "2Pet.3.3"
∷ word (ἐ ∷ σ ∷ χ ∷ ά ∷ τ ∷ ω ∷ ν ∷ []) "2Pet.3.3"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "2Pet.3.3"
∷ word (ἡ ∷ μ ∷ ε ∷ ρ ∷ ῶ ∷ ν ∷ []) "2Pet.3.3"
∷ word (ἐ ∷ ν ∷ []) "2Pet.3.3"
∷ word (ἐ ∷ μ ∷ π ∷ α ∷ ι ∷ γ ∷ μ ∷ ο ∷ ν ∷ ῇ ∷ []) "2Pet.3.3"
∷ word (ἐ ∷ μ ∷ π ∷ α ∷ ῖ ∷ κ ∷ τ ∷ α ∷ ι ∷ []) "2Pet.3.3"
∷ word (κ ∷ α ∷ τ ∷ ὰ ∷ []) "2Pet.3.3"
∷ word (τ ∷ ὰ ∷ ς ∷ []) "2Pet.3.3"
∷ word (ἰ ∷ δ ∷ ί ∷ α ∷ ς ∷ []) "2Pet.3.3"
∷ word (ἐ ∷ π ∷ ι ∷ θ ∷ υ ∷ μ ∷ ί ∷ α ∷ ς ∷ []) "2Pet.3.3"
∷ word (α ∷ ὐ ∷ τ ∷ ῶ ∷ ν ∷ []) "2Pet.3.3"
∷ word (π ∷ ο ∷ ρ ∷ ε ∷ υ ∷ ό ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "2Pet.3.3"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.4"
∷ word (∙λ ∷ έ ∷ γ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.3.4"
∷ word (Π ∷ ο ∷ ῦ ∷ []) "2Pet.3.4"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "2Pet.3.4"
∷ word (ἡ ∷ []) "2Pet.3.4"
∷ word (ἐ ∷ π ∷ α ∷ γ ∷ γ ∷ ε ∷ ∙λ ∷ ί ∷ α ∷ []) "2Pet.3.4"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.3.4"
∷ word (π ∷ α ∷ ρ ∷ ο ∷ υ ∷ σ ∷ ί ∷ α ∷ ς ∷ []) "2Pet.3.4"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "2Pet.3.4"
∷ word (ἀ ∷ φ ∷ []) "2Pet.3.4"
∷ word (ἧ ∷ ς ∷ []) "2Pet.3.4"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.3.4"
∷ word (ο ∷ ἱ ∷ []) "2Pet.3.4"
∷ word (π ∷ α ∷ τ ∷ έ ∷ ρ ∷ ε ∷ ς ∷ []) "2Pet.3.4"
∷ word (ἐ ∷ κ ∷ ο ∷ ι ∷ μ ∷ ή ∷ θ ∷ η ∷ σ ∷ α ∷ ν ∷ []) "2Pet.3.4"
∷ word (π ∷ ά ∷ ν ∷ τ ∷ α ∷ []) "2Pet.3.4"
∷ word (ο ∷ ὕ ∷ τ ∷ ω ∷ ς ∷ []) "2Pet.3.4"
∷ word (δ ∷ ι ∷ α ∷ μ ∷ έ ∷ ν ∷ ε ∷ ι ∷ []) "2Pet.3.4"
∷ word (ἀ ∷ π ∷ []) "2Pet.3.4"
∷ word (ἀ ∷ ρ ∷ χ ∷ ῆ ∷ ς ∷ []) "2Pet.3.4"
∷ word (κ ∷ τ ∷ ί ∷ σ ∷ ε ∷ ω ∷ ς ∷ []) "2Pet.3.4"
∷ word (∙λ ∷ α ∷ ν ∷ θ ∷ ά ∷ ν ∷ ε ∷ ι ∷ []) "2Pet.3.5"
∷ word (γ ∷ ὰ ∷ ρ ∷ []) "2Pet.3.5"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ὺ ∷ ς ∷ []) "2Pet.3.5"
∷ word (τ ∷ ο ∷ ῦ ∷ τ ∷ ο ∷ []) "2Pet.3.5"
∷ word (θ ∷ έ ∷ ∙λ ∷ ο ∷ ν ∷ τ ∷ α ∷ ς ∷ []) "2Pet.3.5"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "2Pet.3.5"
∷ word (ο ∷ ὐ ∷ ρ ∷ α ∷ ν ∷ ο ∷ ὶ ∷ []) "2Pet.3.5"
∷ word (ἦ ∷ σ ∷ α ∷ ν ∷ []) "2Pet.3.5"
∷ word (ἔ ∷ κ ∷ π ∷ α ∷ ∙λ ∷ α ∷ ι ∷ []) "2Pet.3.5"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.5"
∷ word (γ ∷ ῆ ∷ []) "2Pet.3.5"
∷ word (ἐ ∷ ξ ∷ []) "2Pet.3.5"
∷ word (ὕ ∷ δ ∷ α ∷ τ ∷ ο ∷ ς ∷ []) "2Pet.3.5"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.5"
∷ word (δ ∷ ι ∷ []) "2Pet.3.5"
∷ word (ὕ ∷ δ ∷ α ∷ τ ∷ ο ∷ ς ∷ []) "2Pet.3.5"
∷ word (σ ∷ υ ∷ ν ∷ ε ∷ σ ∷ τ ∷ ῶ ∷ σ ∷ α ∷ []) "2Pet.3.5"
∷ word (τ ∷ ῷ ∷ []) "2Pet.3.5"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.3.5"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "2Pet.3.5"
∷ word (∙λ ∷ ό ∷ γ ∷ ῳ ∷ []) "2Pet.3.5"
∷ word (δ ∷ ι ∷ []) "2Pet.3.6"
∷ word (ὧ ∷ ν ∷ []) "2Pet.3.6"
∷ word (ὁ ∷ []) "2Pet.3.6"
∷ word (τ ∷ ό ∷ τ ∷ ε ∷ []) "2Pet.3.6"
∷ word (κ ∷ ό ∷ σ ∷ μ ∷ ο ∷ ς ∷ []) "2Pet.3.6"
∷ word (ὕ ∷ δ ∷ α ∷ τ ∷ ι ∷ []) "2Pet.3.6"
∷ word (κ ∷ α ∷ τ ∷ α ∷ κ ∷ ∙λ ∷ υ ∷ σ ∷ θ ∷ ε ∷ ὶ ∷ ς ∷ []) "2Pet.3.6"
∷ word (ἀ ∷ π ∷ ώ ∷ ∙λ ∷ ε ∷ τ ∷ ο ∷ []) "2Pet.3.6"
∷ word (ο ∷ ἱ ∷ []) "2Pet.3.7"
∷ word (δ ∷ ὲ ∷ []) "2Pet.3.7"
∷ word (ν ∷ ῦ ∷ ν ∷ []) "2Pet.3.7"
∷ word (ο ∷ ὐ ∷ ρ ∷ α ∷ ν ∷ ο ∷ ὶ ∷ []) "2Pet.3.7"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.7"
∷ word (ἡ ∷ []) "2Pet.3.7"
∷ word (γ ∷ ῆ ∷ []) "2Pet.3.7"
∷ word (τ ∷ ῷ ∷ []) "2Pet.3.7"
∷ word (α ∷ ὐ ∷ τ ∷ ῷ ∷ []) "2Pet.3.7"
∷ word (∙λ ∷ ό ∷ γ ∷ ῳ ∷ []) "2Pet.3.7"
∷ word (τ ∷ ε ∷ θ ∷ η ∷ σ ∷ α ∷ υ ∷ ρ ∷ ι ∷ σ ∷ μ ∷ έ ∷ ν ∷ ο ∷ ι ∷ []) "2Pet.3.7"
∷ word (ε ∷ ἰ ∷ σ ∷ ὶ ∷ ν ∷ []) "2Pet.3.7"
∷ word (π ∷ υ ∷ ρ ∷ ὶ ∷ []) "2Pet.3.7"
∷ word (τ ∷ η ∷ ρ ∷ ο ∷ ύ ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "2Pet.3.7"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "2Pet.3.7"
∷ word (ἡ ∷ μ ∷ έ ∷ ρ ∷ α ∷ ν ∷ []) "2Pet.3.7"
∷ word (κ ∷ ρ ∷ ί ∷ σ ∷ ε ∷ ω ∷ ς ∷ []) "2Pet.3.7"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.7"
∷ word (ἀ ∷ π ∷ ω ∷ ∙λ ∷ ε ∷ ί ∷ α ∷ ς ∷ []) "2Pet.3.7"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "2Pet.3.7"
∷ word (ἀ ∷ σ ∷ ε ∷ β ∷ ῶ ∷ ν ∷ []) "2Pet.3.7"
∷ word (ἀ ∷ ν ∷ θ ∷ ρ ∷ ώ ∷ π ∷ ω ∷ ν ∷ []) "2Pet.3.7"
∷ word (Ἓ ∷ ν ∷ []) "2Pet.3.8"
∷ word (δ ∷ ὲ ∷ []) "2Pet.3.8"
∷ word (τ ∷ ο ∷ ῦ ∷ τ ∷ ο ∷ []) "2Pet.3.8"
∷ word (μ ∷ ὴ ∷ []) "2Pet.3.8"
∷ word (∙λ ∷ α ∷ ν ∷ θ ∷ α ∷ ν ∷ έ ∷ τ ∷ ω ∷ []) "2Pet.3.8"
∷ word (ὑ ∷ μ ∷ ᾶ ∷ ς ∷ []) "2Pet.3.8"
∷ word (ἀ ∷ γ ∷ α ∷ π ∷ η ∷ τ ∷ ο ∷ ί ∷ []) "2Pet.3.8"
∷ word (ὅ ∷ τ ∷ ι ∷ []) "2Pet.3.8"
∷ word (μ ∷ ί ∷ α ∷ []) "2Pet.3.8"
∷ word (ἡ ∷ μ ∷ έ ∷ ρ ∷ α ∷ []) "2Pet.3.8"
∷ word (π ∷ α ∷ ρ ∷ ὰ ∷ []) "2Pet.3.8"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ῳ ∷ []) "2Pet.3.8"
∷ word (ὡ ∷ ς ∷ []) "2Pet.3.8"
∷ word (χ ∷ ί ∷ ∙λ ∷ ι ∷ α ∷ []) "2Pet.3.8"
∷ word (ἔ ∷ τ ∷ η ∷ []) "2Pet.3.8"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.8"
∷ word (χ ∷ ί ∷ ∙λ ∷ ι ∷ α ∷ []) "2Pet.3.8"
∷ word (ἔ ∷ τ ∷ η ∷ []) "2Pet.3.8"
∷ word (ὡ ∷ ς ∷ []) "2Pet.3.8"
∷ word (ἡ ∷ μ ∷ έ ∷ ρ ∷ α ∷ []) "2Pet.3.8"
∷ word (μ ∷ ί ∷ α ∷ []) "2Pet.3.8"
∷ word (ο ∷ ὐ ∷ []) "2Pet.3.9"
∷ word (β ∷ ρ ∷ α ∷ δ ∷ ύ ∷ ν ∷ ε ∷ ι ∷ []) "2Pet.3.9"
∷ word (κ ∷ ύ ∷ ρ ∷ ι ∷ ο ∷ ς ∷ []) "2Pet.3.9"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.3.9"
∷ word (ἐ ∷ π ∷ α ∷ γ ∷ γ ∷ ε ∷ ∙λ ∷ ί ∷ α ∷ ς ∷ []) "2Pet.3.9"
∷ word (ὥ ∷ ς ∷ []) "2Pet.3.9"
∷ word (τ ∷ ι ∷ ν ∷ ε ∷ ς ∷ []) "2Pet.3.9"
∷ word (β ∷ ρ ∷ α ∷ δ ∷ ύ ∷ τ ∷ η ∷ τ ∷ α ∷ []) "2Pet.3.9"
∷ word (ἡ ∷ γ ∷ ο ∷ ῦ ∷ ν ∷ τ ∷ α ∷ ι ∷ []) "2Pet.3.9"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ ὰ ∷ []) "2Pet.3.9"
∷ word (μ ∷ α ∷ κ ∷ ρ ∷ ο ∷ θ ∷ υ ∷ μ ∷ ε ∷ ῖ ∷ []) "2Pet.3.9"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "2Pet.3.9"
∷ word (ὑ ∷ μ ∷ ᾶ ∷ ς ∷ []) "2Pet.3.9"
∷ word (μ ∷ ὴ ∷ []) "2Pet.3.9"
∷ word (β ∷ ο ∷ υ ∷ ∙λ ∷ ό ∷ μ ∷ ε ∷ ν ∷ ό ∷ ς ∷ []) "2Pet.3.9"
∷ word (τ ∷ ι ∷ ν ∷ α ∷ ς ∷ []) "2Pet.3.9"
∷ word (ἀ ∷ π ∷ ο ∷ ∙λ ∷ έ ∷ σ ∷ θ ∷ α ∷ ι ∷ []) "2Pet.3.9"
∷ word (ἀ ∷ ∙λ ∷ ∙λ ∷ ὰ ∷ []) "2Pet.3.9"
∷ word (π ∷ ά ∷ ν ∷ τ ∷ α ∷ ς ∷ []) "2Pet.3.9"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "2Pet.3.9"
∷ word (μ ∷ ε ∷ τ ∷ ά ∷ ν ∷ ο ∷ ι ∷ α ∷ ν ∷ []) "2Pet.3.9"
∷ word (χ ∷ ω ∷ ρ ∷ ῆ ∷ σ ∷ α ∷ ι ∷ []) "2Pet.3.9"
∷ word (ἥ ∷ ξ ∷ ε ∷ ι ∷ []) "2Pet.3.10"
∷ word (δ ∷ ὲ ∷ []) "2Pet.3.10"
∷ word (ἡ ∷ μ ∷ έ ∷ ρ ∷ α ∷ []) "2Pet.3.10"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "2Pet.3.10"
∷ word (ὡ ∷ ς ∷ []) "2Pet.3.10"
∷ word (κ ∷ ∙λ ∷ έ ∷ π ∷ τ ∷ η ∷ ς ∷ []) "2Pet.3.10"
∷ word (ἐ ∷ ν ∷ []) "2Pet.3.10"
∷ word (ᾗ ∷ []) "2Pet.3.10"
∷ word (ο ∷ ἱ ∷ []) "2Pet.3.10"
∷ word (ο ∷ ὐ ∷ ρ ∷ α ∷ ν ∷ ο ∷ ὶ ∷ []) "2Pet.3.10"
∷ word (ῥ ∷ ο ∷ ι ∷ ζ ∷ η ∷ δ ∷ ὸ ∷ ν ∷ []) "2Pet.3.10"
∷ word (π ∷ α ∷ ρ ∷ ε ∷ ∙λ ∷ ε ∷ ύ ∷ σ ∷ ο ∷ ν ∷ τ ∷ α ∷ ι ∷ []) "2Pet.3.10"
∷ word (σ ∷ τ ∷ ο ∷ ι ∷ χ ∷ ε ∷ ῖ ∷ α ∷ []) "2Pet.3.10"
∷ word (δ ∷ ὲ ∷ []) "2Pet.3.10"
∷ word (κ ∷ α ∷ υ ∷ σ ∷ ο ∷ ύ ∷ μ ∷ ε ∷ ν ∷ α ∷ []) "2Pet.3.10"
∷ word (∙λ ∷ υ ∷ θ ∷ ή ∷ σ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "2Pet.3.10"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.10"
∷ word (γ ∷ ῆ ∷ []) "2Pet.3.10"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.10"
∷ word (τ ∷ ὰ ∷ []) "2Pet.3.10"
∷ word (ἐ ∷ ν ∷ []) "2Pet.3.10"
∷ word (α ∷ ὐ ∷ τ ∷ ῇ ∷ []) "2Pet.3.10"
∷ word (ἔ ∷ ρ ∷ γ ∷ α ∷ []) "2Pet.3.10"
∷ word (ε ∷ ὑ ∷ ρ ∷ ε ∷ θ ∷ ή ∷ σ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "2Pet.3.10"
∷ word (Τ ∷ ο ∷ ύ ∷ τ ∷ ω ∷ ν ∷ []) "2Pet.3.11"
∷ word (ο ∷ ὕ ∷ τ ∷ ω ∷ ς ∷ []) "2Pet.3.11"
∷ word (π ∷ ά ∷ ν ∷ τ ∷ ω ∷ ν ∷ []) "2Pet.3.11"
∷ word (∙λ ∷ υ ∷ ο ∷ μ ∷ έ ∷ ν ∷ ω ∷ ν ∷ []) "2Pet.3.11"
∷ word (π ∷ ο ∷ τ ∷ α ∷ π ∷ ο ∷ ὺ ∷ ς ∷ []) "2Pet.3.11"
∷ word (δ ∷ ε ∷ ῖ ∷ []) "2Pet.3.11"
∷ word (ὑ ∷ π ∷ ά ∷ ρ ∷ χ ∷ ε ∷ ι ∷ ν ∷ []) "2Pet.3.11"
∷ word (ὑ ∷ μ ∷ ᾶ ∷ ς ∷ []) "2Pet.3.11"
∷ word (ἐ ∷ ν ∷ []) "2Pet.3.11"
∷ word (ἁ ∷ γ ∷ ί ∷ α ∷ ι ∷ ς ∷ []) "2Pet.3.11"
∷ word (ἀ ∷ ν ∷ α ∷ σ ∷ τ ∷ ρ ∷ ο ∷ φ ∷ α ∷ ῖ ∷ ς ∷ []) "2Pet.3.11"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.11"
∷ word (ε ∷ ὐ ∷ σ ∷ ε ∷ β ∷ ε ∷ ί ∷ α ∷ ι ∷ ς ∷ []) "2Pet.3.11"
∷ word (π ∷ ρ ∷ ο ∷ σ ∷ δ ∷ ο ∷ κ ∷ ῶ ∷ ν ∷ τ ∷ α ∷ ς ∷ []) "2Pet.3.12"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.12"
∷ word (σ ∷ π ∷ ε ∷ ύ ∷ δ ∷ ο ∷ ν ∷ τ ∷ α ∷ ς ∷ []) "2Pet.3.12"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.3.12"
∷ word (π ∷ α ∷ ρ ∷ ο ∷ υ ∷ σ ∷ ί ∷ α ∷ ν ∷ []) "2Pet.3.12"
∷ word (τ ∷ ῆ ∷ ς ∷ []) "2Pet.3.12"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.3.12"
∷ word (θ ∷ ε ∷ ο ∷ ῦ ∷ []) "2Pet.3.12"
∷ word (ἡ ∷ μ ∷ έ ∷ ρ ∷ α ∷ ς ∷ []) "2Pet.3.12"
∷ word (δ ∷ ι ∷ []) "2Pet.3.12"
∷ word (ἣ ∷ ν ∷ []) "2Pet.3.12"
∷ word (ο ∷ ὐ ∷ ρ ∷ α ∷ ν ∷ ο ∷ ὶ ∷ []) "2Pet.3.12"
∷ word (π ∷ υ ∷ ρ ∷ ο ∷ ύ ∷ μ ∷ ε ∷ ν ∷ ο ∷ ι ∷ []) "2Pet.3.12"
∷ word (∙λ ∷ υ ∷ θ ∷ ή ∷ σ ∷ ο ∷ ν ∷ τ ∷ α ∷ ι ∷ []) "2Pet.3.12"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.12"
∷ word (σ ∷ τ ∷ ο ∷ ι ∷ χ ∷ ε ∷ ῖ ∷ α ∷ []) "2Pet.3.12"
∷ word (κ ∷ α ∷ υ ∷ σ ∷ ο ∷ ύ ∷ μ ∷ ε ∷ ν ∷ α ∷ []) "2Pet.3.12"
∷ word (τ ∷ ή ∷ κ ∷ ε ∷ τ ∷ α ∷ ι ∷ []) "2Pet.3.12"
∷ word (κ ∷ α ∷ ι ∷ ν ∷ ο ∷ ὺ ∷ ς ∷ []) "2Pet.3.13"
∷ word (δ ∷ ὲ ∷ []) "2Pet.3.13"
∷ word (ο ∷ ὐ ∷ ρ ∷ α ∷ ν ∷ ο ∷ ὺ ∷ ς ∷ []) "2Pet.3.13"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.13"
∷ word (γ ∷ ῆ ∷ ν ∷ []) "2Pet.3.13"
∷ word (κ ∷ α ∷ ι ∷ ν ∷ ὴ ∷ ν ∷ []) "2Pet.3.13"
∷ word (κ ∷ α ∷ τ ∷ ὰ ∷ []) "2Pet.3.13"
∷ word (τ ∷ ὸ ∷ []) "2Pet.3.13"
∷ word (ἐ ∷ π ∷ ά ∷ γ ∷ γ ∷ ε ∷ ∙λ ∷ μ ∷ α ∷ []) "2Pet.3.13"
∷ word (α ∷ ὐ ∷ τ ∷ ο ∷ ῦ ∷ []) "2Pet.3.13"
∷ word (π ∷ ρ ∷ ο ∷ σ ∷ δ ∷ ο ∷ κ ∷ ῶ ∷ μ ∷ ε ∷ ν ∷ []) "2Pet.3.13"
∷ word (ἐ ∷ ν ∷ []) "2Pet.3.13"
∷ word (ο ∷ ἷ ∷ ς ∷ []) "2Pet.3.13"
∷ word (δ ∷ ι ∷ κ ∷ α ∷ ι ∷ ο ∷ σ ∷ ύ ∷ ν ∷ η ∷ []) "2Pet.3.13"
∷ word (κ ∷ α ∷ τ ∷ ο ∷ ι ∷ κ ∷ ε ∷ ῖ ∷ []) "2Pet.3.13"
∷ word (Δ ∷ ι ∷ ό ∷ []) "2Pet.3.14"
∷ word (ἀ ∷ γ ∷ α ∷ π ∷ η ∷ τ ∷ ο ∷ ί ∷ []) "2Pet.3.14"
∷ word (τ ∷ α ∷ ῦ ∷ τ ∷ α ∷ []) "2Pet.3.14"
∷ word (π ∷ ρ ∷ ο ∷ σ ∷ δ ∷ ο ∷ κ ∷ ῶ ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.3.14"
∷ word (σ ∷ π ∷ ο ∷ υ ∷ δ ∷ ά ∷ σ ∷ α ∷ τ ∷ ε ∷ []) "2Pet.3.14"
∷ word (ἄ ∷ σ ∷ π ∷ ι ∷ ∙λ ∷ ο ∷ ι ∷ []) "2Pet.3.14"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.14"
∷ word (ἀ ∷ μ ∷ ώ ∷ μ ∷ η ∷ τ ∷ ο ∷ ι ∷ []) "2Pet.3.14"
∷ word (α ∷ ὐ ∷ τ ∷ ῷ ∷ []) "2Pet.3.14"
∷ word (ε ∷ ὑ ∷ ρ ∷ ε ∷ θ ∷ ῆ ∷ ν ∷ α ∷ ι ∷ []) "2Pet.3.14"
∷ word (ἐ ∷ ν ∷ []) "2Pet.3.14"
∷ word (ε ∷ ἰ ∷ ρ ∷ ή ∷ ν ∷ ῃ ∷ []) "2Pet.3.14"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.15"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.3.15"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.3.15"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "2Pet.3.15"
∷ word (ἡ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.3.15"
∷ word (μ ∷ α ∷ κ ∷ ρ ∷ ο ∷ θ ∷ υ ∷ μ ∷ ί ∷ α ∷ ν ∷ []) "2Pet.3.15"
∷ word (σ ∷ ω ∷ τ ∷ η ∷ ρ ∷ ί ∷ α ∷ ν ∷ []) "2Pet.3.15"
∷ word (ἡ ∷ γ ∷ ε ∷ ῖ ∷ σ ∷ θ ∷ ε ∷ []) "2Pet.3.15"
∷ word (κ ∷ α ∷ θ ∷ ὼ ∷ ς ∷ []) "2Pet.3.15"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.15"
∷ word (ὁ ∷ []) "2Pet.3.15"
∷ word (ἀ ∷ γ ∷ α ∷ π ∷ η ∷ τ ∷ ὸ ∷ ς ∷ []) "2Pet.3.15"
∷ word (ἡ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.3.15"
∷ word (ἀ ∷ δ ∷ ε ∷ ∙λ ∷ φ ∷ ὸ ∷ ς ∷ []) "2Pet.3.15"
∷ word (Π ∷ α ∷ ῦ ∷ ∙λ ∷ ο ∷ ς ∷ []) "2Pet.3.15"
∷ word (κ ∷ α ∷ τ ∷ ὰ ∷ []) "2Pet.3.15"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.3.15"
∷ word (δ ∷ ο ∷ θ ∷ ε ∷ ῖ ∷ σ ∷ α ∷ ν ∷ []) "2Pet.3.15"
∷ word (α ∷ ὐ ∷ τ ∷ ῷ ∷ []) "2Pet.3.15"
∷ word (σ ∷ ο ∷ φ ∷ ί ∷ α ∷ ν ∷ []) "2Pet.3.15"
∷ word (ἔ ∷ γ ∷ ρ ∷ α ∷ ψ ∷ ε ∷ ν ∷ []) "2Pet.3.15"
∷ word (ὑ ∷ μ ∷ ῖ ∷ ν ∷ []) "2Pet.3.15"
∷ word (ὡ ∷ ς ∷ []) "2Pet.3.16"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.16"
∷ word (ἐ ∷ ν ∷ []) "2Pet.3.16"
∷ word (π ∷ ά ∷ σ ∷ α ∷ ι ∷ ς ∷ []) "2Pet.3.16"
∷ word (τ ∷ α ∷ ῖ ∷ ς ∷ []) "2Pet.3.16"
∷ word (ἐ ∷ π ∷ ι ∷ σ ∷ τ ∷ ο ∷ ∙λ ∷ α ∷ ῖ ∷ ς ∷ []) "2Pet.3.16"
∷ word (∙λ ∷ α ∷ ∙λ ∷ ῶ ∷ ν ∷ []) "2Pet.3.16"
∷ word (ἐ ∷ ν ∷ []) "2Pet.3.16"
∷ word (α ∷ ὐ ∷ τ ∷ α ∷ ῖ ∷ ς ∷ []) "2Pet.3.16"
∷ word (π ∷ ε ∷ ρ ∷ ὶ ∷ []) "2Pet.3.16"
∷ word (τ ∷ ο ∷ ύ ∷ τ ∷ ω ∷ ν ∷ []) "2Pet.3.16"
∷ word (ἐ ∷ ν ∷ []) "2Pet.3.16"
∷ word (α ∷ ἷ ∷ ς ∷ []) "2Pet.3.16"
∷ word (ἐ ∷ σ ∷ τ ∷ ι ∷ ν ∷ []) "2Pet.3.16"
∷ word (δ ∷ υ ∷ σ ∷ ν ∷ ό ∷ η ∷ τ ∷ ά ∷ []) "2Pet.3.16"
∷ word (τ ∷ ι ∷ ν ∷ α ∷ []) "2Pet.3.16"
∷ word (ἃ ∷ []) "2Pet.3.16"
∷ word (ο ∷ ἱ ∷ []) "2Pet.3.16"
∷ word (ἀ ∷ μ ∷ α ∷ θ ∷ ε ∷ ῖ ∷ ς ∷ []) "2Pet.3.16"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.16"
∷ word (ἀ ∷ σ ∷ τ ∷ ή ∷ ρ ∷ ι ∷ κ ∷ τ ∷ ο ∷ ι ∷ []) "2Pet.3.16"
∷ word (σ ∷ τ ∷ ρ ∷ ε ∷ β ∷ ∙λ ∷ ο ∷ ῦ ∷ σ ∷ ι ∷ ν ∷ []) "2Pet.3.16"
∷ word (ὡ ∷ ς ∷ []) "2Pet.3.16"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.16"
∷ word (τ ∷ ὰ ∷ ς ∷ []) "2Pet.3.16"
∷ word (∙λ ∷ ο ∷ ι ∷ π ∷ ὰ ∷ ς ∷ []) "2Pet.3.16"
∷ word (γ ∷ ρ ∷ α ∷ φ ∷ ὰ ∷ ς ∷ []) "2Pet.3.16"
∷ word (π ∷ ρ ∷ ὸ ∷ ς ∷ []) "2Pet.3.16"
∷ word (τ ∷ ὴ ∷ ν ∷ []) "2Pet.3.16"
∷ word (ἰ ∷ δ ∷ ί ∷ α ∷ ν ∷ []) "2Pet.3.16"
∷ word (α ∷ ὐ ∷ τ ∷ ῶ ∷ ν ∷ []) "2Pet.3.16"
∷ word (ἀ ∷ π ∷ ώ ∷ ∙λ ∷ ε ∷ ι ∷ α ∷ ν ∷ []) "2Pet.3.16"
∷ word (ὑ ∷ μ ∷ ε ∷ ῖ ∷ ς ∷ []) "2Pet.3.17"
∷ word (ο ∷ ὖ ∷ ν ∷ []) "2Pet.3.17"
∷ word (ἀ ∷ γ ∷ α ∷ π ∷ η ∷ τ ∷ ο ∷ ί ∷ []) "2Pet.3.17"
∷ word (π ∷ ρ ∷ ο ∷ γ ∷ ι ∷ ν ∷ ώ ∷ σ ∷ κ ∷ ο ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.3.17"
∷ word (φ ∷ υ ∷ ∙λ ∷ ά ∷ σ ∷ σ ∷ ε ∷ σ ∷ θ ∷ ε ∷ []) "2Pet.3.17"
∷ word (ἵ ∷ ν ∷ α ∷ []) "2Pet.3.17"
∷ word (μ ∷ ὴ ∷ []) "2Pet.3.17"
∷ word (τ ∷ ῇ ∷ []) "2Pet.3.17"
∷ word (τ ∷ ῶ ∷ ν ∷ []) "2Pet.3.17"
∷ word (ἀ ∷ θ ∷ έ ∷ σ ∷ μ ∷ ω ∷ ν ∷ []) "2Pet.3.17"
∷ word (π ∷ ∙λ ∷ ά ∷ ν ∷ ῃ ∷ []) "2Pet.3.17"
∷ word (σ ∷ υ ∷ ν ∷ α ∷ π ∷ α ∷ χ ∷ θ ∷ έ ∷ ν ∷ τ ∷ ε ∷ ς ∷ []) "2Pet.3.17"
∷ word (ἐ ∷ κ ∷ π ∷ έ ∷ σ ∷ η ∷ τ ∷ ε ∷ []) "2Pet.3.17"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.3.17"
∷ word (ἰ ∷ δ ∷ ί ∷ ο ∷ υ ∷ []) "2Pet.3.17"
∷ word (σ ∷ τ ∷ η ∷ ρ ∷ ι ∷ γ ∷ μ ∷ ο ∷ ῦ ∷ []) "2Pet.3.17"
∷ word (α ∷ ὐ ∷ ξ ∷ ά ∷ ν ∷ ε ∷ τ ∷ ε ∷ []) "2Pet.3.18"
∷ word (δ ∷ ὲ ∷ []) "2Pet.3.18"
∷ word (ἐ ∷ ν ∷ []) "2Pet.3.18"
∷ word (χ ∷ ά ∷ ρ ∷ ι ∷ τ ∷ ι ∷ []) "2Pet.3.18"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.18"
∷ word (γ ∷ ν ∷ ώ ∷ σ ∷ ε ∷ ι ∷ []) "2Pet.3.18"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "2Pet.3.18"
∷ word (κ ∷ υ ∷ ρ ∷ ί ∷ ο ∷ υ ∷ []) "2Pet.3.18"
∷ word (ἡ ∷ μ ∷ ῶ ∷ ν ∷ []) "2Pet.3.18"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.18"
∷ word (σ ∷ ω ∷ τ ∷ ῆ ∷ ρ ∷ ο ∷ ς ∷ []) "2Pet.3.18"
∷ word (Ἰ ∷ η ∷ σ ∷ ο ∷ ῦ ∷ []) "2Pet.3.18"
∷ word (Χ ∷ ρ ∷ ι ∷ σ ∷ τ ∷ ο ∷ ῦ ∷ []) "2Pet.3.18"
∷ word (α ∷ ὐ ∷ τ ∷ ῷ ∷ []) "2Pet.3.18"
∷ word (ἡ ∷ []) "2Pet.3.18"
∷ word (δ ∷ ό ∷ ξ ∷ α ∷ []) "2Pet.3.18"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.18"
∷ word (ν ∷ ῦ ∷ ν ∷ []) "2Pet.3.18"
∷ word (κ ∷ α ∷ ὶ ∷ []) "2Pet.3.18"
∷ word (ε ∷ ἰ ∷ ς ∷ []) "2Pet.3.18"
∷ word (ἡ ∷ μ ∷ έ ∷ ρ ∷ α ∷ ν ∷ []) "2Pet.3.18"
∷ word (α ∷ ἰ ∷ ῶ ∷ ν ∷ ο ∷ ς ∷ []) "2Pet.3.18"
∷ word (ἀ ∷ μ ∷ ή ∷ ν ∷ []) "2Pet.3.18"
∷ []
|
{
"alphanum_fraction": 0.3381454642,
"avg_line_length": 47.5329125338,
"ext": "agda",
"hexsha": "e6edc586335c6b2a0c11eb4fff068eefabff7eb1",
"lang": "Agda",
"max_forks_count": 5,
"max_forks_repo_forks_event_max_datetime": "2017-06-11T11:25:09.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-02-27T22:34:13.000Z",
"max_forks_repo_head_hexsha": "915c46c27c7f8aad5907474d8484f2685a4cd6a7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "scott-fleischman/GreekGrammar",
"max_forks_repo_path": "agda/Text/Greek/SBLGNT/2Pet.agda",
"max_issues_count": 13,
"max_issues_repo_head_hexsha": "915c46c27c7f8aad5907474d8484f2685a4cd6a7",
"max_issues_repo_issues_event_max_datetime": "2020-09-07T11:58:38.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-05-28T20:04:08.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "scott-fleischman/GreekGrammar",
"max_issues_repo_path": "agda/Text/Greek/SBLGNT/2Pet.agda",
"max_line_length": 90,
"max_stars_count": 44,
"max_stars_repo_head_hexsha": "915c46c27c7f8aad5907474d8484f2685a4cd6a7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "scott-fleischman/GreekGrammar",
"max_stars_repo_path": "agda/Text/Greek/SBLGNT/2Pet.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-06T15:41:57.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-05-29T14:48:51.000Z",
"num_tokens": 38003,
"size": 52714
}
|
module Chain
{ A : Set }
(_==_ : A -> A -> Set )
(refl : (x : A) -> x == x)
(trans : (x y z : A) -> x == y -> y == z -> x == z)
where
infix 2 chain>_
infixl 2 _===_
infix 3 _by_
chain>_ : (x : A) -> x == x
chain> x = refl _
_===_ : {x y z : A} -> x == y -> y == z -> x == z
xy === yz = trans _ _ _ xy yz
_by_ : {x : A}(y : A) -> x == y -> x == y
y by eq = eq
|
{
"alphanum_fraction": 0.3697270471,
"avg_line_length": 18.3181818182,
"ext": "agda",
"hexsha": "c53c8f55165034237128f22ec9bed845fe614f4c",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "examples/outdated-and-incorrect/lattice/Chain.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "examples/outdated-and-incorrect/lattice/Chain.agda",
"max_line_length": 55,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "examples/outdated-and-incorrect/lattice/Chain.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 177,
"size": 403
}
|
{-# OPTIONS --without-K --safe #-}
open import Algebra.Construct.DirectProduct
module Construct.DirectProduct where
open import Algebra.Bundles
import Algebra.Construct.DirectProduct as DirectProduct
open import Data.Product
open import Data.Product.Relation.Binary.Pointwise.NonDependent
open import Level using (Level; _⊔_)
private
variable
a b ℓ₁ ℓ₂ : Level
|
{
"alphanum_fraction": 0.7930107527,
"avg_line_length": 21.8823529412,
"ext": "agda",
"hexsha": "ab357e9238828910f6cfba6aef74eb42862bcdb1",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "72030f78934877ad67bf4e36e74e43845cabbf55",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Akshobhya1234/Agda-Algebra",
"max_forks_repo_path": "src/Construct/DirectProduct.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "72030f78934877ad67bf4e36e74e43845cabbf55",
"max_issues_repo_issues_event_max_datetime": "2022-01-31T18:19:52.000Z",
"max_issues_repo_issues_event_min_datetime": "2022-01-02T20:50:34.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Akshobhya1234/Agda-Algebra",
"max_issues_repo_path": "src/Construct/DirectProduct.agda",
"max_line_length": 63,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "72030f78934877ad67bf4e36e74e43845cabbf55",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Akshobhya1234/Agda-Algebra",
"max_stars_repo_path": "src/Construct/DirectProduct.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 86,
"size": 372
}
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Core lemmas for division and modulus operations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Nat.DivMod.Core where
open import Agda.Builtin.Nat using ()
renaming (div-helper to divₕ; mod-helper to modₕ)
open import Data.Nat
open import Data.Nat.Properties
open import Relation.Binary.PropositionalEquality
open ≡-Reasoning
-------------------------------------------------------------------------
-- mod lemmas
modₕ-skipTo0 : ∀ acc n a b → modₕ acc n (b + a) a ≡ modₕ (a + acc) n b 0
modₕ-skipTo0 acc n zero b = cong (λ v → modₕ acc n v 0) (+-identityʳ b)
modₕ-skipTo0 acc n (suc a) b = begin
modₕ acc n (b + suc a) (suc a) ≡⟨ cong (λ v → modₕ acc n v (suc a)) (+-suc b a) ⟩
modₕ acc n (suc b + a) (suc a) ≡⟨⟩
modₕ (suc acc) n (b + a) a ≡⟨ modₕ-skipTo0 (suc acc) n a b ⟩
modₕ (a + suc acc) n b 0 ≡⟨ cong (λ v → modₕ v n b 0) (+-suc a acc) ⟩
modₕ (suc a + acc) n b 0 ∎
modₕ-skipToEnd : ∀ acc n a b → modₕ acc n a (a + b) ≡ acc + a
modₕ-skipToEnd acc n zero b = sym (+-identityʳ acc)
modₕ-skipToEnd acc n (suc a) b = begin
modₕ (suc acc) n a (a + b) ≡⟨ modₕ-skipToEnd (suc acc) n a b ⟩
suc acc + a ≡⟨ sym (+-suc acc a) ⟩
acc + suc a ∎
a[modₕ]1≡0 : ∀ a → modₕ 0 0 a 0 ≡ 0
a[modₕ]1≡0 zero = refl
a[modₕ]1≡0 (suc a) = a[modₕ]1≡0 a
n[modₕ]n≡0 : ∀ acc v → modₕ acc (acc + v) (suc v) v ≡ 0
n[modₕ]n≡0 acc v = modₕ-skipTo0 acc (acc + v) v 1
a[modₕ]n<n : ∀ acc d n → modₕ acc (acc + n) d n ≤ acc + n
a[modₕ]n<n acc zero n = m≤m+n acc n
a[modₕ]n<n acc (suc d) zero = a[modₕ]n<n zero d (acc + 0)
a[modₕ]n<n acc (suc d) (suc n)
rewrite +-suc acc n = a[modₕ]n<n (suc acc) d n
modₕ-idem : ∀ acc a n → modₕ 0 (acc + n) (modₕ acc (acc + n) a n) (acc + n) ≡ modₕ acc (acc + n) a n
modₕ-idem acc zero n = modₕ-skipToEnd 0 (acc + n) acc n
modₕ-idem acc (suc a) zero rewrite +-identityʳ acc = modₕ-idem 0 a acc
modₕ-idem acc (suc a) (suc n) rewrite +-suc acc n = modₕ-idem (suc acc) a n
a+n[modₕ]n≡a[modₕ]n : ∀ acc a n → modₕ acc (acc + n) (acc + a + suc n) n ≡ modₕ acc (acc + n) a n
a+n[modₕ]n≡a[modₕ]n acc zero n rewrite +-identityʳ acc = begin
modₕ acc (acc + n) (acc + suc n) n ≡⟨ cong (λ v → modₕ acc (acc + n) v n) (+-suc acc n) ⟩
modₕ acc (acc + n) (suc acc + n) n ≡⟨ modₕ-skipTo0 acc (acc + n) n (suc acc) ⟩
modₕ (acc + n) (acc + n) (suc acc) 0 ≡⟨⟩
modₕ 0 (acc + n) acc (acc + n) ≡⟨ modₕ-skipToEnd 0 (acc + n) acc n ⟩
acc ∎
a+n[modₕ]n≡a[modₕ]n acc (suc a) zero rewrite +-identityʳ acc = begin
modₕ acc acc (acc + suc a + 1) 0 ≡⟨ cong (λ v → modₕ acc acc v 0) (+-comm (acc + suc a) 1) ⟩
modₕ acc acc (1 + (acc + suc a)) 0 ≡⟨⟩
modₕ 0 acc (acc + suc a) acc ≡⟨ cong (λ v → modₕ 0 acc v acc) (+-comm acc (suc a)) ⟩
modₕ 0 acc (suc a + acc) acc ≡⟨ cong (λ v → modₕ 0 acc v acc) (sym (+-suc a acc)) ⟩
modₕ 0 acc (a + suc acc) acc ≡⟨ a+n[modₕ]n≡a[modₕ]n 0 a acc ⟩
modₕ 0 acc a acc ∎
a+n[modₕ]n≡a[modₕ]n acc (suc a) (suc n) rewrite +-suc acc n = begin
mod₁ (acc + suc a + (2 + n)) (suc n) ≡⟨ cong (λ v → mod₁ (v + suc (suc n)) (suc n)) (+-suc acc a) ⟩
mod₁ (suc acc + a + (2 + n)) (suc n) ≡⟨⟩
mod₂ (acc + a + (2 + n)) n ≡⟨ cong (λ v → mod₂ v n) (sym (+-assoc (acc + a) 1 (suc n))) ⟩
mod₂ (acc + a + 1 + suc n) n ≡⟨ cong (λ v → mod₂ (v + suc n) n) (+-comm (acc + a) 1) ⟩
mod₂ (suc acc + a + suc n) n ≡⟨ a+n[modₕ]n≡a[modₕ]n (suc acc) a n ⟩
mod₂ a n ∎
where
mod₁ = modₕ acc (suc acc + n)
mod₂ = modₕ (suc acc) (suc acc + n)
-------------------------------------------------------------------------
-- division lemmas
-- The quotient and remainder are related to the dividend and
-- divisor in the right way.
division-lemma : ∀ accᵐ accᵈ d n →
accᵐ + accᵈ * suc (accᵐ + n) + d ≡
modₕ accᵐ (accᵐ + n) d n + divₕ accᵈ (accᵐ + n) d n * suc (accᵐ + n)
division-lemma accᵐ accᵈ zero n = +-identityʳ _
division-lemma accᵐ accᵈ (suc d) zero rewrite +-identityʳ accᵐ = begin
accᵐ + accᵈ * suc accᵐ + suc d ≡⟨ +-suc _ d ⟩
suc accᵈ * suc accᵐ + d ≡⟨ division-lemma zero (suc accᵈ) d accᵐ ⟩
modₕ 0 accᵐ d accᵐ +
divₕ (suc accᵈ) accᵐ d accᵐ * suc accᵐ ≡⟨⟩
modₕ accᵐ accᵐ (suc d) 0 +
divₕ accᵈ accᵐ (suc d) 0 * suc accᵐ ∎
division-lemma accᵐ accᵈ (suc d) (suc n) rewrite +-suc accᵐ n = begin
accᵐ + accᵈ * m + suc d ≡⟨ +-suc _ d ⟩
suc (accᵐ + accᵈ * m + d) ≡⟨ division-lemma (suc accᵐ) accᵈ d n ⟩
modₕ _ _ d n + divₕ accᵈ _ d n * m ∎
where
m = 2 + accᵐ + n
|
{
"alphanum_fraction": 0.506954536,
"avg_line_length": 45.8761904762,
"ext": "agda",
"hexsha": "eac7f28783304b5b74fcd64ce749b95060c1ea95",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "omega12345/agda-mode",
"max_forks_repo_path": "test/asset/agda-stdlib-1.0/Data/Nat/DivMod/Core.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "omega12345/agda-mode",
"max_issues_repo_path": "test/asset/agda-stdlib-1.0/Data/Nat/DivMod/Core.agda",
"max_line_length": 101,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "omega12345/agda-mode",
"max_stars_repo_path": "test/asset/agda-stdlib-1.0/Data/Nat/DivMod/Core.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2213,
"size": 4817
}
|
open import SOAS.Metatheory.Syntax
-- Metasubstitution operation
module SOAS.Metatheory.SecondOrder.Metasubstitution {T : Set}(Syn : Syntax {T}) where
open Syntax Syn
open import SOAS.Metatheory.FreeMonoid Syn
open import SOAS.Common
open import SOAS.Families.Core {T}
open import SOAS.Families.Build
open import SOAS.Context
open import SOAS.Variable
open import SOAS.Construction.Structure as Structure
open import SOAS.ContextMaps.Combinators
open import SOAS.ContextMaps.CategoryOfRenamings
open import SOAS.Abstract.Hom
open import SOAS.Abstract.ExpStrength
import SOAS.Abstract.Coalgebra as →□
open →□.Sorted
import SOAS.Abstract.Box as □ ; open □.Sorted
open import Categories.Monad
open import SOAS.Coalgebraic.Monoid
open import SOAS.Metatheory Syn
private
variable
Γ Δ Π : Ctx
α β τ : T
𝔛 𝔜 ℨ : Familyₛ
𝔐 𝔑 : MCtx
open Theory
-- Ground metasubstitution from the monad structure
msub₀ : (𝔛 ⇾̣ 𝕋 𝔜) → 𝕋 𝔛 ⇾̣ 𝕋 𝔜
msub₀ {𝔛}{𝔜} κ t = μ.η 𝔜 (F.₁ κ t) where open Monad ΣMon:Monad
-- Meta-algebra structure on the exponential [ 𝔛 ⊸ 𝒫 ] ⇨ ℳ
[_⊸_]⇨_ᵃ : (𝔛 {𝒫}{ℳ} : Familyₛ) → Coalg 𝒫 → ΣMon ℳ → (𝒫 ⇾̣ ℳ)
→ MetaAlg 𝔛 ([ 𝔛 ⊸ 𝒫 ] ⇨ ℳ)
[_⊸_]⇨_ᵃ 𝔛 {𝒫}{ℳ} 𝒫ᵇ Σℳᵐ ψ = record
{ 𝑎𝑙𝑔 = λ t ζ → ℳ.𝑎𝑙𝑔 (estr [ 𝔛 ⊸ 𝒫ᵇ ]ᵇ ℳ t ζ)
; 𝑣𝑎𝑟 = λ v ζ → ℳ.η v
; 𝑚𝑣𝑎𝑟 = λ 𝔪 ε ζ → ℳ.μ (ψ (ζ 𝔪)) (copair ℳ (λ x → ε x ζ) ℳ.η)
} where module ℳ = ΣMon Σℳᵐ
□[_⊸_]⇨_ᵃ : (𝔛 {𝒫}{ℳ} : Familyₛ) → Coalg 𝒫 → ΣMon ℳ → (𝒫 ⇾̣ ℳ)
→ MetaAlg 𝔛 ([ 𝔛 ⊸ 𝒫 ] ➡ ℳ)
□[ 𝔛 ⊸ 𝒫ᵇ ]⇨ Σℳᵐ ᵃ ψ = □ᵃ 𝔛 ([ 𝔛 ⊸ 𝒫ᵇ ]⇨ Σℳᵐ ᵃ ψ)
-- Derived meta-algebra instance for [ 𝔛 ⊸ 𝕋 𝔜 ] ⇨ 𝕋 𝔜
⟅_⇨_⟆ᵃ : (𝔛 𝔜 : Familyₛ) → MetaAlg 𝔛 ⟅ 𝔛 ⇨ 𝕋 𝔜 ⟆
⟅ 𝔛 ⇨ 𝔜 ⟆ᵃ = [ 𝔛 ⊸ 𝕋ᵇ 𝔜 ]⇨ Σ𝕋ᵐ 𝔜 ᵃ id
module MS {𝔛 𝔜 : Familyₛ} = Semantics 𝔛 ⟅ 𝔛 ⇨ 𝔜 ⟆ᵃ
module □MS {𝔛 𝔜 : Familyₛ} = □Traversal 𝔛 ⟅ 𝔛 ⇨ 𝔜 ⟆ᵃ
-- Metasubstitution operations
-- Base
msub : 𝕋 𝔛 ⇾̣ ⟅ 𝔛 ⇨ 𝕋 𝔜 ⟆
msub = MS.𝕤𝕖𝕞
-- Parametrised
□msub : 𝕋 𝔛 ⇾̣ ⟅ 𝔛 ➡ 𝕋 𝔜 ⟆
□msub = □MS.𝕥𝕣𝕒𝕧
-- Linear
○msub : 𝕋 𝔛 ⇾̣ ⟅ 𝔛 ⊸ 𝕋 𝔜 ⟆
○msub {𝔜 = 𝔜}{Γ = Γ} t ζ = □msub t (inl Γ) λ {_}{Π} 𝔪 → 𝕣𝕖𝕟 𝔜 (ζ 𝔪) (Π ∔∣ inr Γ)
-- Unit parametrisation
□msub-id : (t : 𝕋 𝔛 α Γ)(κ : [ 𝔛 ⊸ 𝕋 𝔜 ] Γ) → □msub t id κ ≡ msub t κ
□msub-id {𝔛}{𝔜 = 𝔜} t κ = cong (λ - → - κ) (□𝕥𝕣𝕒𝕧-id≈𝕤𝕖𝕞 𝔛 ⟅ 𝔛 ⇨ 𝔜 ⟆ᵃ)
-- Unit metasubstitution mapping
ms-unit : [ 𝔛 ⊸ 𝕋 𝔛 ] Γ
ms-unit {𝔛}{Δ = Δ} 𝔪 = 𝕞𝕧𝕒𝕣 𝔛 𝔪 (𝕧𝕒𝕣 𝔛 ∘ inl Δ)
-- | Inductive metasubstitution
-- List of terms in an extended (object variable) context mapped to every element of a metavariable context
data MSub (Γ : Ctx) : MCtx → MCtx → Set₁ where
◦ : MSub Γ ⁅⁆ 𝔑
_◃_ : (𝔑 ▷ 𝕋) α (Π ∔ Γ) → MSub Γ 𝔐 𝔑 → MSub Γ (⁅ Π ⊩ₙ α ⁆ 𝔐) 𝔑
infixr 15 _◃_ _▹_
-- Add term to the end of a metasubstitution map
_▹_ : MSub Γ 𝔐 𝔑 → (𝔑 ▷ 𝕋) τ (Π ∔ Γ) → MSub Γ (𝔐 ⁅ Π ⊩ₙ τ ⁆) 𝔑
◦ ▹ t = t ◃ ◦
(s ◃ ζ) ▹ t = s ◃ (ζ ▹ t)
-- Application of a metasubstitution to a metavariable
ix≀ : MSub Γ 𝔐 𝔑 → [ ∥ 𝔐 ∥ ⊸ 𝔑 ▷ 𝕋 ] Γ
ix≀ (t ◃ ζ) ↓ = t
ix≀ (t ◃ ζ) (↑ 𝔪) = ix≀ ζ 𝔪
-- Term corresponding to the topmost distinguished metavariable of an extended mvar context
_⊩◌ : (Π : Ctx) → (⁅ Π ⊩ₙ β ⁆ 𝔐 ▷ 𝕋) β (Π ∔ Γ)
_⊩◌ {β}{𝔐} Π = ms-unit ↓
◌ : (⁅ β ⁆ 𝔐 ▷ 𝕋) β Γ
◌ = ∅ ⊩◌
-- Weakening of metavariable context
wk≀ : (𝔐 ▷ 𝕋) α Γ → (⁅ Π ⊩ₙ τ ⁆ 𝔐 ▷ 𝕋) α Γ
wk≀ t = 𝕋₁ ↑_ t
-- Extension of the codomain of a metasubstitution
ext≀ : (Π : Ctx)(τ : T) → MSub Γ 𝔐 𝔑 → MSub Γ 𝔐 (⁅ Π ⊩ₙ τ ⁆ 𝔑)
ext≀ Π τ ◦ = ◦
ext≀ Π τ (t ◃ κ) = wk≀ t ◃ (ext≀ Π τ κ)
-- Lifting of a metasubstitution
lift≀ : (Π : Ctx)(τ : T) → MSub Γ 𝔐 𝔑 → MSub Γ (⁅ Π ⊩ₙ τ ⁆ 𝔐) (⁅ Π ⊩ₙ τ ⁆ 𝔑)
lift≀ Π τ κ = (Π ⊩◌) ◃ (ext≀ Π τ κ)
-- Identity metasubstitution
id≀ : (Γ : Ctx) → MSub Γ 𝔐 𝔐
id≀ {⁅⁆} Γ = ◦
id≀ {⁅ Π ⊩ₙ τ ⁆ 𝔐} Γ = lift≀ Π τ (id≀ Γ)
-- Left and right weakening of object context of a metasubstitution
inl≀ : MSub Γ 𝔐 𝔑 → MSub (Γ ∔ Δ) 𝔐 𝔑
inl≀ ◦ = ◦
inl≀ {𝔑 = 𝔑} (_◃_ {Π = Π} t κ) = 𝕣𝕖𝕟 ∥ 𝔑 ∥ t (Π ∔∣ inl _) ◃ (inl≀ κ)
inr≀ : (Γ : Ctx) → MSub Δ 𝔐 𝔑 → MSub (Γ ∔ Δ) 𝔐 𝔑
inr≀ _ ◦ = ◦
inr≀ {Δ}{𝔑 = 𝔑} Γ (_◃_ {Π = Π} t κ) = (𝕣𝕖𝕟 ∥ 𝔑 ∥ t (Π ∔∣ inr Γ)) ◃ (inr≀ Γ κ)
-- Application of weakened metasubstitution corresponds to centre weakening
ix-inr≀ : (κ : MSub Δ 𝔐 𝔑)(𝔪 : Π ⊩ τ ∈ 𝔐)
→ ix≀ (inr≀ Γ κ) 𝔪 ≡ (𝕣𝕖𝕟 ∥ 𝔑 ∥ (ix≀ κ 𝔪) (Π ∔∣ inr Γ))
ix-inr≀ (x ◃ κ) ↓ = refl
ix-inr≀ (x ◃ κ) (↑ 𝔪) = ix-inr≀ κ 𝔪
-- Correctness lemmas of weakening, lifting, identity
ext≀≈𝕋₁pop : (κ : MSub Γ 𝔐 𝔑)(𝔪 : Π ⊩ τ ∈ 𝔐) → ix≀ (ext≀ Δ β κ) 𝔪 ≡ wk≀ (ix≀ κ 𝔪)
ext≀≈𝕋₁pop (x ◃ κ) ↓ = refl
ext≀≈𝕋₁pop (x ◃ κ) (↑ 𝔪) = ext≀≈𝕋₁pop κ 𝔪
lift≀≈𝕋₁pop : (κ : MSub Γ 𝔐 𝔑)(𝔪 : Γ ⊩ α ∈ 𝔐) → ix≀ (lift≀ Γ α κ) (↑ 𝔪) ≡ wk≀ (ix≀ κ 𝔪)
lift≀≈𝕋₁pop (x ◃ κ) ↓ = refl
lift≀≈𝕋₁pop (x ◃ κ) (↑ 𝔪) = lift≀≈𝕋₁pop κ 𝔪
id≀≈ms-unit : (Γ : Ctx)(𝔪 : Π ⊩ τ ∈ 𝔐) → ix≀ (id≀ Γ) 𝔪 ≡ ms-unit 𝔪
id≀≈ms-unit {𝔐 = ⁅ Π ⊩ₙ τ ⁆ 𝔐} Γ ↓ = refl
id≀≈ms-unit {𝔐 = ⁅ Π ⊩ₙ τ ⁆ 𝔐} Γ (↑_ {Δ}{β}{Γ = .Π}{.τ} 𝔪) = begin
ix≀ (ext≀ Π τ (id≀ Γ)) 𝔪
≡⟨ ext≀≈𝕋₁pop (id≀ Γ) 𝔪 ⟩
wk≀ (ix≀ (id≀ Γ) 𝔪)
≡⟨ cong (wk≀) (id≀≈ms-unit Γ 𝔪) ⟩
wk≀ (ms-unit 𝔪)
≡⟨⟩
wk≀ (𝕞𝕧𝕒𝕣 ∥ 𝔐 ∥ 𝔪 (𝕧𝕒𝕣 ∥ 𝔐 ∥ ∘ ∔.i₁))
≡⟨ 𝕋₁∘𝕞𝕧𝕒𝕣[𝕧𝕒𝕣] ↑_ 𝔪 (∔.i₁) ⟩
𝕞𝕧𝕒𝕣 ∥ ⁅ Π ⊩ₙ τ ⁆ 𝔐 ∥ (↑ 𝔪) (𝕧𝕒𝕣 ∥ ⁅ Π ⊩ₙ τ ⁆ 𝔐 ∥ ∘ ∔.i₁)
∎ where open ≡-Reasoning
-- Inductive metasubstitution operations
-- Base
msub≀ : (𝔐 ▷ 𝕋) α Γ → MSub Γ 𝔐 𝔑 → (𝔑 ▷ 𝕋) α Γ
msub≀ t ζ = msub t (ix≀ ζ)
-- Parametrised
□msub≀ : (𝔐 ▷ 𝕋) α Γ → (Γ ↝ Δ) → MSub Δ 𝔐 𝔑 → (𝔑 ▷ 𝕋) α Δ
□msub≀ t ρ ζ = □msub t ρ (ix≀ ζ)
-- Linear
○msub≀ : (𝔐 ▷ 𝕋) α Γ → MSub Δ 𝔐 𝔑 → (𝔑 ▷ 𝕋) α (Γ ∔ Δ)
○msub≀ {Γ = Γ} t ζ = □msub≀ t (inl Γ) (inr≀ Γ ζ)
-- Syntactic sugar for metasubstitution application
_》 : (𝔑 ▷ 𝕋) α (Π ∔ Γ) → MSub Γ (⁅ Π ⊩ₙ α ⁆̣) 𝔑
t 》 = t ◃ ◦
_《_ : (𝔐 ▷ 𝕋) α Γ → MSub Γ 𝔐 𝔑 → (𝔑 ▷ 𝕋) α Γ
_《_ = msub≀
infixr 25 _》
infix 15 _《_
-- Instantiation of a term extended at the start of the context
instₛ : (⁅ Π ⊩ₙ α ⁆ 𝔐 ▷ 𝕋) β Γ → (𝔐 ▷ 𝕋) α (Π ∔ Γ) → (𝔐 ▷ 𝕋) β Γ
instₛ {Γ = Γ} h s = msub≀ h (s ◃ id≀ Γ)
-- Instantiation of a term extended at the end of the context
instₑ : (𝔐 ⁅ Π ⊩ₙ α ⁆ ▷ 𝕋) β Γ → (𝔐 ▷ 𝕋) α (Π ∔ Γ) → (𝔐 ▷ 𝕋) β Γ
instₑ {Γ = Γ} h s = msub≀ h ((id≀ Γ) ▹ s)
-- Instantiation of a term extended twice at the end of the context
instₑ₂ : {Π₁ Π₂ : Ctx}{α₁ α₂ : T}
→ ((𝔐 ⁅ Π₁ ⊩ₙ α₁ ⁆) ⁅ Π₂ ⊩ₙ α₂ ⁆ ▷ 𝕋) β Γ
→ (𝔐 ▷ 𝕋) α₁ (Π₁ ∔ Γ) → (𝔐 ▷ 𝕋) α₂ (Π₂ ∔ Γ) → (𝔐 ▷ 𝕋) β Γ
instₑ₂ {Γ = Γ} h s t = msub≀ h ((id≀ Γ ▹ s) ▹ t)
|
{
"alphanum_fraction": 0.5361921651,
"avg_line_length": 31.1708542714,
"ext": "agda",
"hexsha": "15373a14fbc8a4538a57a8457a4e40d4eb80829d",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b224d31e20cfd010b7c924ce940f3c2f417777e3",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "k4rtik/agda-soas",
"max_forks_repo_path": "SOAS/Metatheory/SecondOrder/Metasubstitution.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "b224d31e20cfd010b7c924ce940f3c2f417777e3",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "k4rtik/agda-soas",
"max_issues_repo_path": "SOAS/Metatheory/SecondOrder/Metasubstitution.agda",
"max_line_length": 107,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "b224d31e20cfd010b7c924ce940f3c2f417777e3",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "k4rtik/agda-soas",
"max_stars_repo_path": "SOAS/Metatheory/SecondOrder/Metasubstitution.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 4013,
"size": 6203
}
|
-- Andreas, 2016-10-11, AIM XXIV, issue #2248
-- COMPILED_TYPE should only work on postulates
data Unit : Set where
unit : Unit
abstract
IO : Set → Set
IO A = A
doNothing : IO Unit
doNothing = unit
{-# COMPILED_TYPE IO IO #-}
main : IO unit
main = doNothing
|
{
"alphanum_fraction": 0.6666666667,
"avg_line_length": 15.1666666667,
"ext": "agda",
"hexsha": "e8a4bf90e418cac175a8f344c831749c8a3d0b51",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "pthariensflame/agda",
"max_forks_repo_path": "test/Fail/Issue2248_COMPILED_TYPE.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "pthariensflame/agda",
"max_issues_repo_path": "test/Fail/Issue2248_COMPILED_TYPE.agda",
"max_line_length": 47,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "222c4c64b2ccf8e0fc2498492731c15e8fef32d4",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "pthariensflame/agda",
"max_stars_repo_path": "test/Fail/Issue2248_COMPILED_TYPE.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 89,
"size": 273
}
|
-- an example showing how to use sigma types to define a type for non-zero natural numbers
module nat-nonzero where
open import bool
open import eq
open import nat
open import nat-thms
open import product
ℕ⁺ : Set
ℕ⁺ = Σ ℕ (λ n → iszero n ≡ ff)
suc⁺ : ℕ⁺ → ℕ⁺
suc⁺ (x , p) = (suc x , refl)
_+⁺_ : ℕ⁺ → ℕ⁺ → ℕ⁺
(x , p) +⁺ (y , q) = x + y , iszerosum2 x y p
_*⁺_ : ℕ⁺ → ℕ⁺ → ℕ⁺
(x , p) *⁺ (y , q) = (x * y , iszeromult x y p q)
|
{
"alphanum_fraction": 0.5787037037,
"avg_line_length": 20.5714285714,
"ext": "agda",
"hexsha": "2d0923f3d48a1d700a48f7936e25be849d32f533",
"lang": "Agda",
"max_forks_count": 17,
"max_forks_repo_forks_event_max_datetime": "2021-11-28T20:13:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-12-03T22:38:15.000Z",
"max_forks_repo_head_hexsha": "f3f0261904577e930bd7646934f756679a6cbba6",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "rfindler/ial",
"max_forks_repo_path": "nat-nonzero.agda",
"max_issues_count": 8,
"max_issues_repo_head_hexsha": "f3f0261904577e930bd7646934f756679a6cbba6",
"max_issues_repo_issues_event_max_datetime": "2022-03-22T03:43:34.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-07-09T22:53:38.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "rfindler/ial",
"max_issues_repo_path": "nat-nonzero.agda",
"max_line_length": 90,
"max_stars_count": 29,
"max_stars_repo_head_hexsha": "f3f0261904577e930bd7646934f756679a6cbba6",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "rfindler/ial",
"max_stars_repo_path": "nat-nonzero.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-04T15:05:12.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-02-06T13:09:31.000Z",
"num_tokens": 190,
"size": 432
}
|
{-# OPTIONS --safe #-}
module Definition.Typed.Consequences.Inequality where
open import Definition.Untyped hiding (U≢ℕ; U≢Π; U≢ne; ℕ≢Π; ℕ≢ne; Π≢ne; U≢Empty; ℕ≢Empty; Empty≢Π; Empty≢ne)
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.EqRelInstance
open import Definition.LogicalRelation
open import Definition.LogicalRelation.Irrelevance
open import Definition.LogicalRelation.ShapeView
open import Definition.LogicalRelation.Fundamental.Reducibility
open import Definition.Typed.Consequences.Syntactic
open import Tools.Product
open import Tools.Empty
import Tools.PropositionalEquality as PE
A≢B : ∀ {A B rA rB Γ} (_⊩′⟨_⟩A_ _⊩′⟨_⟩B_ : Con Term → TypeLevel → Term → Set)
(A-intr : ∀ {l} → Γ ⊩′⟨ l ⟩A A → Γ ⊩⟨ l ⟩ A ^ rA)
(B-intr : ∀ {l} → Γ ⊩′⟨ l ⟩B B → Γ ⊩⟨ l ⟩ B ^ rB)
(A-elim : ∀ {l} → Γ ⊩⟨ l ⟩ A ^ rA → ∃ λ l′ → Γ ⊩′⟨ l′ ⟩A A)
(B-elim : ∀ {l} → Γ ⊩⟨ l ⟩ B ^ rA → ∃ λ l′ → Γ ⊩′⟨ l′ ⟩B B)
(A≢B′ : ∀ {l l′} ([A] : Γ ⊩′⟨ l ⟩A A) ([B] : Γ ⊩′⟨ l′ ⟩B B)
→ ShapeView Γ l l′ A B rA rB (A-intr [A]) (B-intr [B]) → ⊥)
→ Γ ⊢ A ≡ B ^ rA → ⊥
A≢B {A} {B} _ _ A-intr B-intr A-elim B-elim A≢B′ A≡B =
let X = reducibleEq A≡B
[A] = proj₁ X
[B] = proj₁ (proj₂ X)
[A≡B] = proj₂ (proj₂ X)
_ , [A]′ = A-elim ([A])
_ , [B]′ = B-elim ([B])
[A≡B]′ = irrelevanceEq [A] (A-intr [A]′) [A≡B]
in A≢B′ [A]′ [B]′ (goodCases (A-intr [A]′) (B-intr [B]′) [A≡B]′)
U≢ℕ′ : ∀ {Γ A ll B l l′}
([U] : Γ ⊩′⟨ l ⟩U A ^ ll)
([ℕ] : Γ ⊩ℕ B)
→ ShapeView Γ l l′ _ _ [ ! , _ ] [ ! , _ ] (Uᵣ {ll = ll} [U]) (ℕᵣ [ℕ]) → ⊥
U≢ℕ′ a b ()
U≢ℕ-red : ∀ {ll r lU B Γ} → Γ ⊢ B ⇒* ℕ ^ [ ! , ll ] → Γ ⊢ Univ r lU ≡ B ^ [ ! , ll ] → ⊥
U≢ℕ-red {ll} D = A≢B (λ Γ l A → Γ ⊩′⟨ l ⟩U A ^ ll) (λ Γ l B → Γ ⊩ℕ B) Uᵣ ℕᵣ
(λ x → extractMaybeEmb (U-elim x))
(λ x → extractMaybeEmb (ℕ-elim′ D x))
U≢ℕ′
-- U and ℕ cannot be judgmentally equal.
U≢ℕ! : ∀ {r l ll Γ} → Γ ⊢ Univ r l ≡ ℕ ^ [ ! , ll ] → ⊥
U≢ℕ! U≡ℕ =
let _ , ⊢ℕ = syntacticEq U≡ℕ
in U≢ℕ-red (id ⊢ℕ) U≡ℕ
-- U vs Pi
U≢Π′ : ∀ {A lA B rB lB Γ l l′}
([U] : Γ ⊩′⟨ l ⟩U A ^ lA)
([Π] : Γ ⊩′⟨ l′ ⟩Π B ^[ rB , lB ])
→ ShapeView Γ l l′ _ _ _ _ (Uᵣ {ll = lA} [U]) (Πᵣ [Π]) → ⊥
U≢Π′ a b ()
U≢Π-red : ∀ {ll B F G rF lF lG rU lU Γ} → Γ ⊢ B ⇒* Π F ^ rF ° lF ▹ G ° lG ° ll ^ [ ! , ι ll ]
→ Γ ⊢ Univ rU lU ≡ B ^ [ ! , ι ll ] → ⊥
U≢Π-red {ll} D = A≢B (λ Γ l A → Γ ⊩′⟨ l ⟩U A ^ ι ll)
(λ Γ l A → Γ ⊩′⟨ l ⟩Π A ^[ ! , ll ]) Uᵣ Πᵣ
(λ x → extractMaybeEmb (U-elim x))
(λ x → extractMaybeEmb (Π-elim′ D x))
U≢Π′
-- U and Π F ▹ G for any F and G cannot be judgmentally equal.
U≢Π! : ∀ {rU lU F rF lF lG G l Γ} → Γ ⊢ Univ rU lU ≡ Π F ^ rF ° lF ▹ G ° lG ° l ^ [ ! , ι l ] → ⊥
U≢Π! U≡Π =
let _ , ⊢Π = syntacticEq U≡Π
in U≢Π-red (id ⊢Π) U≡Π
-- ∃ vs Pi
∃≢Π′ : ∀ {A lA B rB lB Γ l l′}
([∃] : Γ ⊩′⟨ l ⟩∃ A ^ lA)
([Π] : Γ ⊩′⟨ l′ ⟩Π B ^[ rB , lB ])
→ ShapeView Γ l l′ _ _ _ _ (∃ᵣ [∃]) (Πᵣ [Π]) → ⊥
∃≢Π′ a b ()
∃≢Π-red : ∀ {ll B F G rF lF lG P Q Γ} → Γ ⊢ B ⇒* Π F ^ rF ° lF ▹ G ° lG ° ll ^ [ % , ι ll ]
→ Γ ⊢ ∃ P ▹ Q ≡ B ^ [ % , ι ll ] → ⊥
∃≢Π-red {ll} D = A≢B (λ Γ l A → Γ ⊩′⟨ l ⟩∃ A ^ ll)
(λ Γ l A → Γ ⊩′⟨ l ⟩Π A ^[ % , ll ]) ∃ᵣ Πᵣ
(λ x → extractMaybeEmb (∃-elim x))
(λ x → extractMaybeEmb (Π-elim′ D x))
∃≢Π′
-- U and Π F ▹ G for any F and G cannot be judgmentally equal.
∃≢Π! : ∀ {P Q F rF lF lG G l Γ} → Γ ⊢ ∃ P ▹ Q ≡ Π F ^ rF ° lF ▹ G ° lG ° l ^ [ % , ι l ] → ⊥
∃≢Π! ∃≡Π =
let _ , ⊢Π = syntacticEq ∃≡Π
in ∃≢Π-red (id ⊢Π) ∃≡Π
U≢ne′ : ∀ {A lU r lK K Γ l l′}
([U] : Γ ⊩′⟨ l ⟩U A ^ lU)
([K] : Γ ⊩ne K ^[ r , lK ] )
→ ShapeView Γ l l′ _ _ _ _ (Uᵣ {ll = lU} [U]) (ne [K]) → ⊥
U≢ne′ a b ()
U≢ne-red : ∀ {ll rU lU B K Γ} → Γ ⊢ B ⇒* K ^ [ ! , ι ll ] → Neutral K → Γ ⊢ Univ rU lU ≡ B ^ [ ! , ι ll ] → ⊥
U≢ne-red {ll} D neK = A≢B (λ Γ l A → Γ ⊩′⟨ l ⟩U A ^ ι ll) (λ Γ l B → Γ ⊩ne B ^[ ! , ll ]) Uᵣ ne
(λ x → extractMaybeEmb (U-elim x))
(λ x → extractMaybeEmb (ne-elim′ D neK x PE.refl))
U≢ne′
-- U and K for any neutral K cannot be judgmentally equal.
U≢ne! : ∀ {r l ll K Γ} → Neutral K → Γ ⊢ Univ r l ≡ K ^ [ ! , ι ll ] → ⊥
U≢ne! neK U≡K =
let _ , ⊢K = syntacticEq U≡K
in U≢ne-red (id ⊢K) neK U≡K
ℕ≢Π′ : ∀ {A B Γ ll l l′}
([ℕ] : Γ ⊩ℕ A)
([Π] : Γ ⊩′⟨ l′ ⟩Π B ^[ ! , ll ])
→ ShapeView Γ l l′ _ _ _ _ (ℕᵣ [ℕ]) (Πᵣ [Π]) → ⊥
ℕ≢Π′ a b ()
ℕ≢Π-red : ∀ {A B F rF lF lG G Γ} → Γ ⊢ A ⇒* ℕ ^ [ ! , ι ⁰ ] → Γ ⊢ B ⇒* Π F ^ rF ° lF ▹ G ° lG ° ⁰ ^ [ ! , ι ⁰ ] → Γ ⊢ A ≡ B ^ [ ! , ι ⁰ ] → ⊥
ℕ≢Π-red D D′ = A≢B (λ Γ l A → Γ ⊩ℕ A)
(λ Γ l A → Γ ⊩′⟨ l ⟩Π A ^[ ! , ⁰ ]) ℕᵣ Πᵣ
(λ x → extractMaybeEmb (ℕ-elim′ D x))
(λ x → extractMaybeEmb (Π-elim′ D′ x))
ℕ≢Π′
-- ℕ and Π F ▹ G for any F and G cannot be judgmentally equal.
ℕ≢Π! : ∀ {F rF G lF lG Γ} → Γ ⊢ ℕ ≡ Π F ^ rF ° lF ▹ G ° lG ° ⁰ ^ [ ! , ι ⁰ ] → ⊥
ℕ≢Π! ℕ≡Π =
let ⊢ℕ , ⊢Π = syntacticEq ℕ≡Π
in ℕ≢Π-red (id ⊢ℕ) (id ⊢Π) ℕ≡Π
-- Empty and Π
Empty≢Π′ : ∀ {ll A B Γ l l′}
([Empty] : Γ ⊩Empty A ^ ll)
([Π] : Γ ⊩′⟨ l′ ⟩Π B ^[ % , ll ])
→ ShapeView Γ l l′ _ _ _ _ (Emptyᵣ [Empty]) (Πᵣ [Π]) → ⊥
Empty≢Π′ a b ()
Empty≢Π-red : ∀ {ll A B F rF lF lG G Γ} → Γ ⊢ A ⇒* Empty ll ^ [ % , ι ll ] → Γ ⊢ B ⇒* Π F ^ rF ° lF ▹ G ° lG ° ll ^ [ % , ι ll ]
→ Γ ⊢ A ≡ B ^ [ % , ι ll ] → ⊥
Empty≢Π-red {ll} D D′ = A≢B (λ Γ l A → Γ ⊩Empty A ^ ll)
(λ Γ l A → Γ ⊩′⟨ l ⟩Π A ^[ % , ll ]) Emptyᵣ Πᵣ
(λ x → extractMaybeEmb (Empty-elim′ D x))
(λ x → extractMaybeEmb (Π-elim′ D′ x))
Empty≢Π′
Empty≢Π% : ∀ {F rF lF lG l G Γ} → Γ ⊢ Empty l ≡ Π F ^ rF ° lF ▹ G ° lG ° l ^ [ % , ι l ] → ⊥
Empty≢Π% Empty≡Π =
let ⊢Empty , ⊢Π = syntacticEq Empty≡Π
in Empty≢Π-red (id ⊢Empty) (id ⊢Π) Empty≡Π
ℕ≢ne′ : ∀ {ll A K Γ l l′}
([ℕ] : Γ ⊩ℕ A)
([K] : Γ ⊩ne K ^[ ! , ll ])
→ ShapeView Γ l l′ _ _ _ _ (ℕᵣ [ℕ]) (ne [K]) → ⊥
ℕ≢ne′ a b ()
ℕ≢ne-red : ∀ {A B K Γ} → Γ ⊢ A ⇒* ℕ ^ [ ! , ι ⁰ ] → Γ ⊢ B ⇒* K ^ [ ! , ι ⁰ ] → Neutral K → Γ ⊢ A ≡ B ^ [ ! , ι ⁰ ] → ⊥
ℕ≢ne-red D D′ neK = A≢B (λ Γ l A → Γ ⊩ℕ A) (λ Γ l B → Γ ⊩ne B ^[ ! , ⁰ ]) ℕᵣ ne
(λ x → extractMaybeEmb (ℕ-elim′ D x))
(λ x → extractMaybeEmb (ne-elim′ D′ neK x PE.refl ))
ℕ≢ne′
-- ℕ and K for any neutral K cannot be judgmentally equal.
ℕ≢ne! : ∀ {K Γ} → Neutral K → Γ ⊢ ℕ ≡ K ^ [ ! , ι ⁰ ] → ⊥
ℕ≢ne! neK ℕ≡K =
let ⊢ℕ , ⊢K = syntacticEq ℕ≡K
in ℕ≢ne-red (id ⊢ℕ) (id ⊢K) neK ℕ≡K
-- Empty and neutral
Empty≢ne′ : ∀ {ll A K Γ l l′}
([Empty] : Γ ⊩Empty A ^ ll)
([K] : Γ ⊩ne K ^[ % , ll ])
→ ShapeView Γ l l′ _ _ _ _ (Emptyᵣ [Empty]) (ne [K]) → ⊥
Empty≢ne′ a b ()
Empty≢ne-red : ∀ {ll A B K Γ} → Γ ⊢ A ⇒* Empty ll ^ [ % , ι ll ] → Γ ⊢ B ⇒* K ^ [ % , ι ll ] →
Neutral K → Γ ⊢ A ≡ B ^ [ % , ι ll ] → ⊥
Empty≢ne-red {ll} D D′ neK = A≢B (λ Γ l A → Γ ⊩Empty A ^ ll) (λ Γ l B → Γ ⊩ne B ^[ % , ll ]) Emptyᵣ ne
(λ x → extractMaybeEmb (Empty-elim′ D x))
(λ x → extractMaybeEmb (ne-elim′ D′ neK x PE.refl))
Empty≢ne′
Empty≢ne% : ∀ {l K Γ} → Neutral K → Γ ⊢ Empty l ≡ K ^ [ % , ι l ] → ⊥
Empty≢ne% neK Empty≡K =
let ⊢Empty , ⊢K = syntacticEq Empty≡K
in Empty≢ne-red (id ⊢Empty) (id ⊢K) neK Empty≡K
Π≢ne′ : ∀ {ll A K r Γ l l′}
([Π] : Γ ⊩′⟨ l ⟩Π A ^[ r , ll ])
([K] : Γ ⊩ne K ^[ r , ll ])
→ ShapeView Γ l l′ _ _ _ _ (Πᵣ [Π]) (ne [K]) → ⊥
Π≢ne′ a b ()
Π≢ne-red : ∀ {ll r A B F rF lF lG G K Γ} → Γ ⊢ A ⇒* Π F ^ rF ° lF ▹ G ° lG ° ll ^ [ r , ι ll ]
→ Γ ⊢ B ⇒* K ^ [ r , ι ll ] → Neutral K
→ Γ ⊢ A ≡ B ^ [ r , ι ll ] → ⊥
Π≢ne-red {ll} {r} D D′ neK = A≢B (λ Γ l A → Γ ⊩′⟨ l ⟩Π A ^[ r , ll ])
(λ Γ l B → Γ ⊩ne B ^[ r , ll ]) Πᵣ ne
(λ x → extractMaybeEmb (Π-elim′ D x))
(λ x → extractMaybeEmb (ne-elim′ D′ neK x PE.refl))
Π≢ne′
-- Π F ▹ G and K for any F and G and neutral K cannot be judgmentally equal.
Π≢ne : ∀ {F rF lF lG G K r l Γ} → Neutral K → Γ ⊢ Π F ^ rF ° lF ▹ G ° lG ° l ≡ K ^ [ r , ι l ] → ⊥
Π≢ne neK Π≡K =
let ⊢Π , ⊢K = syntacticEq Π≡K
in Π≢ne-red (id ⊢Π) (id ⊢K) neK Π≡K
|
{
"alphanum_fraction": 0.415824329,
"avg_line_length": 39.4816513761,
"ext": "agda",
"hexsha": "b2a6e9819a9337eb4b0f6bd41476747a2e202e93",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2022-02-15T19:42:19.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-01-26T14:55:51.000Z",
"max_forks_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "CoqHott/logrel-mltt",
"max_forks_repo_path": "Definition/Typed/Consequences/Inequality.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "CoqHott/logrel-mltt",
"max_issues_repo_path": "Definition/Typed/Consequences/Inequality.agda",
"max_line_length": 141,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "e0eeebc4aa5ed791ce3e7c0dc9531bd113dfcc04",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "CoqHott/logrel-mltt",
"max_stars_repo_path": "Definition/Typed/Consequences/Inequality.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-17T16:13:53.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-06-21T08:39:01.000Z",
"num_tokens": 4343,
"size": 8607
}
|
{-
This file contains:
- Definitions equivalences
- Glue types
-}
{-# OPTIONS --cubical --safe #-}
module Cubical.Core.Glue where
open import Cubical.Core.Primitives
open import Agda.Builtin.Cubical.Glue public
using ( isEquiv -- ∀ {ℓ ℓ'} {A : Type ℓ} {B : Type ℓ'} (f : A → B) → Type (ℓ ⊔ ℓ')
; equiv-proof -- ∀ (y : B) → isContr (fiber f y)
; _≃_ -- ∀ {ℓ ℓ'} (A : Type ℓ) (B : Type ℓ') → Type (ℓ ⊔ ℓ')
; equivFun -- ∀ {ℓ ℓ'} {A : Type ℓ} {B : Type ℓ'} → A ≃ B → A → B
; equivProof -- ∀ {ℓ ℓ'} (T : Type ℓ) (A : Type ℓ') (w : T ≃ A) (a : A) φ →
-- Partial φ (fiber (equivFun w) a) → fiber (equivFun w) a
; primGlue -- ∀ {ℓ ℓ'} (A : Type ℓ) {φ : I} (T : Partial φ (Type ℓ'))
-- → (e : PartialP φ (λ o → T o ≃ A)) → Type ℓ'
; prim^unglue -- ∀ {ℓ ℓ'} {A : Type ℓ} {φ : I} {T : Partial φ (Type ℓ')}
-- → {e : PartialP φ (λ o → T o ≃ A)} → primGlue A T e → A
-- The ∀ operation on I. This is commented out as it is not currently used for anything
-- ; primFaceForall -- (I → I) → I
)
renaming ( prim^glue to glue -- ∀ {ℓ ℓ'} {A : Type ℓ} {φ : I} {T : Partial φ (Type ℓ')}
-- → {e : PartialP φ (λ o → T o ≃ A)}
-- → PartialP φ T → A → primGlue A T e
; pathToEquiv to lineToEquiv -- ∀ {ℓ : I → Level} (P : (i : I) → Type (ℓ i)) → P i0 ≃ P i1
)
private
variable
ℓ ℓ' : Level
-- Uncurry Glue to make it more pleasant to use
Glue : (A : Type ℓ) {φ : I}
→ (Te : Partial φ (Σ[ T ∈ Type ℓ' ] T ≃ A))
→ Type ℓ'
Glue A Te = primGlue A (λ x → Te x .fst) (λ x → Te x .snd)
-- Make the φ argument of prim^unglue explicit
unglue : {A : Type ℓ} (φ : I) {T : Partial φ (Type ℓ')}
{e : PartialP φ (λ o → T o ≃ A)} → primGlue A T e → A
unglue φ = prim^unglue {φ = φ}
|
{
"alphanum_fraction": 0.4524408656,
"avg_line_length": 34.8596491228,
"ext": "agda",
"hexsha": "ed024c8dff4965de998f772238a13f1578464de8",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cj-xu/cubical",
"max_forks_repo_path": "Cubical/Core/Glue.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cj-xu/cubical",
"max_issues_repo_path": "Cubical/Core/Glue.agda",
"max_line_length": 102,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cj-xu/cubical",
"max_stars_repo_path": "Cubical/Core/Glue.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 736,
"size": 1987
}
|
-- This module explains how to combine elimination of empty types with pattern
-- match style definitions without running into problems with decidability.
module Introduction.Data.Empty where
-- First we introduce an empty and a singleton type.
data Zero : Set where
data One : Set where
one : One
-- There is a special pattern () which matches any element of an (obviously)
-- empty type. If there is a ()-pattern in a left-hand side the right-hand side
-- can be omitted.
elim-Zero : {A : Set} -> Zero -> A
elim-Zero ()
data _×_ (A B : Set) : Set where
pair : A -> B -> A × B
-- The algorithm for checking if a type is empty is very naive. In this example
-- you cannot replace pair () _ with () because the type checker cannot see
-- that Zero × B is empty.
elim-EmptyPair : {A B : Set} -> Zero × B -> A
elim-EmptyPair (pair () _)
data Nat : Set where
zero : Nat
suc : Nat -> Nat
-- For some empty types finite unfolding is not enough.
ConstZero : Nat -> Set
ConstZero zero = Zero
ConstZero (suc n) = ConstZero n
-- We can still define the elimination function but we have to do it
-- recursively over the n.
elim-ConstZero : (n : Nat) -> ConstZero n -> {A : Set} -> A
elim-ConstZero zero ()
elim-ConstZero (suc n) x = elim-ConstZero n x
|
{
"alphanum_fraction": 0.6869085174,
"avg_line_length": 30.1904761905,
"ext": "agda",
"hexsha": "aa85712588c59176821295ff42dd4fe615aa1901",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "examples/Introduction/Data/Empty.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "examples/Introduction/Data/Empty.agda",
"max_line_length": 79,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "examples/Introduction/Data/Empty.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 345,
"size": 1268
}
|
{-# OPTIONS --type-in-type #-}
Ty : Set
Ty =
(Ty : Set)
(nat top bot : Ty)
(arr prod sum : Ty → Ty → Ty)
→ Ty
nat : Ty; nat = λ _ nat _ _ _ _ _ → nat
top : Ty; top = λ _ _ top _ _ _ _ → top
bot : Ty; bot = λ _ _ _ bot _ _ _ → bot
arr : Ty → Ty → Ty; arr
= λ A B Ty nat top bot arr prod sum →
arr (A Ty nat top bot arr prod sum) (B Ty nat top bot arr prod sum)
prod : Ty → Ty → Ty; prod
= λ A B Ty nat top bot arr prod sum →
prod (A Ty nat top bot arr prod sum) (B Ty nat top bot arr prod sum)
sum : Ty → Ty → Ty; sum
= λ A B Ty nat top bot arr prod sum →
sum (A Ty nat top bot arr prod sum) (B Ty nat top bot arr prod sum)
Con : Set; Con
= (Con : Set)
(nil : Con)
(snoc : Con → Ty → Con)
→ Con
nil : Con; nil
= λ Con nil snoc → nil
snoc : Con → Ty → Con; snoc
= λ Γ A Con nil snoc → snoc (Γ Con nil snoc) A
Var : Con → Ty → Set; Var
= λ Γ A →
(Var : Con → Ty → Set)
(vz : ∀ Γ A → Var (snoc Γ A) A)
(vs : ∀ Γ B A → Var Γ A → Var (snoc Γ B) A)
→ Var Γ A
vz : ∀{Γ A} → Var (snoc Γ A) A; vz
= λ Var vz vs → vz _ _
vs : ∀{Γ B A} → Var Γ A → Var (snoc Γ B) A; vs
= λ x Var vz vs → vs _ _ _ (x Var vz vs)
Tm : Con → Ty → Set; Tm
= λ Γ A →
(Tm : Con → Ty → Set)
(var : ∀ Γ A → Var Γ A → Tm Γ A)
(lam : ∀ Γ A B → Tm (snoc Γ A) B → Tm Γ (arr A B))
(app : ∀ Γ A B → Tm Γ (arr A B) → Tm Γ A → Tm Γ B)
(tt : ∀ Γ → Tm Γ top)
(pair : ∀ Γ A B → Tm Γ A → Tm Γ B → Tm Γ (prod A B))
(fst : ∀ Γ A B → Tm Γ (prod A B) → Tm Γ A)
(snd : ∀ Γ A B → Tm Γ (prod A B) → Tm Γ B)
(left : ∀ Γ A B → Tm Γ A → Tm Γ (sum A B))
(right : ∀ Γ A B → Tm Γ B → Tm Γ (sum A B))
(case : ∀ Γ A B C → Tm Γ (sum A B) → Tm Γ (arr A C) → Tm Γ (arr B C) → Tm Γ C)
(zero : ∀ Γ → Tm Γ nat)
(suc : ∀ Γ → Tm Γ nat → Tm Γ nat)
(rec : ∀ Γ A → Tm Γ nat → Tm Γ (arr nat (arr A A)) → Tm Γ A → Tm Γ A)
→ Tm Γ A
var : ∀{Γ A} → Var Γ A → Tm Γ A; var
= λ x Tm var lam app tt pair fst snd left right case zero suc rec →
var _ _ x
lam : ∀{Γ A B} → Tm (snoc Γ A) B → Tm Γ (arr A B); lam
= λ t Tm var lam app tt pair fst snd left right case zero suc rec →
lam _ _ _ (t Tm var lam app tt pair fst snd left right case zero suc rec)
app : ∀{Γ A B} → Tm Γ (arr A B) → Tm Γ A → Tm Γ B; app
= λ t u Tm var lam app tt pair fst snd left right case zero suc rec →
app _ _ _ (t Tm var lam app tt pair fst snd left right case zero suc rec)
(u Tm var lam app tt pair fst snd left right case zero suc rec)
tt : ∀{Γ} → Tm Γ top; tt
= λ Tm var lam app tt pair fst snd left right case zero suc rec → tt _
pair : ∀{Γ A B} → Tm Γ A → Tm Γ B → Tm Γ (prod A B); pair
= λ t u Tm var lam app tt pair fst snd left right case zero suc rec →
pair _ _ _ (t Tm var lam app tt pair fst snd left right case zero suc rec)
(u Tm var lam app tt pair fst snd left right case zero suc rec)
fst : ∀{Γ A B} → Tm Γ (prod A B) → Tm Γ A; fst
= λ t Tm var lam app tt pair fst snd left right case zero suc rec →
fst _ _ _ (t Tm var lam app tt pair fst snd left right case zero suc rec)
snd : ∀{Γ A B} → Tm Γ (prod A B) → Tm Γ B; snd
= λ t Tm var lam app tt pair fst snd left right case zero suc rec →
snd _ _ _ (t Tm var lam app tt pair fst snd left right case zero suc rec)
left : ∀{Γ A B} → Tm Γ A → Tm Γ (sum A B); left
= λ t Tm var lam app tt pair fst snd left right case zero suc rec →
left _ _ _ (t Tm var lam app tt pair fst snd left right case zero suc rec)
right : ∀{Γ A B} → Tm Γ B → Tm Γ (sum A B); right
= λ t Tm var lam app tt pair fst snd left right case zero suc rec →
right _ _ _ (t Tm var lam app tt pair fst snd left right case zero suc rec)
case : ∀{Γ A B C} → Tm Γ (sum A B) → Tm Γ (arr A C) → Tm Γ (arr B C) → Tm Γ C; case
= λ t u v Tm var lam app tt pair fst snd left right case zero suc rec →
case _ _ _ _
(t Tm var lam app tt pair fst snd left right case zero suc rec)
(u Tm var lam app tt pair fst snd left right case zero suc rec)
(v Tm var lam app tt pair fst snd left right case zero suc rec)
zero : ∀{Γ} → Tm Γ nat; zero
= λ Tm var lam app tt pair fst snd left right case zero suc rec → zero _
suc : ∀{Γ} → Tm Γ nat → Tm Γ nat; suc
= λ t Tm var lam app tt pair fst snd left right case zero suc rec →
suc _ (t Tm var lam app tt pair fst snd left right case zero suc rec)
rec : ∀{Γ A} → Tm Γ nat → Tm Γ (arr nat (arr A A)) → Tm Γ A → Tm Γ A; rec
= λ t u v Tm var lam app tt pair fst snd left right case zero suc rec →
rec _ _
(t Tm var lam app tt pair fst snd left right case zero suc rec)
(u Tm var lam app tt pair fst snd left right case zero suc rec)
(v Tm var lam app tt pair fst snd left right case zero suc rec)
v0 : ∀{Γ A} → Tm (snoc Γ A) A; v0
= var vz
v1 : ∀{Γ A B} → Tm (snoc (snoc Γ A) B) A; v1
= var (vs vz)
v2 : ∀{Γ A B C} → Tm (snoc (snoc (snoc Γ A) B) C) A; v2
= var (vs (vs vz))
v3 : ∀{Γ A B C D} → Tm (snoc (snoc (snoc (snoc Γ A) B) C) D) A; v3
= var (vs (vs (vs vz)))
tbool : Ty; tbool
= sum top top
true : ∀{Γ} → Tm Γ tbool; true
= left tt
tfalse : ∀{Γ} → Tm Γ tbool; tfalse
= right tt
ifthenelse : ∀{Γ A} → Tm Γ (arr tbool (arr A (arr A A))); ifthenelse
= lam (lam (lam (case v2 (lam v2) (lam v1))))
times4 : ∀{Γ A} → Tm Γ (arr (arr A A) (arr A A)); times4
= lam (lam (app v1 (app v1 (app v1 (app v1 v0)))))
add : ∀{Γ} → Tm Γ (arr nat (arr nat nat)); add
= lam (rec v0
(lam (lam (lam (suc (app v1 v0)))))
(lam v0))
mul : ∀{Γ} → Tm Γ (arr nat (arr nat nat)); mul
= lam (rec v0
(lam (lam (lam (app (app add (app v1 v0)) v0))))
(lam zero))
fact : ∀{Γ} → Tm Γ (arr nat nat); fact
= lam (rec v0 (lam (lam (app (app mul (suc v1)) v0)))
(suc zero))
{-# OPTIONS --type-in-type #-}
Ty1 : Set
Ty1 =
(Ty1 : Set)
(nat top bot : Ty1)
(arr prod sum : Ty1 → Ty1 → Ty1)
→ Ty1
nat1 : Ty1; nat1 = λ _ nat1 _ _ _ _ _ → nat1
top1 : Ty1; top1 = λ _ _ top1 _ _ _ _ → top1
bot1 : Ty1; bot1 = λ _ _ _ bot1 _ _ _ → bot1
arr1 : Ty1 → Ty1 → Ty1; arr1
= λ A B Ty1 nat1 top1 bot1 arr1 prod sum →
arr1 (A Ty1 nat1 top1 bot1 arr1 prod sum) (B Ty1 nat1 top1 bot1 arr1 prod sum)
prod1 : Ty1 → Ty1 → Ty1; prod1
= λ A B Ty1 nat1 top1 bot1 arr1 prod1 sum →
prod1 (A Ty1 nat1 top1 bot1 arr1 prod1 sum) (B Ty1 nat1 top1 bot1 arr1 prod1 sum)
sum1 : Ty1 → Ty1 → Ty1; sum1
= λ A B Ty1 nat1 top1 bot1 arr1 prod1 sum1 →
sum1 (A Ty1 nat1 top1 bot1 arr1 prod1 sum1) (B Ty1 nat1 top1 bot1 arr1 prod1 sum1)
Con1 : Set; Con1
= (Con1 : Set)
(nil : Con1)
(snoc : Con1 → Ty1 → Con1)
→ Con1
nil1 : Con1; nil1
= λ Con1 nil1 snoc → nil1
snoc1 : Con1 → Ty1 → Con1; snoc1
= λ Γ A Con1 nil1 snoc1 → snoc1 (Γ Con1 nil1 snoc1) A
Var1 : Con1 → Ty1 → Set; Var1
= λ Γ A →
(Var1 : Con1 → Ty1 → Set)
(vz : ∀ Γ A → Var1 (snoc1 Γ A) A)
(vs : ∀ Γ B A → Var1 Γ A → Var1 (snoc1 Γ B) A)
→ Var1 Γ A
vz1 : ∀{Γ A} → Var1 (snoc1 Γ A) A; vz1
= λ Var1 vz1 vs → vz1 _ _
vs1 : ∀{Γ B A} → Var1 Γ A → Var1 (snoc1 Γ B) A; vs1
= λ x Var1 vz1 vs1 → vs1 _ _ _ (x Var1 vz1 vs1)
Tm1 : Con1 → Ty1 → Set; Tm1
= λ Γ A →
(Tm1 : Con1 → Ty1 → Set)
(var : ∀ Γ A → Var1 Γ A → Tm1 Γ A)
(lam : ∀ Γ A B → Tm1 (snoc1 Γ A) B → Tm1 Γ (arr1 A B))
(app : ∀ Γ A B → Tm1 Γ (arr1 A B) → Tm1 Γ A → Tm1 Γ B)
(tt : ∀ Γ → Tm1 Γ top1)
(pair : ∀ Γ A B → Tm1 Γ A → Tm1 Γ B → Tm1 Γ (prod1 A B))
(fst : ∀ Γ A B → Tm1 Γ (prod1 A B) → Tm1 Γ A)
(snd : ∀ Γ A B → Tm1 Γ (prod1 A B) → Tm1 Γ B)
(left : ∀ Γ A B → Tm1 Γ A → Tm1 Γ (sum1 A B))
(right : ∀ Γ A B → Tm1 Γ B → Tm1 Γ (sum1 A B))
(case : ∀ Γ A B C → Tm1 Γ (sum1 A B) → Tm1 Γ (arr1 A C) → Tm1 Γ (arr1 B C) → Tm1 Γ C)
(zero : ∀ Γ → Tm1 Γ nat1)
(suc : ∀ Γ → Tm1 Γ nat1 → Tm1 Γ nat1)
(rec : ∀ Γ A → Tm1 Γ nat1 → Tm1 Γ (arr1 nat1 (arr1 A A)) → Tm1 Γ A → Tm1 Γ A)
→ Tm1 Γ A
var1 : ∀{Γ A} → Var1 Γ A → Tm1 Γ A; var1
= λ x Tm1 var1 lam app tt pair fst snd left right case zero suc rec →
var1 _ _ x
lam1 : ∀{Γ A B} → Tm1 (snoc1 Γ A) B → Tm1 Γ (arr1 A B); lam1
= λ t Tm1 var1 lam1 app tt pair fst snd left right case zero suc rec →
lam1 _ _ _ (t Tm1 var1 lam1 app tt pair fst snd left right case zero suc rec)
app1 : ∀{Γ A B} → Tm1 Γ (arr1 A B) → Tm1 Γ A → Tm1 Γ B; app1
= λ t u Tm1 var1 lam1 app1 tt pair fst snd left right case zero suc rec →
app1 _ _ _ (t Tm1 var1 lam1 app1 tt pair fst snd left right case zero suc rec)
(u Tm1 var1 lam1 app1 tt pair fst snd left right case zero suc rec)
tt1 : ∀{Γ} → Tm1 Γ top1; tt1
= λ Tm1 var1 lam1 app1 tt1 pair fst snd left right case zero suc rec → tt1 _
pair1 : ∀{Γ A B} → Tm1 Γ A → Tm1 Γ B → Tm1 Γ (prod1 A B); pair1
= λ t u Tm1 var1 lam1 app1 tt1 pair1 fst snd left right case zero suc rec →
pair1 _ _ _ (t Tm1 var1 lam1 app1 tt1 pair1 fst snd left right case zero suc rec)
(u Tm1 var1 lam1 app1 tt1 pair1 fst snd left right case zero suc rec)
fst1 : ∀{Γ A B} → Tm1 Γ (prod1 A B) → Tm1 Γ A; fst1
= λ t Tm1 var1 lam1 app1 tt1 pair1 fst1 snd left right case zero suc rec →
fst1 _ _ _ (t Tm1 var1 lam1 app1 tt1 pair1 fst1 snd left right case zero suc rec)
snd1 : ∀{Γ A B} → Tm1 Γ (prod1 A B) → Tm1 Γ B; snd1
= λ t Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left right case zero suc rec →
snd1 _ _ _ (t Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left right case zero suc rec)
left1 : ∀{Γ A B} → Tm1 Γ A → Tm1 Γ (sum1 A B); left1
= λ t Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right case zero suc rec →
left1 _ _ _ (t Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right case zero suc rec)
right1 : ∀{Γ A B} → Tm1 Γ B → Tm1 Γ (sum1 A B); right1
= λ t Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right1 case zero suc rec →
right1 _ _ _ (t Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right1 case zero suc rec)
case1 : ∀{Γ A B C} → Tm1 Γ (sum1 A B) → Tm1 Γ (arr1 A C) → Tm1 Γ (arr1 B C) → Tm1 Γ C; case1
= λ t u v Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right1 case1 zero suc rec →
case1 _ _ _ _
(t Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right1 case1 zero suc rec)
(u Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right1 case1 zero suc rec)
(v Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right1 case1 zero suc rec)
zero1 : ∀{Γ} → Tm1 Γ nat1; zero1
= λ Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right1 case1 zero1 suc rec → zero1 _
suc1 : ∀{Γ} → Tm1 Γ nat1 → Tm1 Γ nat1; suc1
= λ t Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right1 case1 zero1 suc1 rec →
suc1 _ (t Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right1 case1 zero1 suc1 rec)
rec1 : ∀{Γ A} → Tm1 Γ nat1 → Tm1 Γ (arr1 nat1 (arr1 A A)) → Tm1 Γ A → Tm1 Γ A; rec1
= λ t u v Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right1 case1 zero1 suc1 rec1 →
rec1 _ _
(t Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right1 case1 zero1 suc1 rec1)
(u Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right1 case1 zero1 suc1 rec1)
(v Tm1 var1 lam1 app1 tt1 pair1 fst1 snd1 left1 right1 case1 zero1 suc1 rec1)
v01 : ∀{Γ A} → Tm1 (snoc1 Γ A) A; v01
= var1 vz1
v11 : ∀{Γ A B} → Tm1 (snoc1 (snoc1 Γ A) B) A; v11
= var1 (vs1 vz1)
v21 : ∀{Γ A B C} → Tm1 (snoc1 (snoc1 (snoc1 Γ A) B) C) A; v21
= var1 (vs1 (vs1 vz1))
v31 : ∀{Γ A B C D} → Tm1 (snoc1 (snoc1 (snoc1 (snoc1 Γ A) B) C) D) A; v31
= var1 (vs1 (vs1 (vs1 vz1)))
tbool1 : Ty1; tbool1
= sum1 top1 top1
true1 : ∀{Γ} → Tm1 Γ tbool1; true1
= left1 tt1
tfalse1 : ∀{Γ} → Tm1 Γ tbool1; tfalse1
= right1 tt1
ifthenelse1 : ∀{Γ A} → Tm1 Γ (arr1 tbool1 (arr1 A (arr1 A A))); ifthenelse1
= lam1 (lam1 (lam1 (case1 v21 (lam1 v21) (lam1 v11))))
times41 : ∀{Γ A} → Tm1 Γ (arr1 (arr1 A A) (arr1 A A)); times41
= lam1 (lam1 (app1 v11 (app1 v11 (app1 v11 (app1 v11 v01)))))
add1 : ∀{Γ} → Tm1 Γ (arr1 nat1 (arr1 nat1 nat1)); add1
= lam1 (rec1 v01
(lam1 (lam1 (lam1 (suc1 (app1 v11 v01)))))
(lam1 v01))
mul1 : ∀{Γ} → Tm1 Γ (arr1 nat1 (arr1 nat1 nat1)); mul1
= lam1 (rec1 v01
(lam1 (lam1 (lam1 (app1 (app1 add1 (app1 v11 v01)) v01))))
(lam1 zero1))
fact1 : ∀{Γ} → Tm1 Γ (arr1 nat1 nat1); fact1
= lam1 (rec1 v01 (lam1 (lam1 (app1 (app1 mul1 (suc1 v11)) v01)))
(suc1 zero1))
{-# OPTIONS --type-in-type #-}
Ty2 : Set
Ty2 =
(Ty2 : Set)
(nat top bot : Ty2)
(arr prod sum : Ty2 → Ty2 → Ty2)
→ Ty2
nat2 : Ty2; nat2 = λ _ nat2 _ _ _ _ _ → nat2
top2 : Ty2; top2 = λ _ _ top2 _ _ _ _ → top2
bot2 : Ty2; bot2 = λ _ _ _ bot2 _ _ _ → bot2
arr2 : Ty2 → Ty2 → Ty2; arr2
= λ A B Ty2 nat2 top2 bot2 arr2 prod sum →
arr2 (A Ty2 nat2 top2 bot2 arr2 prod sum) (B Ty2 nat2 top2 bot2 arr2 prod sum)
prod2 : Ty2 → Ty2 → Ty2; prod2
= λ A B Ty2 nat2 top2 bot2 arr2 prod2 sum →
prod2 (A Ty2 nat2 top2 bot2 arr2 prod2 sum) (B Ty2 nat2 top2 bot2 arr2 prod2 sum)
sum2 : Ty2 → Ty2 → Ty2; sum2
= λ A B Ty2 nat2 top2 bot2 arr2 prod2 sum2 →
sum2 (A Ty2 nat2 top2 bot2 arr2 prod2 sum2) (B Ty2 nat2 top2 bot2 arr2 prod2 sum2)
Con2 : Set; Con2
= (Con2 : Set)
(nil : Con2)
(snoc : Con2 → Ty2 → Con2)
→ Con2
nil2 : Con2; nil2
= λ Con2 nil2 snoc → nil2
snoc2 : Con2 → Ty2 → Con2; snoc2
= λ Γ A Con2 nil2 snoc2 → snoc2 (Γ Con2 nil2 snoc2) A
Var2 : Con2 → Ty2 → Set; Var2
= λ Γ A →
(Var2 : Con2 → Ty2 → Set)
(vz : ∀ Γ A → Var2 (snoc2 Γ A) A)
(vs : ∀ Γ B A → Var2 Γ A → Var2 (snoc2 Γ B) A)
→ Var2 Γ A
vz2 : ∀{Γ A} → Var2 (snoc2 Γ A) A; vz2
= λ Var2 vz2 vs → vz2 _ _
vs2 : ∀{Γ B A} → Var2 Γ A → Var2 (snoc2 Γ B) A; vs2
= λ x Var2 vz2 vs2 → vs2 _ _ _ (x Var2 vz2 vs2)
Tm2 : Con2 → Ty2 → Set; Tm2
= λ Γ A →
(Tm2 : Con2 → Ty2 → Set)
(var : ∀ Γ A → Var2 Γ A → Tm2 Γ A)
(lam : ∀ Γ A B → Tm2 (snoc2 Γ A) B → Tm2 Γ (arr2 A B))
(app : ∀ Γ A B → Tm2 Γ (arr2 A B) → Tm2 Γ A → Tm2 Γ B)
(tt : ∀ Γ → Tm2 Γ top2)
(pair : ∀ Γ A B → Tm2 Γ A → Tm2 Γ B → Tm2 Γ (prod2 A B))
(fst : ∀ Γ A B → Tm2 Γ (prod2 A B) → Tm2 Γ A)
(snd : ∀ Γ A B → Tm2 Γ (prod2 A B) → Tm2 Γ B)
(left : ∀ Γ A B → Tm2 Γ A → Tm2 Γ (sum2 A B))
(right : ∀ Γ A B → Tm2 Γ B → Tm2 Γ (sum2 A B))
(case : ∀ Γ A B C → Tm2 Γ (sum2 A B) → Tm2 Γ (arr2 A C) → Tm2 Γ (arr2 B C) → Tm2 Γ C)
(zero : ∀ Γ → Tm2 Γ nat2)
(suc : ∀ Γ → Tm2 Γ nat2 → Tm2 Γ nat2)
(rec : ∀ Γ A → Tm2 Γ nat2 → Tm2 Γ (arr2 nat2 (arr2 A A)) → Tm2 Γ A → Tm2 Γ A)
→ Tm2 Γ A
var2 : ∀{Γ A} → Var2 Γ A → Tm2 Γ A; var2
= λ x Tm2 var2 lam app tt pair fst snd left right case zero suc rec →
var2 _ _ x
lam2 : ∀{Γ A B} → Tm2 (snoc2 Γ A) B → Tm2 Γ (arr2 A B); lam2
= λ t Tm2 var2 lam2 app tt pair fst snd left right case zero suc rec →
lam2 _ _ _ (t Tm2 var2 lam2 app tt pair fst snd left right case zero suc rec)
app2 : ∀{Γ A B} → Tm2 Γ (arr2 A B) → Tm2 Γ A → Tm2 Γ B; app2
= λ t u Tm2 var2 lam2 app2 tt pair fst snd left right case zero suc rec →
app2 _ _ _ (t Tm2 var2 lam2 app2 tt pair fst snd left right case zero suc rec)
(u Tm2 var2 lam2 app2 tt pair fst snd left right case zero suc rec)
tt2 : ∀{Γ} → Tm2 Γ top2; tt2
= λ Tm2 var2 lam2 app2 tt2 pair fst snd left right case zero suc rec → tt2 _
pair2 : ∀{Γ A B} → Tm2 Γ A → Tm2 Γ B → Tm2 Γ (prod2 A B); pair2
= λ t u Tm2 var2 lam2 app2 tt2 pair2 fst snd left right case zero suc rec →
pair2 _ _ _ (t Tm2 var2 lam2 app2 tt2 pair2 fst snd left right case zero suc rec)
(u Tm2 var2 lam2 app2 tt2 pair2 fst snd left right case zero suc rec)
fst2 : ∀{Γ A B} → Tm2 Γ (prod2 A B) → Tm2 Γ A; fst2
= λ t Tm2 var2 lam2 app2 tt2 pair2 fst2 snd left right case zero suc rec →
fst2 _ _ _ (t Tm2 var2 lam2 app2 tt2 pair2 fst2 snd left right case zero suc rec)
snd2 : ∀{Γ A B} → Tm2 Γ (prod2 A B) → Tm2 Γ B; snd2
= λ t Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left right case zero suc rec →
snd2 _ _ _ (t Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left right case zero suc rec)
left2 : ∀{Γ A B} → Tm2 Γ A → Tm2 Γ (sum2 A B); left2
= λ t Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right case zero suc rec →
left2 _ _ _ (t Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right case zero suc rec)
right2 : ∀{Γ A B} → Tm2 Γ B → Tm2 Γ (sum2 A B); right2
= λ t Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right2 case zero suc rec →
right2 _ _ _ (t Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right2 case zero suc rec)
case2 : ∀{Γ A B C} → Tm2 Γ (sum2 A B) → Tm2 Γ (arr2 A C) → Tm2 Γ (arr2 B C) → Tm2 Γ C; case2
= λ t u v Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right2 case2 zero suc rec →
case2 _ _ _ _
(t Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right2 case2 zero suc rec)
(u Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right2 case2 zero suc rec)
(v Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right2 case2 zero suc rec)
zero2 : ∀{Γ} → Tm2 Γ nat2; zero2
= λ Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right2 case2 zero2 suc rec → zero2 _
suc2 : ∀{Γ} → Tm2 Γ nat2 → Tm2 Γ nat2; suc2
= λ t Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right2 case2 zero2 suc2 rec →
suc2 _ (t Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right2 case2 zero2 suc2 rec)
rec2 : ∀{Γ A} → Tm2 Γ nat2 → Tm2 Γ (arr2 nat2 (arr2 A A)) → Tm2 Γ A → Tm2 Γ A; rec2
= λ t u v Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right2 case2 zero2 suc2 rec2 →
rec2 _ _
(t Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right2 case2 zero2 suc2 rec2)
(u Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right2 case2 zero2 suc2 rec2)
(v Tm2 var2 lam2 app2 tt2 pair2 fst2 snd2 left2 right2 case2 zero2 suc2 rec2)
v02 : ∀{Γ A} → Tm2 (snoc2 Γ A) A; v02
= var2 vz2
v12 : ∀{Γ A B} → Tm2 (snoc2 (snoc2 Γ A) B) A; v12
= var2 (vs2 vz2)
v22 : ∀{Γ A B C} → Tm2 (snoc2 (snoc2 (snoc2 Γ A) B) C) A; v22
= var2 (vs2 (vs2 vz2))
v32 : ∀{Γ A B C D} → Tm2 (snoc2 (snoc2 (snoc2 (snoc2 Γ A) B) C) D) A; v32
= var2 (vs2 (vs2 (vs2 vz2)))
tbool2 : Ty2; tbool2
= sum2 top2 top2
true2 : ∀{Γ} → Tm2 Γ tbool2; true2
= left2 tt2
tfalse2 : ∀{Γ} → Tm2 Γ tbool2; tfalse2
= right2 tt2
ifthenelse2 : ∀{Γ A} → Tm2 Γ (arr2 tbool2 (arr2 A (arr2 A A))); ifthenelse2
= lam2 (lam2 (lam2 (case2 v22 (lam2 v22) (lam2 v12))))
times42 : ∀{Γ A} → Tm2 Γ (arr2 (arr2 A A) (arr2 A A)); times42
= lam2 (lam2 (app2 v12 (app2 v12 (app2 v12 (app2 v12 v02)))))
add2 : ∀{Γ} → Tm2 Γ (arr2 nat2 (arr2 nat2 nat2)); add2
= lam2 (rec2 v02
(lam2 (lam2 (lam2 (suc2 (app2 v12 v02)))))
(lam2 v02))
mul2 : ∀{Γ} → Tm2 Γ (arr2 nat2 (arr2 nat2 nat2)); mul2
= lam2 (rec2 v02
(lam2 (lam2 (lam2 (app2 (app2 add2 (app2 v12 v02)) v02))))
(lam2 zero2))
fact2 : ∀{Γ} → Tm2 Γ (arr2 nat2 nat2); fact2
= lam2 (rec2 v02 (lam2 (lam2 (app2 (app2 mul2 (suc2 v12)) v02)))
(suc2 zero2))
{-# OPTIONS --type-in-type #-}
Ty3 : Set
Ty3 =
(Ty3 : Set)
(nat top bot : Ty3)
(arr prod sum : Ty3 → Ty3 → Ty3)
→ Ty3
nat3 : Ty3; nat3 = λ _ nat3 _ _ _ _ _ → nat3
top3 : Ty3; top3 = λ _ _ top3 _ _ _ _ → top3
bot3 : Ty3; bot3 = λ _ _ _ bot3 _ _ _ → bot3
arr3 : Ty3 → Ty3 → Ty3; arr3
= λ A B Ty3 nat3 top3 bot3 arr3 prod sum →
arr3 (A Ty3 nat3 top3 bot3 arr3 prod sum) (B Ty3 nat3 top3 bot3 arr3 prod sum)
prod3 : Ty3 → Ty3 → Ty3; prod3
= λ A B Ty3 nat3 top3 bot3 arr3 prod3 sum →
prod3 (A Ty3 nat3 top3 bot3 arr3 prod3 sum) (B Ty3 nat3 top3 bot3 arr3 prod3 sum)
sum3 : Ty3 → Ty3 → Ty3; sum3
= λ A B Ty3 nat3 top3 bot3 arr3 prod3 sum3 →
sum3 (A Ty3 nat3 top3 bot3 arr3 prod3 sum3) (B Ty3 nat3 top3 bot3 arr3 prod3 sum3)
Con3 : Set; Con3
= (Con3 : Set)
(nil : Con3)
(snoc : Con3 → Ty3 → Con3)
→ Con3
nil3 : Con3; nil3
= λ Con3 nil3 snoc → nil3
snoc3 : Con3 → Ty3 → Con3; snoc3
= λ Γ A Con3 nil3 snoc3 → snoc3 (Γ Con3 nil3 snoc3) A
Var3 : Con3 → Ty3 → Set; Var3
= λ Γ A →
(Var3 : Con3 → Ty3 → Set)
(vz : ∀ Γ A → Var3 (snoc3 Γ A) A)
(vs : ∀ Γ B A → Var3 Γ A → Var3 (snoc3 Γ B) A)
→ Var3 Γ A
vz3 : ∀{Γ A} → Var3 (snoc3 Γ A) A; vz3
= λ Var3 vz3 vs → vz3 _ _
vs3 : ∀{Γ B A} → Var3 Γ A → Var3 (snoc3 Γ B) A; vs3
= λ x Var3 vz3 vs3 → vs3 _ _ _ (x Var3 vz3 vs3)
Tm3 : Con3 → Ty3 → Set; Tm3
= λ Γ A →
(Tm3 : Con3 → Ty3 → Set)
(var : ∀ Γ A → Var3 Γ A → Tm3 Γ A)
(lam : ∀ Γ A B → Tm3 (snoc3 Γ A) B → Tm3 Γ (arr3 A B))
(app : ∀ Γ A B → Tm3 Γ (arr3 A B) → Tm3 Γ A → Tm3 Γ B)
(tt : ∀ Γ → Tm3 Γ top3)
(pair : ∀ Γ A B → Tm3 Γ A → Tm3 Γ B → Tm3 Γ (prod3 A B))
(fst : ∀ Γ A B → Tm3 Γ (prod3 A B) → Tm3 Γ A)
(snd : ∀ Γ A B → Tm3 Γ (prod3 A B) → Tm3 Γ B)
(left : ∀ Γ A B → Tm3 Γ A → Tm3 Γ (sum3 A B))
(right : ∀ Γ A B → Tm3 Γ B → Tm3 Γ (sum3 A B))
(case : ∀ Γ A B C → Tm3 Γ (sum3 A B) → Tm3 Γ (arr3 A C) → Tm3 Γ (arr3 B C) → Tm3 Γ C)
(zero : ∀ Γ → Tm3 Γ nat3)
(suc : ∀ Γ → Tm3 Γ nat3 → Tm3 Γ nat3)
(rec : ∀ Γ A → Tm3 Γ nat3 → Tm3 Γ (arr3 nat3 (arr3 A A)) → Tm3 Γ A → Tm3 Γ A)
→ Tm3 Γ A
var3 : ∀{Γ A} → Var3 Γ A → Tm3 Γ A; var3
= λ x Tm3 var3 lam app tt pair fst snd left right case zero suc rec →
var3 _ _ x
lam3 : ∀{Γ A B} → Tm3 (snoc3 Γ A) B → Tm3 Γ (arr3 A B); lam3
= λ t Tm3 var3 lam3 app tt pair fst snd left right case zero suc rec →
lam3 _ _ _ (t Tm3 var3 lam3 app tt pair fst snd left right case zero suc rec)
app3 : ∀{Γ A B} → Tm3 Γ (arr3 A B) → Tm3 Γ A → Tm3 Γ B; app3
= λ t u Tm3 var3 lam3 app3 tt pair fst snd left right case zero suc rec →
app3 _ _ _ (t Tm3 var3 lam3 app3 tt pair fst snd left right case zero suc rec)
(u Tm3 var3 lam3 app3 tt pair fst snd left right case zero suc rec)
tt3 : ∀{Γ} → Tm3 Γ top3; tt3
= λ Tm3 var3 lam3 app3 tt3 pair fst snd left right case zero suc rec → tt3 _
pair3 : ∀{Γ A B} → Tm3 Γ A → Tm3 Γ B → Tm3 Γ (prod3 A B); pair3
= λ t u Tm3 var3 lam3 app3 tt3 pair3 fst snd left right case zero suc rec →
pair3 _ _ _ (t Tm3 var3 lam3 app3 tt3 pair3 fst snd left right case zero suc rec)
(u Tm3 var3 lam3 app3 tt3 pair3 fst snd left right case zero suc rec)
fst3 : ∀{Γ A B} → Tm3 Γ (prod3 A B) → Tm3 Γ A; fst3
= λ t Tm3 var3 lam3 app3 tt3 pair3 fst3 snd left right case zero suc rec →
fst3 _ _ _ (t Tm3 var3 lam3 app3 tt3 pair3 fst3 snd left right case zero suc rec)
snd3 : ∀{Γ A B} → Tm3 Γ (prod3 A B) → Tm3 Γ B; snd3
= λ t Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left right case zero suc rec →
snd3 _ _ _ (t Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left right case zero suc rec)
left3 : ∀{Γ A B} → Tm3 Γ A → Tm3 Γ (sum3 A B); left3
= λ t Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right case zero suc rec →
left3 _ _ _ (t Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right case zero suc rec)
right3 : ∀{Γ A B} → Tm3 Γ B → Tm3 Γ (sum3 A B); right3
= λ t Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right3 case zero suc rec →
right3 _ _ _ (t Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right3 case zero suc rec)
case3 : ∀{Γ A B C} → Tm3 Γ (sum3 A B) → Tm3 Γ (arr3 A C) → Tm3 Γ (arr3 B C) → Tm3 Γ C; case3
= λ t u v Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right3 case3 zero suc rec →
case3 _ _ _ _
(t Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right3 case3 zero suc rec)
(u Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right3 case3 zero suc rec)
(v Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right3 case3 zero suc rec)
zero3 : ∀{Γ} → Tm3 Γ nat3; zero3
= λ Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right3 case3 zero3 suc rec → zero3 _
suc3 : ∀{Γ} → Tm3 Γ nat3 → Tm3 Γ nat3; suc3
= λ t Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right3 case3 zero3 suc3 rec →
suc3 _ (t Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right3 case3 zero3 suc3 rec)
rec3 : ∀{Γ A} → Tm3 Γ nat3 → Tm3 Γ (arr3 nat3 (arr3 A A)) → Tm3 Γ A → Tm3 Γ A; rec3
= λ t u v Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right3 case3 zero3 suc3 rec3 →
rec3 _ _
(t Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right3 case3 zero3 suc3 rec3)
(u Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right3 case3 zero3 suc3 rec3)
(v Tm3 var3 lam3 app3 tt3 pair3 fst3 snd3 left3 right3 case3 zero3 suc3 rec3)
v03 : ∀{Γ A} → Tm3 (snoc3 Γ A) A; v03
= var3 vz3
v13 : ∀{Γ A B} → Tm3 (snoc3 (snoc3 Γ A) B) A; v13
= var3 (vs3 vz3)
v23 : ∀{Γ A B C} → Tm3 (snoc3 (snoc3 (snoc3 Γ A) B) C) A; v23
= var3 (vs3 (vs3 vz3))
v33 : ∀{Γ A B C D} → Tm3 (snoc3 (snoc3 (snoc3 (snoc3 Γ A) B) C) D) A; v33
= var3 (vs3 (vs3 (vs3 vz3)))
tbool3 : Ty3; tbool3
= sum3 top3 top3
true3 : ∀{Γ} → Tm3 Γ tbool3; true3
= left3 tt3
tfalse3 : ∀{Γ} → Tm3 Γ tbool3; tfalse3
= right3 tt3
ifthenelse3 : ∀{Γ A} → Tm3 Γ (arr3 tbool3 (arr3 A (arr3 A A))); ifthenelse3
= lam3 (lam3 (lam3 (case3 v23 (lam3 v23) (lam3 v13))))
times43 : ∀{Γ A} → Tm3 Γ (arr3 (arr3 A A) (arr3 A A)); times43
= lam3 (lam3 (app3 v13 (app3 v13 (app3 v13 (app3 v13 v03)))))
add3 : ∀{Γ} → Tm3 Γ (arr3 nat3 (arr3 nat3 nat3)); add3
= lam3 (rec3 v03
(lam3 (lam3 (lam3 (suc3 (app3 v13 v03)))))
(lam3 v03))
mul3 : ∀{Γ} → Tm3 Γ (arr3 nat3 (arr3 nat3 nat3)); mul3
= lam3 (rec3 v03
(lam3 (lam3 (lam3 (app3 (app3 add3 (app3 v13 v03)) v03))))
(lam3 zero3))
fact3 : ∀{Γ} → Tm3 Γ (arr3 nat3 nat3); fact3
= lam3 (rec3 v03 (lam3 (lam3 (app3 (app3 mul3 (suc3 v13)) v03)))
(suc3 zero3))
{-# OPTIONS --type-in-type #-}
Ty4 : Set
Ty4 =
(Ty4 : Set)
(nat top bot : Ty4)
(arr prod sum : Ty4 → Ty4 → Ty4)
→ Ty4
nat4 : Ty4; nat4 = λ _ nat4 _ _ _ _ _ → nat4
top4 : Ty4; top4 = λ _ _ top4 _ _ _ _ → top4
bot4 : Ty4; bot4 = λ _ _ _ bot4 _ _ _ → bot4
arr4 : Ty4 → Ty4 → Ty4; arr4
= λ A B Ty4 nat4 top4 bot4 arr4 prod sum →
arr4 (A Ty4 nat4 top4 bot4 arr4 prod sum) (B Ty4 nat4 top4 bot4 arr4 prod sum)
prod4 : Ty4 → Ty4 → Ty4; prod4
= λ A B Ty4 nat4 top4 bot4 arr4 prod4 sum →
prod4 (A Ty4 nat4 top4 bot4 arr4 prod4 sum) (B Ty4 nat4 top4 bot4 arr4 prod4 sum)
sum4 : Ty4 → Ty4 → Ty4; sum4
= λ A B Ty4 nat4 top4 bot4 arr4 prod4 sum4 →
sum4 (A Ty4 nat4 top4 bot4 arr4 prod4 sum4) (B Ty4 nat4 top4 bot4 arr4 prod4 sum4)
Con4 : Set; Con4
= (Con4 : Set)
(nil : Con4)
(snoc : Con4 → Ty4 → Con4)
→ Con4
nil4 : Con4; nil4
= λ Con4 nil4 snoc → nil4
snoc4 : Con4 → Ty4 → Con4; snoc4
= λ Γ A Con4 nil4 snoc4 → snoc4 (Γ Con4 nil4 snoc4) A
Var4 : Con4 → Ty4 → Set; Var4
= λ Γ A →
(Var4 : Con4 → Ty4 → Set)
(vz : ∀ Γ A → Var4 (snoc4 Γ A) A)
(vs : ∀ Γ B A → Var4 Γ A → Var4 (snoc4 Γ B) A)
→ Var4 Γ A
vz4 : ∀{Γ A} → Var4 (snoc4 Γ A) A; vz4
= λ Var4 vz4 vs → vz4 _ _
vs4 : ∀{Γ B A} → Var4 Γ A → Var4 (snoc4 Γ B) A; vs4
= λ x Var4 vz4 vs4 → vs4 _ _ _ (x Var4 vz4 vs4)
Tm4 : Con4 → Ty4 → Set; Tm4
= λ Γ A →
(Tm4 : Con4 → Ty4 → Set)
(var : ∀ Γ A → Var4 Γ A → Tm4 Γ A)
(lam : ∀ Γ A B → Tm4 (snoc4 Γ A) B → Tm4 Γ (arr4 A B))
(app : ∀ Γ A B → Tm4 Γ (arr4 A B) → Tm4 Γ A → Tm4 Γ B)
(tt : ∀ Γ → Tm4 Γ top4)
(pair : ∀ Γ A B → Tm4 Γ A → Tm4 Γ B → Tm4 Γ (prod4 A B))
(fst : ∀ Γ A B → Tm4 Γ (prod4 A B) → Tm4 Γ A)
(snd : ∀ Γ A B → Tm4 Γ (prod4 A B) → Tm4 Γ B)
(left : ∀ Γ A B → Tm4 Γ A → Tm4 Γ (sum4 A B))
(right : ∀ Γ A B → Tm4 Γ B → Tm4 Γ (sum4 A B))
(case : ∀ Γ A B C → Tm4 Γ (sum4 A B) → Tm4 Γ (arr4 A C) → Tm4 Γ (arr4 B C) → Tm4 Γ C)
(zero : ∀ Γ → Tm4 Γ nat4)
(suc : ∀ Γ → Tm4 Γ nat4 → Tm4 Γ nat4)
(rec : ∀ Γ A → Tm4 Γ nat4 → Tm4 Γ (arr4 nat4 (arr4 A A)) → Tm4 Γ A → Tm4 Γ A)
→ Tm4 Γ A
var4 : ∀{Γ A} → Var4 Γ A → Tm4 Γ A; var4
= λ x Tm4 var4 lam app tt pair fst snd left right case zero suc rec →
var4 _ _ x
lam4 : ∀{Γ A B} → Tm4 (snoc4 Γ A) B → Tm4 Γ (arr4 A B); lam4
= λ t Tm4 var4 lam4 app tt pair fst snd left right case zero suc rec →
lam4 _ _ _ (t Tm4 var4 lam4 app tt pair fst snd left right case zero suc rec)
app4 : ∀{Γ A B} → Tm4 Γ (arr4 A B) → Tm4 Γ A → Tm4 Γ B; app4
= λ t u Tm4 var4 lam4 app4 tt pair fst snd left right case zero suc rec →
app4 _ _ _ (t Tm4 var4 lam4 app4 tt pair fst snd left right case zero suc rec)
(u Tm4 var4 lam4 app4 tt pair fst snd left right case zero suc rec)
tt4 : ∀{Γ} → Tm4 Γ top4; tt4
= λ Tm4 var4 lam4 app4 tt4 pair fst snd left right case zero suc rec → tt4 _
pair4 : ∀{Γ A B} → Tm4 Γ A → Tm4 Γ B → Tm4 Γ (prod4 A B); pair4
= λ t u Tm4 var4 lam4 app4 tt4 pair4 fst snd left right case zero suc rec →
pair4 _ _ _ (t Tm4 var4 lam4 app4 tt4 pair4 fst snd left right case zero suc rec)
(u Tm4 var4 lam4 app4 tt4 pair4 fst snd left right case zero suc rec)
fst4 : ∀{Γ A B} → Tm4 Γ (prod4 A B) → Tm4 Γ A; fst4
= λ t Tm4 var4 lam4 app4 tt4 pair4 fst4 snd left right case zero suc rec →
fst4 _ _ _ (t Tm4 var4 lam4 app4 tt4 pair4 fst4 snd left right case zero suc rec)
snd4 : ∀{Γ A B} → Tm4 Γ (prod4 A B) → Tm4 Γ B; snd4
= λ t Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left right case zero suc rec →
snd4 _ _ _ (t Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left right case zero suc rec)
left4 : ∀{Γ A B} → Tm4 Γ A → Tm4 Γ (sum4 A B); left4
= λ t Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right case zero suc rec →
left4 _ _ _ (t Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right case zero suc rec)
right4 : ∀{Γ A B} → Tm4 Γ B → Tm4 Γ (sum4 A B); right4
= λ t Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right4 case zero suc rec →
right4 _ _ _ (t Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right4 case zero suc rec)
case4 : ∀{Γ A B C} → Tm4 Γ (sum4 A B) → Tm4 Γ (arr4 A C) → Tm4 Γ (arr4 B C) → Tm4 Γ C; case4
= λ t u v Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right4 case4 zero suc rec →
case4 _ _ _ _
(t Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right4 case4 zero suc rec)
(u Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right4 case4 zero suc rec)
(v Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right4 case4 zero suc rec)
zero4 : ∀{Γ} → Tm4 Γ nat4; zero4
= λ Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right4 case4 zero4 suc rec → zero4 _
suc4 : ∀{Γ} → Tm4 Γ nat4 → Tm4 Γ nat4; suc4
= λ t Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right4 case4 zero4 suc4 rec →
suc4 _ (t Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right4 case4 zero4 suc4 rec)
rec4 : ∀{Γ A} → Tm4 Γ nat4 → Tm4 Γ (arr4 nat4 (arr4 A A)) → Tm4 Γ A → Tm4 Γ A; rec4
= λ t u v Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right4 case4 zero4 suc4 rec4 →
rec4 _ _
(t Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right4 case4 zero4 suc4 rec4)
(u Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right4 case4 zero4 suc4 rec4)
(v Tm4 var4 lam4 app4 tt4 pair4 fst4 snd4 left4 right4 case4 zero4 suc4 rec4)
v04 : ∀{Γ A} → Tm4 (snoc4 Γ A) A; v04
= var4 vz4
v14 : ∀{Γ A B} → Tm4 (snoc4 (snoc4 Γ A) B) A; v14
= var4 (vs4 vz4)
v24 : ∀{Γ A B C} → Tm4 (snoc4 (snoc4 (snoc4 Γ A) B) C) A; v24
= var4 (vs4 (vs4 vz4))
v34 : ∀{Γ A B C D} → Tm4 (snoc4 (snoc4 (snoc4 (snoc4 Γ A) B) C) D) A; v34
= var4 (vs4 (vs4 (vs4 vz4)))
tbool4 : Ty4; tbool4
= sum4 top4 top4
true4 : ∀{Γ} → Tm4 Γ tbool4; true4
= left4 tt4
tfalse4 : ∀{Γ} → Tm4 Γ tbool4; tfalse4
= right4 tt4
ifthenelse4 : ∀{Γ A} → Tm4 Γ (arr4 tbool4 (arr4 A (arr4 A A))); ifthenelse4
= lam4 (lam4 (lam4 (case4 v24 (lam4 v24) (lam4 v14))))
times44 : ∀{Γ A} → Tm4 Γ (arr4 (arr4 A A) (arr4 A A)); times44
= lam4 (lam4 (app4 v14 (app4 v14 (app4 v14 (app4 v14 v04)))))
add4 : ∀{Γ} → Tm4 Γ (arr4 nat4 (arr4 nat4 nat4)); add4
= lam4 (rec4 v04
(lam4 (lam4 (lam4 (suc4 (app4 v14 v04)))))
(lam4 v04))
mul4 : ∀{Γ} → Tm4 Γ (arr4 nat4 (arr4 nat4 nat4)); mul4
= lam4 (rec4 v04
(lam4 (lam4 (lam4 (app4 (app4 add4 (app4 v14 v04)) v04))))
(lam4 zero4))
fact4 : ∀{Γ} → Tm4 Γ (arr4 nat4 nat4); fact4
= lam4 (rec4 v04 (lam4 (lam4 (app4 (app4 mul4 (suc4 v14)) v04)))
(suc4 zero4))
{-# OPTIONS --type-in-type #-}
Ty5 : Set
Ty5 =
(Ty5 : Set)
(nat top bot : Ty5)
(arr prod sum : Ty5 → Ty5 → Ty5)
→ Ty5
nat5 : Ty5; nat5 = λ _ nat5 _ _ _ _ _ → nat5
top5 : Ty5; top5 = λ _ _ top5 _ _ _ _ → top5
bot5 : Ty5; bot5 = λ _ _ _ bot5 _ _ _ → bot5
arr5 : Ty5 → Ty5 → Ty5; arr5
= λ A B Ty5 nat5 top5 bot5 arr5 prod sum →
arr5 (A Ty5 nat5 top5 bot5 arr5 prod sum) (B Ty5 nat5 top5 bot5 arr5 prod sum)
prod5 : Ty5 → Ty5 → Ty5; prod5
= λ A B Ty5 nat5 top5 bot5 arr5 prod5 sum →
prod5 (A Ty5 nat5 top5 bot5 arr5 prod5 sum) (B Ty5 nat5 top5 bot5 arr5 prod5 sum)
sum5 : Ty5 → Ty5 → Ty5; sum5
= λ A B Ty5 nat5 top5 bot5 arr5 prod5 sum5 →
sum5 (A Ty5 nat5 top5 bot5 arr5 prod5 sum5) (B Ty5 nat5 top5 bot5 arr5 prod5 sum5)
Con5 : Set; Con5
= (Con5 : Set)
(nil : Con5)
(snoc : Con5 → Ty5 → Con5)
→ Con5
nil5 : Con5; nil5
= λ Con5 nil5 snoc → nil5
snoc5 : Con5 → Ty5 → Con5; snoc5
= λ Γ A Con5 nil5 snoc5 → snoc5 (Γ Con5 nil5 snoc5) A
Var5 : Con5 → Ty5 → Set; Var5
= λ Γ A →
(Var5 : Con5 → Ty5 → Set)
(vz : ∀ Γ A → Var5 (snoc5 Γ A) A)
(vs : ∀ Γ B A → Var5 Γ A → Var5 (snoc5 Γ B) A)
→ Var5 Γ A
vz5 : ∀{Γ A} → Var5 (snoc5 Γ A) A; vz5
= λ Var5 vz5 vs → vz5 _ _
vs5 : ∀{Γ B A} → Var5 Γ A → Var5 (snoc5 Γ B) A; vs5
= λ x Var5 vz5 vs5 → vs5 _ _ _ (x Var5 vz5 vs5)
Tm5 : Con5 → Ty5 → Set; Tm5
= λ Γ A →
(Tm5 : Con5 → Ty5 → Set)
(var : ∀ Γ A → Var5 Γ A → Tm5 Γ A)
(lam : ∀ Γ A B → Tm5 (snoc5 Γ A) B → Tm5 Γ (arr5 A B))
(app : ∀ Γ A B → Tm5 Γ (arr5 A B) → Tm5 Γ A → Tm5 Γ B)
(tt : ∀ Γ → Tm5 Γ top5)
(pair : ∀ Γ A B → Tm5 Γ A → Tm5 Γ B → Tm5 Γ (prod5 A B))
(fst : ∀ Γ A B → Tm5 Γ (prod5 A B) → Tm5 Γ A)
(snd : ∀ Γ A B → Tm5 Γ (prod5 A B) → Tm5 Γ B)
(left : ∀ Γ A B → Tm5 Γ A → Tm5 Γ (sum5 A B))
(right : ∀ Γ A B → Tm5 Γ B → Tm5 Γ (sum5 A B))
(case : ∀ Γ A B C → Tm5 Γ (sum5 A B) → Tm5 Γ (arr5 A C) → Tm5 Γ (arr5 B C) → Tm5 Γ C)
(zero : ∀ Γ → Tm5 Γ nat5)
(suc : ∀ Γ → Tm5 Γ nat5 → Tm5 Γ nat5)
(rec : ∀ Γ A → Tm5 Γ nat5 → Tm5 Γ (arr5 nat5 (arr5 A A)) → Tm5 Γ A → Tm5 Γ A)
→ Tm5 Γ A
var5 : ∀{Γ A} → Var5 Γ A → Tm5 Γ A; var5
= λ x Tm5 var5 lam app tt pair fst snd left right case zero suc rec →
var5 _ _ x
lam5 : ∀{Γ A B} → Tm5 (snoc5 Γ A) B → Tm5 Γ (arr5 A B); lam5
= λ t Tm5 var5 lam5 app tt pair fst snd left right case zero suc rec →
lam5 _ _ _ (t Tm5 var5 lam5 app tt pair fst snd left right case zero suc rec)
app5 : ∀{Γ A B} → Tm5 Γ (arr5 A B) → Tm5 Γ A → Tm5 Γ B; app5
= λ t u Tm5 var5 lam5 app5 tt pair fst snd left right case zero suc rec →
app5 _ _ _ (t Tm5 var5 lam5 app5 tt pair fst snd left right case zero suc rec)
(u Tm5 var5 lam5 app5 tt pair fst snd left right case zero suc rec)
tt5 : ∀{Γ} → Tm5 Γ top5; tt5
= λ Tm5 var5 lam5 app5 tt5 pair fst snd left right case zero suc rec → tt5 _
pair5 : ∀{Γ A B} → Tm5 Γ A → Tm5 Γ B → Tm5 Γ (prod5 A B); pair5
= λ t u Tm5 var5 lam5 app5 tt5 pair5 fst snd left right case zero suc rec →
pair5 _ _ _ (t Tm5 var5 lam5 app5 tt5 pair5 fst snd left right case zero suc rec)
(u Tm5 var5 lam5 app5 tt5 pair5 fst snd left right case zero suc rec)
fst5 : ∀{Γ A B} → Tm5 Γ (prod5 A B) → Tm5 Γ A; fst5
= λ t Tm5 var5 lam5 app5 tt5 pair5 fst5 snd left right case zero suc rec →
fst5 _ _ _ (t Tm5 var5 lam5 app5 tt5 pair5 fst5 snd left right case zero suc rec)
snd5 : ∀{Γ A B} → Tm5 Γ (prod5 A B) → Tm5 Γ B; snd5
= λ t Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left right case zero suc rec →
snd5 _ _ _ (t Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left right case zero suc rec)
left5 : ∀{Γ A B} → Tm5 Γ A → Tm5 Γ (sum5 A B); left5
= λ t Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right case zero suc rec →
left5 _ _ _ (t Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right case zero suc rec)
right5 : ∀{Γ A B} → Tm5 Γ B → Tm5 Γ (sum5 A B); right5
= λ t Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right5 case zero suc rec →
right5 _ _ _ (t Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right5 case zero suc rec)
case5 : ∀{Γ A B C} → Tm5 Γ (sum5 A B) → Tm5 Γ (arr5 A C) → Tm5 Γ (arr5 B C) → Tm5 Γ C; case5
= λ t u v Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right5 case5 zero suc rec →
case5 _ _ _ _
(t Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right5 case5 zero suc rec)
(u Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right5 case5 zero suc rec)
(v Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right5 case5 zero suc rec)
zero5 : ∀{Γ} → Tm5 Γ nat5; zero5
= λ Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right5 case5 zero5 suc rec → zero5 _
suc5 : ∀{Γ} → Tm5 Γ nat5 → Tm5 Γ nat5; suc5
= λ t Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right5 case5 zero5 suc5 rec →
suc5 _ (t Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right5 case5 zero5 suc5 rec)
rec5 : ∀{Γ A} → Tm5 Γ nat5 → Tm5 Γ (arr5 nat5 (arr5 A A)) → Tm5 Γ A → Tm5 Γ A; rec5
= λ t u v Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right5 case5 zero5 suc5 rec5 →
rec5 _ _
(t Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right5 case5 zero5 suc5 rec5)
(u Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right5 case5 zero5 suc5 rec5)
(v Tm5 var5 lam5 app5 tt5 pair5 fst5 snd5 left5 right5 case5 zero5 suc5 rec5)
v05 : ∀{Γ A} → Tm5 (snoc5 Γ A) A; v05
= var5 vz5
v15 : ∀{Γ A B} → Tm5 (snoc5 (snoc5 Γ A) B) A; v15
= var5 (vs5 vz5)
v25 : ∀{Γ A B C} → Tm5 (snoc5 (snoc5 (snoc5 Γ A) B) C) A; v25
= var5 (vs5 (vs5 vz5))
v35 : ∀{Γ A B C D} → Tm5 (snoc5 (snoc5 (snoc5 (snoc5 Γ A) B) C) D) A; v35
= var5 (vs5 (vs5 (vs5 vz5)))
tbool5 : Ty5; tbool5
= sum5 top5 top5
true5 : ∀{Γ} → Tm5 Γ tbool5; true5
= left5 tt5
tfalse5 : ∀{Γ} → Tm5 Γ tbool5; tfalse5
= right5 tt5
ifthenelse5 : ∀{Γ A} → Tm5 Γ (arr5 tbool5 (arr5 A (arr5 A A))); ifthenelse5
= lam5 (lam5 (lam5 (case5 v25 (lam5 v25) (lam5 v15))))
times45 : ∀{Γ A} → Tm5 Γ (arr5 (arr5 A A) (arr5 A A)); times45
= lam5 (lam5 (app5 v15 (app5 v15 (app5 v15 (app5 v15 v05)))))
add5 : ∀{Γ} → Tm5 Γ (arr5 nat5 (arr5 nat5 nat5)); add5
= lam5 (rec5 v05
(lam5 (lam5 (lam5 (suc5 (app5 v15 v05)))))
(lam5 v05))
mul5 : ∀{Γ} → Tm5 Γ (arr5 nat5 (arr5 nat5 nat5)); mul5
= lam5 (rec5 v05
(lam5 (lam5 (lam5 (app5 (app5 add5 (app5 v15 v05)) v05))))
(lam5 zero5))
fact5 : ∀{Γ} → Tm5 Γ (arr5 nat5 nat5); fact5
= lam5 (rec5 v05 (lam5 (lam5 (app5 (app5 mul5 (suc5 v15)) v05)))
(suc5 zero5))
{-# OPTIONS --type-in-type #-}
Ty6 : Set
Ty6 =
(Ty6 : Set)
(nat top bot : Ty6)
(arr prod sum : Ty6 → Ty6 → Ty6)
→ Ty6
nat6 : Ty6; nat6 = λ _ nat6 _ _ _ _ _ → nat6
top6 : Ty6; top6 = λ _ _ top6 _ _ _ _ → top6
bot6 : Ty6; bot6 = λ _ _ _ bot6 _ _ _ → bot6
arr6 : Ty6 → Ty6 → Ty6; arr6
= λ A B Ty6 nat6 top6 bot6 arr6 prod sum →
arr6 (A Ty6 nat6 top6 bot6 arr6 prod sum) (B Ty6 nat6 top6 bot6 arr6 prod sum)
prod6 : Ty6 → Ty6 → Ty6; prod6
= λ A B Ty6 nat6 top6 bot6 arr6 prod6 sum →
prod6 (A Ty6 nat6 top6 bot6 arr6 prod6 sum) (B Ty6 nat6 top6 bot6 arr6 prod6 sum)
sum6 : Ty6 → Ty6 → Ty6; sum6
= λ A B Ty6 nat6 top6 bot6 arr6 prod6 sum6 →
sum6 (A Ty6 nat6 top6 bot6 arr6 prod6 sum6) (B Ty6 nat6 top6 bot6 arr6 prod6 sum6)
Con6 : Set; Con6
= (Con6 : Set)
(nil : Con6)
(snoc : Con6 → Ty6 → Con6)
→ Con6
nil6 : Con6; nil6
= λ Con6 nil6 snoc → nil6
snoc6 : Con6 → Ty6 → Con6; snoc6
= λ Γ A Con6 nil6 snoc6 → snoc6 (Γ Con6 nil6 snoc6) A
Var6 : Con6 → Ty6 → Set; Var6
= λ Γ A →
(Var6 : Con6 → Ty6 → Set)
(vz : ∀ Γ A → Var6 (snoc6 Γ A) A)
(vs : ∀ Γ B A → Var6 Γ A → Var6 (snoc6 Γ B) A)
→ Var6 Γ A
vz6 : ∀{Γ A} → Var6 (snoc6 Γ A) A; vz6
= λ Var6 vz6 vs → vz6 _ _
vs6 : ∀{Γ B A} → Var6 Γ A → Var6 (snoc6 Γ B) A; vs6
= λ x Var6 vz6 vs6 → vs6 _ _ _ (x Var6 vz6 vs6)
Tm6 : Con6 → Ty6 → Set; Tm6
= λ Γ A →
(Tm6 : Con6 → Ty6 → Set)
(var : ∀ Γ A → Var6 Γ A → Tm6 Γ A)
(lam : ∀ Γ A B → Tm6 (snoc6 Γ A) B → Tm6 Γ (arr6 A B))
(app : ∀ Γ A B → Tm6 Γ (arr6 A B) → Tm6 Γ A → Tm6 Γ B)
(tt : ∀ Γ → Tm6 Γ top6)
(pair : ∀ Γ A B → Tm6 Γ A → Tm6 Γ B → Tm6 Γ (prod6 A B))
(fst : ∀ Γ A B → Tm6 Γ (prod6 A B) → Tm6 Γ A)
(snd : ∀ Γ A B → Tm6 Γ (prod6 A B) → Tm6 Γ B)
(left : ∀ Γ A B → Tm6 Γ A → Tm6 Γ (sum6 A B))
(right : ∀ Γ A B → Tm6 Γ B → Tm6 Γ (sum6 A B))
(case : ∀ Γ A B C → Tm6 Γ (sum6 A B) → Tm6 Γ (arr6 A C) → Tm6 Γ (arr6 B C) → Tm6 Γ C)
(zero : ∀ Γ → Tm6 Γ nat6)
(suc : ∀ Γ → Tm6 Γ nat6 → Tm6 Γ nat6)
(rec : ∀ Γ A → Tm6 Γ nat6 → Tm6 Γ (arr6 nat6 (arr6 A A)) → Tm6 Γ A → Tm6 Γ A)
→ Tm6 Γ A
var6 : ∀{Γ A} → Var6 Γ A → Tm6 Γ A; var6
= λ x Tm6 var6 lam app tt pair fst snd left right case zero suc rec →
var6 _ _ x
lam6 : ∀{Γ A B} → Tm6 (snoc6 Γ A) B → Tm6 Γ (arr6 A B); lam6
= λ t Tm6 var6 lam6 app tt pair fst snd left right case zero suc rec →
lam6 _ _ _ (t Tm6 var6 lam6 app tt pair fst snd left right case zero suc rec)
app6 : ∀{Γ A B} → Tm6 Γ (arr6 A B) → Tm6 Γ A → Tm6 Γ B; app6
= λ t u Tm6 var6 lam6 app6 tt pair fst snd left right case zero suc rec →
app6 _ _ _ (t Tm6 var6 lam6 app6 tt pair fst snd left right case zero suc rec)
(u Tm6 var6 lam6 app6 tt pair fst snd left right case zero suc rec)
tt6 : ∀{Γ} → Tm6 Γ top6; tt6
= λ Tm6 var6 lam6 app6 tt6 pair fst snd left right case zero suc rec → tt6 _
pair6 : ∀{Γ A B} → Tm6 Γ A → Tm6 Γ B → Tm6 Γ (prod6 A B); pair6
= λ t u Tm6 var6 lam6 app6 tt6 pair6 fst snd left right case zero suc rec →
pair6 _ _ _ (t Tm6 var6 lam6 app6 tt6 pair6 fst snd left right case zero suc rec)
(u Tm6 var6 lam6 app6 tt6 pair6 fst snd left right case zero suc rec)
fst6 : ∀{Γ A B} → Tm6 Γ (prod6 A B) → Tm6 Γ A; fst6
= λ t Tm6 var6 lam6 app6 tt6 pair6 fst6 snd left right case zero suc rec →
fst6 _ _ _ (t Tm6 var6 lam6 app6 tt6 pair6 fst6 snd left right case zero suc rec)
snd6 : ∀{Γ A B} → Tm6 Γ (prod6 A B) → Tm6 Γ B; snd6
= λ t Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left right case zero suc rec →
snd6 _ _ _ (t Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left right case zero suc rec)
left6 : ∀{Γ A B} → Tm6 Γ A → Tm6 Γ (sum6 A B); left6
= λ t Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right case zero suc rec →
left6 _ _ _ (t Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right case zero suc rec)
right6 : ∀{Γ A B} → Tm6 Γ B → Tm6 Γ (sum6 A B); right6
= λ t Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right6 case zero suc rec →
right6 _ _ _ (t Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right6 case zero suc rec)
case6 : ∀{Γ A B C} → Tm6 Γ (sum6 A B) → Tm6 Γ (arr6 A C) → Tm6 Γ (arr6 B C) → Tm6 Γ C; case6
= λ t u v Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right6 case6 zero suc rec →
case6 _ _ _ _
(t Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right6 case6 zero suc rec)
(u Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right6 case6 zero suc rec)
(v Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right6 case6 zero suc rec)
zero6 : ∀{Γ} → Tm6 Γ nat6; zero6
= λ Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right6 case6 zero6 suc rec → zero6 _
suc6 : ∀{Γ} → Tm6 Γ nat6 → Tm6 Γ nat6; suc6
= λ t Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right6 case6 zero6 suc6 rec →
suc6 _ (t Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right6 case6 zero6 suc6 rec)
rec6 : ∀{Γ A} → Tm6 Γ nat6 → Tm6 Γ (arr6 nat6 (arr6 A A)) → Tm6 Γ A → Tm6 Γ A; rec6
= λ t u v Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right6 case6 zero6 suc6 rec6 →
rec6 _ _
(t Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right6 case6 zero6 suc6 rec6)
(u Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right6 case6 zero6 suc6 rec6)
(v Tm6 var6 lam6 app6 tt6 pair6 fst6 snd6 left6 right6 case6 zero6 suc6 rec6)
v06 : ∀{Γ A} → Tm6 (snoc6 Γ A) A; v06
= var6 vz6
v16 : ∀{Γ A B} → Tm6 (snoc6 (snoc6 Γ A) B) A; v16
= var6 (vs6 vz6)
v26 : ∀{Γ A B C} → Tm6 (snoc6 (snoc6 (snoc6 Γ A) B) C) A; v26
= var6 (vs6 (vs6 vz6))
v36 : ∀{Γ A B C D} → Tm6 (snoc6 (snoc6 (snoc6 (snoc6 Γ A) B) C) D) A; v36
= var6 (vs6 (vs6 (vs6 vz6)))
tbool6 : Ty6; tbool6
= sum6 top6 top6
true6 : ∀{Γ} → Tm6 Γ tbool6; true6
= left6 tt6
tfalse6 : ∀{Γ} → Tm6 Γ tbool6; tfalse6
= right6 tt6
ifthenelse6 : ∀{Γ A} → Tm6 Γ (arr6 tbool6 (arr6 A (arr6 A A))); ifthenelse6
= lam6 (lam6 (lam6 (case6 v26 (lam6 v26) (lam6 v16))))
times46 : ∀{Γ A} → Tm6 Γ (arr6 (arr6 A A) (arr6 A A)); times46
= lam6 (lam6 (app6 v16 (app6 v16 (app6 v16 (app6 v16 v06)))))
add6 : ∀{Γ} → Tm6 Γ (arr6 nat6 (arr6 nat6 nat6)); add6
= lam6 (rec6 v06
(lam6 (lam6 (lam6 (suc6 (app6 v16 v06)))))
(lam6 v06))
mul6 : ∀{Γ} → Tm6 Γ (arr6 nat6 (arr6 nat6 nat6)); mul6
= lam6 (rec6 v06
(lam6 (lam6 (lam6 (app6 (app6 add6 (app6 v16 v06)) v06))))
(lam6 zero6))
fact6 : ∀{Γ} → Tm6 Γ (arr6 nat6 nat6); fact6
= lam6 (rec6 v06 (lam6 (lam6 (app6 (app6 mul6 (suc6 v16)) v06)))
(suc6 zero6))
{-# OPTIONS --type-in-type #-}
Ty7 : Set
Ty7 =
(Ty7 : Set)
(nat top bot : Ty7)
(arr prod sum : Ty7 → Ty7 → Ty7)
→ Ty7
nat7 : Ty7; nat7 = λ _ nat7 _ _ _ _ _ → nat7
top7 : Ty7; top7 = λ _ _ top7 _ _ _ _ → top7
bot7 : Ty7; bot7 = λ _ _ _ bot7 _ _ _ → bot7
arr7 : Ty7 → Ty7 → Ty7; arr7
= λ A B Ty7 nat7 top7 bot7 arr7 prod sum →
arr7 (A Ty7 nat7 top7 bot7 arr7 prod sum) (B Ty7 nat7 top7 bot7 arr7 prod sum)
prod7 : Ty7 → Ty7 → Ty7; prod7
= λ A B Ty7 nat7 top7 bot7 arr7 prod7 sum →
prod7 (A Ty7 nat7 top7 bot7 arr7 prod7 sum) (B Ty7 nat7 top7 bot7 arr7 prod7 sum)
sum7 : Ty7 → Ty7 → Ty7; sum7
= λ A B Ty7 nat7 top7 bot7 arr7 prod7 sum7 →
sum7 (A Ty7 nat7 top7 bot7 arr7 prod7 sum7) (B Ty7 nat7 top7 bot7 arr7 prod7 sum7)
Con7 : Set; Con7
= (Con7 : Set)
(nil : Con7)
(snoc : Con7 → Ty7 → Con7)
→ Con7
nil7 : Con7; nil7
= λ Con7 nil7 snoc → nil7
snoc7 : Con7 → Ty7 → Con7; snoc7
= λ Γ A Con7 nil7 snoc7 → snoc7 (Γ Con7 nil7 snoc7) A
Var7 : Con7 → Ty7 → Set; Var7
= λ Γ A →
(Var7 : Con7 → Ty7 → Set)
(vz : ∀ Γ A → Var7 (snoc7 Γ A) A)
(vs : ∀ Γ B A → Var7 Γ A → Var7 (snoc7 Γ B) A)
→ Var7 Γ A
vz7 : ∀{Γ A} → Var7 (snoc7 Γ A) A; vz7
= λ Var7 vz7 vs → vz7 _ _
vs7 : ∀{Γ B A} → Var7 Γ A → Var7 (snoc7 Γ B) A; vs7
= λ x Var7 vz7 vs7 → vs7 _ _ _ (x Var7 vz7 vs7)
Tm7 : Con7 → Ty7 → Set; Tm7
= λ Γ A →
(Tm7 : Con7 → Ty7 → Set)
(var : ∀ Γ A → Var7 Γ A → Tm7 Γ A)
(lam : ∀ Γ A B → Tm7 (snoc7 Γ A) B → Tm7 Γ (arr7 A B))
(app : ∀ Γ A B → Tm7 Γ (arr7 A B) → Tm7 Γ A → Tm7 Γ B)
(tt : ∀ Γ → Tm7 Γ top7)
(pair : ∀ Γ A B → Tm7 Γ A → Tm7 Γ B → Tm7 Γ (prod7 A B))
(fst : ∀ Γ A B → Tm7 Γ (prod7 A B) → Tm7 Γ A)
(snd : ∀ Γ A B → Tm7 Γ (prod7 A B) → Tm7 Γ B)
(left : ∀ Γ A B → Tm7 Γ A → Tm7 Γ (sum7 A B))
(right : ∀ Γ A B → Tm7 Γ B → Tm7 Γ (sum7 A B))
(case : ∀ Γ A B C → Tm7 Γ (sum7 A B) → Tm7 Γ (arr7 A C) → Tm7 Γ (arr7 B C) → Tm7 Γ C)
(zero : ∀ Γ → Tm7 Γ nat7)
(suc : ∀ Γ → Tm7 Γ nat7 → Tm7 Γ nat7)
(rec : ∀ Γ A → Tm7 Γ nat7 → Tm7 Γ (arr7 nat7 (arr7 A A)) → Tm7 Γ A → Tm7 Γ A)
→ Tm7 Γ A
var7 : ∀{Γ A} → Var7 Γ A → Tm7 Γ A; var7
= λ x Tm7 var7 lam app tt pair fst snd left right case zero suc rec →
var7 _ _ x
lam7 : ∀{Γ A B} → Tm7 (snoc7 Γ A) B → Tm7 Γ (arr7 A B); lam7
= λ t Tm7 var7 lam7 app tt pair fst snd left right case zero suc rec →
lam7 _ _ _ (t Tm7 var7 lam7 app tt pair fst snd left right case zero suc rec)
app7 : ∀{Γ A B} → Tm7 Γ (arr7 A B) → Tm7 Γ A → Tm7 Γ B; app7
= λ t u Tm7 var7 lam7 app7 tt pair fst snd left right case zero suc rec →
app7 _ _ _ (t Tm7 var7 lam7 app7 tt pair fst snd left right case zero suc rec)
(u Tm7 var7 lam7 app7 tt pair fst snd left right case zero suc rec)
tt7 : ∀{Γ} → Tm7 Γ top7; tt7
= λ Tm7 var7 lam7 app7 tt7 pair fst snd left right case zero suc rec → tt7 _
pair7 : ∀{Γ A B} → Tm7 Γ A → Tm7 Γ B → Tm7 Γ (prod7 A B); pair7
= λ t u Tm7 var7 lam7 app7 tt7 pair7 fst snd left right case zero suc rec →
pair7 _ _ _ (t Tm7 var7 lam7 app7 tt7 pair7 fst snd left right case zero suc rec)
(u Tm7 var7 lam7 app7 tt7 pair7 fst snd left right case zero suc rec)
fst7 : ∀{Γ A B} → Tm7 Γ (prod7 A B) → Tm7 Γ A; fst7
= λ t Tm7 var7 lam7 app7 tt7 pair7 fst7 snd left right case zero suc rec →
fst7 _ _ _ (t Tm7 var7 lam7 app7 tt7 pair7 fst7 snd left right case zero suc rec)
snd7 : ∀{Γ A B} → Tm7 Γ (prod7 A B) → Tm7 Γ B; snd7
= λ t Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left right case zero suc rec →
snd7 _ _ _ (t Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left right case zero suc rec)
left7 : ∀{Γ A B} → Tm7 Γ A → Tm7 Γ (sum7 A B); left7
= λ t Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right case zero suc rec →
left7 _ _ _ (t Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right case zero suc rec)
right7 : ∀{Γ A B} → Tm7 Γ B → Tm7 Γ (sum7 A B); right7
= λ t Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right7 case zero suc rec →
right7 _ _ _ (t Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right7 case zero suc rec)
case7 : ∀{Γ A B C} → Tm7 Γ (sum7 A B) → Tm7 Γ (arr7 A C) → Tm7 Γ (arr7 B C) → Tm7 Γ C; case7
= λ t u v Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right7 case7 zero suc rec →
case7 _ _ _ _
(t Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right7 case7 zero suc rec)
(u Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right7 case7 zero suc rec)
(v Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right7 case7 zero suc rec)
zero7 : ∀{Γ} → Tm7 Γ nat7; zero7
= λ Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right7 case7 zero7 suc rec → zero7 _
suc7 : ∀{Γ} → Tm7 Γ nat7 → Tm7 Γ nat7; suc7
= λ t Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right7 case7 zero7 suc7 rec →
suc7 _ (t Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right7 case7 zero7 suc7 rec)
rec7 : ∀{Γ A} → Tm7 Γ nat7 → Tm7 Γ (arr7 nat7 (arr7 A A)) → Tm7 Γ A → Tm7 Γ A; rec7
= λ t u v Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right7 case7 zero7 suc7 rec7 →
rec7 _ _
(t Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right7 case7 zero7 suc7 rec7)
(u Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right7 case7 zero7 suc7 rec7)
(v Tm7 var7 lam7 app7 tt7 pair7 fst7 snd7 left7 right7 case7 zero7 suc7 rec7)
v07 : ∀{Γ A} → Tm7 (snoc7 Γ A) A; v07
= var7 vz7
v17 : ∀{Γ A B} → Tm7 (snoc7 (snoc7 Γ A) B) A; v17
= var7 (vs7 vz7)
v27 : ∀{Γ A B C} → Tm7 (snoc7 (snoc7 (snoc7 Γ A) B) C) A; v27
= var7 (vs7 (vs7 vz7))
v37 : ∀{Γ A B C D} → Tm7 (snoc7 (snoc7 (snoc7 (snoc7 Γ A) B) C) D) A; v37
= var7 (vs7 (vs7 (vs7 vz7)))
tbool7 : Ty7; tbool7
= sum7 top7 top7
true7 : ∀{Γ} → Tm7 Γ tbool7; true7
= left7 tt7
tfalse7 : ∀{Γ} → Tm7 Γ tbool7; tfalse7
= right7 tt7
ifthenelse7 : ∀{Γ A} → Tm7 Γ (arr7 tbool7 (arr7 A (arr7 A A))); ifthenelse7
= lam7 (lam7 (lam7 (case7 v27 (lam7 v27) (lam7 v17))))
times47 : ∀{Γ A} → Tm7 Γ (arr7 (arr7 A A) (arr7 A A)); times47
= lam7 (lam7 (app7 v17 (app7 v17 (app7 v17 (app7 v17 v07)))))
add7 : ∀{Γ} → Tm7 Γ (arr7 nat7 (arr7 nat7 nat7)); add7
= lam7 (rec7 v07
(lam7 (lam7 (lam7 (suc7 (app7 v17 v07)))))
(lam7 v07))
mul7 : ∀{Γ} → Tm7 Γ (arr7 nat7 (arr7 nat7 nat7)); mul7
= lam7 (rec7 v07
(lam7 (lam7 (lam7 (app7 (app7 add7 (app7 v17 v07)) v07))))
(lam7 zero7))
fact7 : ∀{Γ} → Tm7 Γ (arr7 nat7 nat7); fact7
= lam7 (rec7 v07 (lam7 (lam7 (app7 (app7 mul7 (suc7 v17)) v07)))
(suc7 zero7))
{-# OPTIONS --type-in-type #-}
Ty8 : Set
Ty8 =
(Ty8 : Set)
(nat top bot : Ty8)
(arr prod sum : Ty8 → Ty8 → Ty8)
→ Ty8
nat8 : Ty8; nat8 = λ _ nat8 _ _ _ _ _ → nat8
top8 : Ty8; top8 = λ _ _ top8 _ _ _ _ → top8
bot8 : Ty8; bot8 = λ _ _ _ bot8 _ _ _ → bot8
arr8 : Ty8 → Ty8 → Ty8; arr8
= λ A B Ty8 nat8 top8 bot8 arr8 prod sum →
arr8 (A Ty8 nat8 top8 bot8 arr8 prod sum) (B Ty8 nat8 top8 bot8 arr8 prod sum)
prod8 : Ty8 → Ty8 → Ty8; prod8
= λ A B Ty8 nat8 top8 bot8 arr8 prod8 sum →
prod8 (A Ty8 nat8 top8 bot8 arr8 prod8 sum) (B Ty8 nat8 top8 bot8 arr8 prod8 sum)
sum8 : Ty8 → Ty8 → Ty8; sum8
= λ A B Ty8 nat8 top8 bot8 arr8 prod8 sum8 →
sum8 (A Ty8 nat8 top8 bot8 arr8 prod8 sum8) (B Ty8 nat8 top8 bot8 arr8 prod8 sum8)
Con8 : Set; Con8
= (Con8 : Set)
(nil : Con8)
(snoc : Con8 → Ty8 → Con8)
→ Con8
nil8 : Con8; nil8
= λ Con8 nil8 snoc → nil8
snoc8 : Con8 → Ty8 → Con8; snoc8
= λ Γ A Con8 nil8 snoc8 → snoc8 (Γ Con8 nil8 snoc8) A
Var8 : Con8 → Ty8 → Set; Var8
= λ Γ A →
(Var8 : Con8 → Ty8 → Set)
(vz : ∀ Γ A → Var8 (snoc8 Γ A) A)
(vs : ∀ Γ B A → Var8 Γ A → Var8 (snoc8 Γ B) A)
→ Var8 Γ A
vz8 : ∀{Γ A} → Var8 (snoc8 Γ A) A; vz8
= λ Var8 vz8 vs → vz8 _ _
vs8 : ∀{Γ B A} → Var8 Γ A → Var8 (snoc8 Γ B) A; vs8
= λ x Var8 vz8 vs8 → vs8 _ _ _ (x Var8 vz8 vs8)
Tm8 : Con8 → Ty8 → Set; Tm8
= λ Γ A →
(Tm8 : Con8 → Ty8 → Set)
(var : ∀ Γ A → Var8 Γ A → Tm8 Γ A)
(lam : ∀ Γ A B → Tm8 (snoc8 Γ A) B → Tm8 Γ (arr8 A B))
(app : ∀ Γ A B → Tm8 Γ (arr8 A B) → Tm8 Γ A → Tm8 Γ B)
(tt : ∀ Γ → Tm8 Γ top8)
(pair : ∀ Γ A B → Tm8 Γ A → Tm8 Γ B → Tm8 Γ (prod8 A B))
(fst : ∀ Γ A B → Tm8 Γ (prod8 A B) → Tm8 Γ A)
(snd : ∀ Γ A B → Tm8 Γ (prod8 A B) → Tm8 Γ B)
(left : ∀ Γ A B → Tm8 Γ A → Tm8 Γ (sum8 A B))
(right : ∀ Γ A B → Tm8 Γ B → Tm8 Γ (sum8 A B))
(case : ∀ Γ A B C → Tm8 Γ (sum8 A B) → Tm8 Γ (arr8 A C) → Tm8 Γ (arr8 B C) → Tm8 Γ C)
(zero : ∀ Γ → Tm8 Γ nat8)
(suc : ∀ Γ → Tm8 Γ nat8 → Tm8 Γ nat8)
(rec : ∀ Γ A → Tm8 Γ nat8 → Tm8 Γ (arr8 nat8 (arr8 A A)) → Tm8 Γ A → Tm8 Γ A)
→ Tm8 Γ A
var8 : ∀{Γ A} → Var8 Γ A → Tm8 Γ A; var8
= λ x Tm8 var8 lam app tt pair fst snd left right case zero suc rec →
var8 _ _ x
lam8 : ∀{Γ A B} → Tm8 (snoc8 Γ A) B → Tm8 Γ (arr8 A B); lam8
= λ t Tm8 var8 lam8 app tt pair fst snd left right case zero suc rec →
lam8 _ _ _ (t Tm8 var8 lam8 app tt pair fst snd left right case zero suc rec)
app8 : ∀{Γ A B} → Tm8 Γ (arr8 A B) → Tm8 Γ A → Tm8 Γ B; app8
= λ t u Tm8 var8 lam8 app8 tt pair fst snd left right case zero suc rec →
app8 _ _ _ (t Tm8 var8 lam8 app8 tt pair fst snd left right case zero suc rec)
(u Tm8 var8 lam8 app8 tt pair fst snd left right case zero suc rec)
tt8 : ∀{Γ} → Tm8 Γ top8; tt8
= λ Tm8 var8 lam8 app8 tt8 pair fst snd left right case zero suc rec → tt8 _
pair8 : ∀{Γ A B} → Tm8 Γ A → Tm8 Γ B → Tm8 Γ (prod8 A B); pair8
= λ t u Tm8 var8 lam8 app8 tt8 pair8 fst snd left right case zero suc rec →
pair8 _ _ _ (t Tm8 var8 lam8 app8 tt8 pair8 fst snd left right case zero suc rec)
(u Tm8 var8 lam8 app8 tt8 pair8 fst snd left right case zero suc rec)
fst8 : ∀{Γ A B} → Tm8 Γ (prod8 A B) → Tm8 Γ A; fst8
= λ t Tm8 var8 lam8 app8 tt8 pair8 fst8 snd left right case zero suc rec →
fst8 _ _ _ (t Tm8 var8 lam8 app8 tt8 pair8 fst8 snd left right case zero suc rec)
snd8 : ∀{Γ A B} → Tm8 Γ (prod8 A B) → Tm8 Γ B; snd8
= λ t Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left right case zero suc rec →
snd8 _ _ _ (t Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left right case zero suc rec)
left8 : ∀{Γ A B} → Tm8 Γ A → Tm8 Γ (sum8 A B); left8
= λ t Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right case zero suc rec →
left8 _ _ _ (t Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right case zero suc rec)
right8 : ∀{Γ A B} → Tm8 Γ B → Tm8 Γ (sum8 A B); right8
= λ t Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right8 case zero suc rec →
right8 _ _ _ (t Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right8 case zero suc rec)
case8 : ∀{Γ A B C} → Tm8 Γ (sum8 A B) → Tm8 Γ (arr8 A C) → Tm8 Γ (arr8 B C) → Tm8 Γ C; case8
= λ t u v Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right8 case8 zero suc rec →
case8 _ _ _ _
(t Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right8 case8 zero suc rec)
(u Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right8 case8 zero suc rec)
(v Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right8 case8 zero suc rec)
zero8 : ∀{Γ} → Tm8 Γ nat8; zero8
= λ Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right8 case8 zero8 suc rec → zero8 _
suc8 : ∀{Γ} → Tm8 Γ nat8 → Tm8 Γ nat8; suc8
= λ t Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right8 case8 zero8 suc8 rec →
suc8 _ (t Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right8 case8 zero8 suc8 rec)
rec8 : ∀{Γ A} → Tm8 Γ nat8 → Tm8 Γ (arr8 nat8 (arr8 A A)) → Tm8 Γ A → Tm8 Γ A; rec8
= λ t u v Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right8 case8 zero8 suc8 rec8 →
rec8 _ _
(t Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right8 case8 zero8 suc8 rec8)
(u Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right8 case8 zero8 suc8 rec8)
(v Tm8 var8 lam8 app8 tt8 pair8 fst8 snd8 left8 right8 case8 zero8 suc8 rec8)
v08 : ∀{Γ A} → Tm8 (snoc8 Γ A) A; v08
= var8 vz8
v18 : ∀{Γ A B} → Tm8 (snoc8 (snoc8 Γ A) B) A; v18
= var8 (vs8 vz8)
v28 : ∀{Γ A B C} → Tm8 (snoc8 (snoc8 (snoc8 Γ A) B) C) A; v28
= var8 (vs8 (vs8 vz8))
v38 : ∀{Γ A B C D} → Tm8 (snoc8 (snoc8 (snoc8 (snoc8 Γ A) B) C) D) A; v38
= var8 (vs8 (vs8 (vs8 vz8)))
tbool8 : Ty8; tbool8
= sum8 top8 top8
true8 : ∀{Γ} → Tm8 Γ tbool8; true8
= left8 tt8
tfalse8 : ∀{Γ} → Tm8 Γ tbool8; tfalse8
= right8 tt8
ifthenelse8 : ∀{Γ A} → Tm8 Γ (arr8 tbool8 (arr8 A (arr8 A A))); ifthenelse8
= lam8 (lam8 (lam8 (case8 v28 (lam8 v28) (lam8 v18))))
times48 : ∀{Γ A} → Tm8 Γ (arr8 (arr8 A A) (arr8 A A)); times48
= lam8 (lam8 (app8 v18 (app8 v18 (app8 v18 (app8 v18 v08)))))
add8 : ∀{Γ} → Tm8 Γ (arr8 nat8 (arr8 nat8 nat8)); add8
= lam8 (rec8 v08
(lam8 (lam8 (lam8 (suc8 (app8 v18 v08)))))
(lam8 v08))
mul8 : ∀{Γ} → Tm8 Γ (arr8 nat8 (arr8 nat8 nat8)); mul8
= lam8 (rec8 v08
(lam8 (lam8 (lam8 (app8 (app8 add8 (app8 v18 v08)) v08))))
(lam8 zero8))
fact8 : ∀{Γ} → Tm8 Γ (arr8 nat8 nat8); fact8
= lam8 (rec8 v08 (lam8 (lam8 (app8 (app8 mul8 (suc8 v18)) v08)))
(suc8 zero8))
{-# OPTIONS --type-in-type #-}
Ty9 : Set
Ty9 =
(Ty9 : Set)
(nat top bot : Ty9)
(arr prod sum : Ty9 → Ty9 → Ty9)
→ Ty9
nat9 : Ty9; nat9 = λ _ nat9 _ _ _ _ _ → nat9
top9 : Ty9; top9 = λ _ _ top9 _ _ _ _ → top9
bot9 : Ty9; bot9 = λ _ _ _ bot9 _ _ _ → bot9
arr9 : Ty9 → Ty9 → Ty9; arr9
= λ A B Ty9 nat9 top9 bot9 arr9 prod sum →
arr9 (A Ty9 nat9 top9 bot9 arr9 prod sum) (B Ty9 nat9 top9 bot9 arr9 prod sum)
prod9 : Ty9 → Ty9 → Ty9; prod9
= λ A B Ty9 nat9 top9 bot9 arr9 prod9 sum →
prod9 (A Ty9 nat9 top9 bot9 arr9 prod9 sum) (B Ty9 nat9 top9 bot9 arr9 prod9 sum)
sum9 : Ty9 → Ty9 → Ty9; sum9
= λ A B Ty9 nat9 top9 bot9 arr9 prod9 sum9 →
sum9 (A Ty9 nat9 top9 bot9 arr9 prod9 sum9) (B Ty9 nat9 top9 bot9 arr9 prod9 sum9)
Con9 : Set; Con9
= (Con9 : Set)
(nil : Con9)
(snoc : Con9 → Ty9 → Con9)
→ Con9
nil9 : Con9; nil9
= λ Con9 nil9 snoc → nil9
snoc9 : Con9 → Ty9 → Con9; snoc9
= λ Γ A Con9 nil9 snoc9 → snoc9 (Γ Con9 nil9 snoc9) A
Var9 : Con9 → Ty9 → Set; Var9
= λ Γ A →
(Var9 : Con9 → Ty9 → Set)
(vz : ∀ Γ A → Var9 (snoc9 Γ A) A)
(vs : ∀ Γ B A → Var9 Γ A → Var9 (snoc9 Γ B) A)
→ Var9 Γ A
vz9 : ∀{Γ A} → Var9 (snoc9 Γ A) A; vz9
= λ Var9 vz9 vs → vz9 _ _
vs9 : ∀{Γ B A} → Var9 Γ A → Var9 (snoc9 Γ B) A; vs9
= λ x Var9 vz9 vs9 → vs9 _ _ _ (x Var9 vz9 vs9)
Tm9 : Con9 → Ty9 → Set; Tm9
= λ Γ A →
(Tm9 : Con9 → Ty9 → Set)
(var : ∀ Γ A → Var9 Γ A → Tm9 Γ A)
(lam : ∀ Γ A B → Tm9 (snoc9 Γ A) B → Tm9 Γ (arr9 A B))
(app : ∀ Γ A B → Tm9 Γ (arr9 A B) → Tm9 Γ A → Tm9 Γ B)
(tt : ∀ Γ → Tm9 Γ top9)
(pair : ∀ Γ A B → Tm9 Γ A → Tm9 Γ B → Tm9 Γ (prod9 A B))
(fst : ∀ Γ A B → Tm9 Γ (prod9 A B) → Tm9 Γ A)
(snd : ∀ Γ A B → Tm9 Γ (prod9 A B) → Tm9 Γ B)
(left : ∀ Γ A B → Tm9 Γ A → Tm9 Γ (sum9 A B))
(right : ∀ Γ A B → Tm9 Γ B → Tm9 Γ (sum9 A B))
(case : ∀ Γ A B C → Tm9 Γ (sum9 A B) → Tm9 Γ (arr9 A C) → Tm9 Γ (arr9 B C) → Tm9 Γ C)
(zero : ∀ Γ → Tm9 Γ nat9)
(suc : ∀ Γ → Tm9 Γ nat9 → Tm9 Γ nat9)
(rec : ∀ Γ A → Tm9 Γ nat9 → Tm9 Γ (arr9 nat9 (arr9 A A)) → Tm9 Γ A → Tm9 Γ A)
→ Tm9 Γ A
var9 : ∀{Γ A} → Var9 Γ A → Tm9 Γ A; var9
= λ x Tm9 var9 lam app tt pair fst snd left right case zero suc rec →
var9 _ _ x
lam9 : ∀{Γ A B} → Tm9 (snoc9 Γ A) B → Tm9 Γ (arr9 A B); lam9
= λ t Tm9 var9 lam9 app tt pair fst snd left right case zero suc rec →
lam9 _ _ _ (t Tm9 var9 lam9 app tt pair fst snd left right case zero suc rec)
app9 : ∀{Γ A B} → Tm9 Γ (arr9 A B) → Tm9 Γ A → Tm9 Γ B; app9
= λ t u Tm9 var9 lam9 app9 tt pair fst snd left right case zero suc rec →
app9 _ _ _ (t Tm9 var9 lam9 app9 tt pair fst snd left right case zero suc rec)
(u Tm9 var9 lam9 app9 tt pair fst snd left right case zero suc rec)
tt9 : ∀{Γ} → Tm9 Γ top9; tt9
= λ Tm9 var9 lam9 app9 tt9 pair fst snd left right case zero suc rec → tt9 _
pair9 : ∀{Γ A B} → Tm9 Γ A → Tm9 Γ B → Tm9 Γ (prod9 A B); pair9
= λ t u Tm9 var9 lam9 app9 tt9 pair9 fst snd left right case zero suc rec →
pair9 _ _ _ (t Tm9 var9 lam9 app9 tt9 pair9 fst snd left right case zero suc rec)
(u Tm9 var9 lam9 app9 tt9 pair9 fst snd left right case zero suc rec)
fst9 : ∀{Γ A B} → Tm9 Γ (prod9 A B) → Tm9 Γ A; fst9
= λ t Tm9 var9 lam9 app9 tt9 pair9 fst9 snd left right case zero suc rec →
fst9 _ _ _ (t Tm9 var9 lam9 app9 tt9 pair9 fst9 snd left right case zero suc rec)
snd9 : ∀{Γ A B} → Tm9 Γ (prod9 A B) → Tm9 Γ B; snd9
= λ t Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left right case zero suc rec →
snd9 _ _ _ (t Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left right case zero suc rec)
left9 : ∀{Γ A B} → Tm9 Γ A → Tm9 Γ (sum9 A B); left9
= λ t Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right case zero suc rec →
left9 _ _ _ (t Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right case zero suc rec)
right9 : ∀{Γ A B} → Tm9 Γ B → Tm9 Γ (sum9 A B); right9
= λ t Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right9 case zero suc rec →
right9 _ _ _ (t Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right9 case zero suc rec)
case9 : ∀{Γ A B C} → Tm9 Γ (sum9 A B) → Tm9 Γ (arr9 A C) → Tm9 Γ (arr9 B C) → Tm9 Γ C; case9
= λ t u v Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right9 case9 zero suc rec →
case9 _ _ _ _
(t Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right9 case9 zero suc rec)
(u Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right9 case9 zero suc rec)
(v Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right9 case9 zero suc rec)
zero9 : ∀{Γ} → Tm9 Γ nat9; zero9
= λ Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right9 case9 zero9 suc rec → zero9 _
suc9 : ∀{Γ} → Tm9 Γ nat9 → Tm9 Γ nat9; suc9
= λ t Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right9 case9 zero9 suc9 rec →
suc9 _ (t Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right9 case9 zero9 suc9 rec)
rec9 : ∀{Γ A} → Tm9 Γ nat9 → Tm9 Γ (arr9 nat9 (arr9 A A)) → Tm9 Γ A → Tm9 Γ A; rec9
= λ t u v Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right9 case9 zero9 suc9 rec9 →
rec9 _ _
(t Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right9 case9 zero9 suc9 rec9)
(u Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right9 case9 zero9 suc9 rec9)
(v Tm9 var9 lam9 app9 tt9 pair9 fst9 snd9 left9 right9 case9 zero9 suc9 rec9)
v09 : ∀{Γ A} → Tm9 (snoc9 Γ A) A; v09
= var9 vz9
v19 : ∀{Γ A B} → Tm9 (snoc9 (snoc9 Γ A) B) A; v19
= var9 (vs9 vz9)
v29 : ∀{Γ A B C} → Tm9 (snoc9 (snoc9 (snoc9 Γ A) B) C) A; v29
= var9 (vs9 (vs9 vz9))
v39 : ∀{Γ A B C D} → Tm9 (snoc9 (snoc9 (snoc9 (snoc9 Γ A) B) C) D) A; v39
= var9 (vs9 (vs9 (vs9 vz9)))
tbool9 : Ty9; tbool9
= sum9 top9 top9
true9 : ∀{Γ} → Tm9 Γ tbool9; true9
= left9 tt9
tfalse9 : ∀{Γ} → Tm9 Γ tbool9; tfalse9
= right9 tt9
ifthenelse9 : ∀{Γ A} → Tm9 Γ (arr9 tbool9 (arr9 A (arr9 A A))); ifthenelse9
= lam9 (lam9 (lam9 (case9 v29 (lam9 v29) (lam9 v19))))
times49 : ∀{Γ A} → Tm9 Γ (arr9 (arr9 A A) (arr9 A A)); times49
= lam9 (lam9 (app9 v19 (app9 v19 (app9 v19 (app9 v19 v09)))))
add9 : ∀{Γ} → Tm9 Γ (arr9 nat9 (arr9 nat9 nat9)); add9
= lam9 (rec9 v09
(lam9 (lam9 (lam9 (suc9 (app9 v19 v09)))))
(lam9 v09))
mul9 : ∀{Γ} → Tm9 Γ (arr9 nat9 (arr9 nat9 nat9)); mul9
= lam9 (rec9 v09
(lam9 (lam9 (lam9 (app9 (app9 add9 (app9 v19 v09)) v09))))
(lam9 zero9))
fact9 : ∀{Γ} → Tm9 Γ (arr9 nat9 nat9); fact9
= lam9 (rec9 v09 (lam9 (lam9 (app9 (app9 mul9 (suc9 v19)) v09)))
(suc9 zero9))
{-# OPTIONS --type-in-type #-}
Ty10 : Set
Ty10 =
(Ty10 : Set)
(nat top bot : Ty10)
(arr prod sum : Ty10 → Ty10 → Ty10)
→ Ty10
nat10 : Ty10; nat10 = λ _ nat10 _ _ _ _ _ → nat10
top10 : Ty10; top10 = λ _ _ top10 _ _ _ _ → top10
bot10 : Ty10; bot10 = λ _ _ _ bot10 _ _ _ → bot10
arr10 : Ty10 → Ty10 → Ty10; arr10
= λ A B Ty10 nat10 top10 bot10 arr10 prod sum →
arr10 (A Ty10 nat10 top10 bot10 arr10 prod sum) (B Ty10 nat10 top10 bot10 arr10 prod sum)
prod10 : Ty10 → Ty10 → Ty10; prod10
= λ A B Ty10 nat10 top10 bot10 arr10 prod10 sum →
prod10 (A Ty10 nat10 top10 bot10 arr10 prod10 sum) (B Ty10 nat10 top10 bot10 arr10 prod10 sum)
sum10 : Ty10 → Ty10 → Ty10; sum10
= λ A B Ty10 nat10 top10 bot10 arr10 prod10 sum10 →
sum10 (A Ty10 nat10 top10 bot10 arr10 prod10 sum10) (B Ty10 nat10 top10 bot10 arr10 prod10 sum10)
Con10 : Set; Con10
= (Con10 : Set)
(nil : Con10)
(snoc : Con10 → Ty10 → Con10)
→ Con10
nil10 : Con10; nil10
= λ Con10 nil10 snoc → nil10
snoc10 : Con10 → Ty10 → Con10; snoc10
= λ Γ A Con10 nil10 snoc10 → snoc10 (Γ Con10 nil10 snoc10) A
Var10 : Con10 → Ty10 → Set; Var10
= λ Γ A →
(Var10 : Con10 → Ty10 → Set)
(vz : ∀ Γ A → Var10 (snoc10 Γ A) A)
(vs : ∀ Γ B A → Var10 Γ A → Var10 (snoc10 Γ B) A)
→ Var10 Γ A
vz10 : ∀{Γ A} → Var10 (snoc10 Γ A) A; vz10
= λ Var10 vz10 vs → vz10 _ _
vs10 : ∀{Γ B A} → Var10 Γ A → Var10 (snoc10 Γ B) A; vs10
= λ x Var10 vz10 vs10 → vs10 _ _ _ (x Var10 vz10 vs10)
Tm10 : Con10 → Ty10 → Set; Tm10
= λ Γ A →
(Tm10 : Con10 → Ty10 → Set)
(var : ∀ Γ A → Var10 Γ A → Tm10 Γ A)
(lam : ∀ Γ A B → Tm10 (snoc10 Γ A) B → Tm10 Γ (arr10 A B))
(app : ∀ Γ A B → Tm10 Γ (arr10 A B) → Tm10 Γ A → Tm10 Γ B)
(tt : ∀ Γ → Tm10 Γ top10)
(pair : ∀ Γ A B → Tm10 Γ A → Tm10 Γ B → Tm10 Γ (prod10 A B))
(fst : ∀ Γ A B → Tm10 Γ (prod10 A B) → Tm10 Γ A)
(snd : ∀ Γ A B → Tm10 Γ (prod10 A B) → Tm10 Γ B)
(left : ∀ Γ A B → Tm10 Γ A → Tm10 Γ (sum10 A B))
(right : ∀ Γ A B → Tm10 Γ B → Tm10 Γ (sum10 A B))
(case : ∀ Γ A B C → Tm10 Γ (sum10 A B) → Tm10 Γ (arr10 A C) → Tm10 Γ (arr10 B C) → Tm10 Γ C)
(zero : ∀ Γ → Tm10 Γ nat10)
(suc : ∀ Γ → Tm10 Γ nat10 → Tm10 Γ nat10)
(rec : ∀ Γ A → Tm10 Γ nat10 → Tm10 Γ (arr10 nat10 (arr10 A A)) → Tm10 Γ A → Tm10 Γ A)
→ Tm10 Γ A
var10 : ∀{Γ A} → Var10 Γ A → Tm10 Γ A; var10
= λ x Tm10 var10 lam app tt pair fst snd left right case zero suc rec →
var10 _ _ x
lam10 : ∀{Γ A B} → Tm10 (snoc10 Γ A) B → Tm10 Γ (arr10 A B); lam10
= λ t Tm10 var10 lam10 app tt pair fst snd left right case zero suc rec →
lam10 _ _ _ (t Tm10 var10 lam10 app tt pair fst snd left right case zero suc rec)
app10 : ∀{Γ A B} → Tm10 Γ (arr10 A B) → Tm10 Γ A → Tm10 Γ B; app10
= λ t u Tm10 var10 lam10 app10 tt pair fst snd left right case zero suc rec →
app10 _ _ _ (t Tm10 var10 lam10 app10 tt pair fst snd left right case zero suc rec)
(u Tm10 var10 lam10 app10 tt pair fst snd left right case zero suc rec)
tt10 : ∀{Γ} → Tm10 Γ top10; tt10
= λ Tm10 var10 lam10 app10 tt10 pair fst snd left right case zero suc rec → tt10 _
pair10 : ∀{Γ A B} → Tm10 Γ A → Tm10 Γ B → Tm10 Γ (prod10 A B); pair10
= λ t u Tm10 var10 lam10 app10 tt10 pair10 fst snd left right case zero suc rec →
pair10 _ _ _ (t Tm10 var10 lam10 app10 tt10 pair10 fst snd left right case zero suc rec)
(u Tm10 var10 lam10 app10 tt10 pair10 fst snd left right case zero suc rec)
fst10 : ∀{Γ A B} → Tm10 Γ (prod10 A B) → Tm10 Γ A; fst10
= λ t Tm10 var10 lam10 app10 tt10 pair10 fst10 snd left right case zero suc rec →
fst10 _ _ _ (t Tm10 var10 lam10 app10 tt10 pair10 fst10 snd left right case zero suc rec)
snd10 : ∀{Γ A B} → Tm10 Γ (prod10 A B) → Tm10 Γ B; snd10
= λ t Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left right case zero suc rec →
snd10 _ _ _ (t Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left right case zero suc rec)
left10 : ∀{Γ A B} → Tm10 Γ A → Tm10 Γ (sum10 A B); left10
= λ t Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right case zero suc rec →
left10 _ _ _ (t Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right case zero suc rec)
right10 : ∀{Γ A B} → Tm10 Γ B → Tm10 Γ (sum10 A B); right10
= λ t Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right10 case zero suc rec →
right10 _ _ _ (t Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right10 case zero suc rec)
case10 : ∀{Γ A B C} → Tm10 Γ (sum10 A B) → Tm10 Γ (arr10 A C) → Tm10 Γ (arr10 B C) → Tm10 Γ C; case10
= λ t u v Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right10 case10 zero suc rec →
case10 _ _ _ _
(t Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right10 case10 zero suc rec)
(u Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right10 case10 zero suc rec)
(v Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right10 case10 zero suc rec)
zero10 : ∀{Γ} → Tm10 Γ nat10; zero10
= λ Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right10 case10 zero10 suc rec → zero10 _
suc10 : ∀{Γ} → Tm10 Γ nat10 → Tm10 Γ nat10; suc10
= λ t Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right10 case10 zero10 suc10 rec →
suc10 _ (t Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right10 case10 zero10 suc10 rec)
rec10 : ∀{Γ A} → Tm10 Γ nat10 → Tm10 Γ (arr10 nat10 (arr10 A A)) → Tm10 Γ A → Tm10 Γ A; rec10
= λ t u v Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right10 case10 zero10 suc10 rec10 →
rec10 _ _
(t Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right10 case10 zero10 suc10 rec10)
(u Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right10 case10 zero10 suc10 rec10)
(v Tm10 var10 lam10 app10 tt10 pair10 fst10 snd10 left10 right10 case10 zero10 suc10 rec10)
v010 : ∀{Γ A} → Tm10 (snoc10 Γ A) A; v010
= var10 vz10
v110 : ∀{Γ A B} → Tm10 (snoc10 (snoc10 Γ A) B) A; v110
= var10 (vs10 vz10)
v210 : ∀{Γ A B C} → Tm10 (snoc10 (snoc10 (snoc10 Γ A) B) C) A; v210
= var10 (vs10 (vs10 vz10))
v310 : ∀{Γ A B C D} → Tm10 (snoc10 (snoc10 (snoc10 (snoc10 Γ A) B) C) D) A; v310
= var10 (vs10 (vs10 (vs10 vz10)))
tbool10 : Ty10; tbool10
= sum10 top10 top10
true10 : ∀{Γ} → Tm10 Γ tbool10; true10
= left10 tt10
tfalse10 : ∀{Γ} → Tm10 Γ tbool10; tfalse10
= right10 tt10
ifthenelse10 : ∀{Γ A} → Tm10 Γ (arr10 tbool10 (arr10 A (arr10 A A))); ifthenelse10
= lam10 (lam10 (lam10 (case10 v210 (lam10 v210) (lam10 v110))))
times410 : ∀{Γ A} → Tm10 Γ (arr10 (arr10 A A) (arr10 A A)); times410
= lam10 (lam10 (app10 v110 (app10 v110 (app10 v110 (app10 v110 v010)))))
add10 : ∀{Γ} → Tm10 Γ (arr10 nat10 (arr10 nat10 nat10)); add10
= lam10 (rec10 v010
(lam10 (lam10 (lam10 (suc10 (app10 v110 v010)))))
(lam10 v010))
mul10 : ∀{Γ} → Tm10 Γ (arr10 nat10 (arr10 nat10 nat10)); mul10
= lam10 (rec10 v010
(lam10 (lam10 (lam10 (app10 (app10 add10 (app10 v110 v010)) v010))))
(lam10 zero10))
fact10 : ∀{Γ} → Tm10 Γ (arr10 nat10 nat10); fact10
= lam10 (rec10 v010 (lam10 (lam10 (app10 (app10 mul10 (suc10 v110)) v010)))
(suc10 zero10))
{-# OPTIONS --type-in-type #-}
Ty11 : Set
Ty11 =
(Ty11 : Set)
(nat top bot : Ty11)
(arr prod sum : Ty11 → Ty11 → Ty11)
→ Ty11
nat11 : Ty11; nat11 = λ _ nat11 _ _ _ _ _ → nat11
top11 : Ty11; top11 = λ _ _ top11 _ _ _ _ → top11
bot11 : Ty11; bot11 = λ _ _ _ bot11 _ _ _ → bot11
arr11 : Ty11 → Ty11 → Ty11; arr11
= λ A B Ty11 nat11 top11 bot11 arr11 prod sum →
arr11 (A Ty11 nat11 top11 bot11 arr11 prod sum) (B Ty11 nat11 top11 bot11 arr11 prod sum)
prod11 : Ty11 → Ty11 → Ty11; prod11
= λ A B Ty11 nat11 top11 bot11 arr11 prod11 sum →
prod11 (A Ty11 nat11 top11 bot11 arr11 prod11 sum) (B Ty11 nat11 top11 bot11 arr11 prod11 sum)
sum11 : Ty11 → Ty11 → Ty11; sum11
= λ A B Ty11 nat11 top11 bot11 arr11 prod11 sum11 →
sum11 (A Ty11 nat11 top11 bot11 arr11 prod11 sum11) (B Ty11 nat11 top11 bot11 arr11 prod11 sum11)
Con11 : Set; Con11
= (Con11 : Set)
(nil : Con11)
(snoc : Con11 → Ty11 → Con11)
→ Con11
nil11 : Con11; nil11
= λ Con11 nil11 snoc → nil11
snoc11 : Con11 → Ty11 → Con11; snoc11
= λ Γ A Con11 nil11 snoc11 → snoc11 (Γ Con11 nil11 snoc11) A
Var11 : Con11 → Ty11 → Set; Var11
= λ Γ A →
(Var11 : Con11 → Ty11 → Set)
(vz : ∀ Γ A → Var11 (snoc11 Γ A) A)
(vs : ∀ Γ B A → Var11 Γ A → Var11 (snoc11 Γ B) A)
→ Var11 Γ A
vz11 : ∀{Γ A} → Var11 (snoc11 Γ A) A; vz11
= λ Var11 vz11 vs → vz11 _ _
vs11 : ∀{Γ B A} → Var11 Γ A → Var11 (snoc11 Γ B) A; vs11
= λ x Var11 vz11 vs11 → vs11 _ _ _ (x Var11 vz11 vs11)
Tm11 : Con11 → Ty11 → Set; Tm11
= λ Γ A →
(Tm11 : Con11 → Ty11 → Set)
(var : ∀ Γ A → Var11 Γ A → Tm11 Γ A)
(lam : ∀ Γ A B → Tm11 (snoc11 Γ A) B → Tm11 Γ (arr11 A B))
(app : ∀ Γ A B → Tm11 Γ (arr11 A B) → Tm11 Γ A → Tm11 Γ B)
(tt : ∀ Γ → Tm11 Γ top11)
(pair : ∀ Γ A B → Tm11 Γ A → Tm11 Γ B → Tm11 Γ (prod11 A B))
(fst : ∀ Γ A B → Tm11 Γ (prod11 A B) → Tm11 Γ A)
(snd : ∀ Γ A B → Tm11 Γ (prod11 A B) → Tm11 Γ B)
(left : ∀ Γ A B → Tm11 Γ A → Tm11 Γ (sum11 A B))
(right : ∀ Γ A B → Tm11 Γ B → Tm11 Γ (sum11 A B))
(case : ∀ Γ A B C → Tm11 Γ (sum11 A B) → Tm11 Γ (arr11 A C) → Tm11 Γ (arr11 B C) → Tm11 Γ C)
(zero : ∀ Γ → Tm11 Γ nat11)
(suc : ∀ Γ → Tm11 Γ nat11 → Tm11 Γ nat11)
(rec : ∀ Γ A → Tm11 Γ nat11 → Tm11 Γ (arr11 nat11 (arr11 A A)) → Tm11 Γ A → Tm11 Γ A)
→ Tm11 Γ A
var11 : ∀{Γ A} → Var11 Γ A → Tm11 Γ A; var11
= λ x Tm11 var11 lam app tt pair fst snd left right case zero suc rec →
var11 _ _ x
lam11 : ∀{Γ A B} → Tm11 (snoc11 Γ A) B → Tm11 Γ (arr11 A B); lam11
= λ t Tm11 var11 lam11 app tt pair fst snd left right case zero suc rec →
lam11 _ _ _ (t Tm11 var11 lam11 app tt pair fst snd left right case zero suc rec)
app11 : ∀{Γ A B} → Tm11 Γ (arr11 A B) → Tm11 Γ A → Tm11 Γ B; app11
= λ t u Tm11 var11 lam11 app11 tt pair fst snd left right case zero suc rec →
app11 _ _ _ (t Tm11 var11 lam11 app11 tt pair fst snd left right case zero suc rec)
(u Tm11 var11 lam11 app11 tt pair fst snd left right case zero suc rec)
tt11 : ∀{Γ} → Tm11 Γ top11; tt11
= λ Tm11 var11 lam11 app11 tt11 pair fst snd left right case zero suc rec → tt11 _
pair11 : ∀{Γ A B} → Tm11 Γ A → Tm11 Γ B → Tm11 Γ (prod11 A B); pair11
= λ t u Tm11 var11 lam11 app11 tt11 pair11 fst snd left right case zero suc rec →
pair11 _ _ _ (t Tm11 var11 lam11 app11 tt11 pair11 fst snd left right case zero suc rec)
(u Tm11 var11 lam11 app11 tt11 pair11 fst snd left right case zero suc rec)
fst11 : ∀{Γ A B} → Tm11 Γ (prod11 A B) → Tm11 Γ A; fst11
= λ t Tm11 var11 lam11 app11 tt11 pair11 fst11 snd left right case zero suc rec →
fst11 _ _ _ (t Tm11 var11 lam11 app11 tt11 pair11 fst11 snd left right case zero suc rec)
snd11 : ∀{Γ A B} → Tm11 Γ (prod11 A B) → Tm11 Γ B; snd11
= λ t Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left right case zero suc rec →
snd11 _ _ _ (t Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left right case zero suc rec)
left11 : ∀{Γ A B} → Tm11 Γ A → Tm11 Γ (sum11 A B); left11
= λ t Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right case zero suc rec →
left11 _ _ _ (t Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right case zero suc rec)
right11 : ∀{Γ A B} → Tm11 Γ B → Tm11 Γ (sum11 A B); right11
= λ t Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right11 case zero suc rec →
right11 _ _ _ (t Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right11 case zero suc rec)
case11 : ∀{Γ A B C} → Tm11 Γ (sum11 A B) → Tm11 Γ (arr11 A C) → Tm11 Γ (arr11 B C) → Tm11 Γ C; case11
= λ t u v Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right11 case11 zero suc rec →
case11 _ _ _ _
(t Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right11 case11 zero suc rec)
(u Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right11 case11 zero suc rec)
(v Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right11 case11 zero suc rec)
zero11 : ∀{Γ} → Tm11 Γ nat11; zero11
= λ Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right11 case11 zero11 suc rec → zero11 _
suc11 : ∀{Γ} → Tm11 Γ nat11 → Tm11 Γ nat11; suc11
= λ t Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right11 case11 zero11 suc11 rec →
suc11 _ (t Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right11 case11 zero11 suc11 rec)
rec11 : ∀{Γ A} → Tm11 Γ nat11 → Tm11 Γ (arr11 nat11 (arr11 A A)) → Tm11 Γ A → Tm11 Γ A; rec11
= λ t u v Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right11 case11 zero11 suc11 rec11 →
rec11 _ _
(t Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right11 case11 zero11 suc11 rec11)
(u Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right11 case11 zero11 suc11 rec11)
(v Tm11 var11 lam11 app11 tt11 pair11 fst11 snd11 left11 right11 case11 zero11 suc11 rec11)
v011 : ∀{Γ A} → Tm11 (snoc11 Γ A) A; v011
= var11 vz11
v111 : ∀{Γ A B} → Tm11 (snoc11 (snoc11 Γ A) B) A; v111
= var11 (vs11 vz11)
v211 : ∀{Γ A B C} → Tm11 (snoc11 (snoc11 (snoc11 Γ A) B) C) A; v211
= var11 (vs11 (vs11 vz11))
v311 : ∀{Γ A B C D} → Tm11 (snoc11 (snoc11 (snoc11 (snoc11 Γ A) B) C) D) A; v311
= var11 (vs11 (vs11 (vs11 vz11)))
tbool11 : Ty11; tbool11
= sum11 top11 top11
true11 : ∀{Γ} → Tm11 Γ tbool11; true11
= left11 tt11
tfalse11 : ∀{Γ} → Tm11 Γ tbool11; tfalse11
= right11 tt11
ifthenelse11 : ∀{Γ A} → Tm11 Γ (arr11 tbool11 (arr11 A (arr11 A A))); ifthenelse11
= lam11 (lam11 (lam11 (case11 v211 (lam11 v211) (lam11 v111))))
times411 : ∀{Γ A} → Tm11 Γ (arr11 (arr11 A A) (arr11 A A)); times411
= lam11 (lam11 (app11 v111 (app11 v111 (app11 v111 (app11 v111 v011)))))
add11 : ∀{Γ} → Tm11 Γ (arr11 nat11 (arr11 nat11 nat11)); add11
= lam11 (rec11 v011
(lam11 (lam11 (lam11 (suc11 (app11 v111 v011)))))
(lam11 v011))
mul11 : ∀{Γ} → Tm11 Γ (arr11 nat11 (arr11 nat11 nat11)); mul11
= lam11 (rec11 v011
(lam11 (lam11 (lam11 (app11 (app11 add11 (app11 v111 v011)) v011))))
(lam11 zero11))
fact11 : ∀{Γ} → Tm11 Γ (arr11 nat11 nat11); fact11
= lam11 (rec11 v011 (lam11 (lam11 (app11 (app11 mul11 (suc11 v111)) v011)))
(suc11 zero11))
{-# OPTIONS --type-in-type #-}
Ty12 : Set
Ty12 =
(Ty12 : Set)
(nat top bot : Ty12)
(arr prod sum : Ty12 → Ty12 → Ty12)
→ Ty12
nat12 : Ty12; nat12 = λ _ nat12 _ _ _ _ _ → nat12
top12 : Ty12; top12 = λ _ _ top12 _ _ _ _ → top12
bot12 : Ty12; bot12 = λ _ _ _ bot12 _ _ _ → bot12
arr12 : Ty12 → Ty12 → Ty12; arr12
= λ A B Ty12 nat12 top12 bot12 arr12 prod sum →
arr12 (A Ty12 nat12 top12 bot12 arr12 prod sum) (B Ty12 nat12 top12 bot12 arr12 prod sum)
prod12 : Ty12 → Ty12 → Ty12; prod12
= λ A B Ty12 nat12 top12 bot12 arr12 prod12 sum →
prod12 (A Ty12 nat12 top12 bot12 arr12 prod12 sum) (B Ty12 nat12 top12 bot12 arr12 prod12 sum)
sum12 : Ty12 → Ty12 → Ty12; sum12
= λ A B Ty12 nat12 top12 bot12 arr12 prod12 sum12 →
sum12 (A Ty12 nat12 top12 bot12 arr12 prod12 sum12) (B Ty12 nat12 top12 bot12 arr12 prod12 sum12)
Con12 : Set; Con12
= (Con12 : Set)
(nil : Con12)
(snoc : Con12 → Ty12 → Con12)
→ Con12
nil12 : Con12; nil12
= λ Con12 nil12 snoc → nil12
snoc12 : Con12 → Ty12 → Con12; snoc12
= λ Γ A Con12 nil12 snoc12 → snoc12 (Γ Con12 nil12 snoc12) A
Var12 : Con12 → Ty12 → Set; Var12
= λ Γ A →
(Var12 : Con12 → Ty12 → Set)
(vz : ∀ Γ A → Var12 (snoc12 Γ A) A)
(vs : ∀ Γ B A → Var12 Γ A → Var12 (snoc12 Γ B) A)
→ Var12 Γ A
vz12 : ∀{Γ A} → Var12 (snoc12 Γ A) A; vz12
= λ Var12 vz12 vs → vz12 _ _
vs12 : ∀{Γ B A} → Var12 Γ A → Var12 (snoc12 Γ B) A; vs12
= λ x Var12 vz12 vs12 → vs12 _ _ _ (x Var12 vz12 vs12)
Tm12 : Con12 → Ty12 → Set; Tm12
= λ Γ A →
(Tm12 : Con12 → Ty12 → Set)
(var : ∀ Γ A → Var12 Γ A → Tm12 Γ A)
(lam : ∀ Γ A B → Tm12 (snoc12 Γ A) B → Tm12 Γ (arr12 A B))
(app : ∀ Γ A B → Tm12 Γ (arr12 A B) → Tm12 Γ A → Tm12 Γ B)
(tt : ∀ Γ → Tm12 Γ top12)
(pair : ∀ Γ A B → Tm12 Γ A → Tm12 Γ B → Tm12 Γ (prod12 A B))
(fst : ∀ Γ A B → Tm12 Γ (prod12 A B) → Tm12 Γ A)
(snd : ∀ Γ A B → Tm12 Γ (prod12 A B) → Tm12 Γ B)
(left : ∀ Γ A B → Tm12 Γ A → Tm12 Γ (sum12 A B))
(right : ∀ Γ A B → Tm12 Γ B → Tm12 Γ (sum12 A B))
(case : ∀ Γ A B C → Tm12 Γ (sum12 A B) → Tm12 Γ (arr12 A C) → Tm12 Γ (arr12 B C) → Tm12 Γ C)
(zero : ∀ Γ → Tm12 Γ nat12)
(suc : ∀ Γ → Tm12 Γ nat12 → Tm12 Γ nat12)
(rec : ∀ Γ A → Tm12 Γ nat12 → Tm12 Γ (arr12 nat12 (arr12 A A)) → Tm12 Γ A → Tm12 Γ A)
→ Tm12 Γ A
var12 : ∀{Γ A} → Var12 Γ A → Tm12 Γ A; var12
= λ x Tm12 var12 lam app tt pair fst snd left right case zero suc rec →
var12 _ _ x
lam12 : ∀{Γ A B} → Tm12 (snoc12 Γ A) B → Tm12 Γ (arr12 A B); lam12
= λ t Tm12 var12 lam12 app tt pair fst snd left right case zero suc rec →
lam12 _ _ _ (t Tm12 var12 lam12 app tt pair fst snd left right case zero suc rec)
app12 : ∀{Γ A B} → Tm12 Γ (arr12 A B) → Tm12 Γ A → Tm12 Γ B; app12
= λ t u Tm12 var12 lam12 app12 tt pair fst snd left right case zero suc rec →
app12 _ _ _ (t Tm12 var12 lam12 app12 tt pair fst snd left right case zero suc rec)
(u Tm12 var12 lam12 app12 tt pair fst snd left right case zero suc rec)
tt12 : ∀{Γ} → Tm12 Γ top12; tt12
= λ Tm12 var12 lam12 app12 tt12 pair fst snd left right case zero suc rec → tt12 _
pair12 : ∀{Γ A B} → Tm12 Γ A → Tm12 Γ B → Tm12 Γ (prod12 A B); pair12
= λ t u Tm12 var12 lam12 app12 tt12 pair12 fst snd left right case zero suc rec →
pair12 _ _ _ (t Tm12 var12 lam12 app12 tt12 pair12 fst snd left right case zero suc rec)
(u Tm12 var12 lam12 app12 tt12 pair12 fst snd left right case zero suc rec)
fst12 : ∀{Γ A B} → Tm12 Γ (prod12 A B) → Tm12 Γ A; fst12
= λ t Tm12 var12 lam12 app12 tt12 pair12 fst12 snd left right case zero suc rec →
fst12 _ _ _ (t Tm12 var12 lam12 app12 tt12 pair12 fst12 snd left right case zero suc rec)
snd12 : ∀{Γ A B} → Tm12 Γ (prod12 A B) → Tm12 Γ B; snd12
= λ t Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left right case zero suc rec →
snd12 _ _ _ (t Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left right case zero suc rec)
left12 : ∀{Γ A B} → Tm12 Γ A → Tm12 Γ (sum12 A B); left12
= λ t Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right case zero suc rec →
left12 _ _ _ (t Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right case zero suc rec)
right12 : ∀{Γ A B} → Tm12 Γ B → Tm12 Γ (sum12 A B); right12
= λ t Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right12 case zero suc rec →
right12 _ _ _ (t Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right12 case zero suc rec)
case12 : ∀{Γ A B C} → Tm12 Γ (sum12 A B) → Tm12 Γ (arr12 A C) → Tm12 Γ (arr12 B C) → Tm12 Γ C; case12
= λ t u v Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right12 case12 zero suc rec →
case12 _ _ _ _
(t Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right12 case12 zero suc rec)
(u Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right12 case12 zero suc rec)
(v Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right12 case12 zero suc rec)
zero12 : ∀{Γ} → Tm12 Γ nat12; zero12
= λ Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right12 case12 zero12 suc rec → zero12 _
suc12 : ∀{Γ} → Tm12 Γ nat12 → Tm12 Γ nat12; suc12
= λ t Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right12 case12 zero12 suc12 rec →
suc12 _ (t Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right12 case12 zero12 suc12 rec)
rec12 : ∀{Γ A} → Tm12 Γ nat12 → Tm12 Γ (arr12 nat12 (arr12 A A)) → Tm12 Γ A → Tm12 Γ A; rec12
= λ t u v Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right12 case12 zero12 suc12 rec12 →
rec12 _ _
(t Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right12 case12 zero12 suc12 rec12)
(u Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right12 case12 zero12 suc12 rec12)
(v Tm12 var12 lam12 app12 tt12 pair12 fst12 snd12 left12 right12 case12 zero12 suc12 rec12)
v012 : ∀{Γ A} → Tm12 (snoc12 Γ A) A; v012
= var12 vz12
v112 : ∀{Γ A B} → Tm12 (snoc12 (snoc12 Γ A) B) A; v112
= var12 (vs12 vz12)
v212 : ∀{Γ A B C} → Tm12 (snoc12 (snoc12 (snoc12 Γ A) B) C) A; v212
= var12 (vs12 (vs12 vz12))
v312 : ∀{Γ A B C D} → Tm12 (snoc12 (snoc12 (snoc12 (snoc12 Γ A) B) C) D) A; v312
= var12 (vs12 (vs12 (vs12 vz12)))
tbool12 : Ty12; tbool12
= sum12 top12 top12
true12 : ∀{Γ} → Tm12 Γ tbool12; true12
= left12 tt12
tfalse12 : ∀{Γ} → Tm12 Γ tbool12; tfalse12
= right12 tt12
ifthenelse12 : ∀{Γ A} → Tm12 Γ (arr12 tbool12 (arr12 A (arr12 A A))); ifthenelse12
= lam12 (lam12 (lam12 (case12 v212 (lam12 v212) (lam12 v112))))
times412 : ∀{Γ A} → Tm12 Γ (arr12 (arr12 A A) (arr12 A A)); times412
= lam12 (lam12 (app12 v112 (app12 v112 (app12 v112 (app12 v112 v012)))))
add12 : ∀{Γ} → Tm12 Γ (arr12 nat12 (arr12 nat12 nat12)); add12
= lam12 (rec12 v012
(lam12 (lam12 (lam12 (suc12 (app12 v112 v012)))))
(lam12 v012))
mul12 : ∀{Γ} → Tm12 Γ (arr12 nat12 (arr12 nat12 nat12)); mul12
= lam12 (rec12 v012
(lam12 (lam12 (lam12 (app12 (app12 add12 (app12 v112 v012)) v012))))
(lam12 zero12))
fact12 : ∀{Γ} → Tm12 Γ (arr12 nat12 nat12); fact12
= lam12 (rec12 v012 (lam12 (lam12 (app12 (app12 mul12 (suc12 v112)) v012)))
(suc12 zero12))
{-# OPTIONS --type-in-type #-}
Ty13 : Set
Ty13 =
(Ty13 : Set)
(nat top bot : Ty13)
(arr prod sum : Ty13 → Ty13 → Ty13)
→ Ty13
nat13 : Ty13; nat13 = λ _ nat13 _ _ _ _ _ → nat13
top13 : Ty13; top13 = λ _ _ top13 _ _ _ _ → top13
bot13 : Ty13; bot13 = λ _ _ _ bot13 _ _ _ → bot13
arr13 : Ty13 → Ty13 → Ty13; arr13
= λ A B Ty13 nat13 top13 bot13 arr13 prod sum →
arr13 (A Ty13 nat13 top13 bot13 arr13 prod sum) (B Ty13 nat13 top13 bot13 arr13 prod sum)
prod13 : Ty13 → Ty13 → Ty13; prod13
= λ A B Ty13 nat13 top13 bot13 arr13 prod13 sum →
prod13 (A Ty13 nat13 top13 bot13 arr13 prod13 sum) (B Ty13 nat13 top13 bot13 arr13 prod13 sum)
sum13 : Ty13 → Ty13 → Ty13; sum13
= λ A B Ty13 nat13 top13 bot13 arr13 prod13 sum13 →
sum13 (A Ty13 nat13 top13 bot13 arr13 prod13 sum13) (B Ty13 nat13 top13 bot13 arr13 prod13 sum13)
Con13 : Set; Con13
= (Con13 : Set)
(nil : Con13)
(snoc : Con13 → Ty13 → Con13)
→ Con13
nil13 : Con13; nil13
= λ Con13 nil13 snoc → nil13
snoc13 : Con13 → Ty13 → Con13; snoc13
= λ Γ A Con13 nil13 snoc13 → snoc13 (Γ Con13 nil13 snoc13) A
Var13 : Con13 → Ty13 → Set; Var13
= λ Γ A →
(Var13 : Con13 → Ty13 → Set)
(vz : ∀ Γ A → Var13 (snoc13 Γ A) A)
(vs : ∀ Γ B A → Var13 Γ A → Var13 (snoc13 Γ B) A)
→ Var13 Γ A
vz13 : ∀{Γ A} → Var13 (snoc13 Γ A) A; vz13
= λ Var13 vz13 vs → vz13 _ _
vs13 : ∀{Γ B A} → Var13 Γ A → Var13 (snoc13 Γ B) A; vs13
= λ x Var13 vz13 vs13 → vs13 _ _ _ (x Var13 vz13 vs13)
Tm13 : Con13 → Ty13 → Set; Tm13
= λ Γ A →
(Tm13 : Con13 → Ty13 → Set)
(var : ∀ Γ A → Var13 Γ A → Tm13 Γ A)
(lam : ∀ Γ A B → Tm13 (snoc13 Γ A) B → Tm13 Γ (arr13 A B))
(app : ∀ Γ A B → Tm13 Γ (arr13 A B) → Tm13 Γ A → Tm13 Γ B)
(tt : ∀ Γ → Tm13 Γ top13)
(pair : ∀ Γ A B → Tm13 Γ A → Tm13 Γ B → Tm13 Γ (prod13 A B))
(fst : ∀ Γ A B → Tm13 Γ (prod13 A B) → Tm13 Γ A)
(snd : ∀ Γ A B → Tm13 Γ (prod13 A B) → Tm13 Γ B)
(left : ∀ Γ A B → Tm13 Γ A → Tm13 Γ (sum13 A B))
(right : ∀ Γ A B → Tm13 Γ B → Tm13 Γ (sum13 A B))
(case : ∀ Γ A B C → Tm13 Γ (sum13 A B) → Tm13 Γ (arr13 A C) → Tm13 Γ (arr13 B C) → Tm13 Γ C)
(zero : ∀ Γ → Tm13 Γ nat13)
(suc : ∀ Γ → Tm13 Γ nat13 → Tm13 Γ nat13)
(rec : ∀ Γ A → Tm13 Γ nat13 → Tm13 Γ (arr13 nat13 (arr13 A A)) → Tm13 Γ A → Tm13 Γ A)
→ Tm13 Γ A
var13 : ∀{Γ A} → Var13 Γ A → Tm13 Γ A; var13
= λ x Tm13 var13 lam app tt pair fst snd left right case zero suc rec →
var13 _ _ x
lam13 : ∀{Γ A B} → Tm13 (snoc13 Γ A) B → Tm13 Γ (arr13 A B); lam13
= λ t Tm13 var13 lam13 app tt pair fst snd left right case zero suc rec →
lam13 _ _ _ (t Tm13 var13 lam13 app tt pair fst snd left right case zero suc rec)
app13 : ∀{Γ A B} → Tm13 Γ (arr13 A B) → Tm13 Γ A → Tm13 Γ B; app13
= λ t u Tm13 var13 lam13 app13 tt pair fst snd left right case zero suc rec →
app13 _ _ _ (t Tm13 var13 lam13 app13 tt pair fst snd left right case zero suc rec)
(u Tm13 var13 lam13 app13 tt pair fst snd left right case zero suc rec)
tt13 : ∀{Γ} → Tm13 Γ top13; tt13
= λ Tm13 var13 lam13 app13 tt13 pair fst snd left right case zero suc rec → tt13 _
pair13 : ∀{Γ A B} → Tm13 Γ A → Tm13 Γ B → Tm13 Γ (prod13 A B); pair13
= λ t u Tm13 var13 lam13 app13 tt13 pair13 fst snd left right case zero suc rec →
pair13 _ _ _ (t Tm13 var13 lam13 app13 tt13 pair13 fst snd left right case zero suc rec)
(u Tm13 var13 lam13 app13 tt13 pair13 fst snd left right case zero suc rec)
fst13 : ∀{Γ A B} → Tm13 Γ (prod13 A B) → Tm13 Γ A; fst13
= λ t Tm13 var13 lam13 app13 tt13 pair13 fst13 snd left right case zero suc rec →
fst13 _ _ _ (t Tm13 var13 lam13 app13 tt13 pair13 fst13 snd left right case zero suc rec)
snd13 : ∀{Γ A B} → Tm13 Γ (prod13 A B) → Tm13 Γ B; snd13
= λ t Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left right case zero suc rec →
snd13 _ _ _ (t Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left right case zero suc rec)
left13 : ∀{Γ A B} → Tm13 Γ A → Tm13 Γ (sum13 A B); left13
= λ t Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right case zero suc rec →
left13 _ _ _ (t Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right case zero suc rec)
right13 : ∀{Γ A B} → Tm13 Γ B → Tm13 Γ (sum13 A B); right13
= λ t Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right13 case zero suc rec →
right13 _ _ _ (t Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right13 case zero suc rec)
case13 : ∀{Γ A B C} → Tm13 Γ (sum13 A B) → Tm13 Γ (arr13 A C) → Tm13 Γ (arr13 B C) → Tm13 Γ C; case13
= λ t u v Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right13 case13 zero suc rec →
case13 _ _ _ _
(t Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right13 case13 zero suc rec)
(u Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right13 case13 zero suc rec)
(v Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right13 case13 zero suc rec)
zero13 : ∀{Γ} → Tm13 Γ nat13; zero13
= λ Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right13 case13 zero13 suc rec → zero13 _
suc13 : ∀{Γ} → Tm13 Γ nat13 → Tm13 Γ nat13; suc13
= λ t Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right13 case13 zero13 suc13 rec →
suc13 _ (t Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right13 case13 zero13 suc13 rec)
rec13 : ∀{Γ A} → Tm13 Γ nat13 → Tm13 Γ (arr13 nat13 (arr13 A A)) → Tm13 Γ A → Tm13 Γ A; rec13
= λ t u v Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right13 case13 zero13 suc13 rec13 →
rec13 _ _
(t Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right13 case13 zero13 suc13 rec13)
(u Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right13 case13 zero13 suc13 rec13)
(v Tm13 var13 lam13 app13 tt13 pair13 fst13 snd13 left13 right13 case13 zero13 suc13 rec13)
v013 : ∀{Γ A} → Tm13 (snoc13 Γ A) A; v013
= var13 vz13
v113 : ∀{Γ A B} → Tm13 (snoc13 (snoc13 Γ A) B) A; v113
= var13 (vs13 vz13)
v213 : ∀{Γ A B C} → Tm13 (snoc13 (snoc13 (snoc13 Γ A) B) C) A; v213
= var13 (vs13 (vs13 vz13))
v313 : ∀{Γ A B C D} → Tm13 (snoc13 (snoc13 (snoc13 (snoc13 Γ A) B) C) D) A; v313
= var13 (vs13 (vs13 (vs13 vz13)))
tbool13 : Ty13; tbool13
= sum13 top13 top13
true13 : ∀{Γ} → Tm13 Γ tbool13; true13
= left13 tt13
tfalse13 : ∀{Γ} → Tm13 Γ tbool13; tfalse13
= right13 tt13
ifthenelse13 : ∀{Γ A} → Tm13 Γ (arr13 tbool13 (arr13 A (arr13 A A))); ifthenelse13
= lam13 (lam13 (lam13 (case13 v213 (lam13 v213) (lam13 v113))))
times413 : ∀{Γ A} → Tm13 Γ (arr13 (arr13 A A) (arr13 A A)); times413
= lam13 (lam13 (app13 v113 (app13 v113 (app13 v113 (app13 v113 v013)))))
add13 : ∀{Γ} → Tm13 Γ (arr13 nat13 (arr13 nat13 nat13)); add13
= lam13 (rec13 v013
(lam13 (lam13 (lam13 (suc13 (app13 v113 v013)))))
(lam13 v013))
mul13 : ∀{Γ} → Tm13 Γ (arr13 nat13 (arr13 nat13 nat13)); mul13
= lam13 (rec13 v013
(lam13 (lam13 (lam13 (app13 (app13 add13 (app13 v113 v013)) v013))))
(lam13 zero13))
fact13 : ∀{Γ} → Tm13 Γ (arr13 nat13 nat13); fact13
= lam13 (rec13 v013 (lam13 (lam13 (app13 (app13 mul13 (suc13 v113)) v013)))
(suc13 zero13))
{-# OPTIONS --type-in-type #-}
Ty14 : Set
Ty14 =
(Ty14 : Set)
(nat top bot : Ty14)
(arr prod sum : Ty14 → Ty14 → Ty14)
→ Ty14
nat14 : Ty14; nat14 = λ _ nat14 _ _ _ _ _ → nat14
top14 : Ty14; top14 = λ _ _ top14 _ _ _ _ → top14
bot14 : Ty14; bot14 = λ _ _ _ bot14 _ _ _ → bot14
arr14 : Ty14 → Ty14 → Ty14; arr14
= λ A B Ty14 nat14 top14 bot14 arr14 prod sum →
arr14 (A Ty14 nat14 top14 bot14 arr14 prod sum) (B Ty14 nat14 top14 bot14 arr14 prod sum)
prod14 : Ty14 → Ty14 → Ty14; prod14
= λ A B Ty14 nat14 top14 bot14 arr14 prod14 sum →
prod14 (A Ty14 nat14 top14 bot14 arr14 prod14 sum) (B Ty14 nat14 top14 bot14 arr14 prod14 sum)
sum14 : Ty14 → Ty14 → Ty14; sum14
= λ A B Ty14 nat14 top14 bot14 arr14 prod14 sum14 →
sum14 (A Ty14 nat14 top14 bot14 arr14 prod14 sum14) (B Ty14 nat14 top14 bot14 arr14 prod14 sum14)
Con14 : Set; Con14
= (Con14 : Set)
(nil : Con14)
(snoc : Con14 → Ty14 → Con14)
→ Con14
nil14 : Con14; nil14
= λ Con14 nil14 snoc → nil14
snoc14 : Con14 → Ty14 → Con14; snoc14
= λ Γ A Con14 nil14 snoc14 → snoc14 (Γ Con14 nil14 snoc14) A
Var14 : Con14 → Ty14 → Set; Var14
= λ Γ A →
(Var14 : Con14 → Ty14 → Set)
(vz : ∀ Γ A → Var14 (snoc14 Γ A) A)
(vs : ∀ Γ B A → Var14 Γ A → Var14 (snoc14 Γ B) A)
→ Var14 Γ A
vz14 : ∀{Γ A} → Var14 (snoc14 Γ A) A; vz14
= λ Var14 vz14 vs → vz14 _ _
vs14 : ∀{Γ B A} → Var14 Γ A → Var14 (snoc14 Γ B) A; vs14
= λ x Var14 vz14 vs14 → vs14 _ _ _ (x Var14 vz14 vs14)
Tm14 : Con14 → Ty14 → Set; Tm14
= λ Γ A →
(Tm14 : Con14 → Ty14 → Set)
(var : ∀ Γ A → Var14 Γ A → Tm14 Γ A)
(lam : ∀ Γ A B → Tm14 (snoc14 Γ A) B → Tm14 Γ (arr14 A B))
(app : ∀ Γ A B → Tm14 Γ (arr14 A B) → Tm14 Γ A → Tm14 Γ B)
(tt : ∀ Γ → Tm14 Γ top14)
(pair : ∀ Γ A B → Tm14 Γ A → Tm14 Γ B → Tm14 Γ (prod14 A B))
(fst : ∀ Γ A B → Tm14 Γ (prod14 A B) → Tm14 Γ A)
(snd : ∀ Γ A B → Tm14 Γ (prod14 A B) → Tm14 Γ B)
(left : ∀ Γ A B → Tm14 Γ A → Tm14 Γ (sum14 A B))
(right : ∀ Γ A B → Tm14 Γ B → Tm14 Γ (sum14 A B))
(case : ∀ Γ A B C → Tm14 Γ (sum14 A B) → Tm14 Γ (arr14 A C) → Tm14 Γ (arr14 B C) → Tm14 Γ C)
(zero : ∀ Γ → Tm14 Γ nat14)
(suc : ∀ Γ → Tm14 Γ nat14 → Tm14 Γ nat14)
(rec : ∀ Γ A → Tm14 Γ nat14 → Tm14 Γ (arr14 nat14 (arr14 A A)) → Tm14 Γ A → Tm14 Γ A)
→ Tm14 Γ A
var14 : ∀{Γ A} → Var14 Γ A → Tm14 Γ A; var14
= λ x Tm14 var14 lam app tt pair fst snd left right case zero suc rec →
var14 _ _ x
lam14 : ∀{Γ A B} → Tm14 (snoc14 Γ A) B → Tm14 Γ (arr14 A B); lam14
= λ t Tm14 var14 lam14 app tt pair fst snd left right case zero suc rec →
lam14 _ _ _ (t Tm14 var14 lam14 app tt pair fst snd left right case zero suc rec)
app14 : ∀{Γ A B} → Tm14 Γ (arr14 A B) → Tm14 Γ A → Tm14 Γ B; app14
= λ t u Tm14 var14 lam14 app14 tt pair fst snd left right case zero suc rec →
app14 _ _ _ (t Tm14 var14 lam14 app14 tt pair fst snd left right case zero suc rec)
(u Tm14 var14 lam14 app14 tt pair fst snd left right case zero suc rec)
tt14 : ∀{Γ} → Tm14 Γ top14; tt14
= λ Tm14 var14 lam14 app14 tt14 pair fst snd left right case zero suc rec → tt14 _
pair14 : ∀{Γ A B} → Tm14 Γ A → Tm14 Γ B → Tm14 Γ (prod14 A B); pair14
= λ t u Tm14 var14 lam14 app14 tt14 pair14 fst snd left right case zero suc rec →
pair14 _ _ _ (t Tm14 var14 lam14 app14 tt14 pair14 fst snd left right case zero suc rec)
(u Tm14 var14 lam14 app14 tt14 pair14 fst snd left right case zero suc rec)
fst14 : ∀{Γ A B} → Tm14 Γ (prod14 A B) → Tm14 Γ A; fst14
= λ t Tm14 var14 lam14 app14 tt14 pair14 fst14 snd left right case zero suc rec →
fst14 _ _ _ (t Tm14 var14 lam14 app14 tt14 pair14 fst14 snd left right case zero suc rec)
snd14 : ∀{Γ A B} → Tm14 Γ (prod14 A B) → Tm14 Γ B; snd14
= λ t Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left right case zero suc rec →
snd14 _ _ _ (t Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left right case zero suc rec)
left14 : ∀{Γ A B} → Tm14 Γ A → Tm14 Γ (sum14 A B); left14
= λ t Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right case zero suc rec →
left14 _ _ _ (t Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right case zero suc rec)
right14 : ∀{Γ A B} → Tm14 Γ B → Tm14 Γ (sum14 A B); right14
= λ t Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right14 case zero suc rec →
right14 _ _ _ (t Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right14 case zero suc rec)
case14 : ∀{Γ A B C} → Tm14 Γ (sum14 A B) → Tm14 Γ (arr14 A C) → Tm14 Γ (arr14 B C) → Tm14 Γ C; case14
= λ t u v Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right14 case14 zero suc rec →
case14 _ _ _ _
(t Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right14 case14 zero suc rec)
(u Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right14 case14 zero suc rec)
(v Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right14 case14 zero suc rec)
zero14 : ∀{Γ} → Tm14 Γ nat14; zero14
= λ Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right14 case14 zero14 suc rec → zero14 _
suc14 : ∀{Γ} → Tm14 Γ nat14 → Tm14 Γ nat14; suc14
= λ t Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right14 case14 zero14 suc14 rec →
suc14 _ (t Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right14 case14 zero14 suc14 rec)
rec14 : ∀{Γ A} → Tm14 Γ nat14 → Tm14 Γ (arr14 nat14 (arr14 A A)) → Tm14 Γ A → Tm14 Γ A; rec14
= λ t u v Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right14 case14 zero14 suc14 rec14 →
rec14 _ _
(t Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right14 case14 zero14 suc14 rec14)
(u Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right14 case14 zero14 suc14 rec14)
(v Tm14 var14 lam14 app14 tt14 pair14 fst14 snd14 left14 right14 case14 zero14 suc14 rec14)
v014 : ∀{Γ A} → Tm14 (snoc14 Γ A) A; v014
= var14 vz14
v114 : ∀{Γ A B} → Tm14 (snoc14 (snoc14 Γ A) B) A; v114
= var14 (vs14 vz14)
v214 : ∀{Γ A B C} → Tm14 (snoc14 (snoc14 (snoc14 Γ A) B) C) A; v214
= var14 (vs14 (vs14 vz14))
v314 : ∀{Γ A B C D} → Tm14 (snoc14 (snoc14 (snoc14 (snoc14 Γ A) B) C) D) A; v314
= var14 (vs14 (vs14 (vs14 vz14)))
tbool14 : Ty14; tbool14
= sum14 top14 top14
true14 : ∀{Γ} → Tm14 Γ tbool14; true14
= left14 tt14
tfalse14 : ∀{Γ} → Tm14 Γ tbool14; tfalse14
= right14 tt14
ifthenelse14 : ∀{Γ A} → Tm14 Γ (arr14 tbool14 (arr14 A (arr14 A A))); ifthenelse14
= lam14 (lam14 (lam14 (case14 v214 (lam14 v214) (lam14 v114))))
times414 : ∀{Γ A} → Tm14 Γ (arr14 (arr14 A A) (arr14 A A)); times414
= lam14 (lam14 (app14 v114 (app14 v114 (app14 v114 (app14 v114 v014)))))
add14 : ∀{Γ} → Tm14 Γ (arr14 nat14 (arr14 nat14 nat14)); add14
= lam14 (rec14 v014
(lam14 (lam14 (lam14 (suc14 (app14 v114 v014)))))
(lam14 v014))
mul14 : ∀{Γ} → Tm14 Γ (arr14 nat14 (arr14 nat14 nat14)); mul14
= lam14 (rec14 v014
(lam14 (lam14 (lam14 (app14 (app14 add14 (app14 v114 v014)) v014))))
(lam14 zero14))
fact14 : ∀{Γ} → Tm14 Γ (arr14 nat14 nat14); fact14
= lam14 (rec14 v014 (lam14 (lam14 (app14 (app14 mul14 (suc14 v114)) v014)))
(suc14 zero14))
{-# OPTIONS --type-in-type #-}
Ty15 : Set
Ty15 =
(Ty15 : Set)
(nat top bot : Ty15)
(arr prod sum : Ty15 → Ty15 → Ty15)
→ Ty15
nat15 : Ty15; nat15 = λ _ nat15 _ _ _ _ _ → nat15
top15 : Ty15; top15 = λ _ _ top15 _ _ _ _ → top15
bot15 : Ty15; bot15 = λ _ _ _ bot15 _ _ _ → bot15
arr15 : Ty15 → Ty15 → Ty15; arr15
= λ A B Ty15 nat15 top15 bot15 arr15 prod sum →
arr15 (A Ty15 nat15 top15 bot15 arr15 prod sum) (B Ty15 nat15 top15 bot15 arr15 prod sum)
prod15 : Ty15 → Ty15 → Ty15; prod15
= λ A B Ty15 nat15 top15 bot15 arr15 prod15 sum →
prod15 (A Ty15 nat15 top15 bot15 arr15 prod15 sum) (B Ty15 nat15 top15 bot15 arr15 prod15 sum)
sum15 : Ty15 → Ty15 → Ty15; sum15
= λ A B Ty15 nat15 top15 bot15 arr15 prod15 sum15 →
sum15 (A Ty15 nat15 top15 bot15 arr15 prod15 sum15) (B Ty15 nat15 top15 bot15 arr15 prod15 sum15)
Con15 : Set; Con15
= (Con15 : Set)
(nil : Con15)
(snoc : Con15 → Ty15 → Con15)
→ Con15
nil15 : Con15; nil15
= λ Con15 nil15 snoc → nil15
snoc15 : Con15 → Ty15 → Con15; snoc15
= λ Γ A Con15 nil15 snoc15 → snoc15 (Γ Con15 nil15 snoc15) A
Var15 : Con15 → Ty15 → Set; Var15
= λ Γ A →
(Var15 : Con15 → Ty15 → Set)
(vz : ∀ Γ A → Var15 (snoc15 Γ A) A)
(vs : ∀ Γ B A → Var15 Γ A → Var15 (snoc15 Γ B) A)
→ Var15 Γ A
vz15 : ∀{Γ A} → Var15 (snoc15 Γ A) A; vz15
= λ Var15 vz15 vs → vz15 _ _
vs15 : ∀{Γ B A} → Var15 Γ A → Var15 (snoc15 Γ B) A; vs15
= λ x Var15 vz15 vs15 → vs15 _ _ _ (x Var15 vz15 vs15)
Tm15 : Con15 → Ty15 → Set; Tm15
= λ Γ A →
(Tm15 : Con15 → Ty15 → Set)
(var : ∀ Γ A → Var15 Γ A → Tm15 Γ A)
(lam : ∀ Γ A B → Tm15 (snoc15 Γ A) B → Tm15 Γ (arr15 A B))
(app : ∀ Γ A B → Tm15 Γ (arr15 A B) → Tm15 Γ A → Tm15 Γ B)
(tt : ∀ Γ → Tm15 Γ top15)
(pair : ∀ Γ A B → Tm15 Γ A → Tm15 Γ B → Tm15 Γ (prod15 A B))
(fst : ∀ Γ A B → Tm15 Γ (prod15 A B) → Tm15 Γ A)
(snd : ∀ Γ A B → Tm15 Γ (prod15 A B) → Tm15 Γ B)
(left : ∀ Γ A B → Tm15 Γ A → Tm15 Γ (sum15 A B))
(right : ∀ Γ A B → Tm15 Γ B → Tm15 Γ (sum15 A B))
(case : ∀ Γ A B C → Tm15 Γ (sum15 A B) → Tm15 Γ (arr15 A C) → Tm15 Γ (arr15 B C) → Tm15 Γ C)
(zero : ∀ Γ → Tm15 Γ nat15)
(suc : ∀ Γ → Tm15 Γ nat15 → Tm15 Γ nat15)
(rec : ∀ Γ A → Tm15 Γ nat15 → Tm15 Γ (arr15 nat15 (arr15 A A)) → Tm15 Γ A → Tm15 Γ A)
→ Tm15 Γ A
var15 : ∀{Γ A} → Var15 Γ A → Tm15 Γ A; var15
= λ x Tm15 var15 lam app tt pair fst snd left right case zero suc rec →
var15 _ _ x
lam15 : ∀{Γ A B} → Tm15 (snoc15 Γ A) B → Tm15 Γ (arr15 A B); lam15
= λ t Tm15 var15 lam15 app tt pair fst snd left right case zero suc rec →
lam15 _ _ _ (t Tm15 var15 lam15 app tt pair fst snd left right case zero suc rec)
app15 : ∀{Γ A B} → Tm15 Γ (arr15 A B) → Tm15 Γ A → Tm15 Γ B; app15
= λ t u Tm15 var15 lam15 app15 tt pair fst snd left right case zero suc rec →
app15 _ _ _ (t Tm15 var15 lam15 app15 tt pair fst snd left right case zero suc rec)
(u Tm15 var15 lam15 app15 tt pair fst snd left right case zero suc rec)
tt15 : ∀{Γ} → Tm15 Γ top15; tt15
= λ Tm15 var15 lam15 app15 tt15 pair fst snd left right case zero suc rec → tt15 _
pair15 : ∀{Γ A B} → Tm15 Γ A → Tm15 Γ B → Tm15 Γ (prod15 A B); pair15
= λ t u Tm15 var15 lam15 app15 tt15 pair15 fst snd left right case zero suc rec →
pair15 _ _ _ (t Tm15 var15 lam15 app15 tt15 pair15 fst snd left right case zero suc rec)
(u Tm15 var15 lam15 app15 tt15 pair15 fst snd left right case zero suc rec)
fst15 : ∀{Γ A B} → Tm15 Γ (prod15 A B) → Tm15 Γ A; fst15
= λ t Tm15 var15 lam15 app15 tt15 pair15 fst15 snd left right case zero suc rec →
fst15 _ _ _ (t Tm15 var15 lam15 app15 tt15 pair15 fst15 snd left right case zero suc rec)
snd15 : ∀{Γ A B} → Tm15 Γ (prod15 A B) → Tm15 Γ B; snd15
= λ t Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left right case zero suc rec →
snd15 _ _ _ (t Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left right case zero suc rec)
left15 : ∀{Γ A B} → Tm15 Γ A → Tm15 Γ (sum15 A B); left15
= λ t Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right case zero suc rec →
left15 _ _ _ (t Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right case zero suc rec)
right15 : ∀{Γ A B} → Tm15 Γ B → Tm15 Γ (sum15 A B); right15
= λ t Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right15 case zero suc rec →
right15 _ _ _ (t Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right15 case zero suc rec)
case15 : ∀{Γ A B C} → Tm15 Γ (sum15 A B) → Tm15 Γ (arr15 A C) → Tm15 Γ (arr15 B C) → Tm15 Γ C; case15
= λ t u v Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right15 case15 zero suc rec →
case15 _ _ _ _
(t Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right15 case15 zero suc rec)
(u Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right15 case15 zero suc rec)
(v Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right15 case15 zero suc rec)
zero15 : ∀{Γ} → Tm15 Γ nat15; zero15
= λ Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right15 case15 zero15 suc rec → zero15 _
suc15 : ∀{Γ} → Tm15 Γ nat15 → Tm15 Γ nat15; suc15
= λ t Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right15 case15 zero15 suc15 rec →
suc15 _ (t Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right15 case15 zero15 suc15 rec)
rec15 : ∀{Γ A} → Tm15 Γ nat15 → Tm15 Γ (arr15 nat15 (arr15 A A)) → Tm15 Γ A → Tm15 Γ A; rec15
= λ t u v Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right15 case15 zero15 suc15 rec15 →
rec15 _ _
(t Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right15 case15 zero15 suc15 rec15)
(u Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right15 case15 zero15 suc15 rec15)
(v Tm15 var15 lam15 app15 tt15 pair15 fst15 snd15 left15 right15 case15 zero15 suc15 rec15)
v015 : ∀{Γ A} → Tm15 (snoc15 Γ A) A; v015
= var15 vz15
v115 : ∀{Γ A B} → Tm15 (snoc15 (snoc15 Γ A) B) A; v115
= var15 (vs15 vz15)
v215 : ∀{Γ A B C} → Tm15 (snoc15 (snoc15 (snoc15 Γ A) B) C) A; v215
= var15 (vs15 (vs15 vz15))
v315 : ∀{Γ A B C D} → Tm15 (snoc15 (snoc15 (snoc15 (snoc15 Γ A) B) C) D) A; v315
= var15 (vs15 (vs15 (vs15 vz15)))
tbool15 : Ty15; tbool15
= sum15 top15 top15
true15 : ∀{Γ} → Tm15 Γ tbool15; true15
= left15 tt15
tfalse15 : ∀{Γ} → Tm15 Γ tbool15; tfalse15
= right15 tt15
ifthenelse15 : ∀{Γ A} → Tm15 Γ (arr15 tbool15 (arr15 A (arr15 A A))); ifthenelse15
= lam15 (lam15 (lam15 (case15 v215 (lam15 v215) (lam15 v115))))
times415 : ∀{Γ A} → Tm15 Γ (arr15 (arr15 A A) (arr15 A A)); times415
= lam15 (lam15 (app15 v115 (app15 v115 (app15 v115 (app15 v115 v015)))))
add15 : ∀{Γ} → Tm15 Γ (arr15 nat15 (arr15 nat15 nat15)); add15
= lam15 (rec15 v015
(lam15 (lam15 (lam15 (suc15 (app15 v115 v015)))))
(lam15 v015))
mul15 : ∀{Γ} → Tm15 Γ (arr15 nat15 (arr15 nat15 nat15)); mul15
= lam15 (rec15 v015
(lam15 (lam15 (lam15 (app15 (app15 add15 (app15 v115 v015)) v015))))
(lam15 zero15))
fact15 : ∀{Γ} → Tm15 Γ (arr15 nat15 nat15); fact15
= lam15 (rec15 v015 (lam15 (lam15 (app15 (app15 mul15 (suc15 v115)) v015)))
(suc15 zero15))
{-# OPTIONS --type-in-type #-}
Ty16 : Set
Ty16 =
(Ty16 : Set)
(nat top bot : Ty16)
(arr prod sum : Ty16 → Ty16 → Ty16)
→ Ty16
nat16 : Ty16; nat16 = λ _ nat16 _ _ _ _ _ → nat16
top16 : Ty16; top16 = λ _ _ top16 _ _ _ _ → top16
bot16 : Ty16; bot16 = λ _ _ _ bot16 _ _ _ → bot16
arr16 : Ty16 → Ty16 → Ty16; arr16
= λ A B Ty16 nat16 top16 bot16 arr16 prod sum →
arr16 (A Ty16 nat16 top16 bot16 arr16 prod sum) (B Ty16 nat16 top16 bot16 arr16 prod sum)
prod16 : Ty16 → Ty16 → Ty16; prod16
= λ A B Ty16 nat16 top16 bot16 arr16 prod16 sum →
prod16 (A Ty16 nat16 top16 bot16 arr16 prod16 sum) (B Ty16 nat16 top16 bot16 arr16 prod16 sum)
sum16 : Ty16 → Ty16 → Ty16; sum16
= λ A B Ty16 nat16 top16 bot16 arr16 prod16 sum16 →
sum16 (A Ty16 nat16 top16 bot16 arr16 prod16 sum16) (B Ty16 nat16 top16 bot16 arr16 prod16 sum16)
Con16 : Set; Con16
= (Con16 : Set)
(nil : Con16)
(snoc : Con16 → Ty16 → Con16)
→ Con16
nil16 : Con16; nil16
= λ Con16 nil16 snoc → nil16
snoc16 : Con16 → Ty16 → Con16; snoc16
= λ Γ A Con16 nil16 snoc16 → snoc16 (Γ Con16 nil16 snoc16) A
Var16 : Con16 → Ty16 → Set; Var16
= λ Γ A →
(Var16 : Con16 → Ty16 → Set)
(vz : ∀ Γ A → Var16 (snoc16 Γ A) A)
(vs : ∀ Γ B A → Var16 Γ A → Var16 (snoc16 Γ B) A)
→ Var16 Γ A
vz16 : ∀{Γ A} → Var16 (snoc16 Γ A) A; vz16
= λ Var16 vz16 vs → vz16 _ _
vs16 : ∀{Γ B A} → Var16 Γ A → Var16 (snoc16 Γ B) A; vs16
= λ x Var16 vz16 vs16 → vs16 _ _ _ (x Var16 vz16 vs16)
Tm16 : Con16 → Ty16 → Set; Tm16
= λ Γ A →
(Tm16 : Con16 → Ty16 → Set)
(var : ∀ Γ A → Var16 Γ A → Tm16 Γ A)
(lam : ∀ Γ A B → Tm16 (snoc16 Γ A) B → Tm16 Γ (arr16 A B))
(app : ∀ Γ A B → Tm16 Γ (arr16 A B) → Tm16 Γ A → Tm16 Γ B)
(tt : ∀ Γ → Tm16 Γ top16)
(pair : ∀ Γ A B → Tm16 Γ A → Tm16 Γ B → Tm16 Γ (prod16 A B))
(fst : ∀ Γ A B → Tm16 Γ (prod16 A B) → Tm16 Γ A)
(snd : ∀ Γ A B → Tm16 Γ (prod16 A B) → Tm16 Γ B)
(left : ∀ Γ A B → Tm16 Γ A → Tm16 Γ (sum16 A B))
(right : ∀ Γ A B → Tm16 Γ B → Tm16 Γ (sum16 A B))
(case : ∀ Γ A B C → Tm16 Γ (sum16 A B) → Tm16 Γ (arr16 A C) → Tm16 Γ (arr16 B C) → Tm16 Γ C)
(zero : ∀ Γ → Tm16 Γ nat16)
(suc : ∀ Γ → Tm16 Γ nat16 → Tm16 Γ nat16)
(rec : ∀ Γ A → Tm16 Γ nat16 → Tm16 Γ (arr16 nat16 (arr16 A A)) → Tm16 Γ A → Tm16 Γ A)
→ Tm16 Γ A
var16 : ∀{Γ A} → Var16 Γ A → Tm16 Γ A; var16
= λ x Tm16 var16 lam app tt pair fst snd left right case zero suc rec →
var16 _ _ x
lam16 : ∀{Γ A B} → Tm16 (snoc16 Γ A) B → Tm16 Γ (arr16 A B); lam16
= λ t Tm16 var16 lam16 app tt pair fst snd left right case zero suc rec →
lam16 _ _ _ (t Tm16 var16 lam16 app tt pair fst snd left right case zero suc rec)
app16 : ∀{Γ A B} → Tm16 Γ (arr16 A B) → Tm16 Γ A → Tm16 Γ B; app16
= λ t u Tm16 var16 lam16 app16 tt pair fst snd left right case zero suc rec →
app16 _ _ _ (t Tm16 var16 lam16 app16 tt pair fst snd left right case zero suc rec)
(u Tm16 var16 lam16 app16 tt pair fst snd left right case zero suc rec)
tt16 : ∀{Γ} → Tm16 Γ top16; tt16
= λ Tm16 var16 lam16 app16 tt16 pair fst snd left right case zero suc rec → tt16 _
pair16 : ∀{Γ A B} → Tm16 Γ A → Tm16 Γ B → Tm16 Γ (prod16 A B); pair16
= λ t u Tm16 var16 lam16 app16 tt16 pair16 fst snd left right case zero suc rec →
pair16 _ _ _ (t Tm16 var16 lam16 app16 tt16 pair16 fst snd left right case zero suc rec)
(u Tm16 var16 lam16 app16 tt16 pair16 fst snd left right case zero suc rec)
fst16 : ∀{Γ A B} → Tm16 Γ (prod16 A B) → Tm16 Γ A; fst16
= λ t Tm16 var16 lam16 app16 tt16 pair16 fst16 snd left right case zero suc rec →
fst16 _ _ _ (t Tm16 var16 lam16 app16 tt16 pair16 fst16 snd left right case zero suc rec)
snd16 : ∀{Γ A B} → Tm16 Γ (prod16 A B) → Tm16 Γ B; snd16
= λ t Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left right case zero suc rec →
snd16 _ _ _ (t Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left right case zero suc rec)
left16 : ∀{Γ A B} → Tm16 Γ A → Tm16 Γ (sum16 A B); left16
= λ t Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right case zero suc rec →
left16 _ _ _ (t Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right case zero suc rec)
right16 : ∀{Γ A B} → Tm16 Γ B → Tm16 Γ (sum16 A B); right16
= λ t Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right16 case zero suc rec →
right16 _ _ _ (t Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right16 case zero suc rec)
case16 : ∀{Γ A B C} → Tm16 Γ (sum16 A B) → Tm16 Γ (arr16 A C) → Tm16 Γ (arr16 B C) → Tm16 Γ C; case16
= λ t u v Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right16 case16 zero suc rec →
case16 _ _ _ _
(t Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right16 case16 zero suc rec)
(u Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right16 case16 zero suc rec)
(v Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right16 case16 zero suc rec)
zero16 : ∀{Γ} → Tm16 Γ nat16; zero16
= λ Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right16 case16 zero16 suc rec → zero16 _
suc16 : ∀{Γ} → Tm16 Γ nat16 → Tm16 Γ nat16; suc16
= λ t Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right16 case16 zero16 suc16 rec →
suc16 _ (t Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right16 case16 zero16 suc16 rec)
rec16 : ∀{Γ A} → Tm16 Γ nat16 → Tm16 Γ (arr16 nat16 (arr16 A A)) → Tm16 Γ A → Tm16 Γ A; rec16
= λ t u v Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right16 case16 zero16 suc16 rec16 →
rec16 _ _
(t Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right16 case16 zero16 suc16 rec16)
(u Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right16 case16 zero16 suc16 rec16)
(v Tm16 var16 lam16 app16 tt16 pair16 fst16 snd16 left16 right16 case16 zero16 suc16 rec16)
v016 : ∀{Γ A} → Tm16 (snoc16 Γ A) A; v016
= var16 vz16
v116 : ∀{Γ A B} → Tm16 (snoc16 (snoc16 Γ A) B) A; v116
= var16 (vs16 vz16)
v216 : ∀{Γ A B C} → Tm16 (snoc16 (snoc16 (snoc16 Γ A) B) C) A; v216
= var16 (vs16 (vs16 vz16))
v316 : ∀{Γ A B C D} → Tm16 (snoc16 (snoc16 (snoc16 (snoc16 Γ A) B) C) D) A; v316
= var16 (vs16 (vs16 (vs16 vz16)))
tbool16 : Ty16; tbool16
= sum16 top16 top16
true16 : ∀{Γ} → Tm16 Γ tbool16; true16
= left16 tt16
tfalse16 : ∀{Γ} → Tm16 Γ tbool16; tfalse16
= right16 tt16
ifthenelse16 : ∀{Γ A} → Tm16 Γ (arr16 tbool16 (arr16 A (arr16 A A))); ifthenelse16
= lam16 (lam16 (lam16 (case16 v216 (lam16 v216) (lam16 v116))))
times416 : ∀{Γ A} → Tm16 Γ (arr16 (arr16 A A) (arr16 A A)); times416
= lam16 (lam16 (app16 v116 (app16 v116 (app16 v116 (app16 v116 v016)))))
add16 : ∀{Γ} → Tm16 Γ (arr16 nat16 (arr16 nat16 nat16)); add16
= lam16 (rec16 v016
(lam16 (lam16 (lam16 (suc16 (app16 v116 v016)))))
(lam16 v016))
mul16 : ∀{Γ} → Tm16 Γ (arr16 nat16 (arr16 nat16 nat16)); mul16
= lam16 (rec16 v016
(lam16 (lam16 (lam16 (app16 (app16 add16 (app16 v116 v016)) v016))))
(lam16 zero16))
fact16 : ∀{Γ} → Tm16 Γ (arr16 nat16 nat16); fact16
= lam16 (rec16 v016 (lam16 (lam16 (app16 (app16 mul16 (suc16 v116)) v016)))
(suc16 zero16))
{-# OPTIONS --type-in-type #-}
Ty17 : Set
Ty17 =
(Ty17 : Set)
(nat top bot : Ty17)
(arr prod sum : Ty17 → Ty17 → Ty17)
→ Ty17
nat17 : Ty17; nat17 = λ _ nat17 _ _ _ _ _ → nat17
top17 : Ty17; top17 = λ _ _ top17 _ _ _ _ → top17
bot17 : Ty17; bot17 = λ _ _ _ bot17 _ _ _ → bot17
arr17 : Ty17 → Ty17 → Ty17; arr17
= λ A B Ty17 nat17 top17 bot17 arr17 prod sum →
arr17 (A Ty17 nat17 top17 bot17 arr17 prod sum) (B Ty17 nat17 top17 bot17 arr17 prod sum)
prod17 : Ty17 → Ty17 → Ty17; prod17
= λ A B Ty17 nat17 top17 bot17 arr17 prod17 sum →
prod17 (A Ty17 nat17 top17 bot17 arr17 prod17 sum) (B Ty17 nat17 top17 bot17 arr17 prod17 sum)
sum17 : Ty17 → Ty17 → Ty17; sum17
= λ A B Ty17 nat17 top17 bot17 arr17 prod17 sum17 →
sum17 (A Ty17 nat17 top17 bot17 arr17 prod17 sum17) (B Ty17 nat17 top17 bot17 arr17 prod17 sum17)
Con17 : Set; Con17
= (Con17 : Set)
(nil : Con17)
(snoc : Con17 → Ty17 → Con17)
→ Con17
nil17 : Con17; nil17
= λ Con17 nil17 snoc → nil17
snoc17 : Con17 → Ty17 → Con17; snoc17
= λ Γ A Con17 nil17 snoc17 → snoc17 (Γ Con17 nil17 snoc17) A
Var17 : Con17 → Ty17 → Set; Var17
= λ Γ A →
(Var17 : Con17 → Ty17 → Set)
(vz : ∀ Γ A → Var17 (snoc17 Γ A) A)
(vs : ∀ Γ B A → Var17 Γ A → Var17 (snoc17 Γ B) A)
→ Var17 Γ A
vz17 : ∀{Γ A} → Var17 (snoc17 Γ A) A; vz17
= λ Var17 vz17 vs → vz17 _ _
vs17 : ∀{Γ B A} → Var17 Γ A → Var17 (snoc17 Γ B) A; vs17
= λ x Var17 vz17 vs17 → vs17 _ _ _ (x Var17 vz17 vs17)
Tm17 : Con17 → Ty17 → Set; Tm17
= λ Γ A →
(Tm17 : Con17 → Ty17 → Set)
(var : ∀ Γ A → Var17 Γ A → Tm17 Γ A)
(lam : ∀ Γ A B → Tm17 (snoc17 Γ A) B → Tm17 Γ (arr17 A B))
(app : ∀ Γ A B → Tm17 Γ (arr17 A B) → Tm17 Γ A → Tm17 Γ B)
(tt : ∀ Γ → Tm17 Γ top17)
(pair : ∀ Γ A B → Tm17 Γ A → Tm17 Γ B → Tm17 Γ (prod17 A B))
(fst : ∀ Γ A B → Tm17 Γ (prod17 A B) → Tm17 Γ A)
(snd : ∀ Γ A B → Tm17 Γ (prod17 A B) → Tm17 Γ B)
(left : ∀ Γ A B → Tm17 Γ A → Tm17 Γ (sum17 A B))
(right : ∀ Γ A B → Tm17 Γ B → Tm17 Γ (sum17 A B))
(case : ∀ Γ A B C → Tm17 Γ (sum17 A B) → Tm17 Γ (arr17 A C) → Tm17 Γ (arr17 B C) → Tm17 Γ C)
(zero : ∀ Γ → Tm17 Γ nat17)
(suc : ∀ Γ → Tm17 Γ nat17 → Tm17 Γ nat17)
(rec : ∀ Γ A → Tm17 Γ nat17 → Tm17 Γ (arr17 nat17 (arr17 A A)) → Tm17 Γ A → Tm17 Γ A)
→ Tm17 Γ A
var17 : ∀{Γ A} → Var17 Γ A → Tm17 Γ A; var17
= λ x Tm17 var17 lam app tt pair fst snd left right case zero suc rec →
var17 _ _ x
lam17 : ∀{Γ A B} → Tm17 (snoc17 Γ A) B → Tm17 Γ (arr17 A B); lam17
= λ t Tm17 var17 lam17 app tt pair fst snd left right case zero suc rec →
lam17 _ _ _ (t Tm17 var17 lam17 app tt pair fst snd left right case zero suc rec)
app17 : ∀{Γ A B} → Tm17 Γ (arr17 A B) → Tm17 Γ A → Tm17 Γ B; app17
= λ t u Tm17 var17 lam17 app17 tt pair fst snd left right case zero suc rec →
app17 _ _ _ (t Tm17 var17 lam17 app17 tt pair fst snd left right case zero suc rec)
(u Tm17 var17 lam17 app17 tt pair fst snd left right case zero suc rec)
tt17 : ∀{Γ} → Tm17 Γ top17; tt17
= λ Tm17 var17 lam17 app17 tt17 pair fst snd left right case zero suc rec → tt17 _
pair17 : ∀{Γ A B} → Tm17 Γ A → Tm17 Γ B → Tm17 Γ (prod17 A B); pair17
= λ t u Tm17 var17 lam17 app17 tt17 pair17 fst snd left right case zero suc rec →
pair17 _ _ _ (t Tm17 var17 lam17 app17 tt17 pair17 fst snd left right case zero suc rec)
(u Tm17 var17 lam17 app17 tt17 pair17 fst snd left right case zero suc rec)
fst17 : ∀{Γ A B} → Tm17 Γ (prod17 A B) → Tm17 Γ A; fst17
= λ t Tm17 var17 lam17 app17 tt17 pair17 fst17 snd left right case zero suc rec →
fst17 _ _ _ (t Tm17 var17 lam17 app17 tt17 pair17 fst17 snd left right case zero suc rec)
snd17 : ∀{Γ A B} → Tm17 Γ (prod17 A B) → Tm17 Γ B; snd17
= λ t Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left right case zero suc rec →
snd17 _ _ _ (t Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left right case zero suc rec)
left17 : ∀{Γ A B} → Tm17 Γ A → Tm17 Γ (sum17 A B); left17
= λ t Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right case zero suc rec →
left17 _ _ _ (t Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right case zero suc rec)
right17 : ∀{Γ A B} → Tm17 Γ B → Tm17 Γ (sum17 A B); right17
= λ t Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right17 case zero suc rec →
right17 _ _ _ (t Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right17 case zero suc rec)
case17 : ∀{Γ A B C} → Tm17 Γ (sum17 A B) → Tm17 Γ (arr17 A C) → Tm17 Γ (arr17 B C) → Tm17 Γ C; case17
= λ t u v Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right17 case17 zero suc rec →
case17 _ _ _ _
(t Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right17 case17 zero suc rec)
(u Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right17 case17 zero suc rec)
(v Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right17 case17 zero suc rec)
zero17 : ∀{Γ} → Tm17 Γ nat17; zero17
= λ Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right17 case17 zero17 suc rec → zero17 _
suc17 : ∀{Γ} → Tm17 Γ nat17 → Tm17 Γ nat17; suc17
= λ t Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right17 case17 zero17 suc17 rec →
suc17 _ (t Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right17 case17 zero17 suc17 rec)
rec17 : ∀{Γ A} → Tm17 Γ nat17 → Tm17 Γ (arr17 nat17 (arr17 A A)) → Tm17 Γ A → Tm17 Γ A; rec17
= λ t u v Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right17 case17 zero17 suc17 rec17 →
rec17 _ _
(t Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right17 case17 zero17 suc17 rec17)
(u Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right17 case17 zero17 suc17 rec17)
(v Tm17 var17 lam17 app17 tt17 pair17 fst17 snd17 left17 right17 case17 zero17 suc17 rec17)
v017 : ∀{Γ A} → Tm17 (snoc17 Γ A) A; v017
= var17 vz17
v117 : ∀{Γ A B} → Tm17 (snoc17 (snoc17 Γ A) B) A; v117
= var17 (vs17 vz17)
v217 : ∀{Γ A B C} → Tm17 (snoc17 (snoc17 (snoc17 Γ A) B) C) A; v217
= var17 (vs17 (vs17 vz17))
v317 : ∀{Γ A B C D} → Tm17 (snoc17 (snoc17 (snoc17 (snoc17 Γ A) B) C) D) A; v317
= var17 (vs17 (vs17 (vs17 vz17)))
tbool17 : Ty17; tbool17
= sum17 top17 top17
true17 : ∀{Γ} → Tm17 Γ tbool17; true17
= left17 tt17
tfalse17 : ∀{Γ} → Tm17 Γ tbool17; tfalse17
= right17 tt17
ifthenelse17 : ∀{Γ A} → Tm17 Γ (arr17 tbool17 (arr17 A (arr17 A A))); ifthenelse17
= lam17 (lam17 (lam17 (case17 v217 (lam17 v217) (lam17 v117))))
times417 : ∀{Γ A} → Tm17 Γ (arr17 (arr17 A A) (arr17 A A)); times417
= lam17 (lam17 (app17 v117 (app17 v117 (app17 v117 (app17 v117 v017)))))
add17 : ∀{Γ} → Tm17 Γ (arr17 nat17 (arr17 nat17 nat17)); add17
= lam17 (rec17 v017
(lam17 (lam17 (lam17 (suc17 (app17 v117 v017)))))
(lam17 v017))
mul17 : ∀{Γ} → Tm17 Γ (arr17 nat17 (arr17 nat17 nat17)); mul17
= lam17 (rec17 v017
(lam17 (lam17 (lam17 (app17 (app17 add17 (app17 v117 v017)) v017))))
(lam17 zero17))
fact17 : ∀{Γ} → Tm17 Γ (arr17 nat17 nat17); fact17
= lam17 (rec17 v017 (lam17 (lam17 (app17 (app17 mul17 (suc17 v117)) v017)))
(suc17 zero17))
{-# OPTIONS --type-in-type #-}
Ty18 : Set
Ty18 =
(Ty18 : Set)
(nat top bot : Ty18)
(arr prod sum : Ty18 → Ty18 → Ty18)
→ Ty18
nat18 : Ty18; nat18 = λ _ nat18 _ _ _ _ _ → nat18
top18 : Ty18; top18 = λ _ _ top18 _ _ _ _ → top18
bot18 : Ty18; bot18 = λ _ _ _ bot18 _ _ _ → bot18
arr18 : Ty18 → Ty18 → Ty18; arr18
= λ A B Ty18 nat18 top18 bot18 arr18 prod sum →
arr18 (A Ty18 nat18 top18 bot18 arr18 prod sum) (B Ty18 nat18 top18 bot18 arr18 prod sum)
prod18 : Ty18 → Ty18 → Ty18; prod18
= λ A B Ty18 nat18 top18 bot18 arr18 prod18 sum →
prod18 (A Ty18 nat18 top18 bot18 arr18 prod18 sum) (B Ty18 nat18 top18 bot18 arr18 prod18 sum)
sum18 : Ty18 → Ty18 → Ty18; sum18
= λ A B Ty18 nat18 top18 bot18 arr18 prod18 sum18 →
sum18 (A Ty18 nat18 top18 bot18 arr18 prod18 sum18) (B Ty18 nat18 top18 bot18 arr18 prod18 sum18)
Con18 : Set; Con18
= (Con18 : Set)
(nil : Con18)
(snoc : Con18 → Ty18 → Con18)
→ Con18
nil18 : Con18; nil18
= λ Con18 nil18 snoc → nil18
snoc18 : Con18 → Ty18 → Con18; snoc18
= λ Γ A Con18 nil18 snoc18 → snoc18 (Γ Con18 nil18 snoc18) A
Var18 : Con18 → Ty18 → Set; Var18
= λ Γ A →
(Var18 : Con18 → Ty18 → Set)
(vz : ∀ Γ A → Var18 (snoc18 Γ A) A)
(vs : ∀ Γ B A → Var18 Γ A → Var18 (snoc18 Γ B) A)
→ Var18 Γ A
vz18 : ∀{Γ A} → Var18 (snoc18 Γ A) A; vz18
= λ Var18 vz18 vs → vz18 _ _
vs18 : ∀{Γ B A} → Var18 Γ A → Var18 (snoc18 Γ B) A; vs18
= λ x Var18 vz18 vs18 → vs18 _ _ _ (x Var18 vz18 vs18)
Tm18 : Con18 → Ty18 → Set; Tm18
= λ Γ A →
(Tm18 : Con18 → Ty18 → Set)
(var : ∀ Γ A → Var18 Γ A → Tm18 Γ A)
(lam : ∀ Γ A B → Tm18 (snoc18 Γ A) B → Tm18 Γ (arr18 A B))
(app : ∀ Γ A B → Tm18 Γ (arr18 A B) → Tm18 Γ A → Tm18 Γ B)
(tt : ∀ Γ → Tm18 Γ top18)
(pair : ∀ Γ A B → Tm18 Γ A → Tm18 Γ B → Tm18 Γ (prod18 A B))
(fst : ∀ Γ A B → Tm18 Γ (prod18 A B) → Tm18 Γ A)
(snd : ∀ Γ A B → Tm18 Γ (prod18 A B) → Tm18 Γ B)
(left : ∀ Γ A B → Tm18 Γ A → Tm18 Γ (sum18 A B))
(right : ∀ Γ A B → Tm18 Γ B → Tm18 Γ (sum18 A B))
(case : ∀ Γ A B C → Tm18 Γ (sum18 A B) → Tm18 Γ (arr18 A C) → Tm18 Γ (arr18 B C) → Tm18 Γ C)
(zero : ∀ Γ → Tm18 Γ nat18)
(suc : ∀ Γ → Tm18 Γ nat18 → Tm18 Γ nat18)
(rec : ∀ Γ A → Tm18 Γ nat18 → Tm18 Γ (arr18 nat18 (arr18 A A)) → Tm18 Γ A → Tm18 Γ A)
→ Tm18 Γ A
var18 : ∀{Γ A} → Var18 Γ A → Tm18 Γ A; var18
= λ x Tm18 var18 lam app tt pair fst snd left right case zero suc rec →
var18 _ _ x
lam18 : ∀{Γ A B} → Tm18 (snoc18 Γ A) B → Tm18 Γ (arr18 A B); lam18
= λ t Tm18 var18 lam18 app tt pair fst snd left right case zero suc rec →
lam18 _ _ _ (t Tm18 var18 lam18 app tt pair fst snd left right case zero suc rec)
app18 : ∀{Γ A B} → Tm18 Γ (arr18 A B) → Tm18 Γ A → Tm18 Γ B; app18
= λ t u Tm18 var18 lam18 app18 tt pair fst snd left right case zero suc rec →
app18 _ _ _ (t Tm18 var18 lam18 app18 tt pair fst snd left right case zero suc rec)
(u Tm18 var18 lam18 app18 tt pair fst snd left right case zero suc rec)
tt18 : ∀{Γ} → Tm18 Γ top18; tt18
= λ Tm18 var18 lam18 app18 tt18 pair fst snd left right case zero suc rec → tt18 _
pair18 : ∀{Γ A B} → Tm18 Γ A → Tm18 Γ B → Tm18 Γ (prod18 A B); pair18
= λ t u Tm18 var18 lam18 app18 tt18 pair18 fst snd left right case zero suc rec →
pair18 _ _ _ (t Tm18 var18 lam18 app18 tt18 pair18 fst snd left right case zero suc rec)
(u Tm18 var18 lam18 app18 tt18 pair18 fst snd left right case zero suc rec)
fst18 : ∀{Γ A B} → Tm18 Γ (prod18 A B) → Tm18 Γ A; fst18
= λ t Tm18 var18 lam18 app18 tt18 pair18 fst18 snd left right case zero suc rec →
fst18 _ _ _ (t Tm18 var18 lam18 app18 tt18 pair18 fst18 snd left right case zero suc rec)
snd18 : ∀{Γ A B} → Tm18 Γ (prod18 A B) → Tm18 Γ B; snd18
= λ t Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left right case zero suc rec →
snd18 _ _ _ (t Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left right case zero suc rec)
left18 : ∀{Γ A B} → Tm18 Γ A → Tm18 Γ (sum18 A B); left18
= λ t Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right case zero suc rec →
left18 _ _ _ (t Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right case zero suc rec)
right18 : ∀{Γ A B} → Tm18 Γ B → Tm18 Γ (sum18 A B); right18
= λ t Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right18 case zero suc rec →
right18 _ _ _ (t Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right18 case zero suc rec)
case18 : ∀{Γ A B C} → Tm18 Γ (sum18 A B) → Tm18 Γ (arr18 A C) → Tm18 Γ (arr18 B C) → Tm18 Γ C; case18
= λ t u v Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right18 case18 zero suc rec →
case18 _ _ _ _
(t Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right18 case18 zero suc rec)
(u Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right18 case18 zero suc rec)
(v Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right18 case18 zero suc rec)
zero18 : ∀{Γ} → Tm18 Γ nat18; zero18
= λ Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right18 case18 zero18 suc rec → zero18 _
suc18 : ∀{Γ} → Tm18 Γ nat18 → Tm18 Γ nat18; suc18
= λ t Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right18 case18 zero18 suc18 rec →
suc18 _ (t Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right18 case18 zero18 suc18 rec)
rec18 : ∀{Γ A} → Tm18 Γ nat18 → Tm18 Γ (arr18 nat18 (arr18 A A)) → Tm18 Γ A → Tm18 Γ A; rec18
= λ t u v Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right18 case18 zero18 suc18 rec18 →
rec18 _ _
(t Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right18 case18 zero18 suc18 rec18)
(u Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right18 case18 zero18 suc18 rec18)
(v Tm18 var18 lam18 app18 tt18 pair18 fst18 snd18 left18 right18 case18 zero18 suc18 rec18)
v018 : ∀{Γ A} → Tm18 (snoc18 Γ A) A; v018
= var18 vz18
v118 : ∀{Γ A B} → Tm18 (snoc18 (snoc18 Γ A) B) A; v118
= var18 (vs18 vz18)
v218 : ∀{Γ A B C} → Tm18 (snoc18 (snoc18 (snoc18 Γ A) B) C) A; v218
= var18 (vs18 (vs18 vz18))
v318 : ∀{Γ A B C D} → Tm18 (snoc18 (snoc18 (snoc18 (snoc18 Γ A) B) C) D) A; v318
= var18 (vs18 (vs18 (vs18 vz18)))
tbool18 : Ty18; tbool18
= sum18 top18 top18
true18 : ∀{Γ} → Tm18 Γ tbool18; true18
= left18 tt18
tfalse18 : ∀{Γ} → Tm18 Γ tbool18; tfalse18
= right18 tt18
ifthenelse18 : ∀{Γ A} → Tm18 Γ (arr18 tbool18 (arr18 A (arr18 A A))); ifthenelse18
= lam18 (lam18 (lam18 (case18 v218 (lam18 v218) (lam18 v118))))
times418 : ∀{Γ A} → Tm18 Γ (arr18 (arr18 A A) (arr18 A A)); times418
= lam18 (lam18 (app18 v118 (app18 v118 (app18 v118 (app18 v118 v018)))))
add18 : ∀{Γ} → Tm18 Γ (arr18 nat18 (arr18 nat18 nat18)); add18
= lam18 (rec18 v018
(lam18 (lam18 (lam18 (suc18 (app18 v118 v018)))))
(lam18 v018))
mul18 : ∀{Γ} → Tm18 Γ (arr18 nat18 (arr18 nat18 nat18)); mul18
= lam18 (rec18 v018
(lam18 (lam18 (lam18 (app18 (app18 add18 (app18 v118 v018)) v018))))
(lam18 zero18))
fact18 : ∀{Γ} → Tm18 Γ (arr18 nat18 nat18); fact18
= lam18 (rec18 v018 (lam18 (lam18 (app18 (app18 mul18 (suc18 v118)) v018)))
(suc18 zero18))
{-# OPTIONS --type-in-type #-}
Ty19 : Set
Ty19 =
(Ty19 : Set)
(nat top bot : Ty19)
(arr prod sum : Ty19 → Ty19 → Ty19)
→ Ty19
nat19 : Ty19; nat19 = λ _ nat19 _ _ _ _ _ → nat19
top19 : Ty19; top19 = λ _ _ top19 _ _ _ _ → top19
bot19 : Ty19; bot19 = λ _ _ _ bot19 _ _ _ → bot19
arr19 : Ty19 → Ty19 → Ty19; arr19
= λ A B Ty19 nat19 top19 bot19 arr19 prod sum →
arr19 (A Ty19 nat19 top19 bot19 arr19 prod sum) (B Ty19 nat19 top19 bot19 arr19 prod sum)
prod19 : Ty19 → Ty19 → Ty19; prod19
= λ A B Ty19 nat19 top19 bot19 arr19 prod19 sum →
prod19 (A Ty19 nat19 top19 bot19 arr19 prod19 sum) (B Ty19 nat19 top19 bot19 arr19 prod19 sum)
sum19 : Ty19 → Ty19 → Ty19; sum19
= λ A B Ty19 nat19 top19 bot19 arr19 prod19 sum19 →
sum19 (A Ty19 nat19 top19 bot19 arr19 prod19 sum19) (B Ty19 nat19 top19 bot19 arr19 prod19 sum19)
Con19 : Set; Con19
= (Con19 : Set)
(nil : Con19)
(snoc : Con19 → Ty19 → Con19)
→ Con19
nil19 : Con19; nil19
= λ Con19 nil19 snoc → nil19
snoc19 : Con19 → Ty19 → Con19; snoc19
= λ Γ A Con19 nil19 snoc19 → snoc19 (Γ Con19 nil19 snoc19) A
Var19 : Con19 → Ty19 → Set; Var19
= λ Γ A →
(Var19 : Con19 → Ty19 → Set)
(vz : ∀ Γ A → Var19 (snoc19 Γ A) A)
(vs : ∀ Γ B A → Var19 Γ A → Var19 (snoc19 Γ B) A)
→ Var19 Γ A
vz19 : ∀{Γ A} → Var19 (snoc19 Γ A) A; vz19
= λ Var19 vz19 vs → vz19 _ _
vs19 : ∀{Γ B A} → Var19 Γ A → Var19 (snoc19 Γ B) A; vs19
= λ x Var19 vz19 vs19 → vs19 _ _ _ (x Var19 vz19 vs19)
Tm19 : Con19 → Ty19 → Set; Tm19
= λ Γ A →
(Tm19 : Con19 → Ty19 → Set)
(var : ∀ Γ A → Var19 Γ A → Tm19 Γ A)
(lam : ∀ Γ A B → Tm19 (snoc19 Γ A) B → Tm19 Γ (arr19 A B))
(app : ∀ Γ A B → Tm19 Γ (arr19 A B) → Tm19 Γ A → Tm19 Γ B)
(tt : ∀ Γ → Tm19 Γ top19)
(pair : ∀ Γ A B → Tm19 Γ A → Tm19 Γ B → Tm19 Γ (prod19 A B))
(fst : ∀ Γ A B → Tm19 Γ (prod19 A B) → Tm19 Γ A)
(snd : ∀ Γ A B → Tm19 Γ (prod19 A B) → Tm19 Γ B)
(left : ∀ Γ A B → Tm19 Γ A → Tm19 Γ (sum19 A B))
(right : ∀ Γ A B → Tm19 Γ B → Tm19 Γ (sum19 A B))
(case : ∀ Γ A B C → Tm19 Γ (sum19 A B) → Tm19 Γ (arr19 A C) → Tm19 Γ (arr19 B C) → Tm19 Γ C)
(zero : ∀ Γ → Tm19 Γ nat19)
(suc : ∀ Γ → Tm19 Γ nat19 → Tm19 Γ nat19)
(rec : ∀ Γ A → Tm19 Γ nat19 → Tm19 Γ (arr19 nat19 (arr19 A A)) → Tm19 Γ A → Tm19 Γ A)
→ Tm19 Γ A
var19 : ∀{Γ A} → Var19 Γ A → Tm19 Γ A; var19
= λ x Tm19 var19 lam app tt pair fst snd left right case zero suc rec →
var19 _ _ x
lam19 : ∀{Γ A B} → Tm19 (snoc19 Γ A) B → Tm19 Γ (arr19 A B); lam19
= λ t Tm19 var19 lam19 app tt pair fst snd left right case zero suc rec →
lam19 _ _ _ (t Tm19 var19 lam19 app tt pair fst snd left right case zero suc rec)
app19 : ∀{Γ A B} → Tm19 Γ (arr19 A B) → Tm19 Γ A → Tm19 Γ B; app19
= λ t u Tm19 var19 lam19 app19 tt pair fst snd left right case zero suc rec →
app19 _ _ _ (t Tm19 var19 lam19 app19 tt pair fst snd left right case zero suc rec)
(u Tm19 var19 lam19 app19 tt pair fst snd left right case zero suc rec)
tt19 : ∀{Γ} → Tm19 Γ top19; tt19
= λ Tm19 var19 lam19 app19 tt19 pair fst snd left right case zero suc rec → tt19 _
pair19 : ∀{Γ A B} → Tm19 Γ A → Tm19 Γ B → Tm19 Γ (prod19 A B); pair19
= λ t u Tm19 var19 lam19 app19 tt19 pair19 fst snd left right case zero suc rec →
pair19 _ _ _ (t Tm19 var19 lam19 app19 tt19 pair19 fst snd left right case zero suc rec)
(u Tm19 var19 lam19 app19 tt19 pair19 fst snd left right case zero suc rec)
fst19 : ∀{Γ A B} → Tm19 Γ (prod19 A B) → Tm19 Γ A; fst19
= λ t Tm19 var19 lam19 app19 tt19 pair19 fst19 snd left right case zero suc rec →
fst19 _ _ _ (t Tm19 var19 lam19 app19 tt19 pair19 fst19 snd left right case zero suc rec)
snd19 : ∀{Γ A B} → Tm19 Γ (prod19 A B) → Tm19 Γ B; snd19
= λ t Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left right case zero suc rec →
snd19 _ _ _ (t Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left right case zero suc rec)
left19 : ∀{Γ A B} → Tm19 Γ A → Tm19 Γ (sum19 A B); left19
= λ t Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right case zero suc rec →
left19 _ _ _ (t Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right case zero suc rec)
right19 : ∀{Γ A B} → Tm19 Γ B → Tm19 Γ (sum19 A B); right19
= λ t Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right19 case zero suc rec →
right19 _ _ _ (t Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right19 case zero suc rec)
case19 : ∀{Γ A B C} → Tm19 Γ (sum19 A B) → Tm19 Γ (arr19 A C) → Tm19 Γ (arr19 B C) → Tm19 Γ C; case19
= λ t u v Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right19 case19 zero suc rec →
case19 _ _ _ _
(t Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right19 case19 zero suc rec)
(u Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right19 case19 zero suc rec)
(v Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right19 case19 zero suc rec)
zero19 : ∀{Γ} → Tm19 Γ nat19; zero19
= λ Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right19 case19 zero19 suc rec → zero19 _
suc19 : ∀{Γ} → Tm19 Γ nat19 → Tm19 Γ nat19; suc19
= λ t Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right19 case19 zero19 suc19 rec →
suc19 _ (t Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right19 case19 zero19 suc19 rec)
rec19 : ∀{Γ A} → Tm19 Γ nat19 → Tm19 Γ (arr19 nat19 (arr19 A A)) → Tm19 Γ A → Tm19 Γ A; rec19
= λ t u v Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right19 case19 zero19 suc19 rec19 →
rec19 _ _
(t Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right19 case19 zero19 suc19 rec19)
(u Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right19 case19 zero19 suc19 rec19)
(v Tm19 var19 lam19 app19 tt19 pair19 fst19 snd19 left19 right19 case19 zero19 suc19 rec19)
v019 : ∀{Γ A} → Tm19 (snoc19 Γ A) A; v019
= var19 vz19
v119 : ∀{Γ A B} → Tm19 (snoc19 (snoc19 Γ A) B) A; v119
= var19 (vs19 vz19)
v219 : ∀{Γ A B C} → Tm19 (snoc19 (snoc19 (snoc19 Γ A) B) C) A; v219
= var19 (vs19 (vs19 vz19))
v319 : ∀{Γ A B C D} → Tm19 (snoc19 (snoc19 (snoc19 (snoc19 Γ A) B) C) D) A; v319
= var19 (vs19 (vs19 (vs19 vz19)))
tbool19 : Ty19; tbool19
= sum19 top19 top19
true19 : ∀{Γ} → Tm19 Γ tbool19; true19
= left19 tt19
tfalse19 : ∀{Γ} → Tm19 Γ tbool19; tfalse19
= right19 tt19
ifthenelse19 : ∀{Γ A} → Tm19 Γ (arr19 tbool19 (arr19 A (arr19 A A))); ifthenelse19
= lam19 (lam19 (lam19 (case19 v219 (lam19 v219) (lam19 v119))))
times419 : ∀{Γ A} → Tm19 Γ (arr19 (arr19 A A) (arr19 A A)); times419
= lam19 (lam19 (app19 v119 (app19 v119 (app19 v119 (app19 v119 v019)))))
add19 : ∀{Γ} → Tm19 Γ (arr19 nat19 (arr19 nat19 nat19)); add19
= lam19 (rec19 v019
(lam19 (lam19 (lam19 (suc19 (app19 v119 v019)))))
(lam19 v019))
mul19 : ∀{Γ} → Tm19 Γ (arr19 nat19 (arr19 nat19 nat19)); mul19
= lam19 (rec19 v019
(lam19 (lam19 (lam19 (app19 (app19 add19 (app19 v119 v019)) v019))))
(lam19 zero19))
fact19 : ∀{Γ} → Tm19 Γ (arr19 nat19 nat19); fact19
= lam19 (rec19 v019 (lam19 (lam19 (app19 (app19 mul19 (suc19 v119)) v019)))
(suc19 zero19))
{-# OPTIONS --type-in-type #-}
Ty20 : Set
Ty20 =
(Ty20 : Set)
(nat top bot : Ty20)
(arr prod sum : Ty20 → Ty20 → Ty20)
→ Ty20
nat20 : Ty20; nat20 = λ _ nat20 _ _ _ _ _ → nat20
top20 : Ty20; top20 = λ _ _ top20 _ _ _ _ → top20
bot20 : Ty20; bot20 = λ _ _ _ bot20 _ _ _ → bot20
arr20 : Ty20 → Ty20 → Ty20; arr20
= λ A B Ty20 nat20 top20 bot20 arr20 prod sum →
arr20 (A Ty20 nat20 top20 bot20 arr20 prod sum) (B Ty20 nat20 top20 bot20 arr20 prod sum)
prod20 : Ty20 → Ty20 → Ty20; prod20
= λ A B Ty20 nat20 top20 bot20 arr20 prod20 sum →
prod20 (A Ty20 nat20 top20 bot20 arr20 prod20 sum) (B Ty20 nat20 top20 bot20 arr20 prod20 sum)
sum20 : Ty20 → Ty20 → Ty20; sum20
= λ A B Ty20 nat20 top20 bot20 arr20 prod20 sum20 →
sum20 (A Ty20 nat20 top20 bot20 arr20 prod20 sum20) (B Ty20 nat20 top20 bot20 arr20 prod20 sum20)
Con20 : Set; Con20
= (Con20 : Set)
(nil : Con20)
(snoc : Con20 → Ty20 → Con20)
→ Con20
nil20 : Con20; nil20
= λ Con20 nil20 snoc → nil20
snoc20 : Con20 → Ty20 → Con20; snoc20
= λ Γ A Con20 nil20 snoc20 → snoc20 (Γ Con20 nil20 snoc20) A
Var20 : Con20 → Ty20 → Set; Var20
= λ Γ A →
(Var20 : Con20 → Ty20 → Set)
(vz : ∀ Γ A → Var20 (snoc20 Γ A) A)
(vs : ∀ Γ B A → Var20 Γ A → Var20 (snoc20 Γ B) A)
→ Var20 Γ A
vz20 : ∀{Γ A} → Var20 (snoc20 Γ A) A; vz20
= λ Var20 vz20 vs → vz20 _ _
vs20 : ∀{Γ B A} → Var20 Γ A → Var20 (snoc20 Γ B) A; vs20
= λ x Var20 vz20 vs20 → vs20 _ _ _ (x Var20 vz20 vs20)
Tm20 : Con20 → Ty20 → Set; Tm20
= λ Γ A →
(Tm20 : Con20 → Ty20 → Set)
(var : ∀ Γ A → Var20 Γ A → Tm20 Γ A)
(lam : ∀ Γ A B → Tm20 (snoc20 Γ A) B → Tm20 Γ (arr20 A B))
(app : ∀ Γ A B → Tm20 Γ (arr20 A B) → Tm20 Γ A → Tm20 Γ B)
(tt : ∀ Γ → Tm20 Γ top20)
(pair : ∀ Γ A B → Tm20 Γ A → Tm20 Γ B → Tm20 Γ (prod20 A B))
(fst : ∀ Γ A B → Tm20 Γ (prod20 A B) → Tm20 Γ A)
(snd : ∀ Γ A B → Tm20 Γ (prod20 A B) → Tm20 Γ B)
(left : ∀ Γ A B → Tm20 Γ A → Tm20 Γ (sum20 A B))
(right : ∀ Γ A B → Tm20 Γ B → Tm20 Γ (sum20 A B))
(case : ∀ Γ A B C → Tm20 Γ (sum20 A B) → Tm20 Γ (arr20 A C) → Tm20 Γ (arr20 B C) → Tm20 Γ C)
(zero : ∀ Γ → Tm20 Γ nat20)
(suc : ∀ Γ → Tm20 Γ nat20 → Tm20 Γ nat20)
(rec : ∀ Γ A → Tm20 Γ nat20 → Tm20 Γ (arr20 nat20 (arr20 A A)) → Tm20 Γ A → Tm20 Γ A)
→ Tm20 Γ A
var20 : ∀{Γ A} → Var20 Γ A → Tm20 Γ A; var20
= λ x Tm20 var20 lam app tt pair fst snd left right case zero suc rec →
var20 _ _ x
lam20 : ∀{Γ A B} → Tm20 (snoc20 Γ A) B → Tm20 Γ (arr20 A B); lam20
= λ t Tm20 var20 lam20 app tt pair fst snd left right case zero suc rec →
lam20 _ _ _ (t Tm20 var20 lam20 app tt pair fst snd left right case zero suc rec)
app20 : ∀{Γ A B} → Tm20 Γ (arr20 A B) → Tm20 Γ A → Tm20 Γ B; app20
= λ t u Tm20 var20 lam20 app20 tt pair fst snd left right case zero suc rec →
app20 _ _ _ (t Tm20 var20 lam20 app20 tt pair fst snd left right case zero suc rec)
(u Tm20 var20 lam20 app20 tt pair fst snd left right case zero suc rec)
tt20 : ∀{Γ} → Tm20 Γ top20; tt20
= λ Tm20 var20 lam20 app20 tt20 pair fst snd left right case zero suc rec → tt20 _
pair20 : ∀{Γ A B} → Tm20 Γ A → Tm20 Γ B → Tm20 Γ (prod20 A B); pair20
= λ t u Tm20 var20 lam20 app20 tt20 pair20 fst snd left right case zero suc rec →
pair20 _ _ _ (t Tm20 var20 lam20 app20 tt20 pair20 fst snd left right case zero suc rec)
(u Tm20 var20 lam20 app20 tt20 pair20 fst snd left right case zero suc rec)
fst20 : ∀{Γ A B} → Tm20 Γ (prod20 A B) → Tm20 Γ A; fst20
= λ t Tm20 var20 lam20 app20 tt20 pair20 fst20 snd left right case zero suc rec →
fst20 _ _ _ (t Tm20 var20 lam20 app20 tt20 pair20 fst20 snd left right case zero suc rec)
snd20 : ∀{Γ A B} → Tm20 Γ (prod20 A B) → Tm20 Γ B; snd20
= λ t Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left right case zero suc rec →
snd20 _ _ _ (t Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left right case zero suc rec)
left20 : ∀{Γ A B} → Tm20 Γ A → Tm20 Γ (sum20 A B); left20
= λ t Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right case zero suc rec →
left20 _ _ _ (t Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right case zero suc rec)
right20 : ∀{Γ A B} → Tm20 Γ B → Tm20 Γ (sum20 A B); right20
= λ t Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right20 case zero suc rec →
right20 _ _ _ (t Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right20 case zero suc rec)
case20 : ∀{Γ A B C} → Tm20 Γ (sum20 A B) → Tm20 Γ (arr20 A C) → Tm20 Γ (arr20 B C) → Tm20 Γ C; case20
= λ t u v Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right20 case20 zero suc rec →
case20 _ _ _ _
(t Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right20 case20 zero suc rec)
(u Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right20 case20 zero suc rec)
(v Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right20 case20 zero suc rec)
zero20 : ∀{Γ} → Tm20 Γ nat20; zero20
= λ Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right20 case20 zero20 suc rec → zero20 _
suc20 : ∀{Γ} → Tm20 Γ nat20 → Tm20 Γ nat20; suc20
= λ t Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right20 case20 zero20 suc20 rec →
suc20 _ (t Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right20 case20 zero20 suc20 rec)
rec20 : ∀{Γ A} → Tm20 Γ nat20 → Tm20 Γ (arr20 nat20 (arr20 A A)) → Tm20 Γ A → Tm20 Γ A; rec20
= λ t u v Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right20 case20 zero20 suc20 rec20 →
rec20 _ _
(t Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right20 case20 zero20 suc20 rec20)
(u Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right20 case20 zero20 suc20 rec20)
(v Tm20 var20 lam20 app20 tt20 pair20 fst20 snd20 left20 right20 case20 zero20 suc20 rec20)
v020 : ∀{Γ A} → Tm20 (snoc20 Γ A) A; v020
= var20 vz20
v120 : ∀{Γ A B} → Tm20 (snoc20 (snoc20 Γ A) B) A; v120
= var20 (vs20 vz20)
v220 : ∀{Γ A B C} → Tm20 (snoc20 (snoc20 (snoc20 Γ A) B) C) A; v220
= var20 (vs20 (vs20 vz20))
v320 : ∀{Γ A B C D} → Tm20 (snoc20 (snoc20 (snoc20 (snoc20 Γ A) B) C) D) A; v320
= var20 (vs20 (vs20 (vs20 vz20)))
tbool20 : Ty20; tbool20
= sum20 top20 top20
true20 : ∀{Γ} → Tm20 Γ tbool20; true20
= left20 tt20
tfalse20 : ∀{Γ} → Tm20 Γ tbool20; tfalse20
= right20 tt20
ifthenelse20 : ∀{Γ A} → Tm20 Γ (arr20 tbool20 (arr20 A (arr20 A A))); ifthenelse20
= lam20 (lam20 (lam20 (case20 v220 (lam20 v220) (lam20 v120))))
times420 : ∀{Γ A} → Tm20 Γ (arr20 (arr20 A A) (arr20 A A)); times420
= lam20 (lam20 (app20 v120 (app20 v120 (app20 v120 (app20 v120 v020)))))
add20 : ∀{Γ} → Tm20 Γ (arr20 nat20 (arr20 nat20 nat20)); add20
= lam20 (rec20 v020
(lam20 (lam20 (lam20 (suc20 (app20 v120 v020)))))
(lam20 v020))
mul20 : ∀{Γ} → Tm20 Γ (arr20 nat20 (arr20 nat20 nat20)); mul20
= lam20 (rec20 v020
(lam20 (lam20 (lam20 (app20 (app20 add20 (app20 v120 v020)) v020))))
(lam20 zero20))
fact20 : ∀{Γ} → Tm20 Γ (arr20 nat20 nat20); fact20
= lam20 (rec20 v020 (lam20 (lam20 (app20 (app20 mul20 (suc20 v120)) v020)))
(suc20 zero20))
{-# OPTIONS --type-in-type #-}
Ty21 : Set
Ty21 =
(Ty21 : Set)
(nat top bot : Ty21)
(arr prod sum : Ty21 → Ty21 → Ty21)
→ Ty21
nat21 : Ty21; nat21 = λ _ nat21 _ _ _ _ _ → nat21
top21 : Ty21; top21 = λ _ _ top21 _ _ _ _ → top21
bot21 : Ty21; bot21 = λ _ _ _ bot21 _ _ _ → bot21
arr21 : Ty21 → Ty21 → Ty21; arr21
= λ A B Ty21 nat21 top21 bot21 arr21 prod sum →
arr21 (A Ty21 nat21 top21 bot21 arr21 prod sum) (B Ty21 nat21 top21 bot21 arr21 prod sum)
prod21 : Ty21 → Ty21 → Ty21; prod21
= λ A B Ty21 nat21 top21 bot21 arr21 prod21 sum →
prod21 (A Ty21 nat21 top21 bot21 arr21 prod21 sum) (B Ty21 nat21 top21 bot21 arr21 prod21 sum)
sum21 : Ty21 → Ty21 → Ty21; sum21
= λ A B Ty21 nat21 top21 bot21 arr21 prod21 sum21 →
sum21 (A Ty21 nat21 top21 bot21 arr21 prod21 sum21) (B Ty21 nat21 top21 bot21 arr21 prod21 sum21)
Con21 : Set; Con21
= (Con21 : Set)
(nil : Con21)
(snoc : Con21 → Ty21 → Con21)
→ Con21
nil21 : Con21; nil21
= λ Con21 nil21 snoc → nil21
snoc21 : Con21 → Ty21 → Con21; snoc21
= λ Γ A Con21 nil21 snoc21 → snoc21 (Γ Con21 nil21 snoc21) A
Var21 : Con21 → Ty21 → Set; Var21
= λ Γ A →
(Var21 : Con21 → Ty21 → Set)
(vz : ∀ Γ A → Var21 (snoc21 Γ A) A)
(vs : ∀ Γ B A → Var21 Γ A → Var21 (snoc21 Γ B) A)
→ Var21 Γ A
vz21 : ∀{Γ A} → Var21 (snoc21 Γ A) A; vz21
= λ Var21 vz21 vs → vz21 _ _
vs21 : ∀{Γ B A} → Var21 Γ A → Var21 (snoc21 Γ B) A; vs21
= λ x Var21 vz21 vs21 → vs21 _ _ _ (x Var21 vz21 vs21)
Tm21 : Con21 → Ty21 → Set; Tm21
= λ Γ A →
(Tm21 : Con21 → Ty21 → Set)
(var : ∀ Γ A → Var21 Γ A → Tm21 Γ A)
(lam : ∀ Γ A B → Tm21 (snoc21 Γ A) B → Tm21 Γ (arr21 A B))
(app : ∀ Γ A B → Tm21 Γ (arr21 A B) → Tm21 Γ A → Tm21 Γ B)
(tt : ∀ Γ → Tm21 Γ top21)
(pair : ∀ Γ A B → Tm21 Γ A → Tm21 Γ B → Tm21 Γ (prod21 A B))
(fst : ∀ Γ A B → Tm21 Γ (prod21 A B) → Tm21 Γ A)
(snd : ∀ Γ A B → Tm21 Γ (prod21 A B) → Tm21 Γ B)
(left : ∀ Γ A B → Tm21 Γ A → Tm21 Γ (sum21 A B))
(right : ∀ Γ A B → Tm21 Γ B → Tm21 Γ (sum21 A B))
(case : ∀ Γ A B C → Tm21 Γ (sum21 A B) → Tm21 Γ (arr21 A C) → Tm21 Γ (arr21 B C) → Tm21 Γ C)
(zero : ∀ Γ → Tm21 Γ nat21)
(suc : ∀ Γ → Tm21 Γ nat21 → Tm21 Γ nat21)
(rec : ∀ Γ A → Tm21 Γ nat21 → Tm21 Γ (arr21 nat21 (arr21 A A)) → Tm21 Γ A → Tm21 Γ A)
→ Tm21 Γ A
var21 : ∀{Γ A} → Var21 Γ A → Tm21 Γ A; var21
= λ x Tm21 var21 lam app tt pair fst snd left right case zero suc rec →
var21 _ _ x
lam21 : ∀{Γ A B} → Tm21 (snoc21 Γ A) B → Tm21 Γ (arr21 A B); lam21
= λ t Tm21 var21 lam21 app tt pair fst snd left right case zero suc rec →
lam21 _ _ _ (t Tm21 var21 lam21 app tt pair fst snd left right case zero suc rec)
app21 : ∀{Γ A B} → Tm21 Γ (arr21 A B) → Tm21 Γ A → Tm21 Γ B; app21
= λ t u Tm21 var21 lam21 app21 tt pair fst snd left right case zero suc rec →
app21 _ _ _ (t Tm21 var21 lam21 app21 tt pair fst snd left right case zero suc rec)
(u Tm21 var21 lam21 app21 tt pair fst snd left right case zero suc rec)
tt21 : ∀{Γ} → Tm21 Γ top21; tt21
= λ Tm21 var21 lam21 app21 tt21 pair fst snd left right case zero suc rec → tt21 _
pair21 : ∀{Γ A B} → Tm21 Γ A → Tm21 Γ B → Tm21 Γ (prod21 A B); pair21
= λ t u Tm21 var21 lam21 app21 tt21 pair21 fst snd left right case zero suc rec →
pair21 _ _ _ (t Tm21 var21 lam21 app21 tt21 pair21 fst snd left right case zero suc rec)
(u Tm21 var21 lam21 app21 tt21 pair21 fst snd left right case zero suc rec)
fst21 : ∀{Γ A B} → Tm21 Γ (prod21 A B) → Tm21 Γ A; fst21
= λ t Tm21 var21 lam21 app21 tt21 pair21 fst21 snd left right case zero suc rec →
fst21 _ _ _ (t Tm21 var21 lam21 app21 tt21 pair21 fst21 snd left right case zero suc rec)
snd21 : ∀{Γ A B} → Tm21 Γ (prod21 A B) → Tm21 Γ B; snd21
= λ t Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left right case zero suc rec →
snd21 _ _ _ (t Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left right case zero suc rec)
left21 : ∀{Γ A B} → Tm21 Γ A → Tm21 Γ (sum21 A B); left21
= λ t Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right case zero suc rec →
left21 _ _ _ (t Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right case zero suc rec)
right21 : ∀{Γ A B} → Tm21 Γ B → Tm21 Γ (sum21 A B); right21
= λ t Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right21 case zero suc rec →
right21 _ _ _ (t Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right21 case zero suc rec)
case21 : ∀{Γ A B C} → Tm21 Γ (sum21 A B) → Tm21 Γ (arr21 A C) → Tm21 Γ (arr21 B C) → Tm21 Γ C; case21
= λ t u v Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right21 case21 zero suc rec →
case21 _ _ _ _
(t Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right21 case21 zero suc rec)
(u Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right21 case21 zero suc rec)
(v Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right21 case21 zero suc rec)
zero21 : ∀{Γ} → Tm21 Γ nat21; zero21
= λ Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right21 case21 zero21 suc rec → zero21 _
suc21 : ∀{Γ} → Tm21 Γ nat21 → Tm21 Γ nat21; suc21
= λ t Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right21 case21 zero21 suc21 rec →
suc21 _ (t Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right21 case21 zero21 suc21 rec)
rec21 : ∀{Γ A} → Tm21 Γ nat21 → Tm21 Γ (arr21 nat21 (arr21 A A)) → Tm21 Γ A → Tm21 Γ A; rec21
= λ t u v Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right21 case21 zero21 suc21 rec21 →
rec21 _ _
(t Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right21 case21 zero21 suc21 rec21)
(u Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right21 case21 zero21 suc21 rec21)
(v Tm21 var21 lam21 app21 tt21 pair21 fst21 snd21 left21 right21 case21 zero21 suc21 rec21)
v021 : ∀{Γ A} → Tm21 (snoc21 Γ A) A; v021
= var21 vz21
v121 : ∀{Γ A B} → Tm21 (snoc21 (snoc21 Γ A) B) A; v121
= var21 (vs21 vz21)
v221 : ∀{Γ A B C} → Tm21 (snoc21 (snoc21 (snoc21 Γ A) B) C) A; v221
= var21 (vs21 (vs21 vz21))
v321 : ∀{Γ A B C D} → Tm21 (snoc21 (snoc21 (snoc21 (snoc21 Γ A) B) C) D) A; v321
= var21 (vs21 (vs21 (vs21 vz21)))
tbool21 : Ty21; tbool21
= sum21 top21 top21
true21 : ∀{Γ} → Tm21 Γ tbool21; true21
= left21 tt21
tfalse21 : ∀{Γ} → Tm21 Γ tbool21; tfalse21
= right21 tt21
ifthenelse21 : ∀{Γ A} → Tm21 Γ (arr21 tbool21 (arr21 A (arr21 A A))); ifthenelse21
= lam21 (lam21 (lam21 (case21 v221 (lam21 v221) (lam21 v121))))
times421 : ∀{Γ A} → Tm21 Γ (arr21 (arr21 A A) (arr21 A A)); times421
= lam21 (lam21 (app21 v121 (app21 v121 (app21 v121 (app21 v121 v021)))))
add21 : ∀{Γ} → Tm21 Γ (arr21 nat21 (arr21 nat21 nat21)); add21
= lam21 (rec21 v021
(lam21 (lam21 (lam21 (suc21 (app21 v121 v021)))))
(lam21 v021))
mul21 : ∀{Γ} → Tm21 Γ (arr21 nat21 (arr21 nat21 nat21)); mul21
= lam21 (rec21 v021
(lam21 (lam21 (lam21 (app21 (app21 add21 (app21 v121 v021)) v021))))
(lam21 zero21))
fact21 : ∀{Γ} → Tm21 Γ (arr21 nat21 nat21); fact21
= lam21 (rec21 v021 (lam21 (lam21 (app21 (app21 mul21 (suc21 v121)) v021)))
(suc21 zero21))
{-# OPTIONS --type-in-type #-}
Ty22 : Set
Ty22 =
(Ty22 : Set)
(nat top bot : Ty22)
(arr prod sum : Ty22 → Ty22 → Ty22)
→ Ty22
nat22 : Ty22; nat22 = λ _ nat22 _ _ _ _ _ → nat22
top22 : Ty22; top22 = λ _ _ top22 _ _ _ _ → top22
bot22 : Ty22; bot22 = λ _ _ _ bot22 _ _ _ → bot22
arr22 : Ty22 → Ty22 → Ty22; arr22
= λ A B Ty22 nat22 top22 bot22 arr22 prod sum →
arr22 (A Ty22 nat22 top22 bot22 arr22 prod sum) (B Ty22 nat22 top22 bot22 arr22 prod sum)
prod22 : Ty22 → Ty22 → Ty22; prod22
= λ A B Ty22 nat22 top22 bot22 arr22 prod22 sum →
prod22 (A Ty22 nat22 top22 bot22 arr22 prod22 sum) (B Ty22 nat22 top22 bot22 arr22 prod22 sum)
sum22 : Ty22 → Ty22 → Ty22; sum22
= λ A B Ty22 nat22 top22 bot22 arr22 prod22 sum22 →
sum22 (A Ty22 nat22 top22 bot22 arr22 prod22 sum22) (B Ty22 nat22 top22 bot22 arr22 prod22 sum22)
Con22 : Set; Con22
= (Con22 : Set)
(nil : Con22)
(snoc : Con22 → Ty22 → Con22)
→ Con22
nil22 : Con22; nil22
= λ Con22 nil22 snoc → nil22
snoc22 : Con22 → Ty22 → Con22; snoc22
= λ Γ A Con22 nil22 snoc22 → snoc22 (Γ Con22 nil22 snoc22) A
Var22 : Con22 → Ty22 → Set; Var22
= λ Γ A →
(Var22 : Con22 → Ty22 → Set)
(vz : ∀ Γ A → Var22 (snoc22 Γ A) A)
(vs : ∀ Γ B A → Var22 Γ A → Var22 (snoc22 Γ B) A)
→ Var22 Γ A
vz22 : ∀{Γ A} → Var22 (snoc22 Γ A) A; vz22
= λ Var22 vz22 vs → vz22 _ _
vs22 : ∀{Γ B A} → Var22 Γ A → Var22 (snoc22 Γ B) A; vs22
= λ x Var22 vz22 vs22 → vs22 _ _ _ (x Var22 vz22 vs22)
Tm22 : Con22 → Ty22 → Set; Tm22
= λ Γ A →
(Tm22 : Con22 → Ty22 → Set)
(var : ∀ Γ A → Var22 Γ A → Tm22 Γ A)
(lam : ∀ Γ A B → Tm22 (snoc22 Γ A) B → Tm22 Γ (arr22 A B))
(app : ∀ Γ A B → Tm22 Γ (arr22 A B) → Tm22 Γ A → Tm22 Γ B)
(tt : ∀ Γ → Tm22 Γ top22)
(pair : ∀ Γ A B → Tm22 Γ A → Tm22 Γ B → Tm22 Γ (prod22 A B))
(fst : ∀ Γ A B → Tm22 Γ (prod22 A B) → Tm22 Γ A)
(snd : ∀ Γ A B → Tm22 Γ (prod22 A B) → Tm22 Γ B)
(left : ∀ Γ A B → Tm22 Γ A → Tm22 Γ (sum22 A B))
(right : ∀ Γ A B → Tm22 Γ B → Tm22 Γ (sum22 A B))
(case : ∀ Γ A B C → Tm22 Γ (sum22 A B) → Tm22 Γ (arr22 A C) → Tm22 Γ (arr22 B C) → Tm22 Γ C)
(zero : ∀ Γ → Tm22 Γ nat22)
(suc : ∀ Γ → Tm22 Γ nat22 → Tm22 Γ nat22)
(rec : ∀ Γ A → Tm22 Γ nat22 → Tm22 Γ (arr22 nat22 (arr22 A A)) → Tm22 Γ A → Tm22 Γ A)
→ Tm22 Γ A
var22 : ∀{Γ A} → Var22 Γ A → Tm22 Γ A; var22
= λ x Tm22 var22 lam app tt pair fst snd left right case zero suc rec →
var22 _ _ x
lam22 : ∀{Γ A B} → Tm22 (snoc22 Γ A) B → Tm22 Γ (arr22 A B); lam22
= λ t Tm22 var22 lam22 app tt pair fst snd left right case zero suc rec →
lam22 _ _ _ (t Tm22 var22 lam22 app tt pair fst snd left right case zero suc rec)
app22 : ∀{Γ A B} → Tm22 Γ (arr22 A B) → Tm22 Γ A → Tm22 Γ B; app22
= λ t u Tm22 var22 lam22 app22 tt pair fst snd left right case zero suc rec →
app22 _ _ _ (t Tm22 var22 lam22 app22 tt pair fst snd left right case zero suc rec)
(u Tm22 var22 lam22 app22 tt pair fst snd left right case zero suc rec)
tt22 : ∀{Γ} → Tm22 Γ top22; tt22
= λ Tm22 var22 lam22 app22 tt22 pair fst snd left right case zero suc rec → tt22 _
pair22 : ∀{Γ A B} → Tm22 Γ A → Tm22 Γ B → Tm22 Γ (prod22 A B); pair22
= λ t u Tm22 var22 lam22 app22 tt22 pair22 fst snd left right case zero suc rec →
pair22 _ _ _ (t Tm22 var22 lam22 app22 tt22 pair22 fst snd left right case zero suc rec)
(u Tm22 var22 lam22 app22 tt22 pair22 fst snd left right case zero suc rec)
fst22 : ∀{Γ A B} → Tm22 Γ (prod22 A B) → Tm22 Γ A; fst22
= λ t Tm22 var22 lam22 app22 tt22 pair22 fst22 snd left right case zero suc rec →
fst22 _ _ _ (t Tm22 var22 lam22 app22 tt22 pair22 fst22 snd left right case zero suc rec)
snd22 : ∀{Γ A B} → Tm22 Γ (prod22 A B) → Tm22 Γ B; snd22
= λ t Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left right case zero suc rec →
snd22 _ _ _ (t Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left right case zero suc rec)
left22 : ∀{Γ A B} → Tm22 Γ A → Tm22 Γ (sum22 A B); left22
= λ t Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right case zero suc rec →
left22 _ _ _ (t Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right case zero suc rec)
right22 : ∀{Γ A B} → Tm22 Γ B → Tm22 Γ (sum22 A B); right22
= λ t Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right22 case zero suc rec →
right22 _ _ _ (t Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right22 case zero suc rec)
case22 : ∀{Γ A B C} → Tm22 Γ (sum22 A B) → Tm22 Γ (arr22 A C) → Tm22 Γ (arr22 B C) → Tm22 Γ C; case22
= λ t u v Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right22 case22 zero suc rec →
case22 _ _ _ _
(t Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right22 case22 zero suc rec)
(u Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right22 case22 zero suc rec)
(v Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right22 case22 zero suc rec)
zero22 : ∀{Γ} → Tm22 Γ nat22; zero22
= λ Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right22 case22 zero22 suc rec → zero22 _
suc22 : ∀{Γ} → Tm22 Γ nat22 → Tm22 Γ nat22; suc22
= λ t Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right22 case22 zero22 suc22 rec →
suc22 _ (t Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right22 case22 zero22 suc22 rec)
rec22 : ∀{Γ A} → Tm22 Γ nat22 → Tm22 Γ (arr22 nat22 (arr22 A A)) → Tm22 Γ A → Tm22 Γ A; rec22
= λ t u v Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right22 case22 zero22 suc22 rec22 →
rec22 _ _
(t Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right22 case22 zero22 suc22 rec22)
(u Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right22 case22 zero22 suc22 rec22)
(v Tm22 var22 lam22 app22 tt22 pair22 fst22 snd22 left22 right22 case22 zero22 suc22 rec22)
v022 : ∀{Γ A} → Tm22 (snoc22 Γ A) A; v022
= var22 vz22
v122 : ∀{Γ A B} → Tm22 (snoc22 (snoc22 Γ A) B) A; v122
= var22 (vs22 vz22)
v222 : ∀{Γ A B C} → Tm22 (snoc22 (snoc22 (snoc22 Γ A) B) C) A; v222
= var22 (vs22 (vs22 vz22))
v322 : ∀{Γ A B C D} → Tm22 (snoc22 (snoc22 (snoc22 (snoc22 Γ A) B) C) D) A; v322
= var22 (vs22 (vs22 (vs22 vz22)))
tbool22 : Ty22; tbool22
= sum22 top22 top22
true22 : ∀{Γ} → Tm22 Γ tbool22; true22
= left22 tt22
tfalse22 : ∀{Γ} → Tm22 Γ tbool22; tfalse22
= right22 tt22
ifthenelse22 : ∀{Γ A} → Tm22 Γ (arr22 tbool22 (arr22 A (arr22 A A))); ifthenelse22
= lam22 (lam22 (lam22 (case22 v222 (lam22 v222) (lam22 v122))))
times422 : ∀{Γ A} → Tm22 Γ (arr22 (arr22 A A) (arr22 A A)); times422
= lam22 (lam22 (app22 v122 (app22 v122 (app22 v122 (app22 v122 v022)))))
add22 : ∀{Γ} → Tm22 Γ (arr22 nat22 (arr22 nat22 nat22)); add22
= lam22 (rec22 v022
(lam22 (lam22 (lam22 (suc22 (app22 v122 v022)))))
(lam22 v022))
mul22 : ∀{Γ} → Tm22 Γ (arr22 nat22 (arr22 nat22 nat22)); mul22
= lam22 (rec22 v022
(lam22 (lam22 (lam22 (app22 (app22 add22 (app22 v122 v022)) v022))))
(lam22 zero22))
fact22 : ∀{Γ} → Tm22 Γ (arr22 nat22 nat22); fact22
= lam22 (rec22 v022 (lam22 (lam22 (app22 (app22 mul22 (suc22 v122)) v022)))
(suc22 zero22))
{-# OPTIONS --type-in-type #-}
Ty23 : Set
Ty23 =
(Ty23 : Set)
(nat top bot : Ty23)
(arr prod sum : Ty23 → Ty23 → Ty23)
→ Ty23
nat23 : Ty23; nat23 = λ _ nat23 _ _ _ _ _ → nat23
top23 : Ty23; top23 = λ _ _ top23 _ _ _ _ → top23
bot23 : Ty23; bot23 = λ _ _ _ bot23 _ _ _ → bot23
arr23 : Ty23 → Ty23 → Ty23; arr23
= λ A B Ty23 nat23 top23 bot23 arr23 prod sum →
arr23 (A Ty23 nat23 top23 bot23 arr23 prod sum) (B Ty23 nat23 top23 bot23 arr23 prod sum)
prod23 : Ty23 → Ty23 → Ty23; prod23
= λ A B Ty23 nat23 top23 bot23 arr23 prod23 sum →
prod23 (A Ty23 nat23 top23 bot23 arr23 prod23 sum) (B Ty23 nat23 top23 bot23 arr23 prod23 sum)
sum23 : Ty23 → Ty23 → Ty23; sum23
= λ A B Ty23 nat23 top23 bot23 arr23 prod23 sum23 →
sum23 (A Ty23 nat23 top23 bot23 arr23 prod23 sum23) (B Ty23 nat23 top23 bot23 arr23 prod23 sum23)
Con23 : Set; Con23
= (Con23 : Set)
(nil : Con23)
(snoc : Con23 → Ty23 → Con23)
→ Con23
nil23 : Con23; nil23
= λ Con23 nil23 snoc → nil23
snoc23 : Con23 → Ty23 → Con23; snoc23
= λ Γ A Con23 nil23 snoc23 → snoc23 (Γ Con23 nil23 snoc23) A
Var23 : Con23 → Ty23 → Set; Var23
= λ Γ A →
(Var23 : Con23 → Ty23 → Set)
(vz : ∀ Γ A → Var23 (snoc23 Γ A) A)
(vs : ∀ Γ B A → Var23 Γ A → Var23 (snoc23 Γ B) A)
→ Var23 Γ A
vz23 : ∀{Γ A} → Var23 (snoc23 Γ A) A; vz23
= λ Var23 vz23 vs → vz23 _ _
vs23 : ∀{Γ B A} → Var23 Γ A → Var23 (snoc23 Γ B) A; vs23
= λ x Var23 vz23 vs23 → vs23 _ _ _ (x Var23 vz23 vs23)
Tm23 : Con23 → Ty23 → Set; Tm23
= λ Γ A →
(Tm23 : Con23 → Ty23 → Set)
(var : ∀ Γ A → Var23 Γ A → Tm23 Γ A)
(lam : ∀ Γ A B → Tm23 (snoc23 Γ A) B → Tm23 Γ (arr23 A B))
(app : ∀ Γ A B → Tm23 Γ (arr23 A B) → Tm23 Γ A → Tm23 Γ B)
(tt : ∀ Γ → Tm23 Γ top23)
(pair : ∀ Γ A B → Tm23 Γ A → Tm23 Γ B → Tm23 Γ (prod23 A B))
(fst : ∀ Γ A B → Tm23 Γ (prod23 A B) → Tm23 Γ A)
(snd : ∀ Γ A B → Tm23 Γ (prod23 A B) → Tm23 Γ B)
(left : ∀ Γ A B → Tm23 Γ A → Tm23 Γ (sum23 A B))
(right : ∀ Γ A B → Tm23 Γ B → Tm23 Γ (sum23 A B))
(case : ∀ Γ A B C → Tm23 Γ (sum23 A B) → Tm23 Γ (arr23 A C) → Tm23 Γ (arr23 B C) → Tm23 Γ C)
(zero : ∀ Γ → Tm23 Γ nat23)
(suc : ∀ Γ → Tm23 Γ nat23 → Tm23 Γ nat23)
(rec : ∀ Γ A → Tm23 Γ nat23 → Tm23 Γ (arr23 nat23 (arr23 A A)) → Tm23 Γ A → Tm23 Γ A)
→ Tm23 Γ A
var23 : ∀{Γ A} → Var23 Γ A → Tm23 Γ A; var23
= λ x Tm23 var23 lam app tt pair fst snd left right case zero suc rec →
var23 _ _ x
lam23 : ∀{Γ A B} → Tm23 (snoc23 Γ A) B → Tm23 Γ (arr23 A B); lam23
= λ t Tm23 var23 lam23 app tt pair fst snd left right case zero suc rec →
lam23 _ _ _ (t Tm23 var23 lam23 app tt pair fst snd left right case zero suc rec)
app23 : ∀{Γ A B} → Tm23 Γ (arr23 A B) → Tm23 Γ A → Tm23 Γ B; app23
= λ t u Tm23 var23 lam23 app23 tt pair fst snd left right case zero suc rec →
app23 _ _ _ (t Tm23 var23 lam23 app23 tt pair fst snd left right case zero suc rec)
(u Tm23 var23 lam23 app23 tt pair fst snd left right case zero suc rec)
tt23 : ∀{Γ} → Tm23 Γ top23; tt23
= λ Tm23 var23 lam23 app23 tt23 pair fst snd left right case zero suc rec → tt23 _
pair23 : ∀{Γ A B} → Tm23 Γ A → Tm23 Γ B → Tm23 Γ (prod23 A B); pair23
= λ t u Tm23 var23 lam23 app23 tt23 pair23 fst snd left right case zero suc rec →
pair23 _ _ _ (t Tm23 var23 lam23 app23 tt23 pair23 fst snd left right case zero suc rec)
(u Tm23 var23 lam23 app23 tt23 pair23 fst snd left right case zero suc rec)
fst23 : ∀{Γ A B} → Tm23 Γ (prod23 A B) → Tm23 Γ A; fst23
= λ t Tm23 var23 lam23 app23 tt23 pair23 fst23 snd left right case zero suc rec →
fst23 _ _ _ (t Tm23 var23 lam23 app23 tt23 pair23 fst23 snd left right case zero suc rec)
snd23 : ∀{Γ A B} → Tm23 Γ (prod23 A B) → Tm23 Γ B; snd23
= λ t Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left right case zero suc rec →
snd23 _ _ _ (t Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left right case zero suc rec)
left23 : ∀{Γ A B} → Tm23 Γ A → Tm23 Γ (sum23 A B); left23
= λ t Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right case zero suc rec →
left23 _ _ _ (t Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right case zero suc rec)
right23 : ∀{Γ A B} → Tm23 Γ B → Tm23 Γ (sum23 A B); right23
= λ t Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right23 case zero suc rec →
right23 _ _ _ (t Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right23 case zero suc rec)
case23 : ∀{Γ A B C} → Tm23 Γ (sum23 A B) → Tm23 Γ (arr23 A C) → Tm23 Γ (arr23 B C) → Tm23 Γ C; case23
= λ t u v Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right23 case23 zero suc rec →
case23 _ _ _ _
(t Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right23 case23 zero suc rec)
(u Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right23 case23 zero suc rec)
(v Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right23 case23 zero suc rec)
zero23 : ∀{Γ} → Tm23 Γ nat23; zero23
= λ Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right23 case23 zero23 suc rec → zero23 _
suc23 : ∀{Γ} → Tm23 Γ nat23 → Tm23 Γ nat23; suc23
= λ t Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right23 case23 zero23 suc23 rec →
suc23 _ (t Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right23 case23 zero23 suc23 rec)
rec23 : ∀{Γ A} → Tm23 Γ nat23 → Tm23 Γ (arr23 nat23 (arr23 A A)) → Tm23 Γ A → Tm23 Γ A; rec23
= λ t u v Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right23 case23 zero23 suc23 rec23 →
rec23 _ _
(t Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right23 case23 zero23 suc23 rec23)
(u Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right23 case23 zero23 suc23 rec23)
(v Tm23 var23 lam23 app23 tt23 pair23 fst23 snd23 left23 right23 case23 zero23 suc23 rec23)
v023 : ∀{Γ A} → Tm23 (snoc23 Γ A) A; v023
= var23 vz23
v123 : ∀{Γ A B} → Tm23 (snoc23 (snoc23 Γ A) B) A; v123
= var23 (vs23 vz23)
v223 : ∀{Γ A B C} → Tm23 (snoc23 (snoc23 (snoc23 Γ A) B) C) A; v223
= var23 (vs23 (vs23 vz23))
v323 : ∀{Γ A B C D} → Tm23 (snoc23 (snoc23 (snoc23 (snoc23 Γ A) B) C) D) A; v323
= var23 (vs23 (vs23 (vs23 vz23)))
tbool23 : Ty23; tbool23
= sum23 top23 top23
true23 : ∀{Γ} → Tm23 Γ tbool23; true23
= left23 tt23
tfalse23 : ∀{Γ} → Tm23 Γ tbool23; tfalse23
= right23 tt23
ifthenelse23 : ∀{Γ A} → Tm23 Γ (arr23 tbool23 (arr23 A (arr23 A A))); ifthenelse23
= lam23 (lam23 (lam23 (case23 v223 (lam23 v223) (lam23 v123))))
times423 : ∀{Γ A} → Tm23 Γ (arr23 (arr23 A A) (arr23 A A)); times423
= lam23 (lam23 (app23 v123 (app23 v123 (app23 v123 (app23 v123 v023)))))
add23 : ∀{Γ} → Tm23 Γ (arr23 nat23 (arr23 nat23 nat23)); add23
= lam23 (rec23 v023
(lam23 (lam23 (lam23 (suc23 (app23 v123 v023)))))
(lam23 v023))
mul23 : ∀{Γ} → Tm23 Γ (arr23 nat23 (arr23 nat23 nat23)); mul23
= lam23 (rec23 v023
(lam23 (lam23 (lam23 (app23 (app23 add23 (app23 v123 v023)) v023))))
(lam23 zero23))
fact23 : ∀{Γ} → Tm23 Γ (arr23 nat23 nat23); fact23
= lam23 (rec23 v023 (lam23 (lam23 (app23 (app23 mul23 (suc23 v123)) v023)))
(suc23 zero23))
{-# OPTIONS --type-in-type #-}
Ty24 : Set
Ty24 =
(Ty24 : Set)
(nat top bot : Ty24)
(arr prod sum : Ty24 → Ty24 → Ty24)
→ Ty24
nat24 : Ty24; nat24 = λ _ nat24 _ _ _ _ _ → nat24
top24 : Ty24; top24 = λ _ _ top24 _ _ _ _ → top24
bot24 : Ty24; bot24 = λ _ _ _ bot24 _ _ _ → bot24
arr24 : Ty24 → Ty24 → Ty24; arr24
= λ A B Ty24 nat24 top24 bot24 arr24 prod sum →
arr24 (A Ty24 nat24 top24 bot24 arr24 prod sum) (B Ty24 nat24 top24 bot24 arr24 prod sum)
prod24 : Ty24 → Ty24 → Ty24; prod24
= λ A B Ty24 nat24 top24 bot24 arr24 prod24 sum →
prod24 (A Ty24 nat24 top24 bot24 arr24 prod24 sum) (B Ty24 nat24 top24 bot24 arr24 prod24 sum)
sum24 : Ty24 → Ty24 → Ty24; sum24
= λ A B Ty24 nat24 top24 bot24 arr24 prod24 sum24 →
sum24 (A Ty24 nat24 top24 bot24 arr24 prod24 sum24) (B Ty24 nat24 top24 bot24 arr24 prod24 sum24)
Con24 : Set; Con24
= (Con24 : Set)
(nil : Con24)
(snoc : Con24 → Ty24 → Con24)
→ Con24
nil24 : Con24; nil24
= λ Con24 nil24 snoc → nil24
snoc24 : Con24 → Ty24 → Con24; snoc24
= λ Γ A Con24 nil24 snoc24 → snoc24 (Γ Con24 nil24 snoc24) A
Var24 : Con24 → Ty24 → Set; Var24
= λ Γ A →
(Var24 : Con24 → Ty24 → Set)
(vz : ∀ Γ A → Var24 (snoc24 Γ A) A)
(vs : ∀ Γ B A → Var24 Γ A → Var24 (snoc24 Γ B) A)
→ Var24 Γ A
vz24 : ∀{Γ A} → Var24 (snoc24 Γ A) A; vz24
= λ Var24 vz24 vs → vz24 _ _
vs24 : ∀{Γ B A} → Var24 Γ A → Var24 (snoc24 Γ B) A; vs24
= λ x Var24 vz24 vs24 → vs24 _ _ _ (x Var24 vz24 vs24)
Tm24 : Con24 → Ty24 → Set; Tm24
= λ Γ A →
(Tm24 : Con24 → Ty24 → Set)
(var : ∀ Γ A → Var24 Γ A → Tm24 Γ A)
(lam : ∀ Γ A B → Tm24 (snoc24 Γ A) B → Tm24 Γ (arr24 A B))
(app : ∀ Γ A B → Tm24 Γ (arr24 A B) → Tm24 Γ A → Tm24 Γ B)
(tt : ∀ Γ → Tm24 Γ top24)
(pair : ∀ Γ A B → Tm24 Γ A → Tm24 Γ B → Tm24 Γ (prod24 A B))
(fst : ∀ Γ A B → Tm24 Γ (prod24 A B) → Tm24 Γ A)
(snd : ∀ Γ A B → Tm24 Γ (prod24 A B) → Tm24 Γ B)
(left : ∀ Γ A B → Tm24 Γ A → Tm24 Γ (sum24 A B))
(right : ∀ Γ A B → Tm24 Γ B → Tm24 Γ (sum24 A B))
(case : ∀ Γ A B C → Tm24 Γ (sum24 A B) → Tm24 Γ (arr24 A C) → Tm24 Γ (arr24 B C) → Tm24 Γ C)
(zero : ∀ Γ → Tm24 Γ nat24)
(suc : ∀ Γ → Tm24 Γ nat24 → Tm24 Γ nat24)
(rec : ∀ Γ A → Tm24 Γ nat24 → Tm24 Γ (arr24 nat24 (arr24 A A)) → Tm24 Γ A → Tm24 Γ A)
→ Tm24 Γ A
var24 : ∀{Γ A} → Var24 Γ A → Tm24 Γ A; var24
= λ x Tm24 var24 lam app tt pair fst snd left right case zero suc rec →
var24 _ _ x
lam24 : ∀{Γ A B} → Tm24 (snoc24 Γ A) B → Tm24 Γ (arr24 A B); lam24
= λ t Tm24 var24 lam24 app tt pair fst snd left right case zero suc rec →
lam24 _ _ _ (t Tm24 var24 lam24 app tt pair fst snd left right case zero suc rec)
app24 : ∀{Γ A B} → Tm24 Γ (arr24 A B) → Tm24 Γ A → Tm24 Γ B; app24
= λ t u Tm24 var24 lam24 app24 tt pair fst snd left right case zero suc rec →
app24 _ _ _ (t Tm24 var24 lam24 app24 tt pair fst snd left right case zero suc rec)
(u Tm24 var24 lam24 app24 tt pair fst snd left right case zero suc rec)
tt24 : ∀{Γ} → Tm24 Γ top24; tt24
= λ Tm24 var24 lam24 app24 tt24 pair fst snd left right case zero suc rec → tt24 _
pair24 : ∀{Γ A B} → Tm24 Γ A → Tm24 Γ B → Tm24 Γ (prod24 A B); pair24
= λ t u Tm24 var24 lam24 app24 tt24 pair24 fst snd left right case zero suc rec →
pair24 _ _ _ (t Tm24 var24 lam24 app24 tt24 pair24 fst snd left right case zero suc rec)
(u Tm24 var24 lam24 app24 tt24 pair24 fst snd left right case zero suc rec)
fst24 : ∀{Γ A B} → Tm24 Γ (prod24 A B) → Tm24 Γ A; fst24
= λ t Tm24 var24 lam24 app24 tt24 pair24 fst24 snd left right case zero suc rec →
fst24 _ _ _ (t Tm24 var24 lam24 app24 tt24 pair24 fst24 snd left right case zero suc rec)
snd24 : ∀{Γ A B} → Tm24 Γ (prod24 A B) → Tm24 Γ B; snd24
= λ t Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left right case zero suc rec →
snd24 _ _ _ (t Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left right case zero suc rec)
left24 : ∀{Γ A B} → Tm24 Γ A → Tm24 Γ (sum24 A B); left24
= λ t Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right case zero suc rec →
left24 _ _ _ (t Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right case zero suc rec)
right24 : ∀{Γ A B} → Tm24 Γ B → Tm24 Γ (sum24 A B); right24
= λ t Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right24 case zero suc rec →
right24 _ _ _ (t Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right24 case zero suc rec)
case24 : ∀{Γ A B C} → Tm24 Γ (sum24 A B) → Tm24 Γ (arr24 A C) → Tm24 Γ (arr24 B C) → Tm24 Γ C; case24
= λ t u v Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right24 case24 zero suc rec →
case24 _ _ _ _
(t Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right24 case24 zero suc rec)
(u Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right24 case24 zero suc rec)
(v Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right24 case24 zero suc rec)
zero24 : ∀{Γ} → Tm24 Γ nat24; zero24
= λ Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right24 case24 zero24 suc rec → zero24 _
suc24 : ∀{Γ} → Tm24 Γ nat24 → Tm24 Γ nat24; suc24
= λ t Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right24 case24 zero24 suc24 rec →
suc24 _ (t Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right24 case24 zero24 suc24 rec)
rec24 : ∀{Γ A} → Tm24 Γ nat24 → Tm24 Γ (arr24 nat24 (arr24 A A)) → Tm24 Γ A → Tm24 Γ A; rec24
= λ t u v Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right24 case24 zero24 suc24 rec24 →
rec24 _ _
(t Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right24 case24 zero24 suc24 rec24)
(u Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right24 case24 zero24 suc24 rec24)
(v Tm24 var24 lam24 app24 tt24 pair24 fst24 snd24 left24 right24 case24 zero24 suc24 rec24)
v024 : ∀{Γ A} → Tm24 (snoc24 Γ A) A; v024
= var24 vz24
v124 : ∀{Γ A B} → Tm24 (snoc24 (snoc24 Γ A) B) A; v124
= var24 (vs24 vz24)
v224 : ∀{Γ A B C} → Tm24 (snoc24 (snoc24 (snoc24 Γ A) B) C) A; v224
= var24 (vs24 (vs24 vz24))
v324 : ∀{Γ A B C D} → Tm24 (snoc24 (snoc24 (snoc24 (snoc24 Γ A) B) C) D) A; v324
= var24 (vs24 (vs24 (vs24 vz24)))
tbool24 : Ty24; tbool24
= sum24 top24 top24
true24 : ∀{Γ} → Tm24 Γ tbool24; true24
= left24 tt24
tfalse24 : ∀{Γ} → Tm24 Γ tbool24; tfalse24
= right24 tt24
ifthenelse24 : ∀{Γ A} → Tm24 Γ (arr24 tbool24 (arr24 A (arr24 A A))); ifthenelse24
= lam24 (lam24 (lam24 (case24 v224 (lam24 v224) (lam24 v124))))
times424 : ∀{Γ A} → Tm24 Γ (arr24 (arr24 A A) (arr24 A A)); times424
= lam24 (lam24 (app24 v124 (app24 v124 (app24 v124 (app24 v124 v024)))))
add24 : ∀{Γ} → Tm24 Γ (arr24 nat24 (arr24 nat24 nat24)); add24
= lam24 (rec24 v024
(lam24 (lam24 (lam24 (suc24 (app24 v124 v024)))))
(lam24 v024))
mul24 : ∀{Γ} → Tm24 Γ (arr24 nat24 (arr24 nat24 nat24)); mul24
= lam24 (rec24 v024
(lam24 (lam24 (lam24 (app24 (app24 add24 (app24 v124 v024)) v024))))
(lam24 zero24))
fact24 : ∀{Γ} → Tm24 Γ (arr24 nat24 nat24); fact24
= lam24 (rec24 v024 (lam24 (lam24 (app24 (app24 mul24 (suc24 v124)) v024)))
(suc24 zero24))
{-# OPTIONS --type-in-type #-}
Ty25 : Set
Ty25 =
(Ty25 : Set)
(nat top bot : Ty25)
(arr prod sum : Ty25 → Ty25 → Ty25)
→ Ty25
nat25 : Ty25; nat25 = λ _ nat25 _ _ _ _ _ → nat25
top25 : Ty25; top25 = λ _ _ top25 _ _ _ _ → top25
bot25 : Ty25; bot25 = λ _ _ _ bot25 _ _ _ → bot25
arr25 : Ty25 → Ty25 → Ty25; arr25
= λ A B Ty25 nat25 top25 bot25 arr25 prod sum →
arr25 (A Ty25 nat25 top25 bot25 arr25 prod sum) (B Ty25 nat25 top25 bot25 arr25 prod sum)
prod25 : Ty25 → Ty25 → Ty25; prod25
= λ A B Ty25 nat25 top25 bot25 arr25 prod25 sum →
prod25 (A Ty25 nat25 top25 bot25 arr25 prod25 sum) (B Ty25 nat25 top25 bot25 arr25 prod25 sum)
sum25 : Ty25 → Ty25 → Ty25; sum25
= λ A B Ty25 nat25 top25 bot25 arr25 prod25 sum25 →
sum25 (A Ty25 nat25 top25 bot25 arr25 prod25 sum25) (B Ty25 nat25 top25 bot25 arr25 prod25 sum25)
Con25 : Set; Con25
= (Con25 : Set)
(nil : Con25)
(snoc : Con25 → Ty25 → Con25)
→ Con25
nil25 : Con25; nil25
= λ Con25 nil25 snoc → nil25
snoc25 : Con25 → Ty25 → Con25; snoc25
= λ Γ A Con25 nil25 snoc25 → snoc25 (Γ Con25 nil25 snoc25) A
Var25 : Con25 → Ty25 → Set; Var25
= λ Γ A →
(Var25 : Con25 → Ty25 → Set)
(vz : ∀ Γ A → Var25 (snoc25 Γ A) A)
(vs : ∀ Γ B A → Var25 Γ A → Var25 (snoc25 Γ B) A)
→ Var25 Γ A
vz25 : ∀{Γ A} → Var25 (snoc25 Γ A) A; vz25
= λ Var25 vz25 vs → vz25 _ _
vs25 : ∀{Γ B A} → Var25 Γ A → Var25 (snoc25 Γ B) A; vs25
= λ x Var25 vz25 vs25 → vs25 _ _ _ (x Var25 vz25 vs25)
Tm25 : Con25 → Ty25 → Set; Tm25
= λ Γ A →
(Tm25 : Con25 → Ty25 → Set)
(var : ∀ Γ A → Var25 Γ A → Tm25 Γ A)
(lam : ∀ Γ A B → Tm25 (snoc25 Γ A) B → Tm25 Γ (arr25 A B))
(app : ∀ Γ A B → Tm25 Γ (arr25 A B) → Tm25 Γ A → Tm25 Γ B)
(tt : ∀ Γ → Tm25 Γ top25)
(pair : ∀ Γ A B → Tm25 Γ A → Tm25 Γ B → Tm25 Γ (prod25 A B))
(fst : ∀ Γ A B → Tm25 Γ (prod25 A B) → Tm25 Γ A)
(snd : ∀ Γ A B → Tm25 Γ (prod25 A B) → Tm25 Γ B)
(left : ∀ Γ A B → Tm25 Γ A → Tm25 Γ (sum25 A B))
(right : ∀ Γ A B → Tm25 Γ B → Tm25 Γ (sum25 A B))
(case : ∀ Γ A B C → Tm25 Γ (sum25 A B) → Tm25 Γ (arr25 A C) → Tm25 Γ (arr25 B C) → Tm25 Γ C)
(zero : ∀ Γ → Tm25 Γ nat25)
(suc : ∀ Γ → Tm25 Γ nat25 → Tm25 Γ nat25)
(rec : ∀ Γ A → Tm25 Γ nat25 → Tm25 Γ (arr25 nat25 (arr25 A A)) → Tm25 Γ A → Tm25 Γ A)
→ Tm25 Γ A
var25 : ∀{Γ A} → Var25 Γ A → Tm25 Γ A; var25
= λ x Tm25 var25 lam app tt pair fst snd left right case zero suc rec →
var25 _ _ x
lam25 : ∀{Γ A B} → Tm25 (snoc25 Γ A) B → Tm25 Γ (arr25 A B); lam25
= λ t Tm25 var25 lam25 app tt pair fst snd left right case zero suc rec →
lam25 _ _ _ (t Tm25 var25 lam25 app tt pair fst snd left right case zero suc rec)
app25 : ∀{Γ A B} → Tm25 Γ (arr25 A B) → Tm25 Γ A → Tm25 Γ B; app25
= λ t u Tm25 var25 lam25 app25 tt pair fst snd left right case zero suc rec →
app25 _ _ _ (t Tm25 var25 lam25 app25 tt pair fst snd left right case zero suc rec)
(u Tm25 var25 lam25 app25 tt pair fst snd left right case zero suc rec)
tt25 : ∀{Γ} → Tm25 Γ top25; tt25
= λ Tm25 var25 lam25 app25 tt25 pair fst snd left right case zero suc rec → tt25 _
pair25 : ∀{Γ A B} → Tm25 Γ A → Tm25 Γ B → Tm25 Γ (prod25 A B); pair25
= λ t u Tm25 var25 lam25 app25 tt25 pair25 fst snd left right case zero suc rec →
pair25 _ _ _ (t Tm25 var25 lam25 app25 tt25 pair25 fst snd left right case zero suc rec)
(u Tm25 var25 lam25 app25 tt25 pair25 fst snd left right case zero suc rec)
fst25 : ∀{Γ A B} → Tm25 Γ (prod25 A B) → Tm25 Γ A; fst25
= λ t Tm25 var25 lam25 app25 tt25 pair25 fst25 snd left right case zero suc rec →
fst25 _ _ _ (t Tm25 var25 lam25 app25 tt25 pair25 fst25 snd left right case zero suc rec)
snd25 : ∀{Γ A B} → Tm25 Γ (prod25 A B) → Tm25 Γ B; snd25
= λ t Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left right case zero suc rec →
snd25 _ _ _ (t Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left right case zero suc rec)
left25 : ∀{Γ A B} → Tm25 Γ A → Tm25 Γ (sum25 A B); left25
= λ t Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right case zero suc rec →
left25 _ _ _ (t Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right case zero suc rec)
right25 : ∀{Γ A B} → Tm25 Γ B → Tm25 Γ (sum25 A B); right25
= λ t Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right25 case zero suc rec →
right25 _ _ _ (t Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right25 case zero suc rec)
case25 : ∀{Γ A B C} → Tm25 Γ (sum25 A B) → Tm25 Γ (arr25 A C) → Tm25 Γ (arr25 B C) → Tm25 Γ C; case25
= λ t u v Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right25 case25 zero suc rec →
case25 _ _ _ _
(t Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right25 case25 zero suc rec)
(u Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right25 case25 zero suc rec)
(v Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right25 case25 zero suc rec)
zero25 : ∀{Γ} → Tm25 Γ nat25; zero25
= λ Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right25 case25 zero25 suc rec → zero25 _
suc25 : ∀{Γ} → Tm25 Γ nat25 → Tm25 Γ nat25; suc25
= λ t Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right25 case25 zero25 suc25 rec →
suc25 _ (t Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right25 case25 zero25 suc25 rec)
rec25 : ∀{Γ A} → Tm25 Γ nat25 → Tm25 Γ (arr25 nat25 (arr25 A A)) → Tm25 Γ A → Tm25 Γ A; rec25
= λ t u v Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right25 case25 zero25 suc25 rec25 →
rec25 _ _
(t Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right25 case25 zero25 suc25 rec25)
(u Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right25 case25 zero25 suc25 rec25)
(v Tm25 var25 lam25 app25 tt25 pair25 fst25 snd25 left25 right25 case25 zero25 suc25 rec25)
v025 : ∀{Γ A} → Tm25 (snoc25 Γ A) A; v025
= var25 vz25
v125 : ∀{Γ A B} → Tm25 (snoc25 (snoc25 Γ A) B) A; v125
= var25 (vs25 vz25)
v225 : ∀{Γ A B C} → Tm25 (snoc25 (snoc25 (snoc25 Γ A) B) C) A; v225
= var25 (vs25 (vs25 vz25))
v325 : ∀{Γ A B C D} → Tm25 (snoc25 (snoc25 (snoc25 (snoc25 Γ A) B) C) D) A; v325
= var25 (vs25 (vs25 (vs25 vz25)))
tbool25 : Ty25; tbool25
= sum25 top25 top25
true25 : ∀{Γ} → Tm25 Γ tbool25; true25
= left25 tt25
tfalse25 : ∀{Γ} → Tm25 Γ tbool25; tfalse25
= right25 tt25
ifthenelse25 : ∀{Γ A} → Tm25 Γ (arr25 tbool25 (arr25 A (arr25 A A))); ifthenelse25
= lam25 (lam25 (lam25 (case25 v225 (lam25 v225) (lam25 v125))))
times425 : ∀{Γ A} → Tm25 Γ (arr25 (arr25 A A) (arr25 A A)); times425
= lam25 (lam25 (app25 v125 (app25 v125 (app25 v125 (app25 v125 v025)))))
add25 : ∀{Γ} → Tm25 Γ (arr25 nat25 (arr25 nat25 nat25)); add25
= lam25 (rec25 v025
(lam25 (lam25 (lam25 (suc25 (app25 v125 v025)))))
(lam25 v025))
mul25 : ∀{Γ} → Tm25 Γ (arr25 nat25 (arr25 nat25 nat25)); mul25
= lam25 (rec25 v025
(lam25 (lam25 (lam25 (app25 (app25 add25 (app25 v125 v025)) v025))))
(lam25 zero25))
fact25 : ∀{Γ} → Tm25 Γ (arr25 nat25 nat25); fact25
= lam25 (rec25 v025 (lam25 (lam25 (app25 (app25 mul25 (suc25 v125)) v025)))
(suc25 zero25))
{-# OPTIONS --type-in-type #-}
Ty26 : Set
Ty26 =
(Ty26 : Set)
(nat top bot : Ty26)
(arr prod sum : Ty26 → Ty26 → Ty26)
→ Ty26
nat26 : Ty26; nat26 = λ _ nat26 _ _ _ _ _ → nat26
top26 : Ty26; top26 = λ _ _ top26 _ _ _ _ → top26
bot26 : Ty26; bot26 = λ _ _ _ bot26 _ _ _ → bot26
arr26 : Ty26 → Ty26 → Ty26; arr26
= λ A B Ty26 nat26 top26 bot26 arr26 prod sum →
arr26 (A Ty26 nat26 top26 bot26 arr26 prod sum) (B Ty26 nat26 top26 bot26 arr26 prod sum)
prod26 : Ty26 → Ty26 → Ty26; prod26
= λ A B Ty26 nat26 top26 bot26 arr26 prod26 sum →
prod26 (A Ty26 nat26 top26 bot26 arr26 prod26 sum) (B Ty26 nat26 top26 bot26 arr26 prod26 sum)
sum26 : Ty26 → Ty26 → Ty26; sum26
= λ A B Ty26 nat26 top26 bot26 arr26 prod26 sum26 →
sum26 (A Ty26 nat26 top26 bot26 arr26 prod26 sum26) (B Ty26 nat26 top26 bot26 arr26 prod26 sum26)
Con26 : Set; Con26
= (Con26 : Set)
(nil : Con26)
(snoc : Con26 → Ty26 → Con26)
→ Con26
nil26 : Con26; nil26
= λ Con26 nil26 snoc → nil26
snoc26 : Con26 → Ty26 → Con26; snoc26
= λ Γ A Con26 nil26 snoc26 → snoc26 (Γ Con26 nil26 snoc26) A
Var26 : Con26 → Ty26 → Set; Var26
= λ Γ A →
(Var26 : Con26 → Ty26 → Set)
(vz : ∀ Γ A → Var26 (snoc26 Γ A) A)
(vs : ∀ Γ B A → Var26 Γ A → Var26 (snoc26 Γ B) A)
→ Var26 Γ A
vz26 : ∀{Γ A} → Var26 (snoc26 Γ A) A; vz26
= λ Var26 vz26 vs → vz26 _ _
vs26 : ∀{Γ B A} → Var26 Γ A → Var26 (snoc26 Γ B) A; vs26
= λ x Var26 vz26 vs26 → vs26 _ _ _ (x Var26 vz26 vs26)
Tm26 : Con26 → Ty26 → Set; Tm26
= λ Γ A →
(Tm26 : Con26 → Ty26 → Set)
(var : ∀ Γ A → Var26 Γ A → Tm26 Γ A)
(lam : ∀ Γ A B → Tm26 (snoc26 Γ A) B → Tm26 Γ (arr26 A B))
(app : ∀ Γ A B → Tm26 Γ (arr26 A B) → Tm26 Γ A → Tm26 Γ B)
(tt : ∀ Γ → Tm26 Γ top26)
(pair : ∀ Γ A B → Tm26 Γ A → Tm26 Γ B → Tm26 Γ (prod26 A B))
(fst : ∀ Γ A B → Tm26 Γ (prod26 A B) → Tm26 Γ A)
(snd : ∀ Γ A B → Tm26 Γ (prod26 A B) → Tm26 Γ B)
(left : ∀ Γ A B → Tm26 Γ A → Tm26 Γ (sum26 A B))
(right : ∀ Γ A B → Tm26 Γ B → Tm26 Γ (sum26 A B))
(case : ∀ Γ A B C → Tm26 Γ (sum26 A B) → Tm26 Γ (arr26 A C) → Tm26 Γ (arr26 B C) → Tm26 Γ C)
(zero : ∀ Γ → Tm26 Γ nat26)
(suc : ∀ Γ → Tm26 Γ nat26 → Tm26 Γ nat26)
(rec : ∀ Γ A → Tm26 Γ nat26 → Tm26 Γ (arr26 nat26 (arr26 A A)) → Tm26 Γ A → Tm26 Γ A)
→ Tm26 Γ A
var26 : ∀{Γ A} → Var26 Γ A → Tm26 Γ A; var26
= λ x Tm26 var26 lam app tt pair fst snd left right case zero suc rec →
var26 _ _ x
lam26 : ∀{Γ A B} → Tm26 (snoc26 Γ A) B → Tm26 Γ (arr26 A B); lam26
= λ t Tm26 var26 lam26 app tt pair fst snd left right case zero suc rec →
lam26 _ _ _ (t Tm26 var26 lam26 app tt pair fst snd left right case zero suc rec)
app26 : ∀{Γ A B} → Tm26 Γ (arr26 A B) → Tm26 Γ A → Tm26 Γ B; app26
= λ t u Tm26 var26 lam26 app26 tt pair fst snd left right case zero suc rec →
app26 _ _ _ (t Tm26 var26 lam26 app26 tt pair fst snd left right case zero suc rec)
(u Tm26 var26 lam26 app26 tt pair fst snd left right case zero suc rec)
tt26 : ∀{Γ} → Tm26 Γ top26; tt26
= λ Tm26 var26 lam26 app26 tt26 pair fst snd left right case zero suc rec → tt26 _
pair26 : ∀{Γ A B} → Tm26 Γ A → Tm26 Γ B → Tm26 Γ (prod26 A B); pair26
= λ t u Tm26 var26 lam26 app26 tt26 pair26 fst snd left right case zero suc rec →
pair26 _ _ _ (t Tm26 var26 lam26 app26 tt26 pair26 fst snd left right case zero suc rec)
(u Tm26 var26 lam26 app26 tt26 pair26 fst snd left right case zero suc rec)
fst26 : ∀{Γ A B} → Tm26 Γ (prod26 A B) → Tm26 Γ A; fst26
= λ t Tm26 var26 lam26 app26 tt26 pair26 fst26 snd left right case zero suc rec →
fst26 _ _ _ (t Tm26 var26 lam26 app26 tt26 pair26 fst26 snd left right case zero suc rec)
snd26 : ∀{Γ A B} → Tm26 Γ (prod26 A B) → Tm26 Γ B; snd26
= λ t Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left right case zero suc rec →
snd26 _ _ _ (t Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left right case zero suc rec)
left26 : ∀{Γ A B} → Tm26 Γ A → Tm26 Γ (sum26 A B); left26
= λ t Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right case zero suc rec →
left26 _ _ _ (t Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right case zero suc rec)
right26 : ∀{Γ A B} → Tm26 Γ B → Tm26 Γ (sum26 A B); right26
= λ t Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right26 case zero suc rec →
right26 _ _ _ (t Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right26 case zero suc rec)
case26 : ∀{Γ A B C} → Tm26 Γ (sum26 A B) → Tm26 Γ (arr26 A C) → Tm26 Γ (arr26 B C) → Tm26 Γ C; case26
= λ t u v Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right26 case26 zero suc rec →
case26 _ _ _ _
(t Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right26 case26 zero suc rec)
(u Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right26 case26 zero suc rec)
(v Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right26 case26 zero suc rec)
zero26 : ∀{Γ} → Tm26 Γ nat26; zero26
= λ Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right26 case26 zero26 suc rec → zero26 _
suc26 : ∀{Γ} → Tm26 Γ nat26 → Tm26 Γ nat26; suc26
= λ t Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right26 case26 zero26 suc26 rec →
suc26 _ (t Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right26 case26 zero26 suc26 rec)
rec26 : ∀{Γ A} → Tm26 Γ nat26 → Tm26 Γ (arr26 nat26 (arr26 A A)) → Tm26 Γ A → Tm26 Γ A; rec26
= λ t u v Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right26 case26 zero26 suc26 rec26 →
rec26 _ _
(t Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right26 case26 zero26 suc26 rec26)
(u Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right26 case26 zero26 suc26 rec26)
(v Tm26 var26 lam26 app26 tt26 pair26 fst26 snd26 left26 right26 case26 zero26 suc26 rec26)
v026 : ∀{Γ A} → Tm26 (snoc26 Γ A) A; v026
= var26 vz26
v126 : ∀{Γ A B} → Tm26 (snoc26 (snoc26 Γ A) B) A; v126
= var26 (vs26 vz26)
v226 : ∀{Γ A B C} → Tm26 (snoc26 (snoc26 (snoc26 Γ A) B) C) A; v226
= var26 (vs26 (vs26 vz26))
v326 : ∀{Γ A B C D} → Tm26 (snoc26 (snoc26 (snoc26 (snoc26 Γ A) B) C) D) A; v326
= var26 (vs26 (vs26 (vs26 vz26)))
tbool26 : Ty26; tbool26
= sum26 top26 top26
true26 : ∀{Γ} → Tm26 Γ tbool26; true26
= left26 tt26
tfalse26 : ∀{Γ} → Tm26 Γ tbool26; tfalse26
= right26 tt26
ifthenelse26 : ∀{Γ A} → Tm26 Γ (arr26 tbool26 (arr26 A (arr26 A A))); ifthenelse26
= lam26 (lam26 (lam26 (case26 v226 (lam26 v226) (lam26 v126))))
times426 : ∀{Γ A} → Tm26 Γ (arr26 (arr26 A A) (arr26 A A)); times426
= lam26 (lam26 (app26 v126 (app26 v126 (app26 v126 (app26 v126 v026)))))
add26 : ∀{Γ} → Tm26 Γ (arr26 nat26 (arr26 nat26 nat26)); add26
= lam26 (rec26 v026
(lam26 (lam26 (lam26 (suc26 (app26 v126 v026)))))
(lam26 v026))
mul26 : ∀{Γ} → Tm26 Γ (arr26 nat26 (arr26 nat26 nat26)); mul26
= lam26 (rec26 v026
(lam26 (lam26 (lam26 (app26 (app26 add26 (app26 v126 v026)) v026))))
(lam26 zero26))
fact26 : ∀{Γ} → Tm26 Γ (arr26 nat26 nat26); fact26
= lam26 (rec26 v026 (lam26 (lam26 (app26 (app26 mul26 (suc26 v126)) v026)))
(suc26 zero26))
{-# OPTIONS --type-in-type #-}
Ty27 : Set
Ty27 =
(Ty27 : Set)
(nat top bot : Ty27)
(arr prod sum : Ty27 → Ty27 → Ty27)
→ Ty27
nat27 : Ty27; nat27 = λ _ nat27 _ _ _ _ _ → nat27
top27 : Ty27; top27 = λ _ _ top27 _ _ _ _ → top27
bot27 : Ty27; bot27 = λ _ _ _ bot27 _ _ _ → bot27
arr27 : Ty27 → Ty27 → Ty27; arr27
= λ A B Ty27 nat27 top27 bot27 arr27 prod sum →
arr27 (A Ty27 nat27 top27 bot27 arr27 prod sum) (B Ty27 nat27 top27 bot27 arr27 prod sum)
prod27 : Ty27 → Ty27 → Ty27; prod27
= λ A B Ty27 nat27 top27 bot27 arr27 prod27 sum →
prod27 (A Ty27 nat27 top27 bot27 arr27 prod27 sum) (B Ty27 nat27 top27 bot27 arr27 prod27 sum)
sum27 : Ty27 → Ty27 → Ty27; sum27
= λ A B Ty27 nat27 top27 bot27 arr27 prod27 sum27 →
sum27 (A Ty27 nat27 top27 bot27 arr27 prod27 sum27) (B Ty27 nat27 top27 bot27 arr27 prod27 sum27)
Con27 : Set; Con27
= (Con27 : Set)
(nil : Con27)
(snoc : Con27 → Ty27 → Con27)
→ Con27
nil27 : Con27; nil27
= λ Con27 nil27 snoc → nil27
snoc27 : Con27 → Ty27 → Con27; snoc27
= λ Γ A Con27 nil27 snoc27 → snoc27 (Γ Con27 nil27 snoc27) A
Var27 : Con27 → Ty27 → Set; Var27
= λ Γ A →
(Var27 : Con27 → Ty27 → Set)
(vz : ∀ Γ A → Var27 (snoc27 Γ A) A)
(vs : ∀ Γ B A → Var27 Γ A → Var27 (snoc27 Γ B) A)
→ Var27 Γ A
vz27 : ∀{Γ A} → Var27 (snoc27 Γ A) A; vz27
= λ Var27 vz27 vs → vz27 _ _
vs27 : ∀{Γ B A} → Var27 Γ A → Var27 (snoc27 Γ B) A; vs27
= λ x Var27 vz27 vs27 → vs27 _ _ _ (x Var27 vz27 vs27)
Tm27 : Con27 → Ty27 → Set; Tm27
= λ Γ A →
(Tm27 : Con27 → Ty27 → Set)
(var : ∀ Γ A → Var27 Γ A → Tm27 Γ A)
(lam : ∀ Γ A B → Tm27 (snoc27 Γ A) B → Tm27 Γ (arr27 A B))
(app : ∀ Γ A B → Tm27 Γ (arr27 A B) → Tm27 Γ A → Tm27 Γ B)
(tt : ∀ Γ → Tm27 Γ top27)
(pair : ∀ Γ A B → Tm27 Γ A → Tm27 Γ B → Tm27 Γ (prod27 A B))
(fst : ∀ Γ A B → Tm27 Γ (prod27 A B) → Tm27 Γ A)
(snd : ∀ Γ A B → Tm27 Γ (prod27 A B) → Tm27 Γ B)
(left : ∀ Γ A B → Tm27 Γ A → Tm27 Γ (sum27 A B))
(right : ∀ Γ A B → Tm27 Γ B → Tm27 Γ (sum27 A B))
(case : ∀ Γ A B C → Tm27 Γ (sum27 A B) → Tm27 Γ (arr27 A C) → Tm27 Γ (arr27 B C) → Tm27 Γ C)
(zero : ∀ Γ → Tm27 Γ nat27)
(suc : ∀ Γ → Tm27 Γ nat27 → Tm27 Γ nat27)
(rec : ∀ Γ A → Tm27 Γ nat27 → Tm27 Γ (arr27 nat27 (arr27 A A)) → Tm27 Γ A → Tm27 Γ A)
→ Tm27 Γ A
var27 : ∀{Γ A} → Var27 Γ A → Tm27 Γ A; var27
= λ x Tm27 var27 lam app tt pair fst snd left right case zero suc rec →
var27 _ _ x
lam27 : ∀{Γ A B} → Tm27 (snoc27 Γ A) B → Tm27 Γ (arr27 A B); lam27
= λ t Tm27 var27 lam27 app tt pair fst snd left right case zero suc rec →
lam27 _ _ _ (t Tm27 var27 lam27 app tt pair fst snd left right case zero suc rec)
app27 : ∀{Γ A B} → Tm27 Γ (arr27 A B) → Tm27 Γ A → Tm27 Γ B; app27
= λ t u Tm27 var27 lam27 app27 tt pair fst snd left right case zero suc rec →
app27 _ _ _ (t Tm27 var27 lam27 app27 tt pair fst snd left right case zero suc rec)
(u Tm27 var27 lam27 app27 tt pair fst snd left right case zero suc rec)
tt27 : ∀{Γ} → Tm27 Γ top27; tt27
= λ Tm27 var27 lam27 app27 tt27 pair fst snd left right case zero suc rec → tt27 _
pair27 : ∀{Γ A B} → Tm27 Γ A → Tm27 Γ B → Tm27 Γ (prod27 A B); pair27
= λ t u Tm27 var27 lam27 app27 tt27 pair27 fst snd left right case zero suc rec →
pair27 _ _ _ (t Tm27 var27 lam27 app27 tt27 pair27 fst snd left right case zero suc rec)
(u Tm27 var27 lam27 app27 tt27 pair27 fst snd left right case zero suc rec)
fst27 : ∀{Γ A B} → Tm27 Γ (prod27 A B) → Tm27 Γ A; fst27
= λ t Tm27 var27 lam27 app27 tt27 pair27 fst27 snd left right case zero suc rec →
fst27 _ _ _ (t Tm27 var27 lam27 app27 tt27 pair27 fst27 snd left right case zero suc rec)
snd27 : ∀{Γ A B} → Tm27 Γ (prod27 A B) → Tm27 Γ B; snd27
= λ t Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left right case zero suc rec →
snd27 _ _ _ (t Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left right case zero suc rec)
left27 : ∀{Γ A B} → Tm27 Γ A → Tm27 Γ (sum27 A B); left27
= λ t Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right case zero suc rec →
left27 _ _ _ (t Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right case zero suc rec)
right27 : ∀{Γ A B} → Tm27 Γ B → Tm27 Γ (sum27 A B); right27
= λ t Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right27 case zero suc rec →
right27 _ _ _ (t Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right27 case zero suc rec)
case27 : ∀{Γ A B C} → Tm27 Γ (sum27 A B) → Tm27 Γ (arr27 A C) → Tm27 Γ (arr27 B C) → Tm27 Γ C; case27
= λ t u v Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right27 case27 zero suc rec →
case27 _ _ _ _
(t Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right27 case27 zero suc rec)
(u Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right27 case27 zero suc rec)
(v Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right27 case27 zero suc rec)
zero27 : ∀{Γ} → Tm27 Γ nat27; zero27
= λ Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right27 case27 zero27 suc rec → zero27 _
suc27 : ∀{Γ} → Tm27 Γ nat27 → Tm27 Γ nat27; suc27
= λ t Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right27 case27 zero27 suc27 rec →
suc27 _ (t Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right27 case27 zero27 suc27 rec)
rec27 : ∀{Γ A} → Tm27 Γ nat27 → Tm27 Γ (arr27 nat27 (arr27 A A)) → Tm27 Γ A → Tm27 Γ A; rec27
= λ t u v Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right27 case27 zero27 suc27 rec27 →
rec27 _ _
(t Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right27 case27 zero27 suc27 rec27)
(u Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right27 case27 zero27 suc27 rec27)
(v Tm27 var27 lam27 app27 tt27 pair27 fst27 snd27 left27 right27 case27 zero27 suc27 rec27)
v027 : ∀{Γ A} → Tm27 (snoc27 Γ A) A; v027
= var27 vz27
v127 : ∀{Γ A B} → Tm27 (snoc27 (snoc27 Γ A) B) A; v127
= var27 (vs27 vz27)
v227 : ∀{Γ A B C} → Tm27 (snoc27 (snoc27 (snoc27 Γ A) B) C) A; v227
= var27 (vs27 (vs27 vz27))
v327 : ∀{Γ A B C D} → Tm27 (snoc27 (snoc27 (snoc27 (snoc27 Γ A) B) C) D) A; v327
= var27 (vs27 (vs27 (vs27 vz27)))
tbool27 : Ty27; tbool27
= sum27 top27 top27
true27 : ∀{Γ} → Tm27 Γ tbool27; true27
= left27 tt27
tfalse27 : ∀{Γ} → Tm27 Γ tbool27; tfalse27
= right27 tt27
ifthenelse27 : ∀{Γ A} → Tm27 Γ (arr27 tbool27 (arr27 A (arr27 A A))); ifthenelse27
= lam27 (lam27 (lam27 (case27 v227 (lam27 v227) (lam27 v127))))
times427 : ∀{Γ A} → Tm27 Γ (arr27 (arr27 A A) (arr27 A A)); times427
= lam27 (lam27 (app27 v127 (app27 v127 (app27 v127 (app27 v127 v027)))))
add27 : ∀{Γ} → Tm27 Γ (arr27 nat27 (arr27 nat27 nat27)); add27
= lam27 (rec27 v027
(lam27 (lam27 (lam27 (suc27 (app27 v127 v027)))))
(lam27 v027))
mul27 : ∀{Γ} → Tm27 Γ (arr27 nat27 (arr27 nat27 nat27)); mul27
= lam27 (rec27 v027
(lam27 (lam27 (lam27 (app27 (app27 add27 (app27 v127 v027)) v027))))
(lam27 zero27))
fact27 : ∀{Γ} → Tm27 Γ (arr27 nat27 nat27); fact27
= lam27 (rec27 v027 (lam27 (lam27 (app27 (app27 mul27 (suc27 v127)) v027)))
(suc27 zero27))
{-# OPTIONS --type-in-type #-}
Ty28 : Set
Ty28 =
(Ty28 : Set)
(nat top bot : Ty28)
(arr prod sum : Ty28 → Ty28 → Ty28)
→ Ty28
nat28 : Ty28; nat28 = λ _ nat28 _ _ _ _ _ → nat28
top28 : Ty28; top28 = λ _ _ top28 _ _ _ _ → top28
bot28 : Ty28; bot28 = λ _ _ _ bot28 _ _ _ → bot28
arr28 : Ty28 → Ty28 → Ty28; arr28
= λ A B Ty28 nat28 top28 bot28 arr28 prod sum →
arr28 (A Ty28 nat28 top28 bot28 arr28 prod sum) (B Ty28 nat28 top28 bot28 arr28 prod sum)
prod28 : Ty28 → Ty28 → Ty28; prod28
= λ A B Ty28 nat28 top28 bot28 arr28 prod28 sum →
prod28 (A Ty28 nat28 top28 bot28 arr28 prod28 sum) (B Ty28 nat28 top28 bot28 arr28 prod28 sum)
sum28 : Ty28 → Ty28 → Ty28; sum28
= λ A B Ty28 nat28 top28 bot28 arr28 prod28 sum28 →
sum28 (A Ty28 nat28 top28 bot28 arr28 prod28 sum28) (B Ty28 nat28 top28 bot28 arr28 prod28 sum28)
Con28 : Set; Con28
= (Con28 : Set)
(nil : Con28)
(snoc : Con28 → Ty28 → Con28)
→ Con28
nil28 : Con28; nil28
= λ Con28 nil28 snoc → nil28
snoc28 : Con28 → Ty28 → Con28; snoc28
= λ Γ A Con28 nil28 snoc28 → snoc28 (Γ Con28 nil28 snoc28) A
Var28 : Con28 → Ty28 → Set; Var28
= λ Γ A →
(Var28 : Con28 → Ty28 → Set)
(vz : ∀ Γ A → Var28 (snoc28 Γ A) A)
(vs : ∀ Γ B A → Var28 Γ A → Var28 (snoc28 Γ B) A)
→ Var28 Γ A
vz28 : ∀{Γ A} → Var28 (snoc28 Γ A) A; vz28
= λ Var28 vz28 vs → vz28 _ _
vs28 : ∀{Γ B A} → Var28 Γ A → Var28 (snoc28 Γ B) A; vs28
= λ x Var28 vz28 vs28 → vs28 _ _ _ (x Var28 vz28 vs28)
Tm28 : Con28 → Ty28 → Set; Tm28
= λ Γ A →
(Tm28 : Con28 → Ty28 → Set)
(var : ∀ Γ A → Var28 Γ A → Tm28 Γ A)
(lam : ∀ Γ A B → Tm28 (snoc28 Γ A) B → Tm28 Γ (arr28 A B))
(app : ∀ Γ A B → Tm28 Γ (arr28 A B) → Tm28 Γ A → Tm28 Γ B)
(tt : ∀ Γ → Tm28 Γ top28)
(pair : ∀ Γ A B → Tm28 Γ A → Tm28 Γ B → Tm28 Γ (prod28 A B))
(fst : ∀ Γ A B → Tm28 Γ (prod28 A B) → Tm28 Γ A)
(snd : ∀ Γ A B → Tm28 Γ (prod28 A B) → Tm28 Γ B)
(left : ∀ Γ A B → Tm28 Γ A → Tm28 Γ (sum28 A B))
(right : ∀ Γ A B → Tm28 Γ B → Tm28 Γ (sum28 A B))
(case : ∀ Γ A B C → Tm28 Γ (sum28 A B) → Tm28 Γ (arr28 A C) → Tm28 Γ (arr28 B C) → Tm28 Γ C)
(zero : ∀ Γ → Tm28 Γ nat28)
(suc : ∀ Γ → Tm28 Γ nat28 → Tm28 Γ nat28)
(rec : ∀ Γ A → Tm28 Γ nat28 → Tm28 Γ (arr28 nat28 (arr28 A A)) → Tm28 Γ A → Tm28 Γ A)
→ Tm28 Γ A
var28 : ∀{Γ A} → Var28 Γ A → Tm28 Γ A; var28
= λ x Tm28 var28 lam app tt pair fst snd left right case zero suc rec →
var28 _ _ x
lam28 : ∀{Γ A B} → Tm28 (snoc28 Γ A) B → Tm28 Γ (arr28 A B); lam28
= λ t Tm28 var28 lam28 app tt pair fst snd left right case zero suc rec →
lam28 _ _ _ (t Tm28 var28 lam28 app tt pair fst snd left right case zero suc rec)
app28 : ∀{Γ A B} → Tm28 Γ (arr28 A B) → Tm28 Γ A → Tm28 Γ B; app28
= λ t u Tm28 var28 lam28 app28 tt pair fst snd left right case zero suc rec →
app28 _ _ _ (t Tm28 var28 lam28 app28 tt pair fst snd left right case zero suc rec)
(u Tm28 var28 lam28 app28 tt pair fst snd left right case zero suc rec)
tt28 : ∀{Γ} → Tm28 Γ top28; tt28
= λ Tm28 var28 lam28 app28 tt28 pair fst snd left right case zero suc rec → tt28 _
pair28 : ∀{Γ A B} → Tm28 Γ A → Tm28 Γ B → Tm28 Γ (prod28 A B); pair28
= λ t u Tm28 var28 lam28 app28 tt28 pair28 fst snd left right case zero suc rec →
pair28 _ _ _ (t Tm28 var28 lam28 app28 tt28 pair28 fst snd left right case zero suc rec)
(u Tm28 var28 lam28 app28 tt28 pair28 fst snd left right case zero suc rec)
fst28 : ∀{Γ A B} → Tm28 Γ (prod28 A B) → Tm28 Γ A; fst28
= λ t Tm28 var28 lam28 app28 tt28 pair28 fst28 snd left right case zero suc rec →
fst28 _ _ _ (t Tm28 var28 lam28 app28 tt28 pair28 fst28 snd left right case zero suc rec)
snd28 : ∀{Γ A B} → Tm28 Γ (prod28 A B) → Tm28 Γ B; snd28
= λ t Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left right case zero suc rec →
snd28 _ _ _ (t Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left right case zero suc rec)
left28 : ∀{Γ A B} → Tm28 Γ A → Tm28 Γ (sum28 A B); left28
= λ t Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right case zero suc rec →
left28 _ _ _ (t Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right case zero suc rec)
right28 : ∀{Γ A B} → Tm28 Γ B → Tm28 Γ (sum28 A B); right28
= λ t Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right28 case zero suc rec →
right28 _ _ _ (t Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right28 case zero suc rec)
case28 : ∀{Γ A B C} → Tm28 Γ (sum28 A B) → Tm28 Γ (arr28 A C) → Tm28 Γ (arr28 B C) → Tm28 Γ C; case28
= λ t u v Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right28 case28 zero suc rec →
case28 _ _ _ _
(t Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right28 case28 zero suc rec)
(u Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right28 case28 zero suc rec)
(v Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right28 case28 zero suc rec)
zero28 : ∀{Γ} → Tm28 Γ nat28; zero28
= λ Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right28 case28 zero28 suc rec → zero28 _
suc28 : ∀{Γ} → Tm28 Γ nat28 → Tm28 Γ nat28; suc28
= λ t Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right28 case28 zero28 suc28 rec →
suc28 _ (t Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right28 case28 zero28 suc28 rec)
rec28 : ∀{Γ A} → Tm28 Γ nat28 → Tm28 Γ (arr28 nat28 (arr28 A A)) → Tm28 Γ A → Tm28 Γ A; rec28
= λ t u v Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right28 case28 zero28 suc28 rec28 →
rec28 _ _
(t Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right28 case28 zero28 suc28 rec28)
(u Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right28 case28 zero28 suc28 rec28)
(v Tm28 var28 lam28 app28 tt28 pair28 fst28 snd28 left28 right28 case28 zero28 suc28 rec28)
v028 : ∀{Γ A} → Tm28 (snoc28 Γ A) A; v028
= var28 vz28
v128 : ∀{Γ A B} → Tm28 (snoc28 (snoc28 Γ A) B) A; v128
= var28 (vs28 vz28)
v228 : ∀{Γ A B C} → Tm28 (snoc28 (snoc28 (snoc28 Γ A) B) C) A; v228
= var28 (vs28 (vs28 vz28))
v328 : ∀{Γ A B C D} → Tm28 (snoc28 (snoc28 (snoc28 (snoc28 Γ A) B) C) D) A; v328
= var28 (vs28 (vs28 (vs28 vz28)))
tbool28 : Ty28; tbool28
= sum28 top28 top28
true28 : ∀{Γ} → Tm28 Γ tbool28; true28
= left28 tt28
tfalse28 : ∀{Γ} → Tm28 Γ tbool28; tfalse28
= right28 tt28
ifthenelse28 : ∀{Γ A} → Tm28 Γ (arr28 tbool28 (arr28 A (arr28 A A))); ifthenelse28
= lam28 (lam28 (lam28 (case28 v228 (lam28 v228) (lam28 v128))))
times428 : ∀{Γ A} → Tm28 Γ (arr28 (arr28 A A) (arr28 A A)); times428
= lam28 (lam28 (app28 v128 (app28 v128 (app28 v128 (app28 v128 v028)))))
add28 : ∀{Γ} → Tm28 Γ (arr28 nat28 (arr28 nat28 nat28)); add28
= lam28 (rec28 v028
(lam28 (lam28 (lam28 (suc28 (app28 v128 v028)))))
(lam28 v028))
mul28 : ∀{Γ} → Tm28 Γ (arr28 nat28 (arr28 nat28 nat28)); mul28
= lam28 (rec28 v028
(lam28 (lam28 (lam28 (app28 (app28 add28 (app28 v128 v028)) v028))))
(lam28 zero28))
fact28 : ∀{Γ} → Tm28 Γ (arr28 nat28 nat28); fact28
= lam28 (rec28 v028 (lam28 (lam28 (app28 (app28 mul28 (suc28 v128)) v028)))
(suc28 zero28))
{-# OPTIONS --type-in-type #-}
Ty29 : Set
Ty29 =
(Ty29 : Set)
(nat top bot : Ty29)
(arr prod sum : Ty29 → Ty29 → Ty29)
→ Ty29
nat29 : Ty29; nat29 = λ _ nat29 _ _ _ _ _ → nat29
top29 : Ty29; top29 = λ _ _ top29 _ _ _ _ → top29
bot29 : Ty29; bot29 = λ _ _ _ bot29 _ _ _ → bot29
arr29 : Ty29 → Ty29 → Ty29; arr29
= λ A B Ty29 nat29 top29 bot29 arr29 prod sum →
arr29 (A Ty29 nat29 top29 bot29 arr29 prod sum) (B Ty29 nat29 top29 bot29 arr29 prod sum)
prod29 : Ty29 → Ty29 → Ty29; prod29
= λ A B Ty29 nat29 top29 bot29 arr29 prod29 sum →
prod29 (A Ty29 nat29 top29 bot29 arr29 prod29 sum) (B Ty29 nat29 top29 bot29 arr29 prod29 sum)
sum29 : Ty29 → Ty29 → Ty29; sum29
= λ A B Ty29 nat29 top29 bot29 arr29 prod29 sum29 →
sum29 (A Ty29 nat29 top29 bot29 arr29 prod29 sum29) (B Ty29 nat29 top29 bot29 arr29 prod29 sum29)
Con29 : Set; Con29
= (Con29 : Set)
(nil : Con29)
(snoc : Con29 → Ty29 → Con29)
→ Con29
nil29 : Con29; nil29
= λ Con29 nil29 snoc → nil29
snoc29 : Con29 → Ty29 → Con29; snoc29
= λ Γ A Con29 nil29 snoc29 → snoc29 (Γ Con29 nil29 snoc29) A
Var29 : Con29 → Ty29 → Set; Var29
= λ Γ A →
(Var29 : Con29 → Ty29 → Set)
(vz : ∀ Γ A → Var29 (snoc29 Γ A) A)
(vs : ∀ Γ B A → Var29 Γ A → Var29 (snoc29 Γ B) A)
→ Var29 Γ A
vz29 : ∀{Γ A} → Var29 (snoc29 Γ A) A; vz29
= λ Var29 vz29 vs → vz29 _ _
vs29 : ∀{Γ B A} → Var29 Γ A → Var29 (snoc29 Γ B) A; vs29
= λ x Var29 vz29 vs29 → vs29 _ _ _ (x Var29 vz29 vs29)
Tm29 : Con29 → Ty29 → Set; Tm29
= λ Γ A →
(Tm29 : Con29 → Ty29 → Set)
(var : ∀ Γ A → Var29 Γ A → Tm29 Γ A)
(lam : ∀ Γ A B → Tm29 (snoc29 Γ A) B → Tm29 Γ (arr29 A B))
(app : ∀ Γ A B → Tm29 Γ (arr29 A B) → Tm29 Γ A → Tm29 Γ B)
(tt : ∀ Γ → Tm29 Γ top29)
(pair : ∀ Γ A B → Tm29 Γ A → Tm29 Γ B → Tm29 Γ (prod29 A B))
(fst : ∀ Γ A B → Tm29 Γ (prod29 A B) → Tm29 Γ A)
(snd : ∀ Γ A B → Tm29 Γ (prod29 A B) → Tm29 Γ B)
(left : ∀ Γ A B → Tm29 Γ A → Tm29 Γ (sum29 A B))
(right : ∀ Γ A B → Tm29 Γ B → Tm29 Γ (sum29 A B))
(case : ∀ Γ A B C → Tm29 Γ (sum29 A B) → Tm29 Γ (arr29 A C) → Tm29 Γ (arr29 B C) → Tm29 Γ C)
(zero : ∀ Γ → Tm29 Γ nat29)
(suc : ∀ Γ → Tm29 Γ nat29 → Tm29 Γ nat29)
(rec : ∀ Γ A → Tm29 Γ nat29 → Tm29 Γ (arr29 nat29 (arr29 A A)) → Tm29 Γ A → Tm29 Γ A)
→ Tm29 Γ A
var29 : ∀{Γ A} → Var29 Γ A → Tm29 Γ A; var29
= λ x Tm29 var29 lam app tt pair fst snd left right case zero suc rec →
var29 _ _ x
lam29 : ∀{Γ A B} → Tm29 (snoc29 Γ A) B → Tm29 Γ (arr29 A B); lam29
= λ t Tm29 var29 lam29 app tt pair fst snd left right case zero suc rec →
lam29 _ _ _ (t Tm29 var29 lam29 app tt pair fst snd left right case zero suc rec)
app29 : ∀{Γ A B} → Tm29 Γ (arr29 A B) → Tm29 Γ A → Tm29 Γ B; app29
= λ t u Tm29 var29 lam29 app29 tt pair fst snd left right case zero suc rec →
app29 _ _ _ (t Tm29 var29 lam29 app29 tt pair fst snd left right case zero suc rec)
(u Tm29 var29 lam29 app29 tt pair fst snd left right case zero suc rec)
tt29 : ∀{Γ} → Tm29 Γ top29; tt29
= λ Tm29 var29 lam29 app29 tt29 pair fst snd left right case zero suc rec → tt29 _
pair29 : ∀{Γ A B} → Tm29 Γ A → Tm29 Γ B → Tm29 Γ (prod29 A B); pair29
= λ t u Tm29 var29 lam29 app29 tt29 pair29 fst snd left right case zero suc rec →
pair29 _ _ _ (t Tm29 var29 lam29 app29 tt29 pair29 fst snd left right case zero suc rec)
(u Tm29 var29 lam29 app29 tt29 pair29 fst snd left right case zero suc rec)
fst29 : ∀{Γ A B} → Tm29 Γ (prod29 A B) → Tm29 Γ A; fst29
= λ t Tm29 var29 lam29 app29 tt29 pair29 fst29 snd left right case zero suc rec →
fst29 _ _ _ (t Tm29 var29 lam29 app29 tt29 pair29 fst29 snd left right case zero suc rec)
snd29 : ∀{Γ A B} → Tm29 Γ (prod29 A B) → Tm29 Γ B; snd29
= λ t Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left right case zero suc rec →
snd29 _ _ _ (t Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left right case zero suc rec)
left29 : ∀{Γ A B} → Tm29 Γ A → Tm29 Γ (sum29 A B); left29
= λ t Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right case zero suc rec →
left29 _ _ _ (t Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right case zero suc rec)
right29 : ∀{Γ A B} → Tm29 Γ B → Tm29 Γ (sum29 A B); right29
= λ t Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right29 case zero suc rec →
right29 _ _ _ (t Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right29 case zero suc rec)
case29 : ∀{Γ A B C} → Tm29 Γ (sum29 A B) → Tm29 Γ (arr29 A C) → Tm29 Γ (arr29 B C) → Tm29 Γ C; case29
= λ t u v Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right29 case29 zero suc rec →
case29 _ _ _ _
(t Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right29 case29 zero suc rec)
(u Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right29 case29 zero suc rec)
(v Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right29 case29 zero suc rec)
zero29 : ∀{Γ} → Tm29 Γ nat29; zero29
= λ Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right29 case29 zero29 suc rec → zero29 _
suc29 : ∀{Γ} → Tm29 Γ nat29 → Tm29 Γ nat29; suc29
= λ t Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right29 case29 zero29 suc29 rec →
suc29 _ (t Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right29 case29 zero29 suc29 rec)
rec29 : ∀{Γ A} → Tm29 Γ nat29 → Tm29 Γ (arr29 nat29 (arr29 A A)) → Tm29 Γ A → Tm29 Γ A; rec29
= λ t u v Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right29 case29 zero29 suc29 rec29 →
rec29 _ _
(t Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right29 case29 zero29 suc29 rec29)
(u Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right29 case29 zero29 suc29 rec29)
(v Tm29 var29 lam29 app29 tt29 pair29 fst29 snd29 left29 right29 case29 zero29 suc29 rec29)
v029 : ∀{Γ A} → Tm29 (snoc29 Γ A) A; v029
= var29 vz29
v129 : ∀{Γ A B} → Tm29 (snoc29 (snoc29 Γ A) B) A; v129
= var29 (vs29 vz29)
v229 : ∀{Γ A B C} → Tm29 (snoc29 (snoc29 (snoc29 Γ A) B) C) A; v229
= var29 (vs29 (vs29 vz29))
v329 : ∀{Γ A B C D} → Tm29 (snoc29 (snoc29 (snoc29 (snoc29 Γ A) B) C) D) A; v329
= var29 (vs29 (vs29 (vs29 vz29)))
tbool29 : Ty29; tbool29
= sum29 top29 top29
true29 : ∀{Γ} → Tm29 Γ tbool29; true29
= left29 tt29
tfalse29 : ∀{Γ} → Tm29 Γ tbool29; tfalse29
= right29 tt29
ifthenelse29 : ∀{Γ A} → Tm29 Γ (arr29 tbool29 (arr29 A (arr29 A A))); ifthenelse29
= lam29 (lam29 (lam29 (case29 v229 (lam29 v229) (lam29 v129))))
times429 : ∀{Γ A} → Tm29 Γ (arr29 (arr29 A A) (arr29 A A)); times429
= lam29 (lam29 (app29 v129 (app29 v129 (app29 v129 (app29 v129 v029)))))
add29 : ∀{Γ} → Tm29 Γ (arr29 nat29 (arr29 nat29 nat29)); add29
= lam29 (rec29 v029
(lam29 (lam29 (lam29 (suc29 (app29 v129 v029)))))
(lam29 v029))
mul29 : ∀{Γ} → Tm29 Γ (arr29 nat29 (arr29 nat29 nat29)); mul29
= lam29 (rec29 v029
(lam29 (lam29 (lam29 (app29 (app29 add29 (app29 v129 v029)) v029))))
(lam29 zero29))
fact29 : ∀{Γ} → Tm29 Γ (arr29 nat29 nat29); fact29
= lam29 (rec29 v029 (lam29 (lam29 (app29 (app29 mul29 (suc29 v129)) v029)))
(suc29 zero29))
{-# OPTIONS --type-in-type #-}
Ty30 : Set
Ty30 =
(Ty30 : Set)
(nat top bot : Ty30)
(arr prod sum : Ty30 → Ty30 → Ty30)
→ Ty30
nat30 : Ty30; nat30 = λ _ nat30 _ _ _ _ _ → nat30
top30 : Ty30; top30 = λ _ _ top30 _ _ _ _ → top30
bot30 : Ty30; bot30 = λ _ _ _ bot30 _ _ _ → bot30
arr30 : Ty30 → Ty30 → Ty30; arr30
= λ A B Ty30 nat30 top30 bot30 arr30 prod sum →
arr30 (A Ty30 nat30 top30 bot30 arr30 prod sum) (B Ty30 nat30 top30 bot30 arr30 prod sum)
prod30 : Ty30 → Ty30 → Ty30; prod30
= λ A B Ty30 nat30 top30 bot30 arr30 prod30 sum →
prod30 (A Ty30 nat30 top30 bot30 arr30 prod30 sum) (B Ty30 nat30 top30 bot30 arr30 prod30 sum)
sum30 : Ty30 → Ty30 → Ty30; sum30
= λ A B Ty30 nat30 top30 bot30 arr30 prod30 sum30 →
sum30 (A Ty30 nat30 top30 bot30 arr30 prod30 sum30) (B Ty30 nat30 top30 bot30 arr30 prod30 sum30)
Con30 : Set; Con30
= (Con30 : Set)
(nil : Con30)
(snoc : Con30 → Ty30 → Con30)
→ Con30
nil30 : Con30; nil30
= λ Con30 nil30 snoc → nil30
snoc30 : Con30 → Ty30 → Con30; snoc30
= λ Γ A Con30 nil30 snoc30 → snoc30 (Γ Con30 nil30 snoc30) A
Var30 : Con30 → Ty30 → Set; Var30
= λ Γ A →
(Var30 : Con30 → Ty30 → Set)
(vz : ∀ Γ A → Var30 (snoc30 Γ A) A)
(vs : ∀ Γ B A → Var30 Γ A → Var30 (snoc30 Γ B) A)
→ Var30 Γ A
vz30 : ∀{Γ A} → Var30 (snoc30 Γ A) A; vz30
= λ Var30 vz30 vs → vz30 _ _
vs30 : ∀{Γ B A} → Var30 Γ A → Var30 (snoc30 Γ B) A; vs30
= λ x Var30 vz30 vs30 → vs30 _ _ _ (x Var30 vz30 vs30)
Tm30 : Con30 → Ty30 → Set; Tm30
= λ Γ A →
(Tm30 : Con30 → Ty30 → Set)
(var : ∀ Γ A → Var30 Γ A → Tm30 Γ A)
(lam : ∀ Γ A B → Tm30 (snoc30 Γ A) B → Tm30 Γ (arr30 A B))
(app : ∀ Γ A B → Tm30 Γ (arr30 A B) → Tm30 Γ A → Tm30 Γ B)
(tt : ∀ Γ → Tm30 Γ top30)
(pair : ∀ Γ A B → Tm30 Γ A → Tm30 Γ B → Tm30 Γ (prod30 A B))
(fst : ∀ Γ A B → Tm30 Γ (prod30 A B) → Tm30 Γ A)
(snd : ∀ Γ A B → Tm30 Γ (prod30 A B) → Tm30 Γ B)
(left : ∀ Γ A B → Tm30 Γ A → Tm30 Γ (sum30 A B))
(right : ∀ Γ A B → Tm30 Γ B → Tm30 Γ (sum30 A B))
(case : ∀ Γ A B C → Tm30 Γ (sum30 A B) → Tm30 Γ (arr30 A C) → Tm30 Γ (arr30 B C) → Tm30 Γ C)
(zero : ∀ Γ → Tm30 Γ nat30)
(suc : ∀ Γ → Tm30 Γ nat30 → Tm30 Γ nat30)
(rec : ∀ Γ A → Tm30 Γ nat30 → Tm30 Γ (arr30 nat30 (arr30 A A)) → Tm30 Γ A → Tm30 Γ A)
→ Tm30 Γ A
var30 : ∀{Γ A} → Var30 Γ A → Tm30 Γ A; var30
= λ x Tm30 var30 lam app tt pair fst snd left right case zero suc rec →
var30 _ _ x
lam30 : ∀{Γ A B} → Tm30 (snoc30 Γ A) B → Tm30 Γ (arr30 A B); lam30
= λ t Tm30 var30 lam30 app tt pair fst snd left right case zero suc rec →
lam30 _ _ _ (t Tm30 var30 lam30 app tt pair fst snd left right case zero suc rec)
app30 : ∀{Γ A B} → Tm30 Γ (arr30 A B) → Tm30 Γ A → Tm30 Γ B; app30
= λ t u Tm30 var30 lam30 app30 tt pair fst snd left right case zero suc rec →
app30 _ _ _ (t Tm30 var30 lam30 app30 tt pair fst snd left right case zero suc rec)
(u Tm30 var30 lam30 app30 tt pair fst snd left right case zero suc rec)
tt30 : ∀{Γ} → Tm30 Γ top30; tt30
= λ Tm30 var30 lam30 app30 tt30 pair fst snd left right case zero suc rec → tt30 _
pair30 : ∀{Γ A B} → Tm30 Γ A → Tm30 Γ B → Tm30 Γ (prod30 A B); pair30
= λ t u Tm30 var30 lam30 app30 tt30 pair30 fst snd left right case zero suc rec →
pair30 _ _ _ (t Tm30 var30 lam30 app30 tt30 pair30 fst snd left right case zero suc rec)
(u Tm30 var30 lam30 app30 tt30 pair30 fst snd left right case zero suc rec)
fst30 : ∀{Γ A B} → Tm30 Γ (prod30 A B) → Tm30 Γ A; fst30
= λ t Tm30 var30 lam30 app30 tt30 pair30 fst30 snd left right case zero suc rec →
fst30 _ _ _ (t Tm30 var30 lam30 app30 tt30 pair30 fst30 snd left right case zero suc rec)
snd30 : ∀{Γ A B} → Tm30 Γ (prod30 A B) → Tm30 Γ B; snd30
= λ t Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left right case zero suc rec →
snd30 _ _ _ (t Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left right case zero suc rec)
left30 : ∀{Γ A B} → Tm30 Γ A → Tm30 Γ (sum30 A B); left30
= λ t Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right case zero suc rec →
left30 _ _ _ (t Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right case zero suc rec)
right30 : ∀{Γ A B} → Tm30 Γ B → Tm30 Γ (sum30 A B); right30
= λ t Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right30 case zero suc rec →
right30 _ _ _ (t Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right30 case zero suc rec)
case30 : ∀{Γ A B C} → Tm30 Γ (sum30 A B) → Tm30 Γ (arr30 A C) → Tm30 Γ (arr30 B C) → Tm30 Γ C; case30
= λ t u v Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right30 case30 zero suc rec →
case30 _ _ _ _
(t Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right30 case30 zero suc rec)
(u Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right30 case30 zero suc rec)
(v Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right30 case30 zero suc rec)
zero30 : ∀{Γ} → Tm30 Γ nat30; zero30
= λ Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right30 case30 zero30 suc rec → zero30 _
suc30 : ∀{Γ} → Tm30 Γ nat30 → Tm30 Γ nat30; suc30
= λ t Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right30 case30 zero30 suc30 rec →
suc30 _ (t Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right30 case30 zero30 suc30 rec)
rec30 : ∀{Γ A} → Tm30 Γ nat30 → Tm30 Γ (arr30 nat30 (arr30 A A)) → Tm30 Γ A → Tm30 Γ A; rec30
= λ t u v Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right30 case30 zero30 suc30 rec30 →
rec30 _ _
(t Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right30 case30 zero30 suc30 rec30)
(u Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right30 case30 zero30 suc30 rec30)
(v Tm30 var30 lam30 app30 tt30 pair30 fst30 snd30 left30 right30 case30 zero30 suc30 rec30)
v030 : ∀{Γ A} → Tm30 (snoc30 Γ A) A; v030
= var30 vz30
v130 : ∀{Γ A B} → Tm30 (snoc30 (snoc30 Γ A) B) A; v130
= var30 (vs30 vz30)
v230 : ∀{Γ A B C} → Tm30 (snoc30 (snoc30 (snoc30 Γ A) B) C) A; v230
= var30 (vs30 (vs30 vz30))
v330 : ∀{Γ A B C D} → Tm30 (snoc30 (snoc30 (snoc30 (snoc30 Γ A) B) C) D) A; v330
= var30 (vs30 (vs30 (vs30 vz30)))
tbool30 : Ty30; tbool30
= sum30 top30 top30
true30 : ∀{Γ} → Tm30 Γ tbool30; true30
= left30 tt30
tfalse30 : ∀{Γ} → Tm30 Γ tbool30; tfalse30
= right30 tt30
ifthenelse30 : ∀{Γ A} → Tm30 Γ (arr30 tbool30 (arr30 A (arr30 A A))); ifthenelse30
= lam30 (lam30 (lam30 (case30 v230 (lam30 v230) (lam30 v130))))
times430 : ∀{Γ A} → Tm30 Γ (arr30 (arr30 A A) (arr30 A A)); times430
= lam30 (lam30 (app30 v130 (app30 v130 (app30 v130 (app30 v130 v030)))))
add30 : ∀{Γ} → Tm30 Γ (arr30 nat30 (arr30 nat30 nat30)); add30
= lam30 (rec30 v030
(lam30 (lam30 (lam30 (suc30 (app30 v130 v030)))))
(lam30 v030))
mul30 : ∀{Γ} → Tm30 Γ (arr30 nat30 (arr30 nat30 nat30)); mul30
= lam30 (rec30 v030
(lam30 (lam30 (lam30 (app30 (app30 add30 (app30 v130 v030)) v030))))
(lam30 zero30))
fact30 : ∀{Γ} → Tm30 Γ (arr30 nat30 nat30); fact30
= lam30 (rec30 v030 (lam30 (lam30 (app30 (app30 mul30 (suc30 v130)) v030)))
(suc30 zero30))
{-# OPTIONS --type-in-type #-}
Ty31 : Set
Ty31 =
(Ty31 : Set)
(nat top bot : Ty31)
(arr prod sum : Ty31 → Ty31 → Ty31)
→ Ty31
nat31 : Ty31; nat31 = λ _ nat31 _ _ _ _ _ → nat31
top31 : Ty31; top31 = λ _ _ top31 _ _ _ _ → top31
bot31 : Ty31; bot31 = λ _ _ _ bot31 _ _ _ → bot31
arr31 : Ty31 → Ty31 → Ty31; arr31
= λ A B Ty31 nat31 top31 bot31 arr31 prod sum →
arr31 (A Ty31 nat31 top31 bot31 arr31 prod sum) (B Ty31 nat31 top31 bot31 arr31 prod sum)
prod31 : Ty31 → Ty31 → Ty31; prod31
= λ A B Ty31 nat31 top31 bot31 arr31 prod31 sum →
prod31 (A Ty31 nat31 top31 bot31 arr31 prod31 sum) (B Ty31 nat31 top31 bot31 arr31 prod31 sum)
sum31 : Ty31 → Ty31 → Ty31; sum31
= λ A B Ty31 nat31 top31 bot31 arr31 prod31 sum31 →
sum31 (A Ty31 nat31 top31 bot31 arr31 prod31 sum31) (B Ty31 nat31 top31 bot31 arr31 prod31 sum31)
Con31 : Set; Con31
= (Con31 : Set)
(nil : Con31)
(snoc : Con31 → Ty31 → Con31)
→ Con31
nil31 : Con31; nil31
= λ Con31 nil31 snoc → nil31
snoc31 : Con31 → Ty31 → Con31; snoc31
= λ Γ A Con31 nil31 snoc31 → snoc31 (Γ Con31 nil31 snoc31) A
Var31 : Con31 → Ty31 → Set; Var31
= λ Γ A →
(Var31 : Con31 → Ty31 → Set)
(vz : ∀ Γ A → Var31 (snoc31 Γ A) A)
(vs : ∀ Γ B A → Var31 Γ A → Var31 (snoc31 Γ B) A)
→ Var31 Γ A
vz31 : ∀{Γ A} → Var31 (snoc31 Γ A) A; vz31
= λ Var31 vz31 vs → vz31 _ _
vs31 : ∀{Γ B A} → Var31 Γ A → Var31 (snoc31 Γ B) A; vs31
= λ x Var31 vz31 vs31 → vs31 _ _ _ (x Var31 vz31 vs31)
Tm31 : Con31 → Ty31 → Set; Tm31
= λ Γ A →
(Tm31 : Con31 → Ty31 → Set)
(var : ∀ Γ A → Var31 Γ A → Tm31 Γ A)
(lam : ∀ Γ A B → Tm31 (snoc31 Γ A) B → Tm31 Γ (arr31 A B))
(app : ∀ Γ A B → Tm31 Γ (arr31 A B) → Tm31 Γ A → Tm31 Γ B)
(tt : ∀ Γ → Tm31 Γ top31)
(pair : ∀ Γ A B → Tm31 Γ A → Tm31 Γ B → Tm31 Γ (prod31 A B))
(fst : ∀ Γ A B → Tm31 Γ (prod31 A B) → Tm31 Γ A)
(snd : ∀ Γ A B → Tm31 Γ (prod31 A B) → Tm31 Γ B)
(left : ∀ Γ A B → Tm31 Γ A → Tm31 Γ (sum31 A B))
(right : ∀ Γ A B → Tm31 Γ B → Tm31 Γ (sum31 A B))
(case : ∀ Γ A B C → Tm31 Γ (sum31 A B) → Tm31 Γ (arr31 A C) → Tm31 Γ (arr31 B C) → Tm31 Γ C)
(zero : ∀ Γ → Tm31 Γ nat31)
(suc : ∀ Γ → Tm31 Γ nat31 → Tm31 Γ nat31)
(rec : ∀ Γ A → Tm31 Γ nat31 → Tm31 Γ (arr31 nat31 (arr31 A A)) → Tm31 Γ A → Tm31 Γ A)
→ Tm31 Γ A
var31 : ∀{Γ A} → Var31 Γ A → Tm31 Γ A; var31
= λ x Tm31 var31 lam app tt pair fst snd left right case zero suc rec →
var31 _ _ x
lam31 : ∀{Γ A B} → Tm31 (snoc31 Γ A) B → Tm31 Γ (arr31 A B); lam31
= λ t Tm31 var31 lam31 app tt pair fst snd left right case zero suc rec →
lam31 _ _ _ (t Tm31 var31 lam31 app tt pair fst snd left right case zero suc rec)
app31 : ∀{Γ A B} → Tm31 Γ (arr31 A B) → Tm31 Γ A → Tm31 Γ B; app31
= λ t u Tm31 var31 lam31 app31 tt pair fst snd left right case zero suc rec →
app31 _ _ _ (t Tm31 var31 lam31 app31 tt pair fst snd left right case zero suc rec)
(u Tm31 var31 lam31 app31 tt pair fst snd left right case zero suc rec)
tt31 : ∀{Γ} → Tm31 Γ top31; tt31
= λ Tm31 var31 lam31 app31 tt31 pair fst snd left right case zero suc rec → tt31 _
pair31 : ∀{Γ A B} → Tm31 Γ A → Tm31 Γ B → Tm31 Γ (prod31 A B); pair31
= λ t u Tm31 var31 lam31 app31 tt31 pair31 fst snd left right case zero suc rec →
pair31 _ _ _ (t Tm31 var31 lam31 app31 tt31 pair31 fst snd left right case zero suc rec)
(u Tm31 var31 lam31 app31 tt31 pair31 fst snd left right case zero suc rec)
fst31 : ∀{Γ A B} → Tm31 Γ (prod31 A B) → Tm31 Γ A; fst31
= λ t Tm31 var31 lam31 app31 tt31 pair31 fst31 snd left right case zero suc rec →
fst31 _ _ _ (t Tm31 var31 lam31 app31 tt31 pair31 fst31 snd left right case zero suc rec)
snd31 : ∀{Γ A B} → Tm31 Γ (prod31 A B) → Tm31 Γ B; snd31
= λ t Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left right case zero suc rec →
snd31 _ _ _ (t Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left right case zero suc rec)
left31 : ∀{Γ A B} → Tm31 Γ A → Tm31 Γ (sum31 A B); left31
= λ t Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right case zero suc rec →
left31 _ _ _ (t Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right case zero suc rec)
right31 : ∀{Γ A B} → Tm31 Γ B → Tm31 Γ (sum31 A B); right31
= λ t Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right31 case zero suc rec →
right31 _ _ _ (t Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right31 case zero suc rec)
case31 : ∀{Γ A B C} → Tm31 Γ (sum31 A B) → Tm31 Γ (arr31 A C) → Tm31 Γ (arr31 B C) → Tm31 Γ C; case31
= λ t u v Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right31 case31 zero suc rec →
case31 _ _ _ _
(t Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right31 case31 zero suc rec)
(u Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right31 case31 zero suc rec)
(v Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right31 case31 zero suc rec)
zero31 : ∀{Γ} → Tm31 Γ nat31; zero31
= λ Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right31 case31 zero31 suc rec → zero31 _
suc31 : ∀{Γ} → Tm31 Γ nat31 → Tm31 Γ nat31; suc31
= λ t Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right31 case31 zero31 suc31 rec →
suc31 _ (t Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right31 case31 zero31 suc31 rec)
rec31 : ∀{Γ A} → Tm31 Γ nat31 → Tm31 Γ (arr31 nat31 (arr31 A A)) → Tm31 Γ A → Tm31 Γ A; rec31
= λ t u v Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right31 case31 zero31 suc31 rec31 →
rec31 _ _
(t Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right31 case31 zero31 suc31 rec31)
(u Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right31 case31 zero31 suc31 rec31)
(v Tm31 var31 lam31 app31 tt31 pair31 fst31 snd31 left31 right31 case31 zero31 suc31 rec31)
v031 : ∀{Γ A} → Tm31 (snoc31 Γ A) A; v031
= var31 vz31
v131 : ∀{Γ A B} → Tm31 (snoc31 (snoc31 Γ A) B) A; v131
= var31 (vs31 vz31)
v231 : ∀{Γ A B C} → Tm31 (snoc31 (snoc31 (snoc31 Γ A) B) C) A; v231
= var31 (vs31 (vs31 vz31))
v331 : ∀{Γ A B C D} → Tm31 (snoc31 (snoc31 (snoc31 (snoc31 Γ A) B) C) D) A; v331
= var31 (vs31 (vs31 (vs31 vz31)))
tbool31 : Ty31; tbool31
= sum31 top31 top31
true31 : ∀{Γ} → Tm31 Γ tbool31; true31
= left31 tt31
tfalse31 : ∀{Γ} → Tm31 Γ tbool31; tfalse31
= right31 tt31
ifthenelse31 : ∀{Γ A} → Tm31 Γ (arr31 tbool31 (arr31 A (arr31 A A))); ifthenelse31
= lam31 (lam31 (lam31 (case31 v231 (lam31 v231) (lam31 v131))))
times431 : ∀{Γ A} → Tm31 Γ (arr31 (arr31 A A) (arr31 A A)); times431
= lam31 (lam31 (app31 v131 (app31 v131 (app31 v131 (app31 v131 v031)))))
add31 : ∀{Γ} → Tm31 Γ (arr31 nat31 (arr31 nat31 nat31)); add31
= lam31 (rec31 v031
(lam31 (lam31 (lam31 (suc31 (app31 v131 v031)))))
(lam31 v031))
mul31 : ∀{Γ} → Tm31 Γ (arr31 nat31 (arr31 nat31 nat31)); mul31
= lam31 (rec31 v031
(lam31 (lam31 (lam31 (app31 (app31 add31 (app31 v131 v031)) v031))))
(lam31 zero31))
fact31 : ∀{Γ} → Tm31 Γ (arr31 nat31 nat31); fact31
= lam31 (rec31 v031 (lam31 (lam31 (app31 (app31 mul31 (suc31 v131)) v031)))
(suc31 zero31))
{-# OPTIONS --type-in-type #-}
Ty32 : Set
Ty32 =
(Ty32 : Set)
(nat top bot : Ty32)
(arr prod sum : Ty32 → Ty32 → Ty32)
→ Ty32
nat32 : Ty32; nat32 = λ _ nat32 _ _ _ _ _ → nat32
top32 : Ty32; top32 = λ _ _ top32 _ _ _ _ → top32
bot32 : Ty32; bot32 = λ _ _ _ bot32 _ _ _ → bot32
arr32 : Ty32 → Ty32 → Ty32; arr32
= λ A B Ty32 nat32 top32 bot32 arr32 prod sum →
arr32 (A Ty32 nat32 top32 bot32 arr32 prod sum) (B Ty32 nat32 top32 bot32 arr32 prod sum)
prod32 : Ty32 → Ty32 → Ty32; prod32
= λ A B Ty32 nat32 top32 bot32 arr32 prod32 sum →
prod32 (A Ty32 nat32 top32 bot32 arr32 prod32 sum) (B Ty32 nat32 top32 bot32 arr32 prod32 sum)
sum32 : Ty32 → Ty32 → Ty32; sum32
= λ A B Ty32 nat32 top32 bot32 arr32 prod32 sum32 →
sum32 (A Ty32 nat32 top32 bot32 arr32 prod32 sum32) (B Ty32 nat32 top32 bot32 arr32 prod32 sum32)
Con32 : Set; Con32
= (Con32 : Set)
(nil : Con32)
(snoc : Con32 → Ty32 → Con32)
→ Con32
nil32 : Con32; nil32
= λ Con32 nil32 snoc → nil32
snoc32 : Con32 → Ty32 → Con32; snoc32
= λ Γ A Con32 nil32 snoc32 → snoc32 (Γ Con32 nil32 snoc32) A
Var32 : Con32 → Ty32 → Set; Var32
= λ Γ A →
(Var32 : Con32 → Ty32 → Set)
(vz : ∀ Γ A → Var32 (snoc32 Γ A) A)
(vs : ∀ Γ B A → Var32 Γ A → Var32 (snoc32 Γ B) A)
→ Var32 Γ A
vz32 : ∀{Γ A} → Var32 (snoc32 Γ A) A; vz32
= λ Var32 vz32 vs → vz32 _ _
vs32 : ∀{Γ B A} → Var32 Γ A → Var32 (snoc32 Γ B) A; vs32
= λ x Var32 vz32 vs32 → vs32 _ _ _ (x Var32 vz32 vs32)
Tm32 : Con32 → Ty32 → Set; Tm32
= λ Γ A →
(Tm32 : Con32 → Ty32 → Set)
(var : ∀ Γ A → Var32 Γ A → Tm32 Γ A)
(lam : ∀ Γ A B → Tm32 (snoc32 Γ A) B → Tm32 Γ (arr32 A B))
(app : ∀ Γ A B → Tm32 Γ (arr32 A B) → Tm32 Γ A → Tm32 Γ B)
(tt : ∀ Γ → Tm32 Γ top32)
(pair : ∀ Γ A B → Tm32 Γ A → Tm32 Γ B → Tm32 Γ (prod32 A B))
(fst : ∀ Γ A B → Tm32 Γ (prod32 A B) → Tm32 Γ A)
(snd : ∀ Γ A B → Tm32 Γ (prod32 A B) → Tm32 Γ B)
(left : ∀ Γ A B → Tm32 Γ A → Tm32 Γ (sum32 A B))
(right : ∀ Γ A B → Tm32 Γ B → Tm32 Γ (sum32 A B))
(case : ∀ Γ A B C → Tm32 Γ (sum32 A B) → Tm32 Γ (arr32 A C) → Tm32 Γ (arr32 B C) → Tm32 Γ C)
(zero : ∀ Γ → Tm32 Γ nat32)
(suc : ∀ Γ → Tm32 Γ nat32 → Tm32 Γ nat32)
(rec : ∀ Γ A → Tm32 Γ nat32 → Tm32 Γ (arr32 nat32 (arr32 A A)) → Tm32 Γ A → Tm32 Γ A)
→ Tm32 Γ A
var32 : ∀{Γ A} → Var32 Γ A → Tm32 Γ A; var32
= λ x Tm32 var32 lam app tt pair fst snd left right case zero suc rec →
var32 _ _ x
lam32 : ∀{Γ A B} → Tm32 (snoc32 Γ A) B → Tm32 Γ (arr32 A B); lam32
= λ t Tm32 var32 lam32 app tt pair fst snd left right case zero suc rec →
lam32 _ _ _ (t Tm32 var32 lam32 app tt pair fst snd left right case zero suc rec)
app32 : ∀{Γ A B} → Tm32 Γ (arr32 A B) → Tm32 Γ A → Tm32 Γ B; app32
= λ t u Tm32 var32 lam32 app32 tt pair fst snd left right case zero suc rec →
app32 _ _ _ (t Tm32 var32 lam32 app32 tt pair fst snd left right case zero suc rec)
(u Tm32 var32 lam32 app32 tt pair fst snd left right case zero suc rec)
tt32 : ∀{Γ} → Tm32 Γ top32; tt32
= λ Tm32 var32 lam32 app32 tt32 pair fst snd left right case zero suc rec → tt32 _
pair32 : ∀{Γ A B} → Tm32 Γ A → Tm32 Γ B → Tm32 Γ (prod32 A B); pair32
= λ t u Tm32 var32 lam32 app32 tt32 pair32 fst snd left right case zero suc rec →
pair32 _ _ _ (t Tm32 var32 lam32 app32 tt32 pair32 fst snd left right case zero suc rec)
(u Tm32 var32 lam32 app32 tt32 pair32 fst snd left right case zero suc rec)
fst32 : ∀{Γ A B} → Tm32 Γ (prod32 A B) → Tm32 Γ A; fst32
= λ t Tm32 var32 lam32 app32 tt32 pair32 fst32 snd left right case zero suc rec →
fst32 _ _ _ (t Tm32 var32 lam32 app32 tt32 pair32 fst32 snd left right case zero suc rec)
snd32 : ∀{Γ A B} → Tm32 Γ (prod32 A B) → Tm32 Γ B; snd32
= λ t Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left right case zero suc rec →
snd32 _ _ _ (t Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left right case zero suc rec)
left32 : ∀{Γ A B} → Tm32 Γ A → Tm32 Γ (sum32 A B); left32
= λ t Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right case zero suc rec →
left32 _ _ _ (t Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right case zero suc rec)
right32 : ∀{Γ A B} → Tm32 Γ B → Tm32 Γ (sum32 A B); right32
= λ t Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right32 case zero suc rec →
right32 _ _ _ (t Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right32 case zero suc rec)
case32 : ∀{Γ A B C} → Tm32 Γ (sum32 A B) → Tm32 Γ (arr32 A C) → Tm32 Γ (arr32 B C) → Tm32 Γ C; case32
= λ t u v Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right32 case32 zero suc rec →
case32 _ _ _ _
(t Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right32 case32 zero suc rec)
(u Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right32 case32 zero suc rec)
(v Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right32 case32 zero suc rec)
zero32 : ∀{Γ} → Tm32 Γ nat32; zero32
= λ Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right32 case32 zero32 suc rec → zero32 _
suc32 : ∀{Γ} → Tm32 Γ nat32 → Tm32 Γ nat32; suc32
= λ t Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right32 case32 zero32 suc32 rec →
suc32 _ (t Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right32 case32 zero32 suc32 rec)
rec32 : ∀{Γ A} → Tm32 Γ nat32 → Tm32 Γ (arr32 nat32 (arr32 A A)) → Tm32 Γ A → Tm32 Γ A; rec32
= λ t u v Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right32 case32 zero32 suc32 rec32 →
rec32 _ _
(t Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right32 case32 zero32 suc32 rec32)
(u Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right32 case32 zero32 suc32 rec32)
(v Tm32 var32 lam32 app32 tt32 pair32 fst32 snd32 left32 right32 case32 zero32 suc32 rec32)
v032 : ∀{Γ A} → Tm32 (snoc32 Γ A) A; v032
= var32 vz32
v132 : ∀{Γ A B} → Tm32 (snoc32 (snoc32 Γ A) B) A; v132
= var32 (vs32 vz32)
v232 : ∀{Γ A B C} → Tm32 (snoc32 (snoc32 (snoc32 Γ A) B) C) A; v232
= var32 (vs32 (vs32 vz32))
v332 : ∀{Γ A B C D} → Tm32 (snoc32 (snoc32 (snoc32 (snoc32 Γ A) B) C) D) A; v332
= var32 (vs32 (vs32 (vs32 vz32)))
tbool32 : Ty32; tbool32
= sum32 top32 top32
true32 : ∀{Γ} → Tm32 Γ tbool32; true32
= left32 tt32
tfalse32 : ∀{Γ} → Tm32 Γ tbool32; tfalse32
= right32 tt32
ifthenelse32 : ∀{Γ A} → Tm32 Γ (arr32 tbool32 (arr32 A (arr32 A A))); ifthenelse32
= lam32 (lam32 (lam32 (case32 v232 (lam32 v232) (lam32 v132))))
times432 : ∀{Γ A} → Tm32 Γ (arr32 (arr32 A A) (arr32 A A)); times432
= lam32 (lam32 (app32 v132 (app32 v132 (app32 v132 (app32 v132 v032)))))
add32 : ∀{Γ} → Tm32 Γ (arr32 nat32 (arr32 nat32 nat32)); add32
= lam32 (rec32 v032
(lam32 (lam32 (lam32 (suc32 (app32 v132 v032)))))
(lam32 v032))
mul32 : ∀{Γ} → Tm32 Γ (arr32 nat32 (arr32 nat32 nat32)); mul32
= lam32 (rec32 v032
(lam32 (lam32 (lam32 (app32 (app32 add32 (app32 v132 v032)) v032))))
(lam32 zero32))
fact32 : ∀{Γ} → Tm32 Γ (arr32 nat32 nat32); fact32
= lam32 (rec32 v032 (lam32 (lam32 (app32 (app32 mul32 (suc32 v132)) v032)))
(suc32 zero32))
{-# OPTIONS --type-in-type #-}
Ty33 : Set
Ty33 =
(Ty33 : Set)
(nat top bot : Ty33)
(arr prod sum : Ty33 → Ty33 → Ty33)
→ Ty33
nat33 : Ty33; nat33 = λ _ nat33 _ _ _ _ _ → nat33
top33 : Ty33; top33 = λ _ _ top33 _ _ _ _ → top33
bot33 : Ty33; bot33 = λ _ _ _ bot33 _ _ _ → bot33
arr33 : Ty33 → Ty33 → Ty33; arr33
= λ A B Ty33 nat33 top33 bot33 arr33 prod sum →
arr33 (A Ty33 nat33 top33 bot33 arr33 prod sum) (B Ty33 nat33 top33 bot33 arr33 prod sum)
prod33 : Ty33 → Ty33 → Ty33; prod33
= λ A B Ty33 nat33 top33 bot33 arr33 prod33 sum →
prod33 (A Ty33 nat33 top33 bot33 arr33 prod33 sum) (B Ty33 nat33 top33 bot33 arr33 prod33 sum)
sum33 : Ty33 → Ty33 → Ty33; sum33
= λ A B Ty33 nat33 top33 bot33 arr33 prod33 sum33 →
sum33 (A Ty33 nat33 top33 bot33 arr33 prod33 sum33) (B Ty33 nat33 top33 bot33 arr33 prod33 sum33)
Con33 : Set; Con33
= (Con33 : Set)
(nil : Con33)
(snoc : Con33 → Ty33 → Con33)
→ Con33
nil33 : Con33; nil33
= λ Con33 nil33 snoc → nil33
snoc33 : Con33 → Ty33 → Con33; snoc33
= λ Γ A Con33 nil33 snoc33 → snoc33 (Γ Con33 nil33 snoc33) A
Var33 : Con33 → Ty33 → Set; Var33
= λ Γ A →
(Var33 : Con33 → Ty33 → Set)
(vz : ∀ Γ A → Var33 (snoc33 Γ A) A)
(vs : ∀ Γ B A → Var33 Γ A → Var33 (snoc33 Γ B) A)
→ Var33 Γ A
vz33 : ∀{Γ A} → Var33 (snoc33 Γ A) A; vz33
= λ Var33 vz33 vs → vz33 _ _
vs33 : ∀{Γ B A} → Var33 Γ A → Var33 (snoc33 Γ B) A; vs33
= λ x Var33 vz33 vs33 → vs33 _ _ _ (x Var33 vz33 vs33)
Tm33 : Con33 → Ty33 → Set; Tm33
= λ Γ A →
(Tm33 : Con33 → Ty33 → Set)
(var : ∀ Γ A → Var33 Γ A → Tm33 Γ A)
(lam : ∀ Γ A B → Tm33 (snoc33 Γ A) B → Tm33 Γ (arr33 A B))
(app : ∀ Γ A B → Tm33 Γ (arr33 A B) → Tm33 Γ A → Tm33 Γ B)
(tt : ∀ Γ → Tm33 Γ top33)
(pair : ∀ Γ A B → Tm33 Γ A → Tm33 Γ B → Tm33 Γ (prod33 A B))
(fst : ∀ Γ A B → Tm33 Γ (prod33 A B) → Tm33 Γ A)
(snd : ∀ Γ A B → Tm33 Γ (prod33 A B) → Tm33 Γ B)
(left : ∀ Γ A B → Tm33 Γ A → Tm33 Γ (sum33 A B))
(right : ∀ Γ A B → Tm33 Γ B → Tm33 Γ (sum33 A B))
(case : ∀ Γ A B C → Tm33 Γ (sum33 A B) → Tm33 Γ (arr33 A C) → Tm33 Γ (arr33 B C) → Tm33 Γ C)
(zero : ∀ Γ → Tm33 Γ nat33)
(suc : ∀ Γ → Tm33 Γ nat33 → Tm33 Γ nat33)
(rec : ∀ Γ A → Tm33 Γ nat33 → Tm33 Γ (arr33 nat33 (arr33 A A)) → Tm33 Γ A → Tm33 Γ A)
→ Tm33 Γ A
var33 : ∀{Γ A} → Var33 Γ A → Tm33 Γ A; var33
= λ x Tm33 var33 lam app tt pair fst snd left right case zero suc rec →
var33 _ _ x
lam33 : ∀{Γ A B} → Tm33 (snoc33 Γ A) B → Tm33 Γ (arr33 A B); lam33
= λ t Tm33 var33 lam33 app tt pair fst snd left right case zero suc rec →
lam33 _ _ _ (t Tm33 var33 lam33 app tt pair fst snd left right case zero suc rec)
app33 : ∀{Γ A B} → Tm33 Γ (arr33 A B) → Tm33 Γ A → Tm33 Γ B; app33
= λ t u Tm33 var33 lam33 app33 tt pair fst snd left right case zero suc rec →
app33 _ _ _ (t Tm33 var33 lam33 app33 tt pair fst snd left right case zero suc rec)
(u Tm33 var33 lam33 app33 tt pair fst snd left right case zero suc rec)
tt33 : ∀{Γ} → Tm33 Γ top33; tt33
= λ Tm33 var33 lam33 app33 tt33 pair fst snd left right case zero suc rec → tt33 _
pair33 : ∀{Γ A B} → Tm33 Γ A → Tm33 Γ B → Tm33 Γ (prod33 A B); pair33
= λ t u Tm33 var33 lam33 app33 tt33 pair33 fst snd left right case zero suc rec →
pair33 _ _ _ (t Tm33 var33 lam33 app33 tt33 pair33 fst snd left right case zero suc rec)
(u Tm33 var33 lam33 app33 tt33 pair33 fst snd left right case zero suc rec)
fst33 : ∀{Γ A B} → Tm33 Γ (prod33 A B) → Tm33 Γ A; fst33
= λ t Tm33 var33 lam33 app33 tt33 pair33 fst33 snd left right case zero suc rec →
fst33 _ _ _ (t Tm33 var33 lam33 app33 tt33 pair33 fst33 snd left right case zero suc rec)
snd33 : ∀{Γ A B} → Tm33 Γ (prod33 A B) → Tm33 Γ B; snd33
= λ t Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left right case zero suc rec →
snd33 _ _ _ (t Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left right case zero suc rec)
left33 : ∀{Γ A B} → Tm33 Γ A → Tm33 Γ (sum33 A B); left33
= λ t Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right case zero suc rec →
left33 _ _ _ (t Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right case zero suc rec)
right33 : ∀{Γ A B} → Tm33 Γ B → Tm33 Γ (sum33 A B); right33
= λ t Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right33 case zero suc rec →
right33 _ _ _ (t Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right33 case zero suc rec)
case33 : ∀{Γ A B C} → Tm33 Γ (sum33 A B) → Tm33 Γ (arr33 A C) → Tm33 Γ (arr33 B C) → Tm33 Γ C; case33
= λ t u v Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right33 case33 zero suc rec →
case33 _ _ _ _
(t Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right33 case33 zero suc rec)
(u Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right33 case33 zero suc rec)
(v Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right33 case33 zero suc rec)
zero33 : ∀{Γ} → Tm33 Γ nat33; zero33
= λ Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right33 case33 zero33 suc rec → zero33 _
suc33 : ∀{Γ} → Tm33 Γ nat33 → Tm33 Γ nat33; suc33
= λ t Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right33 case33 zero33 suc33 rec →
suc33 _ (t Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right33 case33 zero33 suc33 rec)
rec33 : ∀{Γ A} → Tm33 Γ nat33 → Tm33 Γ (arr33 nat33 (arr33 A A)) → Tm33 Γ A → Tm33 Γ A; rec33
= λ t u v Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right33 case33 zero33 suc33 rec33 →
rec33 _ _
(t Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right33 case33 zero33 suc33 rec33)
(u Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right33 case33 zero33 suc33 rec33)
(v Tm33 var33 lam33 app33 tt33 pair33 fst33 snd33 left33 right33 case33 zero33 suc33 rec33)
v033 : ∀{Γ A} → Tm33 (snoc33 Γ A) A; v033
= var33 vz33
v133 : ∀{Γ A B} → Tm33 (snoc33 (snoc33 Γ A) B) A; v133
= var33 (vs33 vz33)
v233 : ∀{Γ A B C} → Tm33 (snoc33 (snoc33 (snoc33 Γ A) B) C) A; v233
= var33 (vs33 (vs33 vz33))
v333 : ∀{Γ A B C D} → Tm33 (snoc33 (snoc33 (snoc33 (snoc33 Γ A) B) C) D) A; v333
= var33 (vs33 (vs33 (vs33 vz33)))
tbool33 : Ty33; tbool33
= sum33 top33 top33
true33 : ∀{Γ} → Tm33 Γ tbool33; true33
= left33 tt33
tfalse33 : ∀{Γ} → Tm33 Γ tbool33; tfalse33
= right33 tt33
ifthenelse33 : ∀{Γ A} → Tm33 Γ (arr33 tbool33 (arr33 A (arr33 A A))); ifthenelse33
= lam33 (lam33 (lam33 (case33 v233 (lam33 v233) (lam33 v133))))
times433 : ∀{Γ A} → Tm33 Γ (arr33 (arr33 A A) (arr33 A A)); times433
= lam33 (lam33 (app33 v133 (app33 v133 (app33 v133 (app33 v133 v033)))))
add33 : ∀{Γ} → Tm33 Γ (arr33 nat33 (arr33 nat33 nat33)); add33
= lam33 (rec33 v033
(lam33 (lam33 (lam33 (suc33 (app33 v133 v033)))))
(lam33 v033))
mul33 : ∀{Γ} → Tm33 Γ (arr33 nat33 (arr33 nat33 nat33)); mul33
= lam33 (rec33 v033
(lam33 (lam33 (lam33 (app33 (app33 add33 (app33 v133 v033)) v033))))
(lam33 zero33))
fact33 : ∀{Γ} → Tm33 Γ (arr33 nat33 nat33); fact33
= lam33 (rec33 v033 (lam33 (lam33 (app33 (app33 mul33 (suc33 v133)) v033)))
(suc33 zero33))
{-# OPTIONS --type-in-type #-}
Ty34 : Set
Ty34 =
(Ty34 : Set)
(nat top bot : Ty34)
(arr prod sum : Ty34 → Ty34 → Ty34)
→ Ty34
nat34 : Ty34; nat34 = λ _ nat34 _ _ _ _ _ → nat34
top34 : Ty34; top34 = λ _ _ top34 _ _ _ _ → top34
bot34 : Ty34; bot34 = λ _ _ _ bot34 _ _ _ → bot34
arr34 : Ty34 → Ty34 → Ty34; arr34
= λ A B Ty34 nat34 top34 bot34 arr34 prod sum →
arr34 (A Ty34 nat34 top34 bot34 arr34 prod sum) (B Ty34 nat34 top34 bot34 arr34 prod sum)
prod34 : Ty34 → Ty34 → Ty34; prod34
= λ A B Ty34 nat34 top34 bot34 arr34 prod34 sum →
prod34 (A Ty34 nat34 top34 bot34 arr34 prod34 sum) (B Ty34 nat34 top34 bot34 arr34 prod34 sum)
sum34 : Ty34 → Ty34 → Ty34; sum34
= λ A B Ty34 nat34 top34 bot34 arr34 prod34 sum34 →
sum34 (A Ty34 nat34 top34 bot34 arr34 prod34 sum34) (B Ty34 nat34 top34 bot34 arr34 prod34 sum34)
Con34 : Set; Con34
= (Con34 : Set)
(nil : Con34)
(snoc : Con34 → Ty34 → Con34)
→ Con34
nil34 : Con34; nil34
= λ Con34 nil34 snoc → nil34
snoc34 : Con34 → Ty34 → Con34; snoc34
= λ Γ A Con34 nil34 snoc34 → snoc34 (Γ Con34 nil34 snoc34) A
Var34 : Con34 → Ty34 → Set; Var34
= λ Γ A →
(Var34 : Con34 → Ty34 → Set)
(vz : ∀ Γ A → Var34 (snoc34 Γ A) A)
(vs : ∀ Γ B A → Var34 Γ A → Var34 (snoc34 Γ B) A)
→ Var34 Γ A
vz34 : ∀{Γ A} → Var34 (snoc34 Γ A) A; vz34
= λ Var34 vz34 vs → vz34 _ _
vs34 : ∀{Γ B A} → Var34 Γ A → Var34 (snoc34 Γ B) A; vs34
= λ x Var34 vz34 vs34 → vs34 _ _ _ (x Var34 vz34 vs34)
Tm34 : Con34 → Ty34 → Set; Tm34
= λ Γ A →
(Tm34 : Con34 → Ty34 → Set)
(var : ∀ Γ A → Var34 Γ A → Tm34 Γ A)
(lam : ∀ Γ A B → Tm34 (snoc34 Γ A) B → Tm34 Γ (arr34 A B))
(app : ∀ Γ A B → Tm34 Γ (arr34 A B) → Tm34 Γ A → Tm34 Γ B)
(tt : ∀ Γ → Tm34 Γ top34)
(pair : ∀ Γ A B → Tm34 Γ A → Tm34 Γ B → Tm34 Γ (prod34 A B))
(fst : ∀ Γ A B → Tm34 Γ (prod34 A B) → Tm34 Γ A)
(snd : ∀ Γ A B → Tm34 Γ (prod34 A B) → Tm34 Γ B)
(left : ∀ Γ A B → Tm34 Γ A → Tm34 Γ (sum34 A B))
(right : ∀ Γ A B → Tm34 Γ B → Tm34 Γ (sum34 A B))
(case : ∀ Γ A B C → Tm34 Γ (sum34 A B) → Tm34 Γ (arr34 A C) → Tm34 Γ (arr34 B C) → Tm34 Γ C)
(zero : ∀ Γ → Tm34 Γ nat34)
(suc : ∀ Γ → Tm34 Γ nat34 → Tm34 Γ nat34)
(rec : ∀ Γ A → Tm34 Γ nat34 → Tm34 Γ (arr34 nat34 (arr34 A A)) → Tm34 Γ A → Tm34 Γ A)
→ Tm34 Γ A
var34 : ∀{Γ A} → Var34 Γ A → Tm34 Γ A; var34
= λ x Tm34 var34 lam app tt pair fst snd left right case zero suc rec →
var34 _ _ x
lam34 : ∀{Γ A B} → Tm34 (snoc34 Γ A) B → Tm34 Γ (arr34 A B); lam34
= λ t Tm34 var34 lam34 app tt pair fst snd left right case zero suc rec →
lam34 _ _ _ (t Tm34 var34 lam34 app tt pair fst snd left right case zero suc rec)
app34 : ∀{Γ A B} → Tm34 Γ (arr34 A B) → Tm34 Γ A → Tm34 Γ B; app34
= λ t u Tm34 var34 lam34 app34 tt pair fst snd left right case zero suc rec →
app34 _ _ _ (t Tm34 var34 lam34 app34 tt pair fst snd left right case zero suc rec)
(u Tm34 var34 lam34 app34 tt pair fst snd left right case zero suc rec)
tt34 : ∀{Γ} → Tm34 Γ top34; tt34
= λ Tm34 var34 lam34 app34 tt34 pair fst snd left right case zero suc rec → tt34 _
pair34 : ∀{Γ A B} → Tm34 Γ A → Tm34 Γ B → Tm34 Γ (prod34 A B); pair34
= λ t u Tm34 var34 lam34 app34 tt34 pair34 fst snd left right case zero suc rec →
pair34 _ _ _ (t Tm34 var34 lam34 app34 tt34 pair34 fst snd left right case zero suc rec)
(u Tm34 var34 lam34 app34 tt34 pair34 fst snd left right case zero suc rec)
fst34 : ∀{Γ A B} → Tm34 Γ (prod34 A B) → Tm34 Γ A; fst34
= λ t Tm34 var34 lam34 app34 tt34 pair34 fst34 snd left right case zero suc rec →
fst34 _ _ _ (t Tm34 var34 lam34 app34 tt34 pair34 fst34 snd left right case zero suc rec)
snd34 : ∀{Γ A B} → Tm34 Γ (prod34 A B) → Tm34 Γ B; snd34
= λ t Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left right case zero suc rec →
snd34 _ _ _ (t Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left right case zero suc rec)
left34 : ∀{Γ A B} → Tm34 Γ A → Tm34 Γ (sum34 A B); left34
= λ t Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right case zero suc rec →
left34 _ _ _ (t Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right case zero suc rec)
right34 : ∀{Γ A B} → Tm34 Γ B → Tm34 Γ (sum34 A B); right34
= λ t Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right34 case zero suc rec →
right34 _ _ _ (t Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right34 case zero suc rec)
case34 : ∀{Γ A B C} → Tm34 Γ (sum34 A B) → Tm34 Γ (arr34 A C) → Tm34 Γ (arr34 B C) → Tm34 Γ C; case34
= λ t u v Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right34 case34 zero suc rec →
case34 _ _ _ _
(t Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right34 case34 zero suc rec)
(u Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right34 case34 zero suc rec)
(v Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right34 case34 zero suc rec)
zero34 : ∀{Γ} → Tm34 Γ nat34; zero34
= λ Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right34 case34 zero34 suc rec → zero34 _
suc34 : ∀{Γ} → Tm34 Γ nat34 → Tm34 Γ nat34; suc34
= λ t Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right34 case34 zero34 suc34 rec →
suc34 _ (t Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right34 case34 zero34 suc34 rec)
rec34 : ∀{Γ A} → Tm34 Γ nat34 → Tm34 Γ (arr34 nat34 (arr34 A A)) → Tm34 Γ A → Tm34 Γ A; rec34
= λ t u v Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right34 case34 zero34 suc34 rec34 →
rec34 _ _
(t Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right34 case34 zero34 suc34 rec34)
(u Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right34 case34 zero34 suc34 rec34)
(v Tm34 var34 lam34 app34 tt34 pair34 fst34 snd34 left34 right34 case34 zero34 suc34 rec34)
v034 : ∀{Γ A} → Tm34 (snoc34 Γ A) A; v034
= var34 vz34
v134 : ∀{Γ A B} → Tm34 (snoc34 (snoc34 Γ A) B) A; v134
= var34 (vs34 vz34)
v234 : ∀{Γ A B C} → Tm34 (snoc34 (snoc34 (snoc34 Γ A) B) C) A; v234
= var34 (vs34 (vs34 vz34))
v334 : ∀{Γ A B C D} → Tm34 (snoc34 (snoc34 (snoc34 (snoc34 Γ A) B) C) D) A; v334
= var34 (vs34 (vs34 (vs34 vz34)))
tbool34 : Ty34; tbool34
= sum34 top34 top34
true34 : ∀{Γ} → Tm34 Γ tbool34; true34
= left34 tt34
tfalse34 : ∀{Γ} → Tm34 Γ tbool34; tfalse34
= right34 tt34
ifthenelse34 : ∀{Γ A} → Tm34 Γ (arr34 tbool34 (arr34 A (arr34 A A))); ifthenelse34
= lam34 (lam34 (lam34 (case34 v234 (lam34 v234) (lam34 v134))))
times434 : ∀{Γ A} → Tm34 Γ (arr34 (arr34 A A) (arr34 A A)); times434
= lam34 (lam34 (app34 v134 (app34 v134 (app34 v134 (app34 v134 v034)))))
add34 : ∀{Γ} → Tm34 Γ (arr34 nat34 (arr34 nat34 nat34)); add34
= lam34 (rec34 v034
(lam34 (lam34 (lam34 (suc34 (app34 v134 v034)))))
(lam34 v034))
mul34 : ∀{Γ} → Tm34 Γ (arr34 nat34 (arr34 nat34 nat34)); mul34
= lam34 (rec34 v034
(lam34 (lam34 (lam34 (app34 (app34 add34 (app34 v134 v034)) v034))))
(lam34 zero34))
fact34 : ∀{Γ} → Tm34 Γ (arr34 nat34 nat34); fact34
= lam34 (rec34 v034 (lam34 (lam34 (app34 (app34 mul34 (suc34 v134)) v034)))
(suc34 zero34))
{-# OPTIONS --type-in-type #-}
Ty35 : Set
Ty35 =
(Ty35 : Set)
(nat top bot : Ty35)
(arr prod sum : Ty35 → Ty35 → Ty35)
→ Ty35
nat35 : Ty35; nat35 = λ _ nat35 _ _ _ _ _ → nat35
top35 : Ty35; top35 = λ _ _ top35 _ _ _ _ → top35
bot35 : Ty35; bot35 = λ _ _ _ bot35 _ _ _ → bot35
arr35 : Ty35 → Ty35 → Ty35; arr35
= λ A B Ty35 nat35 top35 bot35 arr35 prod sum →
arr35 (A Ty35 nat35 top35 bot35 arr35 prod sum) (B Ty35 nat35 top35 bot35 arr35 prod sum)
prod35 : Ty35 → Ty35 → Ty35; prod35
= λ A B Ty35 nat35 top35 bot35 arr35 prod35 sum →
prod35 (A Ty35 nat35 top35 bot35 arr35 prod35 sum) (B Ty35 nat35 top35 bot35 arr35 prod35 sum)
sum35 : Ty35 → Ty35 → Ty35; sum35
= λ A B Ty35 nat35 top35 bot35 arr35 prod35 sum35 →
sum35 (A Ty35 nat35 top35 bot35 arr35 prod35 sum35) (B Ty35 nat35 top35 bot35 arr35 prod35 sum35)
Con35 : Set; Con35
= (Con35 : Set)
(nil : Con35)
(snoc : Con35 → Ty35 → Con35)
→ Con35
nil35 : Con35; nil35
= λ Con35 nil35 snoc → nil35
snoc35 : Con35 → Ty35 → Con35; snoc35
= λ Γ A Con35 nil35 snoc35 → snoc35 (Γ Con35 nil35 snoc35) A
Var35 : Con35 → Ty35 → Set; Var35
= λ Γ A →
(Var35 : Con35 → Ty35 → Set)
(vz : ∀ Γ A → Var35 (snoc35 Γ A) A)
(vs : ∀ Γ B A → Var35 Γ A → Var35 (snoc35 Γ B) A)
→ Var35 Γ A
vz35 : ∀{Γ A} → Var35 (snoc35 Γ A) A; vz35
= λ Var35 vz35 vs → vz35 _ _
vs35 : ∀{Γ B A} → Var35 Γ A → Var35 (snoc35 Γ B) A; vs35
= λ x Var35 vz35 vs35 → vs35 _ _ _ (x Var35 vz35 vs35)
Tm35 : Con35 → Ty35 → Set; Tm35
= λ Γ A →
(Tm35 : Con35 → Ty35 → Set)
(var : ∀ Γ A → Var35 Γ A → Tm35 Γ A)
(lam : ∀ Γ A B → Tm35 (snoc35 Γ A) B → Tm35 Γ (arr35 A B))
(app : ∀ Γ A B → Tm35 Γ (arr35 A B) → Tm35 Γ A → Tm35 Γ B)
(tt : ∀ Γ → Tm35 Γ top35)
(pair : ∀ Γ A B → Tm35 Γ A → Tm35 Γ B → Tm35 Γ (prod35 A B))
(fst : ∀ Γ A B → Tm35 Γ (prod35 A B) → Tm35 Γ A)
(snd : ∀ Γ A B → Tm35 Γ (prod35 A B) → Tm35 Γ B)
(left : ∀ Γ A B → Tm35 Γ A → Tm35 Γ (sum35 A B))
(right : ∀ Γ A B → Tm35 Γ B → Tm35 Γ (sum35 A B))
(case : ∀ Γ A B C → Tm35 Γ (sum35 A B) → Tm35 Γ (arr35 A C) → Tm35 Γ (arr35 B C) → Tm35 Γ C)
(zero : ∀ Γ → Tm35 Γ nat35)
(suc : ∀ Γ → Tm35 Γ nat35 → Tm35 Γ nat35)
(rec : ∀ Γ A → Tm35 Γ nat35 → Tm35 Γ (arr35 nat35 (arr35 A A)) → Tm35 Γ A → Tm35 Γ A)
→ Tm35 Γ A
var35 : ∀{Γ A} → Var35 Γ A → Tm35 Γ A; var35
= λ x Tm35 var35 lam app tt pair fst snd left right case zero suc rec →
var35 _ _ x
lam35 : ∀{Γ A B} → Tm35 (snoc35 Γ A) B → Tm35 Γ (arr35 A B); lam35
= λ t Tm35 var35 lam35 app tt pair fst snd left right case zero suc rec →
lam35 _ _ _ (t Tm35 var35 lam35 app tt pair fst snd left right case zero suc rec)
app35 : ∀{Γ A B} → Tm35 Γ (arr35 A B) → Tm35 Γ A → Tm35 Γ B; app35
= λ t u Tm35 var35 lam35 app35 tt pair fst snd left right case zero suc rec →
app35 _ _ _ (t Tm35 var35 lam35 app35 tt pair fst snd left right case zero suc rec)
(u Tm35 var35 lam35 app35 tt pair fst snd left right case zero suc rec)
tt35 : ∀{Γ} → Tm35 Γ top35; tt35
= λ Tm35 var35 lam35 app35 tt35 pair fst snd left right case zero suc rec → tt35 _
pair35 : ∀{Γ A B} → Tm35 Γ A → Tm35 Γ B → Tm35 Γ (prod35 A B); pair35
= λ t u Tm35 var35 lam35 app35 tt35 pair35 fst snd left right case zero suc rec →
pair35 _ _ _ (t Tm35 var35 lam35 app35 tt35 pair35 fst snd left right case zero suc rec)
(u Tm35 var35 lam35 app35 tt35 pair35 fst snd left right case zero suc rec)
fst35 : ∀{Γ A B} → Tm35 Γ (prod35 A B) → Tm35 Γ A; fst35
= λ t Tm35 var35 lam35 app35 tt35 pair35 fst35 snd left right case zero suc rec →
fst35 _ _ _ (t Tm35 var35 lam35 app35 tt35 pair35 fst35 snd left right case zero suc rec)
snd35 : ∀{Γ A B} → Tm35 Γ (prod35 A B) → Tm35 Γ B; snd35
= λ t Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left right case zero suc rec →
snd35 _ _ _ (t Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left right case zero suc rec)
left35 : ∀{Γ A B} → Tm35 Γ A → Tm35 Γ (sum35 A B); left35
= λ t Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right case zero suc rec →
left35 _ _ _ (t Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right case zero suc rec)
right35 : ∀{Γ A B} → Tm35 Γ B → Tm35 Γ (sum35 A B); right35
= λ t Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right35 case zero suc rec →
right35 _ _ _ (t Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right35 case zero suc rec)
case35 : ∀{Γ A B C} → Tm35 Γ (sum35 A B) → Tm35 Γ (arr35 A C) → Tm35 Γ (arr35 B C) → Tm35 Γ C; case35
= λ t u v Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right35 case35 zero suc rec →
case35 _ _ _ _
(t Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right35 case35 zero suc rec)
(u Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right35 case35 zero suc rec)
(v Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right35 case35 zero suc rec)
zero35 : ∀{Γ} → Tm35 Γ nat35; zero35
= λ Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right35 case35 zero35 suc rec → zero35 _
suc35 : ∀{Γ} → Tm35 Γ nat35 → Tm35 Γ nat35; suc35
= λ t Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right35 case35 zero35 suc35 rec →
suc35 _ (t Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right35 case35 zero35 suc35 rec)
rec35 : ∀{Γ A} → Tm35 Γ nat35 → Tm35 Γ (arr35 nat35 (arr35 A A)) → Tm35 Γ A → Tm35 Γ A; rec35
= λ t u v Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right35 case35 zero35 suc35 rec35 →
rec35 _ _
(t Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right35 case35 zero35 suc35 rec35)
(u Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right35 case35 zero35 suc35 rec35)
(v Tm35 var35 lam35 app35 tt35 pair35 fst35 snd35 left35 right35 case35 zero35 suc35 rec35)
v035 : ∀{Γ A} → Tm35 (snoc35 Γ A) A; v035
= var35 vz35
v135 : ∀{Γ A B} → Tm35 (snoc35 (snoc35 Γ A) B) A; v135
= var35 (vs35 vz35)
v235 : ∀{Γ A B C} → Tm35 (snoc35 (snoc35 (snoc35 Γ A) B) C) A; v235
= var35 (vs35 (vs35 vz35))
v335 : ∀{Γ A B C D} → Tm35 (snoc35 (snoc35 (snoc35 (snoc35 Γ A) B) C) D) A; v335
= var35 (vs35 (vs35 (vs35 vz35)))
tbool35 : Ty35; tbool35
= sum35 top35 top35
true35 : ∀{Γ} → Tm35 Γ tbool35; true35
= left35 tt35
tfalse35 : ∀{Γ} → Tm35 Γ tbool35; tfalse35
= right35 tt35
ifthenelse35 : ∀{Γ A} → Tm35 Γ (arr35 tbool35 (arr35 A (arr35 A A))); ifthenelse35
= lam35 (lam35 (lam35 (case35 v235 (lam35 v235) (lam35 v135))))
times435 : ∀{Γ A} → Tm35 Γ (arr35 (arr35 A A) (arr35 A A)); times435
= lam35 (lam35 (app35 v135 (app35 v135 (app35 v135 (app35 v135 v035)))))
add35 : ∀{Γ} → Tm35 Γ (arr35 nat35 (arr35 nat35 nat35)); add35
= lam35 (rec35 v035
(lam35 (lam35 (lam35 (suc35 (app35 v135 v035)))))
(lam35 v035))
mul35 : ∀{Γ} → Tm35 Γ (arr35 nat35 (arr35 nat35 nat35)); mul35
= lam35 (rec35 v035
(lam35 (lam35 (lam35 (app35 (app35 add35 (app35 v135 v035)) v035))))
(lam35 zero35))
fact35 : ∀{Γ} → Tm35 Γ (arr35 nat35 nat35); fact35
= lam35 (rec35 v035 (lam35 (lam35 (app35 (app35 mul35 (suc35 v135)) v035)))
(suc35 zero35))
{-# OPTIONS --type-in-type #-}
Ty36 : Set
Ty36 =
(Ty36 : Set)
(nat top bot : Ty36)
(arr prod sum : Ty36 → Ty36 → Ty36)
→ Ty36
nat36 : Ty36; nat36 = λ _ nat36 _ _ _ _ _ → nat36
top36 : Ty36; top36 = λ _ _ top36 _ _ _ _ → top36
bot36 : Ty36; bot36 = λ _ _ _ bot36 _ _ _ → bot36
arr36 : Ty36 → Ty36 → Ty36; arr36
= λ A B Ty36 nat36 top36 bot36 arr36 prod sum →
arr36 (A Ty36 nat36 top36 bot36 arr36 prod sum) (B Ty36 nat36 top36 bot36 arr36 prod sum)
prod36 : Ty36 → Ty36 → Ty36; prod36
= λ A B Ty36 nat36 top36 bot36 arr36 prod36 sum →
prod36 (A Ty36 nat36 top36 bot36 arr36 prod36 sum) (B Ty36 nat36 top36 bot36 arr36 prod36 sum)
sum36 : Ty36 → Ty36 → Ty36; sum36
= λ A B Ty36 nat36 top36 bot36 arr36 prod36 sum36 →
sum36 (A Ty36 nat36 top36 bot36 arr36 prod36 sum36) (B Ty36 nat36 top36 bot36 arr36 prod36 sum36)
Con36 : Set; Con36
= (Con36 : Set)
(nil : Con36)
(snoc : Con36 → Ty36 → Con36)
→ Con36
nil36 : Con36; nil36
= λ Con36 nil36 snoc → nil36
snoc36 : Con36 → Ty36 → Con36; snoc36
= λ Γ A Con36 nil36 snoc36 → snoc36 (Γ Con36 nil36 snoc36) A
Var36 : Con36 → Ty36 → Set; Var36
= λ Γ A →
(Var36 : Con36 → Ty36 → Set)
(vz : ∀ Γ A → Var36 (snoc36 Γ A) A)
(vs : ∀ Γ B A → Var36 Γ A → Var36 (snoc36 Γ B) A)
→ Var36 Γ A
vz36 : ∀{Γ A} → Var36 (snoc36 Γ A) A; vz36
= λ Var36 vz36 vs → vz36 _ _
vs36 : ∀{Γ B A} → Var36 Γ A → Var36 (snoc36 Γ B) A; vs36
= λ x Var36 vz36 vs36 → vs36 _ _ _ (x Var36 vz36 vs36)
Tm36 : Con36 → Ty36 → Set; Tm36
= λ Γ A →
(Tm36 : Con36 → Ty36 → Set)
(var : ∀ Γ A → Var36 Γ A → Tm36 Γ A)
(lam : ∀ Γ A B → Tm36 (snoc36 Γ A) B → Tm36 Γ (arr36 A B))
(app : ∀ Γ A B → Tm36 Γ (arr36 A B) → Tm36 Γ A → Tm36 Γ B)
(tt : ∀ Γ → Tm36 Γ top36)
(pair : ∀ Γ A B → Tm36 Γ A → Tm36 Γ B → Tm36 Γ (prod36 A B))
(fst : ∀ Γ A B → Tm36 Γ (prod36 A B) → Tm36 Γ A)
(snd : ∀ Γ A B → Tm36 Γ (prod36 A B) → Tm36 Γ B)
(left : ∀ Γ A B → Tm36 Γ A → Tm36 Γ (sum36 A B))
(right : ∀ Γ A B → Tm36 Γ B → Tm36 Γ (sum36 A B))
(case : ∀ Γ A B C → Tm36 Γ (sum36 A B) → Tm36 Γ (arr36 A C) → Tm36 Γ (arr36 B C) → Tm36 Γ C)
(zero : ∀ Γ → Tm36 Γ nat36)
(suc : ∀ Γ → Tm36 Γ nat36 → Tm36 Γ nat36)
(rec : ∀ Γ A → Tm36 Γ nat36 → Tm36 Γ (arr36 nat36 (arr36 A A)) → Tm36 Γ A → Tm36 Γ A)
→ Tm36 Γ A
var36 : ∀{Γ A} → Var36 Γ A → Tm36 Γ A; var36
= λ x Tm36 var36 lam app tt pair fst snd left right case zero suc rec →
var36 _ _ x
lam36 : ∀{Γ A B} → Tm36 (snoc36 Γ A) B → Tm36 Γ (arr36 A B); lam36
= λ t Tm36 var36 lam36 app tt pair fst snd left right case zero suc rec →
lam36 _ _ _ (t Tm36 var36 lam36 app tt pair fst snd left right case zero suc rec)
app36 : ∀{Γ A B} → Tm36 Γ (arr36 A B) → Tm36 Γ A → Tm36 Γ B; app36
= λ t u Tm36 var36 lam36 app36 tt pair fst snd left right case zero suc rec →
app36 _ _ _ (t Tm36 var36 lam36 app36 tt pair fst snd left right case zero suc rec)
(u Tm36 var36 lam36 app36 tt pair fst snd left right case zero suc rec)
tt36 : ∀{Γ} → Tm36 Γ top36; tt36
= λ Tm36 var36 lam36 app36 tt36 pair fst snd left right case zero suc rec → tt36 _
pair36 : ∀{Γ A B} → Tm36 Γ A → Tm36 Γ B → Tm36 Γ (prod36 A B); pair36
= λ t u Tm36 var36 lam36 app36 tt36 pair36 fst snd left right case zero suc rec →
pair36 _ _ _ (t Tm36 var36 lam36 app36 tt36 pair36 fst snd left right case zero suc rec)
(u Tm36 var36 lam36 app36 tt36 pair36 fst snd left right case zero suc rec)
fst36 : ∀{Γ A B} → Tm36 Γ (prod36 A B) → Tm36 Γ A; fst36
= λ t Tm36 var36 lam36 app36 tt36 pair36 fst36 snd left right case zero suc rec →
fst36 _ _ _ (t Tm36 var36 lam36 app36 tt36 pair36 fst36 snd left right case zero suc rec)
snd36 : ∀{Γ A B} → Tm36 Γ (prod36 A B) → Tm36 Γ B; snd36
= λ t Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left right case zero suc rec →
snd36 _ _ _ (t Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left right case zero suc rec)
left36 : ∀{Γ A B} → Tm36 Γ A → Tm36 Γ (sum36 A B); left36
= λ t Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right case zero suc rec →
left36 _ _ _ (t Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right case zero suc rec)
right36 : ∀{Γ A B} → Tm36 Γ B → Tm36 Γ (sum36 A B); right36
= λ t Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right36 case zero suc rec →
right36 _ _ _ (t Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right36 case zero suc rec)
case36 : ∀{Γ A B C} → Tm36 Γ (sum36 A B) → Tm36 Γ (arr36 A C) → Tm36 Γ (arr36 B C) → Tm36 Γ C; case36
= λ t u v Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right36 case36 zero suc rec →
case36 _ _ _ _
(t Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right36 case36 zero suc rec)
(u Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right36 case36 zero suc rec)
(v Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right36 case36 zero suc rec)
zero36 : ∀{Γ} → Tm36 Γ nat36; zero36
= λ Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right36 case36 zero36 suc rec → zero36 _
suc36 : ∀{Γ} → Tm36 Γ nat36 → Tm36 Γ nat36; suc36
= λ t Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right36 case36 zero36 suc36 rec →
suc36 _ (t Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right36 case36 zero36 suc36 rec)
rec36 : ∀{Γ A} → Tm36 Γ nat36 → Tm36 Γ (arr36 nat36 (arr36 A A)) → Tm36 Γ A → Tm36 Γ A; rec36
= λ t u v Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right36 case36 zero36 suc36 rec36 →
rec36 _ _
(t Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right36 case36 zero36 suc36 rec36)
(u Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right36 case36 zero36 suc36 rec36)
(v Tm36 var36 lam36 app36 tt36 pair36 fst36 snd36 left36 right36 case36 zero36 suc36 rec36)
v036 : ∀{Γ A} → Tm36 (snoc36 Γ A) A; v036
= var36 vz36
v136 : ∀{Γ A B} → Tm36 (snoc36 (snoc36 Γ A) B) A; v136
= var36 (vs36 vz36)
v236 : ∀{Γ A B C} → Tm36 (snoc36 (snoc36 (snoc36 Γ A) B) C) A; v236
= var36 (vs36 (vs36 vz36))
v336 : ∀{Γ A B C D} → Tm36 (snoc36 (snoc36 (snoc36 (snoc36 Γ A) B) C) D) A; v336
= var36 (vs36 (vs36 (vs36 vz36)))
tbool36 : Ty36; tbool36
= sum36 top36 top36
true36 : ∀{Γ} → Tm36 Γ tbool36; true36
= left36 tt36
tfalse36 : ∀{Γ} → Tm36 Γ tbool36; tfalse36
= right36 tt36
ifthenelse36 : ∀{Γ A} → Tm36 Γ (arr36 tbool36 (arr36 A (arr36 A A))); ifthenelse36
= lam36 (lam36 (lam36 (case36 v236 (lam36 v236) (lam36 v136))))
times436 : ∀{Γ A} → Tm36 Γ (arr36 (arr36 A A) (arr36 A A)); times436
= lam36 (lam36 (app36 v136 (app36 v136 (app36 v136 (app36 v136 v036)))))
add36 : ∀{Γ} → Tm36 Γ (arr36 nat36 (arr36 nat36 nat36)); add36
= lam36 (rec36 v036
(lam36 (lam36 (lam36 (suc36 (app36 v136 v036)))))
(lam36 v036))
mul36 : ∀{Γ} → Tm36 Γ (arr36 nat36 (arr36 nat36 nat36)); mul36
= lam36 (rec36 v036
(lam36 (lam36 (lam36 (app36 (app36 add36 (app36 v136 v036)) v036))))
(lam36 zero36))
fact36 : ∀{Γ} → Tm36 Γ (arr36 nat36 nat36); fact36
= lam36 (rec36 v036 (lam36 (lam36 (app36 (app36 mul36 (suc36 v136)) v036)))
(suc36 zero36))
{-# OPTIONS --type-in-type #-}
Ty37 : Set
Ty37 =
(Ty37 : Set)
(nat top bot : Ty37)
(arr prod sum : Ty37 → Ty37 → Ty37)
→ Ty37
nat37 : Ty37; nat37 = λ _ nat37 _ _ _ _ _ → nat37
top37 : Ty37; top37 = λ _ _ top37 _ _ _ _ → top37
bot37 : Ty37; bot37 = λ _ _ _ bot37 _ _ _ → bot37
arr37 : Ty37 → Ty37 → Ty37; arr37
= λ A B Ty37 nat37 top37 bot37 arr37 prod sum →
arr37 (A Ty37 nat37 top37 bot37 arr37 prod sum) (B Ty37 nat37 top37 bot37 arr37 prod sum)
prod37 : Ty37 → Ty37 → Ty37; prod37
= λ A B Ty37 nat37 top37 bot37 arr37 prod37 sum →
prod37 (A Ty37 nat37 top37 bot37 arr37 prod37 sum) (B Ty37 nat37 top37 bot37 arr37 prod37 sum)
sum37 : Ty37 → Ty37 → Ty37; sum37
= λ A B Ty37 nat37 top37 bot37 arr37 prod37 sum37 →
sum37 (A Ty37 nat37 top37 bot37 arr37 prod37 sum37) (B Ty37 nat37 top37 bot37 arr37 prod37 sum37)
Con37 : Set; Con37
= (Con37 : Set)
(nil : Con37)
(snoc : Con37 → Ty37 → Con37)
→ Con37
nil37 : Con37; nil37
= λ Con37 nil37 snoc → nil37
snoc37 : Con37 → Ty37 → Con37; snoc37
= λ Γ A Con37 nil37 snoc37 → snoc37 (Γ Con37 nil37 snoc37) A
Var37 : Con37 → Ty37 → Set; Var37
= λ Γ A →
(Var37 : Con37 → Ty37 → Set)
(vz : ∀ Γ A → Var37 (snoc37 Γ A) A)
(vs : ∀ Γ B A → Var37 Γ A → Var37 (snoc37 Γ B) A)
→ Var37 Γ A
vz37 : ∀{Γ A} → Var37 (snoc37 Γ A) A; vz37
= λ Var37 vz37 vs → vz37 _ _
vs37 : ∀{Γ B A} → Var37 Γ A → Var37 (snoc37 Γ B) A; vs37
= λ x Var37 vz37 vs37 → vs37 _ _ _ (x Var37 vz37 vs37)
Tm37 : Con37 → Ty37 → Set; Tm37
= λ Γ A →
(Tm37 : Con37 → Ty37 → Set)
(var : ∀ Γ A → Var37 Γ A → Tm37 Γ A)
(lam : ∀ Γ A B → Tm37 (snoc37 Γ A) B → Tm37 Γ (arr37 A B))
(app : ∀ Γ A B → Tm37 Γ (arr37 A B) → Tm37 Γ A → Tm37 Γ B)
(tt : ∀ Γ → Tm37 Γ top37)
(pair : ∀ Γ A B → Tm37 Γ A → Tm37 Γ B → Tm37 Γ (prod37 A B))
(fst : ∀ Γ A B → Tm37 Γ (prod37 A B) → Tm37 Γ A)
(snd : ∀ Γ A B → Tm37 Γ (prod37 A B) → Tm37 Γ B)
(left : ∀ Γ A B → Tm37 Γ A → Tm37 Γ (sum37 A B))
(right : ∀ Γ A B → Tm37 Γ B → Tm37 Γ (sum37 A B))
(case : ∀ Γ A B C → Tm37 Γ (sum37 A B) → Tm37 Γ (arr37 A C) → Tm37 Γ (arr37 B C) → Tm37 Γ C)
(zero : ∀ Γ → Tm37 Γ nat37)
(suc : ∀ Γ → Tm37 Γ nat37 → Tm37 Γ nat37)
(rec : ∀ Γ A → Tm37 Γ nat37 → Tm37 Γ (arr37 nat37 (arr37 A A)) → Tm37 Γ A → Tm37 Γ A)
→ Tm37 Γ A
var37 : ∀{Γ A} → Var37 Γ A → Tm37 Γ A; var37
= λ x Tm37 var37 lam app tt pair fst snd left right case zero suc rec →
var37 _ _ x
lam37 : ∀{Γ A B} → Tm37 (snoc37 Γ A) B → Tm37 Γ (arr37 A B); lam37
= λ t Tm37 var37 lam37 app tt pair fst snd left right case zero suc rec →
lam37 _ _ _ (t Tm37 var37 lam37 app tt pair fst snd left right case zero suc rec)
app37 : ∀{Γ A B} → Tm37 Γ (arr37 A B) → Tm37 Γ A → Tm37 Γ B; app37
= λ t u Tm37 var37 lam37 app37 tt pair fst snd left right case zero suc rec →
app37 _ _ _ (t Tm37 var37 lam37 app37 tt pair fst snd left right case zero suc rec)
(u Tm37 var37 lam37 app37 tt pair fst snd left right case zero suc rec)
tt37 : ∀{Γ} → Tm37 Γ top37; tt37
= λ Tm37 var37 lam37 app37 tt37 pair fst snd left right case zero suc rec → tt37 _
pair37 : ∀{Γ A B} → Tm37 Γ A → Tm37 Γ B → Tm37 Γ (prod37 A B); pair37
= λ t u Tm37 var37 lam37 app37 tt37 pair37 fst snd left right case zero suc rec →
pair37 _ _ _ (t Tm37 var37 lam37 app37 tt37 pair37 fst snd left right case zero suc rec)
(u Tm37 var37 lam37 app37 tt37 pair37 fst snd left right case zero suc rec)
fst37 : ∀{Γ A B} → Tm37 Γ (prod37 A B) → Tm37 Γ A; fst37
= λ t Tm37 var37 lam37 app37 tt37 pair37 fst37 snd left right case zero suc rec →
fst37 _ _ _ (t Tm37 var37 lam37 app37 tt37 pair37 fst37 snd left right case zero suc rec)
snd37 : ∀{Γ A B} → Tm37 Γ (prod37 A B) → Tm37 Γ B; snd37
= λ t Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left right case zero suc rec →
snd37 _ _ _ (t Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left right case zero suc rec)
left37 : ∀{Γ A B} → Tm37 Γ A → Tm37 Γ (sum37 A B); left37
= λ t Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right case zero suc rec →
left37 _ _ _ (t Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right case zero suc rec)
right37 : ∀{Γ A B} → Tm37 Γ B → Tm37 Γ (sum37 A B); right37
= λ t Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right37 case zero suc rec →
right37 _ _ _ (t Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right37 case zero suc rec)
case37 : ∀{Γ A B C} → Tm37 Γ (sum37 A B) → Tm37 Γ (arr37 A C) → Tm37 Γ (arr37 B C) → Tm37 Γ C; case37
= λ t u v Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right37 case37 zero suc rec →
case37 _ _ _ _
(t Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right37 case37 zero suc rec)
(u Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right37 case37 zero suc rec)
(v Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right37 case37 zero suc rec)
zero37 : ∀{Γ} → Tm37 Γ nat37; zero37
= λ Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right37 case37 zero37 suc rec → zero37 _
suc37 : ∀{Γ} → Tm37 Γ nat37 → Tm37 Γ nat37; suc37
= λ t Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right37 case37 zero37 suc37 rec →
suc37 _ (t Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right37 case37 zero37 suc37 rec)
rec37 : ∀{Γ A} → Tm37 Γ nat37 → Tm37 Γ (arr37 nat37 (arr37 A A)) → Tm37 Γ A → Tm37 Γ A; rec37
= λ t u v Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right37 case37 zero37 suc37 rec37 →
rec37 _ _
(t Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right37 case37 zero37 suc37 rec37)
(u Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right37 case37 zero37 suc37 rec37)
(v Tm37 var37 lam37 app37 tt37 pair37 fst37 snd37 left37 right37 case37 zero37 suc37 rec37)
v037 : ∀{Γ A} → Tm37 (snoc37 Γ A) A; v037
= var37 vz37
v137 : ∀{Γ A B} → Tm37 (snoc37 (snoc37 Γ A) B) A; v137
= var37 (vs37 vz37)
v237 : ∀{Γ A B C} → Tm37 (snoc37 (snoc37 (snoc37 Γ A) B) C) A; v237
= var37 (vs37 (vs37 vz37))
v337 : ∀{Γ A B C D} → Tm37 (snoc37 (snoc37 (snoc37 (snoc37 Γ A) B) C) D) A; v337
= var37 (vs37 (vs37 (vs37 vz37)))
tbool37 : Ty37; tbool37
= sum37 top37 top37
true37 : ∀{Γ} → Tm37 Γ tbool37; true37
= left37 tt37
tfalse37 : ∀{Γ} → Tm37 Γ tbool37; tfalse37
= right37 tt37
ifthenelse37 : ∀{Γ A} → Tm37 Γ (arr37 tbool37 (arr37 A (arr37 A A))); ifthenelse37
= lam37 (lam37 (lam37 (case37 v237 (lam37 v237) (lam37 v137))))
times437 : ∀{Γ A} → Tm37 Γ (arr37 (arr37 A A) (arr37 A A)); times437
= lam37 (lam37 (app37 v137 (app37 v137 (app37 v137 (app37 v137 v037)))))
add37 : ∀{Γ} → Tm37 Γ (arr37 nat37 (arr37 nat37 nat37)); add37
= lam37 (rec37 v037
(lam37 (lam37 (lam37 (suc37 (app37 v137 v037)))))
(lam37 v037))
mul37 : ∀{Γ} → Tm37 Γ (arr37 nat37 (arr37 nat37 nat37)); mul37
= lam37 (rec37 v037
(lam37 (lam37 (lam37 (app37 (app37 add37 (app37 v137 v037)) v037))))
(lam37 zero37))
fact37 : ∀{Γ} → Tm37 Γ (arr37 nat37 nat37); fact37
= lam37 (rec37 v037 (lam37 (lam37 (app37 (app37 mul37 (suc37 v137)) v037)))
(suc37 zero37))
{-# OPTIONS --type-in-type #-}
Ty38 : Set
Ty38 =
(Ty38 : Set)
(nat top bot : Ty38)
(arr prod sum : Ty38 → Ty38 → Ty38)
→ Ty38
nat38 : Ty38; nat38 = λ _ nat38 _ _ _ _ _ → nat38
top38 : Ty38; top38 = λ _ _ top38 _ _ _ _ → top38
bot38 : Ty38; bot38 = λ _ _ _ bot38 _ _ _ → bot38
arr38 : Ty38 → Ty38 → Ty38; arr38
= λ A B Ty38 nat38 top38 bot38 arr38 prod sum →
arr38 (A Ty38 nat38 top38 bot38 arr38 prod sum) (B Ty38 nat38 top38 bot38 arr38 prod sum)
prod38 : Ty38 → Ty38 → Ty38; prod38
= λ A B Ty38 nat38 top38 bot38 arr38 prod38 sum →
prod38 (A Ty38 nat38 top38 bot38 arr38 prod38 sum) (B Ty38 nat38 top38 bot38 arr38 prod38 sum)
sum38 : Ty38 → Ty38 → Ty38; sum38
= λ A B Ty38 nat38 top38 bot38 arr38 prod38 sum38 →
sum38 (A Ty38 nat38 top38 bot38 arr38 prod38 sum38) (B Ty38 nat38 top38 bot38 arr38 prod38 sum38)
Con38 : Set; Con38
= (Con38 : Set)
(nil : Con38)
(snoc : Con38 → Ty38 → Con38)
→ Con38
nil38 : Con38; nil38
= λ Con38 nil38 snoc → nil38
snoc38 : Con38 → Ty38 → Con38; snoc38
= λ Γ A Con38 nil38 snoc38 → snoc38 (Γ Con38 nil38 snoc38) A
Var38 : Con38 → Ty38 → Set; Var38
= λ Γ A →
(Var38 : Con38 → Ty38 → Set)
(vz : ∀ Γ A → Var38 (snoc38 Γ A) A)
(vs : ∀ Γ B A → Var38 Γ A → Var38 (snoc38 Γ B) A)
→ Var38 Γ A
vz38 : ∀{Γ A} → Var38 (snoc38 Γ A) A; vz38
= λ Var38 vz38 vs → vz38 _ _
vs38 : ∀{Γ B A} → Var38 Γ A → Var38 (snoc38 Γ B) A; vs38
= λ x Var38 vz38 vs38 → vs38 _ _ _ (x Var38 vz38 vs38)
Tm38 : Con38 → Ty38 → Set; Tm38
= λ Γ A →
(Tm38 : Con38 → Ty38 → Set)
(var : ∀ Γ A → Var38 Γ A → Tm38 Γ A)
(lam : ∀ Γ A B → Tm38 (snoc38 Γ A) B → Tm38 Γ (arr38 A B))
(app : ∀ Γ A B → Tm38 Γ (arr38 A B) → Tm38 Γ A → Tm38 Γ B)
(tt : ∀ Γ → Tm38 Γ top38)
(pair : ∀ Γ A B → Tm38 Γ A → Tm38 Γ B → Tm38 Γ (prod38 A B))
(fst : ∀ Γ A B → Tm38 Γ (prod38 A B) → Tm38 Γ A)
(snd : ∀ Γ A B → Tm38 Γ (prod38 A B) → Tm38 Γ B)
(left : ∀ Γ A B → Tm38 Γ A → Tm38 Γ (sum38 A B))
(right : ∀ Γ A B → Tm38 Γ B → Tm38 Γ (sum38 A B))
(case : ∀ Γ A B C → Tm38 Γ (sum38 A B) → Tm38 Γ (arr38 A C) → Tm38 Γ (arr38 B C) → Tm38 Γ C)
(zero : ∀ Γ → Tm38 Γ nat38)
(suc : ∀ Γ → Tm38 Γ nat38 → Tm38 Γ nat38)
(rec : ∀ Γ A → Tm38 Γ nat38 → Tm38 Γ (arr38 nat38 (arr38 A A)) → Tm38 Γ A → Tm38 Γ A)
→ Tm38 Γ A
var38 : ∀{Γ A} → Var38 Γ A → Tm38 Γ A; var38
= λ x Tm38 var38 lam app tt pair fst snd left right case zero suc rec →
var38 _ _ x
lam38 : ∀{Γ A B} → Tm38 (snoc38 Γ A) B → Tm38 Γ (arr38 A B); lam38
= λ t Tm38 var38 lam38 app tt pair fst snd left right case zero suc rec →
lam38 _ _ _ (t Tm38 var38 lam38 app tt pair fst snd left right case zero suc rec)
app38 : ∀{Γ A B} → Tm38 Γ (arr38 A B) → Tm38 Γ A → Tm38 Γ B; app38
= λ t u Tm38 var38 lam38 app38 tt pair fst snd left right case zero suc rec →
app38 _ _ _ (t Tm38 var38 lam38 app38 tt pair fst snd left right case zero suc rec)
(u Tm38 var38 lam38 app38 tt pair fst snd left right case zero suc rec)
tt38 : ∀{Γ} → Tm38 Γ top38; tt38
= λ Tm38 var38 lam38 app38 tt38 pair fst snd left right case zero suc rec → tt38 _
pair38 : ∀{Γ A B} → Tm38 Γ A → Tm38 Γ B → Tm38 Γ (prod38 A B); pair38
= λ t u Tm38 var38 lam38 app38 tt38 pair38 fst snd left right case zero suc rec →
pair38 _ _ _ (t Tm38 var38 lam38 app38 tt38 pair38 fst snd left right case zero suc rec)
(u Tm38 var38 lam38 app38 tt38 pair38 fst snd left right case zero suc rec)
fst38 : ∀{Γ A B} → Tm38 Γ (prod38 A B) → Tm38 Γ A; fst38
= λ t Tm38 var38 lam38 app38 tt38 pair38 fst38 snd left right case zero suc rec →
fst38 _ _ _ (t Tm38 var38 lam38 app38 tt38 pair38 fst38 snd left right case zero suc rec)
snd38 : ∀{Γ A B} → Tm38 Γ (prod38 A B) → Tm38 Γ B; snd38
= λ t Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left right case zero suc rec →
snd38 _ _ _ (t Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left right case zero suc rec)
left38 : ∀{Γ A B} → Tm38 Γ A → Tm38 Γ (sum38 A B); left38
= λ t Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right case zero suc rec →
left38 _ _ _ (t Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right case zero suc rec)
right38 : ∀{Γ A B} → Tm38 Γ B → Tm38 Γ (sum38 A B); right38
= λ t Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right38 case zero suc rec →
right38 _ _ _ (t Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right38 case zero suc rec)
case38 : ∀{Γ A B C} → Tm38 Γ (sum38 A B) → Tm38 Γ (arr38 A C) → Tm38 Γ (arr38 B C) → Tm38 Γ C; case38
= λ t u v Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right38 case38 zero suc rec →
case38 _ _ _ _
(t Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right38 case38 zero suc rec)
(u Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right38 case38 zero suc rec)
(v Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right38 case38 zero suc rec)
zero38 : ∀{Γ} → Tm38 Γ nat38; zero38
= λ Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right38 case38 zero38 suc rec → zero38 _
suc38 : ∀{Γ} → Tm38 Γ nat38 → Tm38 Γ nat38; suc38
= λ t Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right38 case38 zero38 suc38 rec →
suc38 _ (t Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right38 case38 zero38 suc38 rec)
rec38 : ∀{Γ A} → Tm38 Γ nat38 → Tm38 Γ (arr38 nat38 (arr38 A A)) → Tm38 Γ A → Tm38 Γ A; rec38
= λ t u v Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right38 case38 zero38 suc38 rec38 →
rec38 _ _
(t Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right38 case38 zero38 suc38 rec38)
(u Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right38 case38 zero38 suc38 rec38)
(v Tm38 var38 lam38 app38 tt38 pair38 fst38 snd38 left38 right38 case38 zero38 suc38 rec38)
v038 : ∀{Γ A} → Tm38 (snoc38 Γ A) A; v038
= var38 vz38
v138 : ∀{Γ A B} → Tm38 (snoc38 (snoc38 Γ A) B) A; v138
= var38 (vs38 vz38)
v238 : ∀{Γ A B C} → Tm38 (snoc38 (snoc38 (snoc38 Γ A) B) C) A; v238
= var38 (vs38 (vs38 vz38))
v338 : ∀{Γ A B C D} → Tm38 (snoc38 (snoc38 (snoc38 (snoc38 Γ A) B) C) D) A; v338
= var38 (vs38 (vs38 (vs38 vz38)))
tbool38 : Ty38; tbool38
= sum38 top38 top38
true38 : ∀{Γ} → Tm38 Γ tbool38; true38
= left38 tt38
tfalse38 : ∀{Γ} → Tm38 Γ tbool38; tfalse38
= right38 tt38
ifthenelse38 : ∀{Γ A} → Tm38 Γ (arr38 tbool38 (arr38 A (arr38 A A))); ifthenelse38
= lam38 (lam38 (lam38 (case38 v238 (lam38 v238) (lam38 v138))))
times438 : ∀{Γ A} → Tm38 Γ (arr38 (arr38 A A) (arr38 A A)); times438
= lam38 (lam38 (app38 v138 (app38 v138 (app38 v138 (app38 v138 v038)))))
add38 : ∀{Γ} → Tm38 Γ (arr38 nat38 (arr38 nat38 nat38)); add38
= lam38 (rec38 v038
(lam38 (lam38 (lam38 (suc38 (app38 v138 v038)))))
(lam38 v038))
mul38 : ∀{Γ} → Tm38 Γ (arr38 nat38 (arr38 nat38 nat38)); mul38
= lam38 (rec38 v038
(lam38 (lam38 (lam38 (app38 (app38 add38 (app38 v138 v038)) v038))))
(lam38 zero38))
fact38 : ∀{Γ} → Tm38 Γ (arr38 nat38 nat38); fact38
= lam38 (rec38 v038 (lam38 (lam38 (app38 (app38 mul38 (suc38 v138)) v038)))
(suc38 zero38))
{-# OPTIONS --type-in-type #-}
Ty39 : Set
Ty39 =
(Ty39 : Set)
(nat top bot : Ty39)
(arr prod sum : Ty39 → Ty39 → Ty39)
→ Ty39
nat39 : Ty39; nat39 = λ _ nat39 _ _ _ _ _ → nat39
top39 : Ty39; top39 = λ _ _ top39 _ _ _ _ → top39
bot39 : Ty39; bot39 = λ _ _ _ bot39 _ _ _ → bot39
arr39 : Ty39 → Ty39 → Ty39; arr39
= λ A B Ty39 nat39 top39 bot39 arr39 prod sum →
arr39 (A Ty39 nat39 top39 bot39 arr39 prod sum) (B Ty39 nat39 top39 bot39 arr39 prod sum)
prod39 : Ty39 → Ty39 → Ty39; prod39
= λ A B Ty39 nat39 top39 bot39 arr39 prod39 sum →
prod39 (A Ty39 nat39 top39 bot39 arr39 prod39 sum) (B Ty39 nat39 top39 bot39 arr39 prod39 sum)
sum39 : Ty39 → Ty39 → Ty39; sum39
= λ A B Ty39 nat39 top39 bot39 arr39 prod39 sum39 →
sum39 (A Ty39 nat39 top39 bot39 arr39 prod39 sum39) (B Ty39 nat39 top39 bot39 arr39 prod39 sum39)
Con39 : Set; Con39
= (Con39 : Set)
(nil : Con39)
(snoc : Con39 → Ty39 → Con39)
→ Con39
nil39 : Con39; nil39
= λ Con39 nil39 snoc → nil39
snoc39 : Con39 → Ty39 → Con39; snoc39
= λ Γ A Con39 nil39 snoc39 → snoc39 (Γ Con39 nil39 snoc39) A
Var39 : Con39 → Ty39 → Set; Var39
= λ Γ A →
(Var39 : Con39 → Ty39 → Set)
(vz : ∀ Γ A → Var39 (snoc39 Γ A) A)
(vs : ∀ Γ B A → Var39 Γ A → Var39 (snoc39 Γ B) A)
→ Var39 Γ A
vz39 : ∀{Γ A} → Var39 (snoc39 Γ A) A; vz39
= λ Var39 vz39 vs → vz39 _ _
vs39 : ∀{Γ B A} → Var39 Γ A → Var39 (snoc39 Γ B) A; vs39
= λ x Var39 vz39 vs39 → vs39 _ _ _ (x Var39 vz39 vs39)
Tm39 : Con39 → Ty39 → Set; Tm39
= λ Γ A →
(Tm39 : Con39 → Ty39 → Set)
(var : ∀ Γ A → Var39 Γ A → Tm39 Γ A)
(lam : ∀ Γ A B → Tm39 (snoc39 Γ A) B → Tm39 Γ (arr39 A B))
(app : ∀ Γ A B → Tm39 Γ (arr39 A B) → Tm39 Γ A → Tm39 Γ B)
(tt : ∀ Γ → Tm39 Γ top39)
(pair : ∀ Γ A B → Tm39 Γ A → Tm39 Γ B → Tm39 Γ (prod39 A B))
(fst : ∀ Γ A B → Tm39 Γ (prod39 A B) → Tm39 Γ A)
(snd : ∀ Γ A B → Tm39 Γ (prod39 A B) → Tm39 Γ B)
(left : ∀ Γ A B → Tm39 Γ A → Tm39 Γ (sum39 A B))
(right : ∀ Γ A B → Tm39 Γ B → Tm39 Γ (sum39 A B))
(case : ∀ Γ A B C → Tm39 Γ (sum39 A B) → Tm39 Γ (arr39 A C) → Tm39 Γ (arr39 B C) → Tm39 Γ C)
(zero : ∀ Γ → Tm39 Γ nat39)
(suc : ∀ Γ → Tm39 Γ nat39 → Tm39 Γ nat39)
(rec : ∀ Γ A → Tm39 Γ nat39 → Tm39 Γ (arr39 nat39 (arr39 A A)) → Tm39 Γ A → Tm39 Γ A)
→ Tm39 Γ A
var39 : ∀{Γ A} → Var39 Γ A → Tm39 Γ A; var39
= λ x Tm39 var39 lam app tt pair fst snd left right case zero suc rec →
var39 _ _ x
lam39 : ∀{Γ A B} → Tm39 (snoc39 Γ A) B → Tm39 Γ (arr39 A B); lam39
= λ t Tm39 var39 lam39 app tt pair fst snd left right case zero suc rec →
lam39 _ _ _ (t Tm39 var39 lam39 app tt pair fst snd left right case zero suc rec)
app39 : ∀{Γ A B} → Tm39 Γ (arr39 A B) → Tm39 Γ A → Tm39 Γ B; app39
= λ t u Tm39 var39 lam39 app39 tt pair fst snd left right case zero suc rec →
app39 _ _ _ (t Tm39 var39 lam39 app39 tt pair fst snd left right case zero suc rec)
(u Tm39 var39 lam39 app39 tt pair fst snd left right case zero suc rec)
tt39 : ∀{Γ} → Tm39 Γ top39; tt39
= λ Tm39 var39 lam39 app39 tt39 pair fst snd left right case zero suc rec → tt39 _
pair39 : ∀{Γ A B} → Tm39 Γ A → Tm39 Γ B → Tm39 Γ (prod39 A B); pair39
= λ t u Tm39 var39 lam39 app39 tt39 pair39 fst snd left right case zero suc rec →
pair39 _ _ _ (t Tm39 var39 lam39 app39 tt39 pair39 fst snd left right case zero suc rec)
(u Tm39 var39 lam39 app39 tt39 pair39 fst snd left right case zero suc rec)
fst39 : ∀{Γ A B} → Tm39 Γ (prod39 A B) → Tm39 Γ A; fst39
= λ t Tm39 var39 lam39 app39 tt39 pair39 fst39 snd left right case zero suc rec →
fst39 _ _ _ (t Tm39 var39 lam39 app39 tt39 pair39 fst39 snd left right case zero suc rec)
snd39 : ∀{Γ A B} → Tm39 Γ (prod39 A B) → Tm39 Γ B; snd39
= λ t Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left right case zero suc rec →
snd39 _ _ _ (t Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left right case zero suc rec)
left39 : ∀{Γ A B} → Tm39 Γ A → Tm39 Γ (sum39 A B); left39
= λ t Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right case zero suc rec →
left39 _ _ _ (t Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right case zero suc rec)
right39 : ∀{Γ A B} → Tm39 Γ B → Tm39 Γ (sum39 A B); right39
= λ t Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right39 case zero suc rec →
right39 _ _ _ (t Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right39 case zero suc rec)
case39 : ∀{Γ A B C} → Tm39 Γ (sum39 A B) → Tm39 Γ (arr39 A C) → Tm39 Γ (arr39 B C) → Tm39 Γ C; case39
= λ t u v Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right39 case39 zero suc rec →
case39 _ _ _ _
(t Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right39 case39 zero suc rec)
(u Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right39 case39 zero suc rec)
(v Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right39 case39 zero suc rec)
zero39 : ∀{Γ} → Tm39 Γ nat39; zero39
= λ Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right39 case39 zero39 suc rec → zero39 _
suc39 : ∀{Γ} → Tm39 Γ nat39 → Tm39 Γ nat39; suc39
= λ t Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right39 case39 zero39 suc39 rec →
suc39 _ (t Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right39 case39 zero39 suc39 rec)
rec39 : ∀{Γ A} → Tm39 Γ nat39 → Tm39 Γ (arr39 nat39 (arr39 A A)) → Tm39 Γ A → Tm39 Γ A; rec39
= λ t u v Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right39 case39 zero39 suc39 rec39 →
rec39 _ _
(t Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right39 case39 zero39 suc39 rec39)
(u Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right39 case39 zero39 suc39 rec39)
(v Tm39 var39 lam39 app39 tt39 pair39 fst39 snd39 left39 right39 case39 zero39 suc39 rec39)
v039 : ∀{Γ A} → Tm39 (snoc39 Γ A) A; v039
= var39 vz39
v139 : ∀{Γ A B} → Tm39 (snoc39 (snoc39 Γ A) B) A; v139
= var39 (vs39 vz39)
v239 : ∀{Γ A B C} → Tm39 (snoc39 (snoc39 (snoc39 Γ A) B) C) A; v239
= var39 (vs39 (vs39 vz39))
v339 : ∀{Γ A B C D} → Tm39 (snoc39 (snoc39 (snoc39 (snoc39 Γ A) B) C) D) A; v339
= var39 (vs39 (vs39 (vs39 vz39)))
tbool39 : Ty39; tbool39
= sum39 top39 top39
true39 : ∀{Γ} → Tm39 Γ tbool39; true39
= left39 tt39
tfalse39 : ∀{Γ} → Tm39 Γ tbool39; tfalse39
= right39 tt39
ifthenelse39 : ∀{Γ A} → Tm39 Γ (arr39 tbool39 (arr39 A (arr39 A A))); ifthenelse39
= lam39 (lam39 (lam39 (case39 v239 (lam39 v239) (lam39 v139))))
times439 : ∀{Γ A} → Tm39 Γ (arr39 (arr39 A A) (arr39 A A)); times439
= lam39 (lam39 (app39 v139 (app39 v139 (app39 v139 (app39 v139 v039)))))
add39 : ∀{Γ} → Tm39 Γ (arr39 nat39 (arr39 nat39 nat39)); add39
= lam39 (rec39 v039
(lam39 (lam39 (lam39 (suc39 (app39 v139 v039)))))
(lam39 v039))
mul39 : ∀{Γ} → Tm39 Γ (arr39 nat39 (arr39 nat39 nat39)); mul39
= lam39 (rec39 v039
(lam39 (lam39 (lam39 (app39 (app39 add39 (app39 v139 v039)) v039))))
(lam39 zero39))
fact39 : ∀{Γ} → Tm39 Γ (arr39 nat39 nat39); fact39
= lam39 (rec39 v039 (lam39 (lam39 (app39 (app39 mul39 (suc39 v139)) v039)))
(suc39 zero39))
|
{
"alphanum_fraction": 0.6261748993,
"avg_line_length": 42.1659388646,
"ext": "agda",
"hexsha": "9fbf0b4edc1ecb165716e07195513f0aac130634",
"lang": "Agda",
"max_forks_count": 19,
"max_forks_repo_forks_event_max_datetime": "2022-03-03T19:46:54.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-12-05T21:11:34.000Z",
"max_forks_repo_head_hexsha": "6a87f295148bd753d2519d50c2e1011b64c859ff",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "int-index/smalltt",
"max_forks_repo_path": "bench/stlc_lessimpl5k.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "6a87f295148bd753d2519d50c2e1011b64c859ff",
"max_issues_repo_issues_event_max_datetime": "2022-02-28T21:51:10.000Z",
"max_issues_repo_issues_event_min_datetime": "2020-03-16T09:14:57.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "int-index/smalltt",
"max_issues_repo_path": "bench/stlc_lessimpl5k.agda",
"max_line_length": 102,
"max_stars_count": 377,
"max_stars_repo_head_hexsha": "6a87f295148bd753d2519d50c2e1011b64c859ff",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "int-index/smalltt",
"max_stars_repo_path": "bench/stlc_lessimpl5k.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-19T21:31:01.000Z",
"max_stars_repo_stars_event_min_datetime": "2017-11-26T16:57:16.000Z",
"num_tokens": 116293,
"size": 280024
}
|
{-# OPTIONS --without-K #-}
open import Base
open import Spaces.Interval
module Spaces.IntervalProps where
bool-split : bool {zero} → Set
bool-split true = unit
bool-split false = ⊥
-- If [bool] is contractible, then [true ≡ false]
bool-contr-path : is-contr (bool {zero}) → true ≡ false
bool-contr-path (x , f) = (f true) ∘ ! (f false)
-- But if [true ≡ false], then [⊥]
bool-is-not-contr : ¬ (is-contr bool)
bool-is-not-contr f = transport bool-split (bool-contr-path f) tt
I-is-contr : is-contr I
I-is-contr =
(zer , I-rec (λ (t : I) → t ≡ zer) refl (! seg)
(trans-id≡cst seg refl ∘ refl-right-unit (! seg)))
interval-implies-funext : ∀ {i j} (A : Set i) (B : Set j) (f g : A → B)
(h : (x : A) → f x ≡ g x) → f ≡ g
interval-implies-funext A B f g h =
ap (λ i a → I-rec-nondep _ (f a) (g a) (h a) i) seg
|
{
"alphanum_fraction": 0.5964071856,
"avg_line_length": 28.7931034483,
"ext": "agda",
"hexsha": "ec9c0be4f497622460a85ded55d990e9b94e8d8d",
"lang": "Agda",
"max_forks_count": 50,
"max_forks_repo_forks_event_max_datetime": "2022-02-14T03:03:25.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-10T01:48:08.000Z",
"max_forks_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nicolaikraus/HoTT-Agda",
"max_forks_repo_path": "old/Spaces/IntervalProps.agda",
"max_issues_count": 31,
"max_issues_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_issues_repo_issues_event_max_datetime": "2021-10-03T19:15:25.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-03-05T20:09:00.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nicolaikraus/HoTT-Agda",
"max_issues_repo_path": "old/Spaces/IntervalProps.agda",
"max_line_length": 71,
"max_stars_count": 294,
"max_stars_repo_head_hexsha": "f8fa68bf753d64d7f45556ca09d0da7976709afa",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "UlrikBuchholtz/HoTT-Agda",
"max_stars_repo_path": "old/Spaces/IntervalProps.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-20T13:54:45.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T16:23:23.000Z",
"num_tokens": 300,
"size": 835
}
|
-- Giving /lift \phi/ the the first hole TWICE (the first time you get an type error), causes the following internal error:
-- An internal error has occurred. Please report this as a bug.
-- Location of the error:
-- src/full/Agda/TypeChecking/Reduce/Monad.hs:118
------------------------------------------------------------------------
-- Library
infixr 9 _∘_
_∘_ : ∀ {a b c}
{A : Set a} {B : A → Set b} {C : {x : A} → B x → Set c} →
(∀ {x} (y : B x) → C y) → (g : (x : A) → B x) →
((x : A) → C (g x))
f ∘ g = λ x → f (g x)
data ⊥ : Set where
data _⊎_ (A : Set) (B : Set) : Set where
inj₁ : (x : A) → A ⊎ B
inj₂ : (y : B) → A ⊎ B
[_,_] : ∀ {A : Set} {B : Set} {C : A ⊎ B → Set} →
((x : A) → C (inj₁ x)) → ((x : B) → C (inj₂ x)) →
((x : A ⊎ B) → C x)
[ f , g ] (inj₁ x) = f x
[ f , g ] (inj₂ y) = g y
[_,_]₁ : ∀ {A : Set} {B : Set} {C : A ⊎ B → Set₁} →
((x : A) → C (inj₁ x)) → ((x : B) → C (inj₂ x)) →
((x : A ⊎ B) → C x)
[ f , g ]₁ (inj₁ x) = f x
[ f , g ]₁ (inj₂ y) = g y
record Σ (X : Set) (Y : X → Set) : Set where
constructor _,_
field
proj₁ : X
proj₂ : Y proj₁
open Σ public
_×_ : Set → Set → Set
X × Y = Σ X λ _ → Y
data _≡_ {X : Set} (x : X) : X → Set where
refl : x ≡ x
subst : ∀ {A} (P : A → Set) {x y} → x ≡ y → P x → P y
subst P refl p = p
Pow : Set → Set₁
Pow X = X → Set
_∈_ : ∀ {X} → X → Pow X → Set
x ∈ P = P x
infix 4 _⊆_
_⊆_ : ∀ {X} → Pow X → Pow X → Set
P ⊆ Q = ∀ {x} → x ∈ P → x ∈ Q
_∪_ : ∀ {X} → Pow X → Pow X → Pow X
P ∪ Q = λ x → P x ⊎ Q x
_⇒_ : ∀ {X} → Pow X → Pow X → Pow X
P ⇒ Q = λ x → x ∈ P → x ∈ Q
record _▷_ (I O : Set) : Set₁ where
constructor _◃_/_
field
Parameter : (o : O) → Set
Arity : ∀ {o} (p : Parameter o) → Set
input : ∀ {o} (p : Parameter o) (a : Arity p) → I
open _▷_ public
Sig = λ I → I ▷ I
⟦_⟧ : ∀ {I O} → I ▷ O → (Pow I → Pow O)
⟦ P ◃ A / s ⟧ X o = Σ (P o) λ p → ((a : A p) → X (s p a))
data μ {I} (Ω : Sig I) : Pow I where
sup : ⟦ Ω ⟧ (μ Ω) ⊆ μ Ω
const^C : ∀ {I O} → Pow O → I ▷ O
const^C X = X ◃ (λ _ → ⊥) / λ x ()
_⊎^C_ : ∀ {I O} → I ▷ O → I ▷ O → I ▷ O
(P₁ ◃ A₁ / s₁) ⊎^C (P₂ ◃ A₂ / s₂) = (P₁ ∪ P₂) ◃ [ A₁ , A₂ ]₁ / [ s₁ , s₂ ]
_⊙^C_ : ∀ {I J} → I ▷ I → J ▷ J → (I × J) ▷ (I × J)
(P₁ ◃ A₁ / s₁) ⊙^C (P₂ ◃ A₂ / s₂) = (λ { (i , j) → P₁ i ⊎ P₂ j })
◃ [ A₁ , A₂ ]₁
/ (λ { {_ , j} (inj₁ p₁) a₁ → s₁ p₁ a₁ , j
; {i , _} (inj₂ p₂) a₂ → i , s₂ p₂ a₂
})
_⋆^C_ : ∀ {O} → O ▷ O → Pow O → O ▷ O
Σ ⋆^C X = const^C X ⊎^C Σ
_⋆_ : ∀ {O} → O ▷ O → Pow O → Pow O
Σ ⋆ X = μ (Σ ⋆^C X)
Alg : ∀ {I} → Sig I → Pow I → Set
Alg Ω X = ⟦ Ω ⟧ X ⊆ X
do : ∀ {O} {Σ : O ▷ O} {X} → Alg Σ (Σ ⋆ X)
do (p , k) = sup (inj₂ p , k)
Hom : ∀ {I J} → Sig (I × J) → Pow (I × J) → Pow I → Sig J → Pow J → Set
Hom Ω U V Ψ W = Alg (const^C U ⊎^C Ω)
((V ∘ proj₁) ⇒ ((Ψ ⋆ W) ∘ proj₂))
_⋊_ : ∀ {I O} (C : I ▷ O) Z → (I × Z) ▷ (O × Z)
(P ◃ A / s) ⋊ Z = (P ∘ proj₁) ◃ A / λ {oz} p a → s p a , proj₂ oz
record ContainerMorphism
{I₁ I₂ O₁ O₂}
(C₁ : I₁ ▷ O₁) (C₂ : I₂ ▷ O₂)
(f : I₁ → I₂) (g : O₁ → O₂)
(_∼_ : I₂ → I₂ → Set) (_≈_ : Set → Set → Set)
(_·_ : ∀ {A B} → A ≈ B → A → B) : Set where
field
parameter : Parameter C₁ ⊆ Parameter C₂ ∘ g
arity : ∀ {o} {p₁ : Parameter C₁ o} →
Arity C₂ (parameter p₁) ≈ Arity C₁ p₁
coherent : ∀ {o} {p₁ : Parameter C₁ o} {a₂ : Arity C₂ (parameter p₁)} →
f (input C₁ p₁ (arity · a₂)) ∼ input C₂ (parameter p₁) a₂
open ContainerMorphism public
_⇛[_/_]_ : ∀ {I₁ I₂ O₁ O₂} → I₁ ▷ O₁ → (I₁ → I₂) → (O₁ → O₂) →
I₂ ▷ O₂ → Set
C₁ ⇛[ f / g ] C₂ = ContainerMorphism C₁ C₂ f g _≡_ (λ R₂ R₁ → R₂ → R₁)
(λ f x → f x)
_⇛[_]_ : ∀ {I J} → I ▷ I → (I → J) → J ▷ J → Set
C₁ ⇛[ f ] C₂ = C₁ ⇛[ f / f ] C₂
⟪_⟫ : ∀ {I J} {C₁ : I ▷ I} {C₂ : J ▷ J} {f : I → J} →
C₁ ⇛[ f ] C₂ → (X : Pow J) → ⟦ C₁ ⟧ (X ∘ f) ⊆ ⟦ C₂ ⟧ X ∘ f
⟪ m ⟫ X (c , k) = parameter m c , λ a₂ →
subst X (coherent m) (k (arity m a₂))
------------------------------------------------------------------------
weaken : ∀ {I J} {Ω : Sig I} {Ψ : Sig J} {X : Pow J} {f : I → J} →
Alg Ψ X → Ω ⇛[ f ] Ψ → Alg Ω (X ∘ f)
weaken {X = X} φ m (p , k) = φ (⟪ m ⟫ X (p , k))
lift : ∀ {I J} {Ω : Sig I} {U : Pow (I × J)} {V : Pow I} {Ψ : Sig J} {W : Pow J} →
Hom (Ω ⋊ J) U V Ψ W →
Hom (Ω ⊙^C Ψ) U V Ψ W
lift φ (inj₁ u , _) = φ (inj₁ u , λ ())
lift φ (inj₂ (inj₁ p) , k) = φ (inj₂ p , k)
lift φ (inj₂ (inj₂ p) , k) = λ v → do (p , λ a → k a v)
handle : ∀ {I J K} {Ω : Sig I} {Ω′ : Sig J} {Ω″ : Sig K}
{U : Pow (J × K)} {V : Pow J} {W : Pow K} {f : I → J × K} →
Hom (Ω′ ⋊ K) U V Ω″ W → Ω ⇛[ f ] (Ω′ ⊙^C Ω″) →
∀ {i} → i ∈ (Ω ⋆ (U ∘ f)) → let (j , k) = f i in
j ∈ V → k ∈ (Ω″ ⋆ W)
handle φ m (sup (inj₁ u , _)) v = φ (inj₁ u , λ ()) v
handle φ m (sup (inj₂ p , k)) v = weaken {!lift φ!} {!!} {!!}
-- Expected outcome:
-- giving "lift φ" twice should give the same error twice.
|
{
"alphanum_fraction": 0.396991886,
"avg_line_length": 29.899408284,
"ext": "agda",
"hexsha": "530a8cfd92d230fbe759120561aaba710e168067",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "redfish64/autonomic-agda",
"max_forks_repo_path": "test/interaction/Issue1365.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "redfish64/autonomic-agda",
"max_issues_repo_path": "test/interaction/Issue1365.agda",
"max_line_length": 123,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "redfish64/autonomic-agda",
"max_stars_repo_path": "test/interaction/Issue1365.agda",
"max_stars_repo_stars_event_max_datetime": "2015-12-07T20:14:00.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-03-28T14:51:03.000Z",
"num_tokens": 2479,
"size": 5053
}
|
{-# OPTIONS --type-in-type #-}
module meta-cedille where
open import Data.String using (toList)
open import IO using (Main; run)
open import Monads.Except
open import Monads.ExceptT
open import Prelude
open import Prelude.Strings
open import Parse.Generate
open import Parse.TreeConvert
open import Bootstrap.InitEnv
open import CoreTheory
open import Execution
record EvalFlags : Set where
field
printAnything : Bool
printInfo : Bool -- print the results generated by a top level command
initFlagsDefault : EvalFlags
initFlagsDefault = record
{ printAnything = false
; printInfo = false
}
runtimeFlagsDefault : EvalFlags
runtimeFlagsDefault = record
{ printAnything = true
; printInfo = true
}
eval : MetaContext → String → EvalFlags → IO (MetaContext × Bool)
eval Γ "" _ = return (Γ , true)
eval Γ input flags = let open EvalFlags flags in do
(s , (inj₂ (out , _))) ← execute (parseAndExecute input) Γ
where (_ , (inj₁ err)) → putStrErr err >> return (Γ , false)
if printAnything ∧ printInfo
then putStr $ unlines out
else return tt
return (contextFromState s , true)
rep : MetaContext → IO MetaContext
rep Γ = do
putStr "\nλ> "
flushStdout
input ← getLine
proj₁ <$> eval Γ input runtimeFlagsDefault
{-# NON_TERMINATING #-}
loop : ∀ {a} {A : Set a} → A → (A → IO A) → IO ⊤
loop start f = do
res ← f start
loop res f
repl : MetaContext → IO ⊤
repl start = loop start rep
record Options : Set where
field
startRepl : Bool
importFiles : List String
verbose : Bool
showHelp : Bool
defaultOptions : Options
defaultOptions = record
{ startRepl = true
; importFiles = []
; verbose = false
; showHelp = false }
{-# TERMINATING #-}
readOptions : ExceptT IO String Options
readOptions = do
args ← getArgs
return $ readArgs args defaultOptions
where
argumentDec : Decidable _
argumentDec s = false ≟ isInit "--" (toList s)
readArgs : List String → Options → Except String Options
readArgs [] current = return current
readArgs ("--no-repl" ∷ input) current = readArgs input record current { startRepl = false }
readArgs ("--verbose" ∷ input) current = readArgs input record current { verbose = true }
readArgs ("--help" ∷ input) current = readArgs input record current { showHelp = true }
readArgs ("--load" ∷ input) current with span argumentDec input
... | (files , rest) = readArgs rest record current { importFiles = files }
readArgs (x ∷ input) current = inj₁ ("Unknown option: " + x)
helpString : String
helpString = "Usage: meta-cedille [OPTIONS...]\n" +
concat ((λ { (fst , snd) → " --" + padRight ' ' padLength fst + snd + "\n" }) <$> helpTable)
where
helpTable : List (String × String)
helpTable =
("help" , "Show this help") ∷
("load [FILES]" , "Loads a list of files before starting the REPL") ∷
("verbose" , "Print supressed output before starting the REPL") ∷
("no-repl" , "Exits the program when the REPL would start") ∷ []
padLength : ℕ
padLength = 4 + maximum (Data.String.length ∘ proj₁ <$> helpTable)
initGrammar : Grammar
initGrammar = from-inj₂ $ preCoreGrammar {{Except-Monad}} {{Except-MonadExcept}}
bootstrapMetaContext : MetaContext
bootstrapMetaContext =
emptyGlobalContext , record { grammar = initGrammar ; namespace = "" ; evaluator = Sort-A □ }
loadFiles : MetaContext → EvalFlags → List String → IO (MetaContext × Bool)
loadFiles context flags [] = return (context , true)
loadFiles context flags files =
eval context (concat $ map (λ file → "import " + file + ".") files) flags
main : Main
main = run $ do
(inj₂ o) ← readOptions
where (inj₁ x) → putStr x
let open Options o in
if showHelp then putStr helpString else do
(init , successInit) ← eval bootstrapMetaContext initEnv initFlagsDefault
let initFlags = if verbose then runtimeFlagsDefault else initFlagsDefault
(postLoad , successLoad) ← loadFiles init initFlags importFiles
if startRepl
then repl postLoad
else if successInit ∧ successLoad
then exitSuccess
else exitFailure
|
{
"alphanum_fraction": 0.6678529063,
"avg_line_length": 31.2222222222,
"ext": "agda",
"hexsha": "d085a131b1ac825dd51ed48bc5be419c57a87ade",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2021-10-20T10:46:20.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-06-27T23:12:48.000Z",
"max_forks_repo_head_hexsha": "62fa6f36e4555360d94041113749bbb6d291691c",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "WhatisRT/meta-cedille",
"max_forks_repo_path": "src/meta-cedille.agda",
"max_issues_count": 10,
"max_issues_repo_head_hexsha": "62fa6f36e4555360d94041113749bbb6d291691c",
"max_issues_repo_issues_event_max_datetime": "2020-04-25T15:29:17.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-06-13T17:44:43.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "WhatisRT/meta-cedille",
"max_issues_repo_path": "src/meta-cedille.agda",
"max_line_length": 97,
"max_stars_count": 35,
"max_stars_repo_head_hexsha": "62fa6f36e4555360d94041113749bbb6d291691c",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "WhatisRT/meta-cedille",
"max_stars_repo_path": "src/meta-cedille.agda",
"max_stars_repo_stars_event_max_datetime": "2021-10-12T22:59:10.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-06-13T07:44:50.000Z",
"num_tokens": 1135,
"size": 4215
}
|
------------------------------------------------------------------------
-- Functors and natural transformations (for 1-categories)
------------------------------------------------------------------------
-- The code is based on the presentation in the HoTT book (but might
-- not follow it exactly).
{-# OPTIONS --without-K --safe #-}
open import Equality
module Functor
{reflexive} (eq : ∀ {a p} → Equality-with-J a p reflexive) where
import Surjection
open import Bijection eq hiding (id; _∘_; inverse; step-↔; finally-↔)
open import Category eq
open Derived-definitions-and-properties eq
open import Equivalence eq as Eq using (_≃_; module _≃_; ↔⇒≃)
open import Function-universe eq hiding (id; _∘_)
open import H-level eq
open import H-level.Closure eq
open import Logical-equivalence using (_⇔_; module _⇔_)
open import Prelude as P hiding (id; _^_)
------------------------------------------------------------------------
-- Functors
Functor : ∀ {ℓ₁ ℓ₂ ℓ₃ ℓ₄} →
Precategory ℓ₁ ℓ₂ → Precategory ℓ₃ ℓ₄ → Type _
Functor C D =
-- Object map.
∃ λ (F₀ : Obj C → Obj D) →
-- Morphism map.
∃ λ (F : ∀ {X Y} → Hom C X Y → Hom D (F₀ X) (F₀ Y)) →
-- F should be homomorphic with respect to identity and composition.
(∀ {X} → F (id C {X = X}) ≡ id D) ×
(∀ {X Y Z} {f : Hom C X Y} {g : Hom C Y Z} →
F (_∙_ C g f) ≡ _∙_ D (F g) (F f))
where open Precategory
-- A wrapper.
infix 4 _⇨_
record _⇨_ {ℓ₁ ℓ₂ ℓ₃ ℓ₄}
(C : Precategory ℓ₁ ℓ₂) (D : Precategory ℓ₃ ℓ₄) :
Type (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃ ⊔ ℓ₄) where
field
functor : Functor C D
open Precategory
infixr 10 _⊚_ _⊙_
-- Object map.
_⊚_ : Obj C → Obj D
_⊚_ = proj₁ functor
-- Morphism map.
_⊙_ : ∀ {X Y} → Hom C X Y → Hom D (_⊚_ X) (_⊚_ Y)
_⊙_ = proj₁ (proj₂ functor)
-- The morphism map is homomorphic with respect to identity.
⊙-id : ∀ {X} → _⊙_ (id C {X = X}) ≡ id D
⊙-id = proj₁ (proj₂ (proj₂ functor))
-- The morphism map is homomorphic with respect to composition.
⊙-∙ : ∀ {X Y Z} {f : Hom C X Y} {g : Hom C Y Z} →
_⊙_ (_∙_ C g f) ≡ _∙_ D (_⊙_ g) (_⊙_ f)
⊙-∙ = proj₂ (proj₂ (proj₂ functor))
open _⇨_ public
private
module Dummy₁ where
abstract
-- The homomorphism properties are propositional (assuming
-- extensionality).
functor-properties-propositional :
∀ {ℓ₁ ℓ₂ ℓ₃ ℓ₄} →
Extensionality (ℓ₁ ⊔ ℓ₂) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₄) →
{C : Precategory ℓ₁ ℓ₂} {D : Precategory ℓ₃ ℓ₄}
(F : C ⇨ D) → let open Precategory in
Is-proposition ((∀ {X} → F ⊙ id C {X = X} ≡ id D) ×
(∀ {X Y Z} {f : Hom C X Y} {g : Hom C Y Z} →
F ⊙ (_∙_ C g f) ≡ _∙_ D (F ⊙ g) (F ⊙ f)))
functor-properties-propositional {ℓ₁} {ℓ₂} ext {D = D} _ = ×-closure 1
(implicit-Π-closure (lower-extensionality ℓ₂ (ℓ₁ ⊔ ℓ₂) ext) 1 λ _ →
Precategory.Hom-is-set D)
(implicit-Π-closure (lower-extensionality ℓ₂ lzero ext) 1 λ _ →
implicit-Π-closure (lower-extensionality ℓ₂ lzero ext) 1 λ _ →
implicit-Π-closure (lower-extensionality ℓ₂ ℓ₁ ext) 1 λ _ →
implicit-Π-closure (lower-extensionality ℓ₁ ℓ₁ ext) 1 λ _ →
implicit-Π-closure (lower-extensionality ℓ₁ (ℓ₁ ⊔ ℓ₂) ext) 1 λ _ →
Precategory.Hom-is-set D)
open Dummy₁ public
private
module Dummy₂ where
abstract
-- Functor equality is equivalent to equality of the corresponding
-- maps, suitably transported (assuming extensionality).
equality-characterisation⇨ :
∀ {ℓ₁ ℓ₂ ℓ₃ ℓ₄} →
Extensionality (ℓ₁ ⊔ ℓ₂) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₄) →
{C : Precategory ℓ₁ ℓ₂} {D : Precategory ℓ₃ ℓ₄} {F G : C ⇨ D} →
let open Precategory in
(F ≡ G)
≃
∃ λ (⊚F≡⊚G : _⊚_ F ≡ _⊚_ G) →
_≡_ {A = ∀ {X Y} → Hom C X Y → Hom D (G ⊚ X) (G ⊚ Y)}
(subst (λ F → ∀ {X Y} → Hom C X Y → Hom D (F X) (F Y))
⊚F≡⊚G (_⊙_ F))
(_⊙_ G)
equality-characterisation⇨ ext {C} {D} {F} {G} =
let P : (Obj C → Obj D) → Type _
P = λ F₀ → ∀ {X Y} → Hom C X Y → Hom D (F₀ X) (F₀ Y)
Q : ∃ P → Type _
Q = λ { (F₀ , F) → (∀ {X} → F (id C {X = X}) ≡ id D) ×
(∀ {X Y Z} {f : Hom C X Y} {g : Hom C Y Z} →
F (_∙_ C g f) ≡ _∙_ D (F g) (F f)) }
in
(F ≡ G) ↝⟨ ↔⇒≃ record
{ surjection = record
{ logical-equivalence = record
{ to = cong functor
; from = cong λ f → record { functor = f }
}
; right-inverse-of = λ _ → trans (cong-∘ _ _ _) (sym $ cong-id _)
}
; left-inverse-of = λ _ → trans (cong-∘ _ _ _) (sym $ cong-id _)
} ⟩
(functor F ≡ functor G) ↔⟨ inverse Σ-≡,≡↔≡ ⟩
(∃ λ (⊚F≡⊚G : _⊚_ F ≡ _⊚_ G) →
subst (λ F₀ → ∃ λ (F : P F₀) → Q (F₀ , F)) ⊚F≡⊚G
(proj₂ $ functor F) ≡ proj₂ (functor G)) ↝⟨ ∃-cong (λ ⊚F≡⊚G → ≡⇒↝ _ $ cong (λ x → x ≡ proj₂ (functor G)) $
push-subst-pair P Q) ⟩
(∃ λ (⊚F≡⊚G : _⊚_ F ≡ _⊚_ G) →
_≡_ {A = ∃ λ (H : P (_⊚_ G)) → Q (_⊚_ G , H)}
( subst P ⊚F≡⊚G (_⊙_ F)
, subst Q (Σ-≡,≡→≡ ⊚F≡⊚G (refl _)) (proj₂ $ proj₂ $ functor F)
)
(proj₂ (functor G))) ↔⟨ ∃-cong (λ ⊚F≡⊚G → inverse $
ignore-propositional-component
(functor-properties-propositional ext G)) ⟩□
(∃ λ (⊚F≡⊚G : _⊚_ F ≡ _⊚_ G) →
(λ {_ _} → subst P ⊚F≡⊚G (_⊙_ F)) ≡ _⊙_ G) □
where open Precategory
-- Some simplification lemmas.
proj₁-to-equality-characterisation⇨ :
∀ {ℓ₁ ℓ₂ ℓ₃ ℓ₄}
(ext : Extensionality (ℓ₁ ⊔ ℓ₂) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₄))
{C : Precategory ℓ₁ ℓ₂} {D : Precategory ℓ₃ ℓ₄} {F G : C ⇨ D} →
let open Precategory in
(F≡G : F ≡ G) →
proj₁ (_≃_.to (equality-characterisation⇨ ext {F = F} {G = G}) F≡G)
≡
cong _⊚_ F≡G
proj₁-to-equality-characterisation⇨ ext F≡G =
proj₁ (_≃_.to (equality-characterisation⇨ ext) F≡G) ≡⟨ proj₁-Σ-≡,≡←≡ _ ⟩
cong proj₁ (cong functor F≡G) ≡⟨ cong-∘ _ _ _ ⟩∎
cong _⊚_ F≡G ∎
cong-⊚-from-equality-characterisation⇨ :
∀ {ℓ₁ ℓ₂ ℓ₃ ℓ₄}
(ext : Extensionality (ℓ₁ ⊔ ℓ₂) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₄))
{C : Precategory ℓ₁ ℓ₂} {D : Precategory ℓ₃ ℓ₄} {F G : C ⇨ D} →
let open Precategory in
(⊚F≡⊚G : _⊚_ F ≡ _⊚_ G) →
(⊙F≡⊙G : _≡_ {A = ∀ {X Y} → Hom C X Y → Hom D (G ⊚ X) (G ⊚ Y)}
(subst (λ F → ∀ {X Y} → Hom C X Y → Hom D (F X) (F Y))
⊚F≡⊚G (_⊙_ F))
(_⊙_ G)) →
cong _⊚_ (_≃_.from (equality-characterisation⇨ ext {F = F} {G = G})
(⊚F≡⊚G , ⊙F≡⊙G))
≡
⊚F≡⊚G
cong-⊚-from-equality-characterisation⇨ ext {F = F} {G} ⊚F≡⊚G ⊙F≡⊙G =
cong _⊚_ (_≃_.from (equality-characterisation⇨ ext {F = F} {G = G})
(⊚F≡⊚G , ⊙F≡⊙G)) ≡⟨ cong-∘ _ _ _ ⟩
cong proj₁ (Σ-≡,≡→≡ ⊚F≡⊚G _) ≡⟨ proj₁-Σ-≡,≡→≡ _ _ ⟩∎
⊚F≡⊚G ∎
open Dummy₂ public
private
module Dummy₃ where
abstract
-- Another equality characterisation lemma.
equality-characterisation≡⇨ :
∀ {ℓ₁ ℓ₂ ℓ₃ ℓ₄} →
Extensionality (ℓ₁ ⊔ ℓ₂) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₄) →
{C : Precategory ℓ₁ ℓ₂} {D : Precategory ℓ₃ ℓ₄} {F G : C ⇨ D}
{eq₁ eq₂ : F ≡ G} →
(eq₁ ≡ eq₂) ≃ (cong _⊚_ eq₁ ≡ cong _⊚_ eq₂)
equality-characterisation≡⇨ {ℓ₁} {ℓ₂} ext {D = D} {eq₁ = eq₁} {eq₂} =
eq₁ ≡ eq₂ ↝⟨ inverse $ Eq.≃-≡ (equality-characterisation⇨ ext) ⟩
_≃_.to (equality-characterisation⇨ ext) eq₁ ≡
_≃_.to (equality-characterisation⇨ ext) eq₂ ↔⟨ inverse $ ignore-propositional-component
(implicit-Π-closure (lower-extensionality ℓ₂ lzero ext) 2 λ _ →
implicit-Π-closure (lower-extensionality ℓ₂ ℓ₁ ext) 2 λ _ →
Π-closure (lower-extensionality ℓ₁ (ℓ₁ ⊔ ℓ₂) ext) 2 λ _ →
Precategory.Hom-is-set D) ⟩
proj₁ (_≃_.to (equality-characterisation⇨ ext) eq₁) ≡
proj₁ (_≃_.to (equality-characterisation⇨ ext) eq₂) ↝⟨ ≡⇒↝ _ (cong₂ _≡_ (proj₁-to-equality-characterisation⇨ _ _)
(proj₁-to-equality-characterisation⇨ _ _)) ⟩□
cong _⊚_ eq₁ ≡ cong _⊚_ eq₂ □
open Dummy₃ public
-- Identity functor.
id⇨ : ∀ {ℓ₁ ℓ₂} {C : Precategory ℓ₁ ℓ₂} → C ⇨ C
functor id⇨ = P.id , P.id , refl _ , refl _
-- Composition of functors.
infixr 10 _∙⇨_
_∙⇨_ : ∀ {ℓ₁ ℓ₂} {C : Precategory ℓ₁ ℓ₂}
{ℓ₃ ℓ₄} {D : Precategory ℓ₃ ℓ₄}
{ℓ₅ ℓ₆} {E : Precategory ℓ₅ ℓ₆} →
D ⇨ E → C ⇨ D → C ⇨ E
functor (_∙⇨_ {C = C} {D = D} {E = E} G F) =
(G ⊚_) ∘ (F ⊚_) ,
(G ⊙_) ∘ (F ⊙_) ,
(G ⊙ F ⊙ id C ≡⟨ cong (G ⊙_) $ ⊙-id F ⟩
G ⊙ id D ≡⟨ ⊙-id G ⟩∎
id E ∎) ,
(λ {_ _ _ f g} →
G ⊙ F ⊙ _∙_ C g f ≡⟨ cong (G ⊙_) $ ⊙-∙ F ⟩
G ⊙ _∙_ D (F ⊙ g) (F ⊙ f) ≡⟨ ⊙-∙ G ⟩∎
_∙_ E (G ⊙ F ⊙ g) (G ⊙ F ⊙ f) ∎)
where
open Precategory
-- id⇨ is a left identity (assuming extensionality).
id⇨∙⇨ :
∀ {ℓ₁ ℓ₂} {C : Precategory ℓ₁ ℓ₂}
{ℓ₃ ℓ₄} {D : Precategory ℓ₃ ℓ₄} →
Extensionality (ℓ₁ ⊔ ℓ₂) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₄) →
{F : C ⇨ D} → id⇨ ∙⇨ F ≡ F
id⇨∙⇨ ext {F} = _≃_.from (equality-characterisation⇨ ext)
( refl (F ⊚_)
, (subst _ (refl (F ⊚_)) (λ {_ _} → F ⊙_) ≡⟨ subst-refl _ _ ⟩∎
(λ {_ _} → F ⊙_) ∎)
)
-- id⇨ is a right identity (assuming extensionality).
∙⇨id⇨ :
∀ {ℓ₁ ℓ₂} {C : Precategory ℓ₁ ℓ₂}
{ℓ₃ ℓ₄} {D : Precategory ℓ₃ ℓ₄} →
Extensionality (ℓ₁ ⊔ ℓ₂) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₄) →
{F : C ⇨ D} → F ∙⇨ id⇨ ≡ F
∙⇨id⇨ ext {F} = _≃_.from (equality-characterisation⇨ ext)
( refl (F ⊚_)
, (subst _ (refl (F ⊚_)) (λ {_ _} → F ⊙_) ≡⟨ subst-refl _ _ ⟩∎
(λ {_ _} → F ⊙_) ∎)
)
-- _∙⇨_ is associative (assuming extensionality).
∙⇨-assoc :
∀ {ℓ₁ ℓ₂} {C₁ : Precategory ℓ₁ ℓ₂}
{ℓ₃ ℓ₄} {C₂ : Precategory ℓ₃ ℓ₄}
{ℓ₅ ℓ₆} {C₃ : Precategory ℓ₅ ℓ₆}
{ℓ₇ ℓ₈} {C₄ : Precategory ℓ₇ ℓ₈} →
Extensionality (ℓ₁ ⊔ ℓ₂) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₈) →
(F : C₃ ⇨ C₄) (G : C₂ ⇨ C₃) {H : C₁ ⇨ C₂} →
F ∙⇨ (G ∙⇨ H) ≡ (F ∙⇨ G) ∙⇨ H
∙⇨-assoc ext F G {H} = _≃_.from (equality-characterisation⇨ ext)
( refl _
, (subst _ (refl _) (λ {_ _} → (F ∙⇨ G ∙⇨ H) ⊙_) ≡⟨ subst-refl _ _ ⟩
(λ {_ _} → (F ∙⇨ G ∙⇨ H) ⊙_) ∎)
)
------------------------------------------------------------------------
-- Natural transformations
Natural-transformation :
∀ {ℓ₁ ℓ₂} {C : Precategory ℓ₁ ℓ₂}
{ℓ₃ ℓ₄} {D : Precategory ℓ₃ ℓ₄} →
C ⇨ D → C ⇨ D → Type _
Natural-transformation {C = C} {D = D} F G =
-- Morphisms.
∃ λ (γ : ∀ {X} → Hom D (F ⊚ X) (G ⊚ X)) →
-- Naturality.
∀ {X Y} {f : Hom C X Y} → (G ⊙ f) ∙ γ ≡ γ ∙ (F ⊙ f)
where
open Precategory hiding (_∙_)
open Precategory D using (_∙_)
-- A wrapper.
infix 4 _⇾_
record _⇾_ {ℓ₁ ℓ₂} {C : Precategory ℓ₁ ℓ₂}
{ℓ₃ ℓ₄} {D : Precategory ℓ₃ ℓ₄}
(F G : C ⇨ D) : Type (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃ ⊔ ℓ₄) where
field
natural-transformation : Natural-transformation F G
open Precategory hiding (_∙_)
open Precategory D using (_∙_)
-- Morphisms.
transformation : ∀ {X} → Hom D (F ⊚ X) (G ⊚ X)
transformation = proj₁ natural-transformation
-- Naturality.
natural : ∀ {X Y} {f : Hom C X Y} →
(G ⊙ f) ∙ transformation ≡ transformation ∙ (F ⊙ f)
natural = proj₂ natural-transformation
private
module Dummy₄ where
abstract
-- The naturality property is a proposition (assuming
-- extensionality).
naturality-propositional :
∀ {ℓ₁ ℓ₂ ℓ₃ ℓ₄} →
Extensionality (ℓ₁ ⊔ ℓ₂) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₄) →
{C : Precategory ℓ₁ ℓ₂} {D : Precategory ℓ₃ ℓ₄}
(F G : C ⇨ D) →
let open Precategory hiding (_∙_); open Precategory D using (_∙_) in
{transformation : ∀ {X} → Hom D (F ⊚ X) (G ⊚ X)} →
Is-proposition (∀ {X Y} {f : Hom C X Y} →
(G ⊙ f) ∙ transformation ≡
transformation ∙ (F ⊙ f))
naturality-propositional {ℓ₁} {ℓ₂} ext {D = D} _ _ =
implicit-Π-closure (lower-extensionality ℓ₂ lzero ext) 1 λ _ →
implicit-Π-closure (lower-extensionality ℓ₂ ℓ₁ ext) 1 λ _ →
implicit-Π-closure (lower-extensionality ℓ₁ (ℓ₁ ⊔ ℓ₂) ext) 1 λ _ →
Precategory.Hom-is-set D
-- Natural transformation equality is equivalent to pointwise
-- equality of the corresponding "transformations" (assuming
-- extensionality).
equality-characterisation⇾ :
∀ {ℓ₁ ℓ₂ ℓ₃ ℓ₄} →
Extensionality (ℓ₁ ⊔ ℓ₂) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₄) →
{C : Precategory ℓ₁ ℓ₂} {D : Precategory ℓ₃ ℓ₄}
{F G : C ⇨ D} {γ δ : F ⇾ G} →
(γ ≡ δ)
≃
(∀ {X} → _⇾_.transformation γ {X = X} ≡
_⇾_.transformation δ {X = X})
equality-characterisation⇾ {ℓ₁} {ℓ₂} ext {F = F} {G} {γ} {δ} =
γ ≡ δ ↝⟨ inverse $ Eq.≃-≡ $ ↔⇒≃ record
{ surjection = record
{ logical-equivalence = record
{ to = _⇾_.natural-transformation
; from = λ γ → record { natural-transformation = γ }
}
; right-inverse-of = refl
}
; left-inverse-of = refl
} ⟩
_⇾_.natural-transformation γ ≡ _⇾_.natural-transformation δ ↔⟨ inverse $ ignore-propositional-component
(naturality-propositional ext F G) ⟩
(λ {X} → _⇾_.transformation γ {X = X}) ≡ _⇾_.transformation δ ↝⟨ inverse $ Eq.≃-≡ (Eq.↔⇒≃ implicit-Π↔Π) ⟩
(λ X → _⇾_.transformation γ {X = X}) ≡
(λ X → _⇾_.transformation δ {X = X}) ↝⟨ inverse $ Eq.extensionality-isomorphism
(lower-extensionality ℓ₂ (ℓ₁ ⊔ ℓ₂) ext) ⟩
(∀ X → _⇾_.transformation γ {X = X} ≡
_⇾_.transformation δ {X = X}) ↔⟨ inverse implicit-Π↔Π ⟩□
(∀ {X} → _⇾_.transformation γ {X = X} ≡
_⇾_.transformation δ {X = X}) □
-- Natural transformations form sets (assuming extensionality).
⇾-set :
∀ {ℓ₁ ℓ₂ ℓ₃ ℓ₄} →
Extensionality (ℓ₁ ⊔ ℓ₂) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₄) →
{C : Precategory ℓ₁ ℓ₂} {D : Precategory ℓ₃ ℓ₄} {F G : C ⇨ D} →
Is-set (F ⇾ G)
⇾-set {ℓ₁} {ℓ₂} ext {D = D} {F = F} {G = G} =
let surj = record
{ logical-equivalence = record
{ to = λ γ → record { natural-transformation = γ }
; from = _⇾_.natural-transformation
}
; right-inverse-of = refl
} in
respects-surjection surj 2 $
Σ-closure 2
(implicit-Π-closure
(lower-extensionality ℓ₂ (ℓ₁ ⊔ ℓ₂) ext) 2 λ _ →
Precategory.Hom-is-set D)
(λ _ → mono₁ 1 $ naturality-propositional ext F G)
open Dummy₄ public
-- Identity natural transformation.
id⇾ : ∀ {ℓ₁ ℓ₂} {C : Precategory ℓ₁ ℓ₂}
{ℓ₃ ℓ₄} {D : Precategory ℓ₃ ℓ₄}
(F : C ⇨ D) → F ⇾ F
id⇾ {C = C} {D = D} F =
record { natural-transformation = id , Dummy₅.nat }
where
open Precategory D
module Dummy₅ where
abstract
nat : ∀ {X Y} {f : Precategory.Hom C X Y} →
(F ⊙ f) ∙ id ≡ id ∙ (F ⊙ f)
nat {f = f} =
(F ⊙ f) ∙ id ≡⟨ right-identity ⟩
F ⊙ f ≡⟨ sym $ left-identity ⟩∎
id ∙ (F ⊙ f) ∎
-- Composition of natural transformations.
infixr 10 _∙⇾_
_∙⇾_ : ∀ {ℓ₁ ℓ₂} {C : Precategory ℓ₁ ℓ₂}
{ℓ₃ ℓ₄} {D : Precategory ℓ₃ ℓ₄}
{F G H : C ⇨ D} →
G ⇾ H → F ⇾ G → F ⇾ H
_∙⇾_ {C = C} {D = D} {F} {G} {H} γ δ =
record { natural-transformation = ε , Dummy₅.nat }
where
open Precategory D
open _⇾_
ε : ∀ {X} → Hom (F ⊚ X) (H ⊚ X)
ε = transformation γ ∙ transformation δ
module Dummy₅ where
abstract
nat : ∀ {X Y} {f : Precategory.Hom C X Y} →
(H ⊙ f) ∙ ε ≡ ε ∙ (F ⊙ f)
nat {f = f} =
(H ⊙ f) ∙ (transformation γ ∙ transformation δ) ≡⟨ assoc ⟩
((H ⊙ f) ∙ transformation γ) ∙ transformation δ ≡⟨ cong (λ f → f ∙ _) $ natural γ ⟩
(transformation γ ∙ (G ⊙ f)) ∙ transformation δ ≡⟨ sym assoc ⟩
transformation γ ∙ ((G ⊙ f) ∙ transformation δ) ≡⟨ cong (_∙_ _) $ natural δ ⟩
transformation γ ∙ (transformation δ ∙ (F ⊙ f)) ≡⟨ assoc ⟩∎
(transformation γ ∙ transformation δ) ∙ (F ⊙ f) ∎
-- Composition of functors and natural transformations.
infixr 10 _⇾∙⇨_ _⇨∙⇾_
_⇾∙⇨_ : ∀ {ℓ₁ ℓ₂} {C : Precategory ℓ₁ ℓ₂}
{ℓ₃ ℓ₄} {D : Precategory ℓ₃ ℓ₄}
{ℓ₅ ℓ₆} {E : Precategory ℓ₅ ℓ₆}
{G H : D ⇨ E} →
G ⇾ H → (F : C ⇨ D) → (G ∙⇨ F) ⇾ (H ∙⇨ F)
_⇾_.natural-transformation (γ ⇾∙⇨ _) = transformation , natural
where
open _⇾_ γ
_⇨∙⇾_ : ∀ {ℓ₁ ℓ₂} {C : Precategory ℓ₁ ℓ₂}
{ℓ₃ ℓ₄} {D : Precategory ℓ₃ ℓ₄}
{ℓ₅ ℓ₆} {E : Precategory ℓ₅ ℓ₆}
{G H : C ⇨ D} →
(F : D ⇨ E) → G ⇾ H → (F ∙⇨ G) ⇾ (F ∙⇨ H)
_⇾_.natural-transformation (_⇨∙⇾_ {C = C} {D = D} {E = E} {G} {H} F γ) =
ε , Dummy₅.nat
where
open Precategory
open _⇾_ γ
ε : ∀ {X} → Hom E (F ⊚ G ⊚ X) (F ⊚ H ⊚ X)
ε = F ⊙ transformation
module Dummy₅ where
abstract
nat : ∀ {X Y} {f : Hom C X Y} →
_∙_ E (F ⊙ H ⊙ f) ε ≡ _∙_ E ε (F ⊙ G ⊙ f)
nat {f = f} =
_∙_ E (F ⊙ H ⊙ f) (F ⊙ transformation) ≡⟨ sym $ ⊙-∙ F ⟩
F ⊙ _∙_ D (H ⊙ f) transformation ≡⟨ cong (F ⊙_) natural ⟩
F ⊙ _∙_ D transformation (G ⊙ f) ≡⟨ ⊙-∙ F ⟩∎
_∙_ E (F ⊙ transformation) (F ⊙ G ⊙ f) ∎
------------------------------------------------------------------------
-- Functor precategories
-- Functor precategories are defined using extensionality.
infix 10 _^_
_^_ : ∀ {ℓ₁ ℓ₂ ℓ₃ ℓ₄} →
Precategory ℓ₁ ℓ₂ → Precategory ℓ₃ ℓ₄ →
Extensionality (ℓ₃ ⊔ ℓ₄) (ℓ₂ ⊔ ℓ₃ ⊔ ℓ₄) →
Precategory _ _
(D ^ C) ext = record
{ precategory =
(C ⇨ D)
, (λ F G → (F ⇾ G) , ⇾-set ext)
, id⇾ _
, _∙⇾_
, _≃_.from (equality-characterisation⇾ ext) left-identity
, _≃_.from (equality-characterisation⇾ ext) right-identity
, _≃_.from (equality-characterisation⇾ ext) assoc
}
where
open Precategory D
private
module Dummy₅ where
abstract
-- The natural transformation γ is an isomorphism in (D ^ C) ext iff
-- _⇾_.transformation γ {X = X} is an isomorphism in D for every X.
natural-isomorphism-lemma :
∀ {ℓ₁ ℓ₂ ℓ₃ ℓ₄}
(ext : Extensionality (ℓ₁ ⊔ ℓ₂) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₄)) →
{C : Precategory ℓ₁ ℓ₂} {D : Precategory ℓ₃ ℓ₄}
{F G : C ⇨ D} {γ : F ⇾ G} → let open Precategory in
Is-isomorphism ((D ^ C) ext) γ ⇔
(∀ {X} → Is-isomorphism D (_⇾_.transformation γ {X = X}))
natural-isomorphism-lemma ext {D = D} {F} {G} {γ} = record
{ to = λ { (δ , γδ , δγ) →
transformation δ ,
(transformation γ ∙ transformation δ ≡⟨⟩
transformation (γ ∙⇾ δ) ≡⟨ cong (λ ε → transformation ε) γδ ⟩
transformation (id⇾ G) ≡⟨⟩
id ∎) ,
(transformation δ ∙ transformation γ ≡⟨⟩
transformation (δ ∙⇾ γ) ≡⟨ cong (λ ε → transformation ε) δγ ⟩
transformation (id⇾ F) ≡⟨⟩
id ∎) }
; from = λ iso →
record { natural-transformation =
proj₁ iso ,
(λ {_ _ f} →
(F ⊙ f) ∙ proj₁ iso ≡⟨ sym left-identity ⟩
id ∙ (F ⊙ f) ∙ proj₁ iso ≡⟨ cong (λ g → g ∙ (F ⊙ f) ∙ proj₁ iso) $ sym $ proj₂ (proj₂ iso) ⟩
(proj₁ iso ∙ transformation γ) ∙ (F ⊙ f) ∙ proj₁ iso ≡⟨ sym assoc ⟩
proj₁ iso ∙ (transformation γ ∙ (F ⊙ f) ∙ proj₁ iso) ≡⟨ cong (_ ∙_) assoc ⟩
proj₁ iso ∙ ((transformation γ ∙ (F ⊙ f)) ∙ proj₁ iso) ≡⟨ cong (λ g → _ ∙ (g ∙ _)) $ sym $ natural γ ⟩
proj₁ iso ∙ (((G ⊙ f) ∙ transformation γ) ∙ proj₁ iso) ≡⟨ cong (_ ∙_) $ sym assoc ⟩
proj₁ iso ∙ (G ⊙ f) ∙ (transformation γ ∙ proj₁ iso) ≡⟨ cong ((_ ∙_) ∘ ((G ⊙ f) ∙_)) $ proj₁ (proj₂ iso) ⟩
proj₁ iso ∙ (G ⊙ f) ∙ id ≡⟨ assoc ⟩
(proj₁ iso ∙ (G ⊙ f)) ∙ id ≡⟨ right-identity ⟩∎
proj₁ iso ∙ (G ⊙ f) ∎) } ,
_≃_.from (equality-characterisation⇾ ext) (proj₁ (proj₂ iso)) ,
_≃_.from (equality-characterisation⇾ ext) (proj₂ (proj₂ iso))
}
where
open Precategory D
open _⇾_
open Dummy₅ public
abstract
-- If D is a category, then (D ^ C) ext is also a category.
infix 10 _↑_
_↑_ : ∀ {ℓ₁ ℓ₂ ℓ₃ ℓ₄} →
Category ℓ₁ ℓ₂ → Precategory ℓ₃ ℓ₄ →
Extensionality (ℓ₃ ⊔ ℓ₄) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃ ⊔ ℓ₄) →
Category (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃ ⊔ ℓ₄) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃ ⊔ ℓ₄)
_↑_ {ℓ₁} {ℓ₂} {ℓ₃} {ℓ₄} D C ext = record { category =
D^C ,
(λ {F G} → _≃_.is-equivalence $ ↔⇒≃ $ record
{ surjection = record
{ logical-equivalence = record
{ to = Precategory.≡→≅ D^C
; from = λ { (F⇾G , F⇾G-iso) →
let γ : ∀ X → F ⊚ X ≅ G ⊚ X
γ _ = _⇾_.transformation F⇾G ,
_⇔_.to (natural-isomorphism-lemma ext₁) F⇾G-iso
⊚F≡⊚G : _⊚_ F ≡ _⊚_ G
⊚F≡⊚G = apply-ext (Eq.good-ext ext₂) λ X →
F ⊚ X ≡⟨ ≅→≡ (γ X) ⟩∎
G ⊚ X ∎
cong-⊚F≡⊚G : ∀ {X} → cong (λ H → H X) ⊚F≡⊚G ≡ ≅→≡ (γ X)
cong-⊚F≡⊚G = Eq.cong-good-ext ext₂ (≅→≡ ∘ γ)
⊙F≡⊙G : _≡_ {A = ∀ {X Y} → HomC X Y → Hom (G ⊚ X) (G ⊚ Y)}
(subst (λ F → ∀ {X Y} → HomC X Y → Hom (F X) (F Y))
⊚F≡⊚G
(_⊙_ F))
(_⊙_ G)
⊙F≡⊙G =
implicit-extensionality (lower-extensionality ℓ₄ ℓ₁ ext) λ X →
implicit-extensionality (lower-extensionality ℓ₄ (ℓ₁ ⊔ ℓ₃) ext) λ Y →
apply-ext (lower-extensionality ℓ₃ (ℓ₁ ⊔ ℓ₃ ⊔ ℓ₄) ext) λ f →
subst (λ F → ∀ {X Y} → HomC X Y → Hom (F X) (F Y))
⊚F≡⊚G (_⊙_ F) f ≡⟨ cong (λ H → H f) $ sym $
push-subst-implicit-application ⊚F≡⊚G
(λ F X → ∀ {Y} → HomC X Y → Hom (F X) (F Y)) ⟩
subst (λ F → ∀ {Y} → HomC X Y → Hom (F X) (F Y))
⊚F≡⊚G (_⊙_ F) f ≡⟨ cong (λ H → H f) $ sym $
push-subst-implicit-application ⊚F≡⊚G
(λ F Y → HomC X Y → Hom (F X) (F Y)) ⟩
subst (λ F → HomC X Y → Hom (F X) (F Y))
⊚F≡⊚G (_⊙_ F) f ≡⟨ sym $ push-subst-application ⊚F≡⊚G
(λ F _ → Hom (F X) (F Y)) ⟩
subst (λ F → Hom (F X) (F Y)) ⊚F≡⊚G (F ⊙ f) ≡⟨ subst-∘ (uncurry Hom) (λ H → (H X , H Y)) ⊚F≡⊚G ⟩
subst (uncurry Hom)
(cong (λ H → (H X , H Y)) ⊚F≡⊚G) (F ⊙ f) ≡⟨ cong (λ p → subst (uncurry Hom) p (F ⊙ f)) $ sym $
cong₂-cong-cong {eq = ⊚F≡⊚G} (λ H → H X) (λ H → H Y) _,_ ⟩
subst (uncurry Hom)
(cong₂ _,_ (cong (λ H → H X) ⊚F≡⊚G)
(cong (λ H → H Y) ⊚F≡⊚G)) (F ⊙ f) ≡⟨ cong₂ (λ p q → subst (uncurry Hom) (cong₂ _,_ p q) (F ⊙ f))
cong-⊚F≡⊚G cong-⊚F≡⊚G ⟩
subst (uncurry Hom)
(cong₂ _,_ (≅→≡ (γ X)) (≅→≡ (γ Y))) (F ⊙ f) ≡⟨ Hom-, (≅→≡ (γ X)) (≅→≡ (γ Y)) ⟩
≡→≅ (≅→≡ (γ Y)) ¹ ∙ (F ⊙ f) ∙ ≡→≅ (≅→≡ (γ X)) ⁻¹ ≡⟨ cong₂ (λ p q → p ¹ ∙ (F ⊙ f) ∙ q ⁻¹)
(_≃_.right-inverse-of ≡≃≅ _)
(_≃_.right-inverse-of ≡≃≅ _) ⟩
γ Y ¹ ∙ (F ⊙ f) ∙ γ X ⁻¹ ≡⟨ assoc ⟩
(γ Y ¹ ∙ (F ⊙ f)) ∙ γ X ⁻¹ ≡⟨ cong (_∙ γ X ⁻¹) $ sym $ _⇾_.natural F⇾G ⟩
((G ⊙ f) ∙ γ X ¹) ∙ γ X ⁻¹ ≡⟨ sym assoc ⟩
(G ⊙ f) ∙ γ X ¹ ∙ γ X ⁻¹ ≡⟨ cong (_ ∙_) $ γ X ¹⁻¹ ⟩
(G ⊙ f) ∙ id ≡⟨ right-identity ⟩∎
G ⊙ f ∎
in _≃_.from (equality-characterisation⇨ ext₁)
(⊚F≡⊚G , ⊙F≡⊙G) }
}
; right-inverse-of = λ { (F⇾G , F⇾G-iso) →
_≃_.from (Precategory.≡≃≡¹ D^C) $
_≃_.from (equality-characterisation⇾ ext₁) λ {X} →
_⇾_.transformation (proj₁ (Precategory.≡→≅ D^C _)) ≡⟨⟩
_⇾_.transformation
(proj₁ (elim (λ {F G} _ → Precategory._≅_ D^C F G)
(λ _ → Precategory.id≅ D^C) _)) ≡⟨ elim (λ {F G} F≡G →
_⇾_.transformation (proj₁ (Precategory.≡→≅ D^C F≡G)) ≡
elim (λ {F G} _ → Hom (F X) (G X)) (λ _ → id) (cong _⊚_ F≡G))
(λ F →
_⇾_.transformation
(proj₁ (elim (λ {F G} _ → Precategory._≅_ D^C F G)
(λ _ → Precategory.id≅ D^C) (refl F))) ≡⟨ cong (λ f → _⇾_.transformation (proj₁ f) {X = X}) $
elim-refl (λ {X Y} _ → Precategory._≅_ D^C X Y) _ ⟩
_⇾_.transformation {F = F}
(proj₁ (Precategory.id≅ D^C)) ≡⟨⟩
id ≡⟨ sym $ elim-refl (λ {F G} _ → Hom (F X) (G X)) _ ⟩
elim (λ {F G} _ → Hom (F X) (G X))
(λ _ → id) (refl (_⊚_ F)) ≡⟨ cong (elim (λ {F G} _ → Hom (F X) (G X)) _) $
sym $ cong-refl _⊚_ ⟩∎
elim (λ {F G} _ → Hom (F X) (G X))
(λ _ → id) (cong _⊚_ (refl F)) ∎)
_ ⟩
elim (λ {F G} _ → Hom (F X) (G X))
(λ _ → id) (cong _⊚_ _) ≡⟨ cong (elim (λ {F G} _ → Hom (F X) (G X)) (λ _ → id)) $
cong-⊚-from-equality-characterisation⇨ _ _ _ ⟩
elim (λ {F G} _ → Hom (F X) (G X)) (λ _ → id)
(apply-ext (Eq.good-ext ext₂) λ Y →
≅→≡ (_⇾_.transformation F⇾G {X = Y} , _)) ≡⟨ Eq.elim-good-ext ext₂ _ _ _ ⟩
elim (λ {X Y} _ → Hom X Y) (λ _ → id)
(≅→≡ (_⇾_.transformation F⇾G {X = X} , _)) ≡⟨ elim (λ {X Y} X≡Y → elim (λ {X Y} _ → Hom X Y) (λ _ → id) X≡Y ≡
proj₁ (≡→≅ X≡Y))
(λ X →
elim (λ {X Y} _ → Hom X Y) (λ _ → id) (refl X) ≡⟨ elim-refl (λ {X Y} _ → Hom X Y) _ ⟩
id ≡⟨⟩
proj₁ id≅ ≡⟨ cong proj₁ (sym ≡→≅-refl) ⟩∎
proj₁ (≡→≅ (refl X)) ∎ )
_ ⟩
proj₁ (≡→≅ (≅→≡ (_⇾_.transformation F⇾G {X = X} , _))) ≡⟨ cong proj₁ (_≃_.right-inverse-of ≡≃≅ _) ⟩∎
_⇾_.transformation F⇾G {X = X} ∎ }
}
; left-inverse-of = λ F≡G →
_≃_.from (equality-characterisation≡⇨ ext₁) (
cong _⊚_ _ ≡⟨ cong-⊚-from-equality-characterisation⇨ _ _ _ ⟩
apply-ext (Eq.good-ext ext₂) (λ X →
≅→≡ ( _⇾_.transformation
(proj₁ $ Precategory.≡→≅ D^C F≡G) {X = X}
, _
)) ≡⟨ elim
(λ {F G} F≡G → (f : (X : _) → _) →
apply-ext (Eq.good-ext ext₂) (λ X →
≅→≡ (_⇾_.transformation (proj₁ $ Precategory.≡→≅ D^C F≡G) , f X)) ≡
cong _⊚_ F≡G)
(λ F _ →
apply-ext (Eq.good-ext ext₂) (λ _ →
≅→≡ ( _⇾_.transformation
(proj₁ $ Precategory.≡→≅ D^C (refl F))
, _
)) ≡⟨ cong (apply-ext (Eq.good-ext ext₂)) (apply-ext ext₂ λ X → cong ≅→≡ $
Σ-≡,≡→≡ (cong (λ f → _⇾_.transformation (proj₁ f) {X = X}) $
Precategory.≡→≅-refl D^C)
(refl _)) ⟩
apply-ext (Eq.good-ext ext₂) (λ _ →
≅→≡ ( _⇾_.transformation {F = F}
(proj₁ $ Precategory.id≅ D^C)
, _
)) ≡⟨⟩
apply-ext (Eq.good-ext ext₂) (λ _ → ≅→≡ (id , _)) ≡⟨ cong (apply-ext (Eq.good-ext ext₂)) (apply-ext ext₂ λ _ →
cong ≅→≡ $ _≃_.from ≡≃≡¹ $ refl _) ⟩
apply-ext (Eq.good-ext ext₂) (λ _ → ≅→≡ id≅) ≡⟨ cong (apply-ext (Eq.good-ext ext₂)) (apply-ext ext₂ λ _ →
≅→≡-refl) ⟩
apply-ext (Eq.good-ext ext₂) (λ X → refl (F ⊚ X)) ≡⟨ Eq.good-ext-refl ext₂ _ ⟩
refl (_⊚_ F) ≡⟨ sym $ cong-refl _ ⟩∎
cong _⊚_ (refl F) ∎)
F≡G _ ⟩∎
cong _⊚_ F≡G ∎)
}) }
where
open Category D
open Precategory C using () renaming (Hom to HomC)
ext₁ : Extensionality (ℓ₃ ⊔ ℓ₄) (ℓ₂ ⊔ ℓ₃ ⊔ ℓ₄)
ext₁ = lower-extensionality lzero ℓ₁ ext
ext₂ : Extensionality ℓ₃ ℓ₁
ext₂ = lower-extensionality ℓ₄ (ℓ₂ ⊔ ℓ₃ ⊔ ℓ₄) ext
D^C : Precategory (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃ ⊔ ℓ₄) (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃ ⊔ ℓ₄)
D^C = (precategory ^ C) ext₁
|
{
"alphanum_fraction": 0.3836160336,
"avg_line_length": 43.5235069886,
"ext": "agda",
"hexsha": "596dab1834b1e284de6b1d676a7e596096e588e7",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/equality",
"max_forks_repo_path": "src/Functor.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/equality",
"max_issues_repo_path": "src/Functor.agda",
"max_line_length": 147,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "402b20615cfe9ca944662380d7b2d69b0f175200",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/equality",
"max_stars_repo_path": "src/Functor.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-02T17:18:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-05-21T22:58:50.000Z",
"num_tokens": 12227,
"size": 34253
}
|
-- Binding signatures
module SOAS.Syntax.Signature (T : Set) where
open import SOAS.Syntax.Arguments {T}
open import SOAS.Common
open import SOAS.Context
open import SOAS.Variable
open import SOAS.Families.Core {T}
open import SOAS.Families.BCCC {T} using (⊤ₘ)
open import SOAS.Coalgebraic.Strength
open import SOAS.Coalgebraic.Lift
open import SOAS.Coalgebraic.Map
open import SOAS.Abstract.Hom
open import SOAS.Abstract.ExpStrength
import SOAS.Abstract.Coalgebra as →□
open →□.Sorted
open →□.Unsorted renaming (Coalg to UCoalg ; Coalg⇒ to UCoalg⇒)
open import Data.List.Base using ([] ; _∷_ ; List)
private
variable
Γ Δ Θ : Ctx
α τ : T
-- Binding signature for a second-order syntax, consisting of a set of operators
-- O and an arity assignment ∣_∣
record Signature (O : Set) : Set₁ where
constructor sig
field ∣_∣ : O → List (Ctx × T) × T
-- Sort and arity of an operator
Sort : O → T
Sort o = proj₂ ∣ o ∣
Arity : O → List (Ctx × T)
Arity o = proj₁ ∣ o ∣
-- Signature endofunctor
⅀F : Functor 𝔽amiliesₛ 𝔽amiliesₛ
⅀F = record
{ F₀ = λ 𝒳 α Γ → Σ[ o ∈ O ] (α ≡ Sort o × Arg (Arity o) 𝒳 Γ)
; F₁ = λ{ f (o , e , ar) → o , e , (F₁ o f ar)}
; identity = λ{ {x = o , e , ar} → cong (λ - → o , e , -) (identity o) }
; homomorphism = λ{ {x = o , e , ar} → cong (λ - → o , e , -) (homomorphism o) }
; F-resp-≈ = λ{ p {x = o , e , ar} → cong (λ - → o , e , -) (F-resp-≈ o p) }
} where open module AF o = Functor (ArgF (Arity o))
pattern _⋮_ o ar = (o , refl , ar)
infix 1 _⋮_
open import SOAS.Metatheory.Algebra {T} ⅀F public
-- Coalgebraic and exponential strength for signature endofunctor
private
str : {𝒫 : Familyₛ}(𝒫ᴮ : Coalgₚ 𝒫)(𝒳 : Familyₛ)
(as : List (Ctx × T))(σ : Γ ~[ 𝒫 ]↝ Δ)
→ Arg as 〖 𝒫 , 𝒳 〗 Γ → Arg as 𝒳 Δ
str 𝒫ᴮ 𝒳 [] σ x = tt
str 𝒫ᴮ 𝒳 ((Θ , τ) ∷ []) σ h = h (lift 𝒫ᴮ Θ σ)
str 𝒫ᴮ 𝒳 ((Θ , τ) ∷ a ∷ as) σ (h , at) = h (lift 𝒫ᴮ Θ σ) , str 𝒫ᴮ 𝒳 (a ∷ as) σ at
str-nat₁ : {𝒫 𝒬 𝒳 : Familyₛ} {𝒫ᴮ : Coalgₚ 𝒫} {𝒬ᴮ : Coalgₚ 𝒬}
→ {f : 𝒬 ⇾̣ 𝒫} (fᴮ⇒ : Coalgₚ⇒ 𝒬ᴮ 𝒫ᴮ f)
→ (as : List (Ctx × T))
→ (h : Arg as 〖 𝒫 , 𝒳 〗 Γ) (σ : Γ ~[ 𝒬 ]↝ Δ)
→ str 𝒫ᴮ 𝒳 as (λ x → f (σ x)) h
≡ str 𝒬ᴮ 𝒳 as σ (Arg₁ as (λ{ h′ ς → h′ (λ v → f (ς v))}) h)
str-nat₁ fᴮ⇒ [] h σ = refl
str-nat₁ {𝒳 = 𝒳} fᴮ⇒ ((Θ , τ) ∷ []) h σ = lift-comp 𝒳 Θ fᴮ⇒ h σ
str-nat₁ {𝒳 = 𝒳} fᴮ⇒ ((Θ , τ) ∷ a ∷ as) (h , ap) σ =
cong₂ _,_ (lift-comp 𝒳 Θ fᴮ⇒ h σ) (str-nat₁ fᴮ⇒ (a ∷ as) ap σ)
str-nat₂ : {𝒫 𝒳 𝒴 : Familyₛ} {𝒫ᴮ : Coalgₚ 𝒫}
→ (f : 𝒳 ⇾̣ 𝒴)
→ (as : List (Ctx × T))
→ (h : Arg as 〖 𝒫 , 𝒳 〗 Γ) (σ : Γ ~[ 𝒫 ]↝ Δ)
→ str 𝒫ᴮ 𝒴 as σ (Arg₁ as (λ{ h′ ς → f (h′ ς)}) h)
≡ Arg₁ as f (str 𝒫ᴮ 𝒳 as σ h)
str-nat₂ f [] h σ = refl
str-nat₂ f ((Θ , τ) ∷ []) h σ = refl
str-nat₂ f ((Θ , τ) ∷ a ∷ as) (h , ap) σ = cong (_ ,_) (str-nat₂ f (a ∷ as) ap σ)
str-unit : (𝒳 : Familyₛ)
→ (as : List (Ctx × T))
→ (h : Arg as 〖 ℐ , 𝒳 〗 Γ)
→ str ℐᴮ 𝒳 as id h
≡ Arg₁ as (λ b → b id) h
str-unit 𝒳 [] h = refl
str-unit 𝒳 ((Θ , τ) ∷ []) h = rlift-id 𝒳 Θ h
str-unit 𝒳 ((Θ , τ) ∷ a ∷ as) (h , ap) = cong₂ _,_ (rlift-id 𝒳 Θ h) (str-unit 𝒳 (a ∷ as) ap)
str-assoc : (𝒳 : Familyₛ) {𝒫 𝒬 ℛ : Familyₛ}
{𝒫ᴮ : Coalgₚ 𝒫} {𝒬ᴮ : Coalgₚ 𝒬} {ℛᴮ : Coalgₚ ℛ}
→ {f : 𝒫 ⇾̣ 〖 𝒬 , ℛ 〗} (fᶜ : Coalgebraic 𝒫ᴮ 𝒬ᴮ ℛᴮ f)
→ (open Coalgebraic fᶜ)
→ (as : List (Ctx × T))
→ (h : Arg as 〖 ℛ , 𝒳 〗 Γ) (σ : Γ ~[ 𝒫 ]↝ Δ) (ς : Δ ~[ 𝒬 ]↝ Θ)
→ str ℛᴮ 𝒳 as (λ v → f (σ v) ς) h
≡ str 𝒬ᴮ 𝒳 as ς (str 〖𝒫,𝒴〗ᴮ 〖 𝒬 , 𝒳 〗 as (f ∘ σ) (Arg₁ as (λ{ h ς σ → h (λ v → ς v σ)}) h))
str-assoc 𝒳 fᶜ [] h σ ς = refl
str-assoc 𝒳 fᶜ ((Ξ , τ) ∷ []) h σ ς = lift-assoc 𝒳 Ξ fᶜ h σ ς
str-assoc 𝒳 fᶜ ((Ξ , τ) ∷ a ∷ as) (h , ap) σ ς = cong₂ _,_ (lift-assoc 𝒳 Ξ fᶜ h σ ς) (str-assoc 𝒳 fᶜ (a ∷ as) ap σ ς)
estr : {X : Family}(Xᵇ : UCoalg X)(𝒴 : Familyₛ)
(as : List (Ctx × T))
→ Arg as (X ⇨ 𝒴) Γ → (x : X Γ) → Arg as 𝒴 Γ
estr Xᵇ 𝒴 [] at x = tt
estr Xᵇ 𝒴 ((Θ , τ) ∷ []) e x = e (UCoalg.wkr Xᵇ Θ x)
estr Xᵇ 𝒴 ((Θ , τ) ∷ a ∷ as) (e , at) x = (e (UCoalg.wkr Xᵇ Θ x)) , estr Xᵇ 𝒴 (a ∷ as) at x
estr-nat₁ : {X X′ : Family} {Xᵇ : UCoalg X}
{X′ᵇ : UCoalg X′} {𝒴 : Familyₛ} {f : X′ ⇾ X} →
UCoalg⇒ X′ᵇ Xᵇ f →
(as : List (Ctx × T))
(h : Arg as (X ⇨ 𝒴) Γ)(x : X′ Γ)
→ estr Xᵇ 𝒴 as h (f x)
≡ estr X′ᵇ 𝒴 as (Arg₁ as (λ e x₁ → e (f x₁)) h) x
estr-nat₁ fᵇ⇒ [] h x = refl
estr-nat₁ fᵇ⇒ ((Θ , τ) ∷ []) h x = cong h (sym (UCoalg⇒.⟨r⟩ fᵇ⇒))
estr-nat₁ fᵇ⇒ ((Θ , τ) ∷ a ∷ as) (h , at) x = cong₂ _,_ (cong h (sym (UCoalg⇒.⟨r⟩ fᵇ⇒))) (estr-nat₁ fᵇ⇒ (a ∷ as) at x)
estr-nat₂ : {X : Family} {Xᵇ : UCoalg X}
{𝒴 𝒴′ : Familyₛ} (g : 𝒴 ⇾̣ 𝒴′) (as : List (Ctx × T))(at : Arg as (X ⇨ 𝒴) Γ) (x : X Γ)
→ estr Xᵇ 𝒴′ as (Arg₁ as (λ e x → g (e x)) at) x
≡ Arg₁ as g (estr Xᵇ 𝒴 as at x)
estr-nat₂ g [] at x = refl
estr-nat₂ g ((Θ , τ) ∷ []) h x = refl
estr-nat₂ g ((Θ , τ) ∷ a ∷ as) (h , at) x = cong (_ ,_) (estr-nat₂ g (a ∷ as) at x)
estr-unit : {𝒴 : Familyₛ} (as : List (Ctx × T)) {at : Arg as (⊤ₘ ⇨ 𝒴) Γ}
→ estr ⊤ᵇ 𝒴 as at tt ≡ Arg₁ as (λ e′ → e′ tt) at
estr-unit [] = refl
estr-unit ((Θ , τ) ∷ []) = refl
estr-unit ((Θ , τ) ∷ a ∷ as) = cong (_ ,_) (estr-unit (a ∷ as))
-- Compatible strengths for the signature endofunctor
⅀:CompatStr : CompatStrengths ⅀F
⅀:CompatStr = record
{ CoalgStr = record
{ str = λ{ 𝒫ᴮ 𝒳 (o , e , ap) σ → o , (e , str 𝒫ᴮ 𝒳 (Arity o) σ ap) }
; str-nat₁ = λ{ fᴮ⇒ (o , e , ap) σ → cong (λ - → o , e , -) (str-nat₁ fᴮ⇒ (Arity o) ap σ)}
; str-nat₂ = λ{ f (o , e , ap) σ → cong (λ - → o , e , -) (str-nat₂ f (Arity o) ap σ)}
; str-unit = λ{ 𝒳 (o , e , ap) → cong (λ - → o , e , -) (str-unit 𝒳 (Arity o) ap)}
; str-assoc = λ{ 𝒳 fᶜ (o , e , ap) σ ς → cong (λ - → o , e , -) (str-assoc 𝒳 fᶜ (Arity o) ap σ ς)}
}
; ExpStr = record
{ estr = λ{ Xᵇ 𝒴 (o , refl , at) x → o , refl , estr Xᵇ 𝒴 (Arity o) at x }
; estr-nat₁ = λ{ fᵇ⇒ (o , refl , at) x → cong (λ - → o , refl , -) (estr-nat₁ fᵇ⇒ (Arity o) at x)}
; estr-nat₂ = λ{ g (o , refl , at) x → cong (λ - → o , refl , -) (estr-nat₂ g (Arity o) at x) }
; estr-unit = λ{ {e = (o , refl , at)} → cong (λ - → o , refl , -) (estr-unit (Arity o)) } }
}
|
{
"alphanum_fraction": 0.4736680955,
"avg_line_length": 41.0817610063,
"ext": "agda",
"hexsha": "e4abbc945b0231b182fbb8d8482633efe489e86d",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2022-01-24T12:49:17.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-09T20:39:59.000Z",
"max_forks_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "JoeyEremondi/agda-soas",
"max_forks_repo_path": "SOAS/Syntax/Signature.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_issues_repo_issues_event_max_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "JoeyEremondi/agda-soas",
"max_issues_repo_path": "SOAS/Syntax/Signature.agda",
"max_line_length": 122,
"max_stars_count": 39,
"max_stars_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "JoeyEremondi/agda-soas",
"max_stars_repo_path": "SOAS/Syntax/Signature.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-19T17:33:12.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-11-09T20:39:55.000Z",
"num_tokens": 3327,
"size": 6532
}
|
{-
Definition of the torus as a HIT together with a proof that it is
equivalent to two circles
-}
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.Torus.Base where
open import Cubical.Core.Glue
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Nat
open import Cubical.Data.Int
open import Cubical.Data.Prod hiding (_×_) renaming (_×Σ_ to _×_)
open import Cubical.HITs.S1
data Torus : Type₀ where
point : Torus
line1 : point ≡ point
line2 : point ≡ point
square : PathP (λ i → line1 i ≡ line1 i) line2 line2
t2c : Torus → S¹ × S¹
t2c point = ( base , base )
t2c (line1 i) = ( loop i , base )
t2c (line2 j) = ( base , loop j )
t2c (square i j) = ( loop i , loop j )
c2t : S¹ × S¹ → Torus
c2t (base , base) = point
c2t (loop i , base) = line1 i
c2t (base , loop j) = line2 j
c2t (loop i , loop j) = square i j
c2t-t2c : ∀ (t : Torus) → c2t (t2c t) ≡ t
c2t-t2c point = refl
c2t-t2c (line1 _) = refl
c2t-t2c (line2 _) = refl
c2t-t2c (square _ _) = refl
t2c-c2t : ∀ (p : S¹ × S¹) → t2c (c2t p) ≡ p
t2c-c2t (base , base) = refl
t2c-c2t (base , loop _) = refl
t2c-c2t (loop _ , base) = refl
t2c-c2t (loop _ , loop _) = refl
Torus≡S¹×S¹ : Torus ≡ S¹ × S¹
Torus≡S¹×S¹ = isoToPath (iso t2c c2t t2c-c2t c2t-t2c)
ΩTorus : Type₀
ΩTorus = point ≡ point
-- TODO: upstream
lemPathAnd : ∀ {ℓ} {A B : Type ℓ} (t u : A × B) →
Path _ (t ≡ u) ((t .fst ≡ u .fst) × ((t .snd) ≡ (u .snd)))
lemPathAnd t u = isoToPath (iso (λ tu → (λ i → tu i .fst) , λ i → tu i .snd)
(λ tu i → tu .fst i , tu .snd i)
(λ y → refl)
(λ x → refl))
funDep : ∀ {ℓ} {A B : Type ℓ} (p : A ≡ B) (u0 : A) (u1 : B) →
(Path A u0 (transport (λ i → p (~ i)) u1)) ≡ (Path B (transport p u0) u1)
funDep p u0 u1 i = Path (p i) (transp (λ j → p (i ∧ j)) (~ i) u0) (transp (λ j → p (i ∨ ~ j)) i u1)
-- Can this proof be simplified?
ΩTorus≡Int×Int : ΩTorus ≡ Int × Int
ΩTorus≡Int×Int =
ΩTorus
≡⟨ (λ i → Path Torus point (transp (\ j → Torus≡S¹×S¹ (~ j ∧ i)) (~ i)
(glue (λ { (i = i0) → point
; (i = i1) → (base , base) }) (base , base)))) ⟩
Path Torus point (transp (\ i → Torus≡S¹×S¹ (~ i)) i0 (base , base))
≡⟨ funDep (λ i → Torus≡S¹×S¹ i) point (base , base) ⟩
Path (S¹ × S¹) (transp (\ i → Torus≡S¹×S¹ i) i0 point) (base , base)
≡⟨ (λ i → Path _ (transp (λ j → Torus≡S¹×S¹ (j ∨ i)) i
(glue (λ { (i = i0) → point
; (i = i1) → (base , base) }) (base , base))) (base , base)) ⟩
Path (S¹ × S¹) (base , base) (base , base)
≡⟨ lemPathAnd (base , base) (base , base) ⟩
ΩS¹ × ΩS¹
≡⟨ (λ i → ΩS¹≡Int i × ΩS¹≡Int i) ⟩
Int × Int ∎
-- Computing the winding numbers on the torus
windingTorus : ΩTorus → Int × Int
windingTorus l = ( winding (λ i → t2c (l i) .fst)
, winding (λ i → t2c (l i) .snd))
module _ where
private
test1 : windingTorus (line1 ∙ line2) ≡ (pos 1 , pos 1)
test1 = refl
test2 : windingTorus (line1 ∙ line2 ∙ sym line1 ∙ sym line1) ≡ (negsuc 0 , pos 1)
test2 = refl
|
{
"alphanum_fraction": 0.5347285411,
"avg_line_length": 32.6435643564,
"ext": "agda",
"hexsha": "71fdd013cee661b557c0001a00671d759685ee64",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cj-xu/cubical",
"max_forks_repo_path": "Cubical/HITs/Torus/Base.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cj-xu/cubical",
"max_issues_repo_path": "Cubical/HITs/Torus/Base.agda",
"max_line_length": 100,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "7fd336c6d31a6e6d58a44114831aacd63f422545",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cj-xu/cubical",
"max_stars_repo_path": "Cubical/HITs/Torus/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1353,
"size": 3297
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.