id
stringlengths 27
136
| text
stringlengths 4
1.05M
|
|---|---|
algebraic-stack_agda0000_doc_8528 | {-# OPTIONS --cubical --safe #-}
module Data.String where
open import Agda.Builtin.String using (String) public
open import Agda.Builtin.String
open import Agda.Builtin.String.Properties
open import Agda.Builtin.Char using (Char) public
open import Agda.Builtin.Char
open import Agda.Builtin.Char.Properties
open import Relation.Binary
open import Relation.Binary.Construct.On
import Data.Nat.Order as ℕ
open import Function.Injective
open import Function
open import Path
open import Data.List
open import Data.List.Relation.Binary.Lexicographic
unpack : String → List Char
unpack = primStringToList
pack : List Char → String
pack = primStringFromList
charOrd : TotalOrder Char _ _
charOrd = on-ord primCharToNat lemma ℕ.totalOrder
where
lemma : Injective primCharToNat
lemma x y p = builtin-eq-to-path (primCharToNatInjective x y (path-to-builtin-eq p ))
listCharOrd : TotalOrder (List Char) _ _
listCharOrd = listOrd charOrd
stringOrd : TotalOrder String _ _
stringOrd = on-ord primStringToList lemma listCharOrd
where
lemma : Injective primStringToList
lemma x y p = builtin-eq-to-path (primStringToListInjective x y (path-to-builtin-eq p))
|
algebraic-stack_agda0000_doc_8529 | -- Example usage of solver
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Experiment.Categories.Solver.Category.Example
{o ℓ e} (𝒞 : Category o ℓ e) where
open import Experiment.Categories.Solver.Category 𝒞
open Category 𝒞
open HomReasoning
private
variable
A B C D E : Obj
module _ (f : D ⇒ E) (g : C ⇒ D) (h : B ⇒ C) (i : A ⇒ B) where
_ : (f ∘ id ∘ g) ∘ id ∘ h ∘ i ≈ f ∘ (g ∘ h) ∘ i
_ = solve ((∥-∥ :∘ :id :∘ ∥-∥) :∘ :id :∘ ∥-∥ :∘ ∥-∥)
(∥-∥ :∘ (∥-∥ :∘ ∥-∥) :∘ ∥-∥)
refl
|
algebraic-stack_agda0000_doc_8530 | ----------------------------------------------------------------
-- This file contains the definition of isomorphisms. --
----------------------------------------------------------------
module Category.Iso where
open import Category.Category
record Iso {l : Level}{ℂ : Cat {l}}{A B : Obj ℂ} (f : el (Hom ℂ A B)) : Set l where
field
inv : el (Hom ℂ B A)
left-inv-ax : ⟨ Hom ℂ A A ⟩[ f ○[ comp ℂ ] inv ≡ id ℂ ]
right-inv-ax : ⟨ Hom ℂ B B ⟩[ inv ○[ comp ℂ ] f ≡ id ℂ ]
open Iso public
|
algebraic-stack_agda0000_doc_8531 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- The Cowriter type and some operations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --sized-types #-}
module Codata.Cowriter where
open import Size
import Level as L
open import Codata.Thunk using (Thunk; force)
open import Codata.Conat
open import Codata.Delay using (Delay; later; now)
open import Codata.Stream as Stream using (Stream; _∷_)
open import Data.Unit
open import Data.List using (List; []; _∷_)
open import Data.List.NonEmpty using (List⁺; _∷_)
open import Data.Nat.Base as Nat using (ℕ; zero; suc)
open import Data.Product as Prod using (_×_; _,_)
open import Data.Sum as Sum using (_⊎_; inj₁; inj₂)
open import Data.Vec using (Vec; []; _∷_)
open import Data.BoundedVec as BVec using (BoundedVec)
open import Function
data Cowriter {w a} (W : Set w) (A : Set a) (i : Size) : Set (a L.⊔ w) where
[_] : A → Cowriter W A i
_∷_ : W → Thunk (Cowriter W A) i → Cowriter W A i
------------------------------------------------------------------------
-- Relationship to Delay.
module _ {a} {A : Set a} where
fromDelay : ∀ {i} → Delay A i → Cowriter ⊤ A i
fromDelay (now a) = [ a ]
fromDelay (later da) = _ ∷ λ where .force → fromDelay (da .force)
module _ {w a} {W : Set w} {A : Set a} where
toDelay : ∀ {i} → Cowriter W A i → Delay A i
toDelay [ a ] = now a
toDelay (_ ∷ ca) = later λ where .force → toDelay (ca .force)
------------------------------------------------------------------------
-- Basic functions.
fromStream : ∀ {i} → Stream W i → Cowriter W A i
fromStream (w ∷ ws) = w ∷ λ where .force → fromStream (ws .force)
repeat : W → Cowriter W A ∞
repeat = fromStream ∘′ Stream.repeat
length : ∀ {i} → Cowriter W A i → Conat i
length [ _ ] = zero
length (w ∷ cw) = suc λ where .force → length (cw .force)
splitAt : ∀ (n : ℕ) → Cowriter W A ∞ → (Vec W n × Cowriter W A ∞) ⊎ (BoundedVec W n × A)
splitAt zero cw = inj₁ ([] , cw)
splitAt (suc n) [ a ] = inj₂ (BVec.[] , a)
splitAt (suc n) (w ∷ cw) = Sum.map (Prod.map₁ (w ∷_)) (Prod.map₁ (w BVec.∷_))
$ splitAt n (cw .force)
take : ∀ (n : ℕ) → Cowriter W A ∞ → Vec W n ⊎ (BoundedVec W n × A)
take n = Sum.map₁ Prod.proj₁ ∘′ splitAt n
infixr 5 _++_ _⁺++_
_++_ : ∀ {i} → List W → Cowriter W A i → Cowriter W A i
[] ++ ca = ca
(w ∷ ws) ++ ca = w ∷ λ where .force → ws ++ ca
_⁺++_ : ∀ {i} → List⁺ W → Thunk (Cowriter W A) i → Cowriter W A i
(w ∷ ws) ⁺++ ca = w ∷ λ where .force → ws ++ ca .force
concat : ∀ {i} → Cowriter (List⁺ W) A i → Cowriter W A i
concat [ a ] = [ a ]
concat (w ∷ ca) = w ⁺++ λ where .force → concat (ca .force)
module _ {w x a b} {W : Set w} {X : Set x} {A : Set a} {B : Set b} where
------------------------------------------------------------------------
-- Functor, Applicative and Monad
map : ∀ {i} → (W → X) → (A → B) → Cowriter W A i → Cowriter X B i
map f g [ a ] = [ g a ]
map f g (w ∷ cw) = f w ∷ λ where .force → map f g (cw .force)
module _ {w a r} {W : Set w} {A : Set a} {R : Set r} where
map₁ : ∀ {i} → (W → R) → Cowriter W A i → Cowriter R A i
map₁ f = map f id
map₂ : ∀ {i} → (A → R) → Cowriter W A i → Cowriter W R i
map₂ = map id
ap : ∀ {i} → Cowriter W (A → R) i → Cowriter W A i → Cowriter W R i
ap [ f ] ca = map₂ f ca
ap (w ∷ cf) ca = w ∷ λ where .force → ap (cf .force) ca
_>>=_ : ∀ {i} → Cowriter W A i → (A → Cowriter W R i) → Cowriter W R i
[ a ] >>= f = f a
(w ∷ ca) >>= f = w ∷ λ where .force → ca .force >>= f
------------------------------------------------------------------------
-- Construction.
module _ {w s a} {W : Set w} {S : Set s} {A : Set a} where
unfold : ∀ {i} → (S → (W × S) ⊎ A) → S → Cowriter W A i
unfold next seed with next seed
... | inj₁ (w , seed') = w ∷ λ where .force → unfold next seed'
... | inj₂ a = [ a ]
|
algebraic-stack_agda0000_doc_8532 | module Dave.Algebra.Naturals.Bin where
open import Dave.Algebra.Naturals.Definition
open import Dave.Algebra.Naturals.Addition
open import Dave.Algebra.Naturals.Multiplication
open import Dave.Embedding
data Bin : Set where
⟨⟩ : Bin
_t : Bin → Bin
_f : Bin → Bin
inc : Bin → Bin
inc ⟨⟩ = ⟨⟩ t
inc (b t) = (inc b) f
inc (b f) = b t
to : ℕ → Bin
to zero = ⟨⟩ f
to (suc n) = inc (to n)
from : Bin → ℕ
from ⟨⟩ = zero
from (b t) = 1 + 2 * (from b)
from (b f) = 2 * (from b)
from6 = from (⟨⟩ t t f)
from23 = from (⟨⟩ t f t t t)
from23WithZeros = from (⟨⟩ f f f t f t t t)
Bin-ℕ-Suc-Homomorph : ∀ (b : Bin) → from (inc b) ≡ suc (from b)
Bin-ℕ-Suc-Homomorph ⟨⟩ = refl
Bin-ℕ-Suc-Homomorph (b t) = begin
from (inc (b t)) ≡⟨⟩
from ((inc b) f) ≡⟨⟩
2 * (from (inc b)) ≡⟨ cong (λ a → 2 * a) (Bin-ℕ-Suc-Homomorph b) ⟩
2 * suc (from b) ≡⟨⟩
2 * (1 + (from b)) ≡⟨ *-distrib1ₗ-+ₗ 2 (from b) ⟩
2 + 2 * (from b) ≡⟨⟩
suc (1 + 2 * (from b)) ≡⟨⟩
suc (from (b t)) ∎
Bin-ℕ-Suc-Homomorph (b f) = begin
from (inc (b f)) ≡⟨⟩
from (b t) ≡⟨⟩
1 + 2 * (from b) ≡⟨⟩
suc (2 * from b) ≡⟨⟩
suc (from (b f)) ∎
to-inverse-from : ∀ (n : ℕ) → from (to n) ≡ n
to-inverse-from zero = refl
to-inverse-from (suc n) = begin
from (to (suc n)) ≡⟨⟩
from (inc (to n)) ≡⟨ Bin-ℕ-Suc-Homomorph (to n) ⟩
suc (from (to n)) ≡⟨ cong (λ a → suc a) (to-inverse-from n) ⟩
suc n ∎
ℕ≲Bin : ℕ ≲ Bin
ℕ≲Bin = record
{
to = to;
from = from;
from∘to = to-inverse-from
} |
algebraic-stack_agda0000_doc_8533 | open import ExtractSac as ES using ()
open import Extract (ES.kompile-fun)
open import Data.Nat as N using (ℕ; zero; suc; _≤_; _≥_; _<_; _>_; s≤s; z≤n; _∸_)
import Data.Nat.DivMod as N
open import Data.Nat.Properties as N
open import Data.List as L using (List; []; _∷_)
open import Data.Vec as V using (Vec; []; _∷_)
import Data.Vec.Properties as V
open import Data.Fin as F using (Fin; zero; suc; #_)
import Data.Fin.Properties as F
open import Data.Product as Prod using (Σ; _,_; curry; uncurry) renaming (_×_ to _×ₜ_)
open import Data.String
open import Relation.Binary.PropositionalEquality
open import Structures
open import Function
open import Array.Base
open import Array.Properties
open import APL2
open import Agda.Builtin.Float
open import Reflection
open import ReflHelper
pattern I0 = (zero ∷ [])
pattern I1 = (suc zero ∷ [])
pattern I2 = (suc (suc zero) ∷ [])
pattern I3 = (suc (suc (suc zero)) ∷ [])
-- backin←{(d w in)←⍵⋄⊃+/,w{(⍴in)↑(-⍵+⍴d)↑⍺×d}¨⍳⍴w}
backin : ∀ {n s s₁} → (inp : Ar Float n s)
→ (w : Ar Float n s₁)
→ {≥ : ▴ s ≥a ▴ s₁}
→ (d : Ar Float n $ ▾ ((s - s₁){≥} + 1))
→ Ar Float n s
backin {n}{s}{s₁} inp w d = let
ixs = ι ρ w
use-ixs i,pf = let
i , pf = i,pf
iv = a→ix i (ρ w) pf
wᵢ = sel w (subst-ix (λ i → V.lookup∘tabulate _ i) iv)
--x = pre-pad i 0.0 (d ×ᵣ wᵢ)
x = (i + ρ d) -↑⟨ 0.0 ⟩ (d ×ᵣ wᵢ)
y = (ρ inp) ↑⟨ 0.0 ⟩ x
in y
s = reduce-1d _+ᵣ_ (cst 0.0) (, use-ixs ̈ ixs)
in subst-ar (λ i → V.lookup∘tabulate _ i) s
kbin = kompile backin (quote _≥a_ ∷ quote reduce-1d ∷ quote _↑⟨_⟩_ ∷ quote _-↑⟨_⟩_ ∷ quote a→ix ∷ []) []
rkbin = frefl backin (quote _≥a_ ∷ quote reduce-1d ∷ quote _↑⟨_⟩_ ∷ quote _-↑⟨_⟩_ ∷ quote a→ix ∷ [])
fin-id : ∀ {n} → Fin n → Fin n
fin-id x = x
s-w+1≤s : ∀ {s w} → s ≥ w → s > 0 → w > 0 → s N.∸ w N.+ 1 ≤ s
s-w+1≤s {suc s} {suc w} (s≤s s≥w) s>0 w>0 rewrite (+-comm (s ∸ w) 1) = s≤s (m∸n≤m s w)
helper : ∀ {n} {sI sw : Vec ℕ n}
→ s→a sI ≥a s→a sw
→ (cst 0) <a s→a sI
→ (cst 0) <a s→a sw
→ (iv : Ix 1 (n ∷ []))
→ V.lookup sI (ix-lookup iv zero) ≥
V.lookup (V.tabulate (λ i → V.lookup sI i ∸ V.lookup sw i N.+ 1))
(ix-lookup iv zero)
helper {sI = sI} {sw} sI≥sw sI>0 sw>0 (x ∷ [])
rewrite (V.lookup∘tabulate (λ i → V.lookup sI i ∸ V.lookup sw i N.+ 1) x) =
s-w+1≤s (sI≥sw (x ∷ [])) (sI>0 (x ∷ [])) (sw>0 (x ∷ []))
a≤b⇒b≡c⇒a≤c : ∀ {a b c} → a ≤ b → b ≡ c → a ≤ c
a≤b⇒b≡c⇒a≤c a≤b refl = a≤b
-- sI - (sI - sw + 1) + 1 = sw
shape-same : ∀ {n} {sI sw : Vec ℕ n}
→ s→a sI ≥a s→a sw
→ (cst 0) <a s→a sI
→ (cst 0) <a s→a sw
→ (i : Fin n)
→ V.lookup
(V.tabulate
(λ i₁ →
V.lookup sI i₁ ∸
V.lookup (V.tabulate (λ i₂ → V.lookup sI i₂ ∸ V.lookup sw i₂ N.+ 1)) i₁
N.+ 1))
i
≡ V.lookup sw i
shape-same {suc n} {x ∷ sI} {y ∷ sw} I≥w I>0 w>0 zero =
begin
x ∸ (x ∸ y N.+ 1) N.+ 1 ≡⟨ sym $ +-∸-comm {m = x} 1 {o = (x ∸ y N.+ 1)} (s-w+1≤s (I≥w I0) (I>0 I0) (w>0 I0)) ⟩
x N.+ 1 ∸ (x ∸ y N.+ 1) ≡⟨ cong (x N.+ 1 ∸_) (sym $ +-∸-comm {m = x} 1 {o = y} (I≥w I0)) ⟩
x N.+ 1 ∸ (x N.+ 1 ∸ y) ≡⟨ m∸[m∸n]≡n {m = x N.+ 1} {n = y} (a≤b⇒b≡c⇒a≤c (≤-step $ I≥w I0) (+-comm 1 x)) ⟩
y
∎
where open ≡-Reasoning
shape-same {suc n} {x ∷ sI} {x₁ ∷ sw} I≥w I>0 w>0 (suc i) =
shape-same {sI = sI} {sw = sw} (λ { (i ∷ []) → I≥w (suc i ∷ []) })
(λ { (i ∷ []) → I>0 (suc i ∷ []) })
(λ { (i ∷ []) → w>0 (suc i ∷ []) }) i
{-backmulticonv ← {
(d_out weights in bias) ← ⍵
d_in ← +⌿d_out {backin ⍺ ⍵ in} ⍤((⍴⍴in), (⍴⍴in)) ⊢ weights
d_w ← {⍵ conv in} ⍤(⍴⍴in) ⊢ d_out
d_bias ← backbias ⍤(⍴⍴in) ⊢ d_out
d_in d_w d_bias
}-}
backmulticonv : ∀ {n m}{sI sw so}
→ (W : Ar (Ar Float n sw) m so)
→ (I : Ar Float n sI)
→ (B : Ar Float m so)
-- We can get rid of these two expressions if we rewrite
-- the convolution to accept s+1 ≥ w, and not s ≥ w.
→ {>I : (cst 0) <a s→a sI}
→ {>w : (cst 0) <a s→a sw}
→ {≥ : s→a sI ≥a s→a sw}
→ (δo : Ar (Ar Float n (a→s $ (s→a sI - s→a sw) {≥} + 1)) m so)
→ {- (typeOf W) ×ₜ-} (typeOf I) --×ₜ (typeOf B)
backmulticonv {n} {sI = sI} {sw} {so} W I B {sI>0} {sw>0} {sI≥sw} δo = let
δI = reduce-1d _+ᵣ_ (cst 0.0) (, (W ̈⟨ (λ x y → backin I x {sI≥sw} y) ⟩ δo))
{-
δW = (λ x → (x conv I) {≥ = λ { iv@(i ∷ []) → subst₂ _≤_ (sym $ V.lookup∘tabulate _ i) refl
$ s-w+1≤s (sI≥sw iv) (sI>0 iv) (sw>0 iv) } }) ̈ δo
δB = backbias ̈ δo
-}
in --(imap (λ iv → subst-ar (shape-same {sI = sI} {sw = sw} sI≥sw sI>0 sw>0) (sel δW iv)) ,
δI {-,
imap (λ iv → ▾ (sel δB iv))) -}
where open import Example-04
open import Example-03
kbckmconv = kompile backmulticonv (quote _≥a_ ∷ quote _<a_ ∷ quote reduce-1d ∷ quote _↑⟨_⟩_ ∷ quote _-↑⟨_⟩_ ∷ quote a→ix ∷ quote _conv_ ∷ []) []
where open import Example-04
conv-fns : List (String ×ₜ Name)
conv-fns = ("blog" , quote blog)
∷ ("backbias" , quote backbias)
∷ ("logistic" , quote logistic)
∷ ("meansqerr" , quote meansqerr)
∷ ("backavgpool" , quote backavgpool)
∷ ("avgpool" , quote avgpool)
∷ ("conv" , quote _conv_)
∷ ("multiconv" , quote multiconv)
∷ ("backin", quote backin)
∷ ("backmulticonv" , quote backmulticonv)
∷ []
where open import Example-03
open import Example-04
-- * test-zhang
-- * train-zhang
|
algebraic-stack_agda0000_doc_8534 | module Properties.Base where
open import Data.Maybe hiding (All)
open import Data.List
open import Data.List.All
open import Data.Product
open import Data.Sum
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
open import Typing
open import Global
open import Values
open import Session
open import Schedule
one-step : ∀ {G} → (∃ λ G' → ThreadPool (G' ++ G)) → Event × (∃ λ G → ThreadPool G)
one-step{G} (G1 , tp)
with ssplit-refl-left-inactive (G1 ++ G)
... | G' , ina-G' , ss-GG'
with Alternative.step ss-GG' tp (tnil ina-G')
... | ev , tp' = ev , ( _ , tp')
restart : ∀ {G} → Command G → Command G
restart (Ready ss v κ) = apply-cont ss κ v
restart cmd = cmd
-- auxiliary lemmas
lift-unrestricted :
∀ {t G} (unrt : Unr t) (v : Val G t)
→ unrestricted-val unrt (lift-val v) ≡ ::-inactive (unrestricted-val unrt v)
lift-unrestricted-venv :
∀ {Φ G} (unrt : All Unr Φ) (ϱ : VEnv G Φ)
→ unrestricted-venv unrt (lift-venv ϱ) ≡ ::-inactive (unrestricted-venv unrt ϱ)
lift-unrestricted UUnit (VUnit inaG) = refl
lift-unrestricted UInt (VInt i inaG) = refl
lift-unrestricted (UPair unrt unrt₁) (VPair ss-GG₁G₂ v v₁)
rewrite lift-unrestricted unrt v | lift-unrestricted unrt₁ v₁
= refl
lift-unrestricted UFun (VFun (inj₁ ()) ϱ e)
lift-unrestricted UFun (VFun (inj₂ y) ϱ e) = lift-unrestricted-venv y ϱ
lift-unrestricted-venv [] (vnil ina) = refl
lift-unrestricted-venv (px ∷ unrt) (vcons ssp v ϱ)
rewrite lift-unrestricted px v | lift-unrestricted-venv unrt ϱ
= refl
unrestricted-empty : ∀ {t} → (unrt : Unr t) (v : Val [] t) → unrestricted-val unrt v ≡ []-inactive
unrestricted-empty-venv : ∀ {t} → (unrt : All Unr t) (v : VEnv [] t) → unrestricted-venv unrt v ≡ []-inactive
unrestricted-empty UUnit (VUnit []-inactive) = refl
unrestricted-empty UInt (VInt i []-inactive) = refl
unrestricted-empty (UPair unrt unrt₁) (VPair ss-[] v v₁)
rewrite unrestricted-empty unrt v | unrestricted-empty unrt₁ v₁
= refl
unrestricted-empty UFun (VFun (inj₁ ()) ϱ e)
unrestricted-empty UFun (VFun (inj₂ y) ϱ e) = unrestricted-empty-venv y ϱ
unrestricted-empty-venv [] (vnil []-inactive) = refl
unrestricted-empty-venv (px ∷ unrt) (vcons ss-[] v v₁)
rewrite unrestricted-empty px v | unrestricted-empty-venv unrt v₁
= refl
split-env-lemma :
∀ { Φ Φ₁ Φ₂ }
(sp : Split Φ Φ₁ Φ₂)
(ϱ : VEnv [] Φ)
→ ∃ λ ϱ₁ → ∃ λ ϱ₂ →
split-env sp (lift-venv ϱ) ≡
(((nothing ∷ []) , (nothing ∷ [])) , (ss-both ss-[]) , lift-venv ϱ₁ , lift-venv ϱ₂)
split-env-lemma [] (vnil []-inactive) =
(vnil []-inactive) , ((vnil []-inactive) , refl)
split-env-lemma (dupl unrt sp) (vcons ss-[] v ϱ)
with split-env-lemma sp ϱ | unrestricted-val unrt v
... | ϱ₁ , ϱ₂ , spe== | unr-v
rewrite inactive-left-ssplit ss-[] unr-v | lift-unrestricted unrt v | unrestricted-empty unrt v | spe==
with ssplit-compose3 (ss-both ss-[]) (ss-both ss-[])
... | ssc3
= (vcons ss-[] v ϱ₁)
, (vcons ss-[] v ϱ₂)
, refl
split-env-lemma (Split.drop unrt sp) (vcons ss-[] v ϱ)
with split-env-lemma sp ϱ | unrestricted-val unrt v
... | ϱ₁ , ϱ₂ , spe== | unr-v
rewrite lift-unrestricted unrt v | unrestricted-empty unrt v
= ϱ₁ , ϱ₂ , spe==
split-env-lemma (left sp) (vcons ss-[] v ϱ)
with split-env-lemma sp ϱ
... | ϱ₁ , ϱ₂ , spe==
rewrite spe==
with ssplit-compose3 (ss-both ss-[]) (ss-both ss-[])
... | ssc3
= (vcons ss-[] v ϱ₁) , (ϱ₂ , refl)
split-env-lemma (rght sp) (vcons ss-[] v ϱ)
with split-env-lemma sp ϱ
... | ϱ₁ , ϱ₂ , spe==
rewrite spe==
with ssplit-compose4 (ss-both ss-[]) (ss-both ss-[])
... | ssc4
= ϱ₁ , (vcons ss-[] v ϱ₂) , refl
split-env-right-lemma :
∀ {Φ} (ϱ : VEnv [] Φ) →
split-env (split-all-right Φ) (lift-venv ϱ)
≡
(((nothing ∷ []) , (nothing ∷ [])) , (ss-both ss-[]) , vnil (::-inactive []-inactive) , lift-venv ϱ)
split-env-right-lemma (vnil []-inactive) = refl
split-env-right-lemma (vcons ss-[] v ϱ)
with split-env-right-lemma ϱ
... | sperl
rewrite sperl
with ssplit-compose4 (ss-both ss-[]) (ss-both ss-[])
... | ssc4
= refl
split-env-right-lemma0 :
∀ {Φ} (ϱ : VEnv [] Φ) →
split-env (split-all-right Φ) ϱ
≡
(([] , []) , ss-[] , vnil []-inactive , ϱ)
split-env-right-lemma0 (vnil []-inactive) = refl
split-env-right-lemma0 (vcons ss-[] v ϱ)
rewrite split-env-right-lemma0 ϱ
= refl
split-env-left-lemma0 :
∀ {Φ} (ϱ : VEnv [] Φ) →
split-env (split-all-left Φ) ϱ
≡
(([] , []) , ss-[] , ϱ , vnil []-inactive)
split-env-left-lemma0 (vnil []-inactive) = refl
split-env-left-lemma0 (vcons ss-[] v ϱ)
rewrite split-env-left-lemma0 ϱ
= refl
split-env-lemma-2T : Set
split-env-lemma-2T =
∀ { Φ Φ₁ Φ₂ }
(sp : Split Φ Φ₁ Φ₂)
(ϱ : VEnv [] Φ)
→ ∃ λ ϱ₁ → ∃ λ ϱ₂ →
split-env sp (lift-venv ϱ) ≡
(_ , (ss-both ss-[]) , lift-venv ϱ₁ , lift-venv ϱ₂)
×
split-env sp ϱ ≡
(_ , ss-[] , ϱ₁ , ϱ₂)
split-env-lemma-2 : split-env-lemma-2T
split-env-lemma-2 [] (vnil []-inactive)
= (vnil []-inactive) , ((vnil []-inactive) , (refl , refl))
split-env-lemma-2 (dupl unrt sp) (vcons ss-[] v ϱ)
with split-env-lemma-2 sp ϱ
... | ϱ₁ , ϱ₂ , selift-ind , se-ind
rewrite se-ind | lift-unrestricted unrt v
with unrestricted-val unrt v
... | []-inactive
rewrite selift-ind
with ssplit-compose3 (ss-both ss-[]) (ss-both ss-[])
... | ssc3
= (vcons ss-[] v ϱ₁) , (vcons ss-[] v ϱ₂) , refl , refl
split-env-lemma-2 (Split.drop unrt sp) (vcons ss-[] v ϱ)
with split-env-lemma-2 sp ϱ
... | ϱ₁ , ϱ₂ , selift-ind , se-ind
rewrite se-ind | lift-unrestricted unrt v
with unrestricted-val unrt v
... | []-inactive
= ϱ₁ , ϱ₂ , selift-ind , se-ind
split-env-lemma-2 (left sp) (vcons ss-[] v ϱ)
with split-env-lemma-2 sp ϱ
... | ϱ₁ , ϱ₂ , selift-ind , se-ind
rewrite se-ind | selift-ind
with ssplit-compose3 (ss-both ss-[]) (ss-both ss-[])
... | ssc3
= (vcons ss-[] v ϱ₁) , ϱ₂ , refl , refl
split-env-lemma-2 (rght sp) (vcons ss-[] v ϱ)
with split-env-lemma-2 sp ϱ
... | ϱ₁ , ϱ₂ , selift-ind , se-ind
rewrite se-ind | selift-ind
with ssplit-compose4 (ss-both ss-[]) (ss-both ss-[])
... | ssc4
= ϱ₁ , (vcons ss-[] v ϱ₂) , refl , refl
split-rotate-lemma : ∀ {Φ} →
split-rotate (split-all-left Φ) (split-all-right Φ)
≡
(Φ , split-all-right Φ , split-all-left Φ)
split-rotate-lemma {[]} = refl
split-rotate-lemma {x ∷ Φ}
rewrite split-rotate-lemma {Φ}
= refl
split-rotate-lemma' : ∀ {Φ Φ₁ Φ₂}
(sp : Split Φ Φ₁ Φ₂) →
split-rotate (split-all-left Φ) sp
≡
(Φ₂ , sp , split-all-left Φ₂)
split-rotate-lemma' {[]} [] = refl
split-rotate-lemma' {x ∷ Φ} (dupl un-x sp)
rewrite split-rotate-lemma' {Φ} sp
= refl
split-rotate-lemma' {x ∷ Φ} {Φ₁} {Φ₂} (Split.drop un-x sp)
rewrite split-rotate-lemma' {Φ} sp
= refl
split-rotate-lemma' {x ∷ Φ} (left sp)
rewrite split-rotate-lemma' {Φ} sp
= refl
split-rotate-lemma' {x ∷ Φ} (rght sp)
rewrite split-rotate-lemma' {Φ} sp
= refl
ssplit-compose-lemma : ∀ ss →
ssplit-compose ss-[] ss ≡ ([] , ss-[] , ss-[])
ssplit-compose-lemma ss-[] = refl
|
algebraic-stack_agda0000_doc_8535 |
open import Oscar.Prelude
open import Oscar.Class.IsFunctor
open import Oscar.Class.Reflexivity
open import Oscar.Class.Smap
open import Oscar.Class.Surjection
open import Oscar.Class.Transitivity
module Oscar.Class.Functor where
record Functor 𝔬₁ 𝔯₁ ℓ₁ 𝔬₂ 𝔯₂ ℓ₂ : Ø ↑̂ (𝔬₁ ∙̂ 𝔯₁ ∙̂ ℓ₁ ∙̂ 𝔬₂ ∙̂ 𝔯₂ ∙̂ ℓ₂) where
constructor ∁
field
{𝔒₁} : Ø 𝔬₁
_∼₁_ : 𝔒₁ → 𝔒₁ → Ø 𝔯₁
_∼̇₁_ : ∀ {x y} → x ∼₁ y → x ∼₁ y → Ø ℓ₁
ε₁ : Reflexivity.type _∼₁_
_↦₁_ : Transitivity.type _∼₁_
{𝔒₂} : Ø 𝔬₂
_∼₂_ : 𝔒₂ → 𝔒₂ → Ø 𝔯₂
_∼̇₂_ : ∀ {x y} → x ∼₂ y → x ∼₂ y → Ø ℓ₂
ε₂ : Reflexivity.type _∼₂_
_↦₂_ : Transitivity.type _∼₂_
{μ} : Surjection.type 𝔒₁ 𝔒₂
functor-smap : Smap.type _∼₁_ _∼₂_ μ μ -- FIXME cannot name this § or smap b/c of namespace conflict
⦃ `IsFunctor ⦄ : IsFunctor _∼₁_ _∼̇₁_ ε₁ _↦₁_ _∼₂_ _∼̇₂_ ε₂ _↦₂_ functor-smap
|
algebraic-stack_agda0000_doc_8536 | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Overloading ⟦_⟧ notation
--
-- This module defines a general mechanism for overloading the
-- ⟦_⟧ notation, using Agda’s instance arguments.
------------------------------------------------------------------------
module Base.Denotation.Notation where
open import Level
record Meaning (Syntax : Set) {ℓ : Level} : Set (suc ℓ) where
constructor
meaning
field
{Semantics} : Set ℓ
⟨_⟩⟦_⟧ : Syntax → Semantics
open Meaning {{...}} public
renaming (⟨_⟩⟦_⟧ to ⟦_⟧)
open Meaning public
using (⟨_⟩⟦_⟧)
|
algebraic-stack_agda0000_doc_8537 | {-# OPTIONS --allow-unsolved-metas #-}
module IsLiteralProblem where
open import OscarPrelude
open import IsLiteralSequent
open import Problem
record IsLiteralProblem (𝔓 : Problem) : Set
where
constructor _¶_
field
{problem} : Problem
isLiteralInferences : All IsLiteralSequent (inferences 𝔓)
isLiteralInterest : IsLiteralSequent (interest 𝔓)
open IsLiteralProblem public
instance EqIsLiteralProblem : ∀ {𝔓} → Eq (IsLiteralProblem 𝔓)
EqIsLiteralProblem = {!!}
|
algebraic-stack_agda0000_doc_8538 | module Pi-.Invariants where
open import Data.Empty
open import Data.Unit
open import Data.Sum
open import Data.Product
open import Relation.Binary.Core
open import Relation.Binary
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
open import Data.Nat
open import Data.Nat.Properties
open import Function using (_∘_)
open import Pi-.Syntax
open import Pi-.Opsem
open import Pi-.NoRepeat
open import Pi-.Dir
-- Direction of values
dir𝕍 : ∀ {t} → ⟦ t ⟧ → Dir
dir𝕍 {𝟘} ()
dir𝕍 {𝟙} v = ▷
dir𝕍 {_ +ᵤ _} (inj₁ x) = dir𝕍 x
dir𝕍 {_ +ᵤ _} (inj₂ y) = dir𝕍 y
dir𝕍 {_ ×ᵤ _} (x , y) = dir𝕍 x ×ᵈⁱʳ dir𝕍 y
dir𝕍 { - _} (- v) = -ᵈⁱʳ (dir𝕍 v)
-- Execution direction of states
dirState : State → Dir
dirState ⟨ _ ∣ _ ∣ _ ⟩▷ = ▷
dirState ［ _ ∣ _ ∣ _ ］▷ = ▷
dirState ⟨ _ ∣ _ ∣ _ ⟩◁ = ◁
dirState ［ _ ∣ _ ∣ _ ］◁ = ◁
dirCtx : ∀ {A B} → Context {A} {B} → Dir
dirCtx ☐ = ▷
dirCtx (☐⨾ c₂ • κ) = dirCtx κ
dirCtx (c₁ ⨾☐• κ) = dirCtx κ
dirCtx (☐⊕ c₂ • κ) = dirCtx κ
dirCtx (c₁ ⊕☐• κ) = dirCtx κ
dirCtx (☐⊗[ c₂ , x ]• κ) = dir𝕍 x ×ᵈⁱʳ dirCtx κ
dirCtx ([ c₁ , x ]⊗☐• κ) = dir𝕍 x ×ᵈⁱʳ dirCtx κ
dirState𝕍 : State → Dir
dirState𝕍 ⟨ _ ∣ v ∣ κ ⟩▷ = dir𝕍 v ×ᵈⁱʳ dirCtx κ
dirState𝕍 ［ _ ∣ v ∣ κ ］▷ = dir𝕍 v ×ᵈⁱʳ dirCtx κ
dirState𝕍 ⟨ _ ∣ v ∣ κ ⟩◁ = dir𝕍 v ×ᵈⁱʳ dirCtx κ
dirState𝕍 ［ _ ∣ v ∣ κ ］◁ = dir𝕍 v ×ᵈⁱʳ dirCtx κ
δdir : ∀ {A B} (c : A ↔ B) {b : base c} → (v : ⟦ A ⟧) → dir𝕍 v ≡ dir𝕍 (δ c {b} v)
δdir unite₊l (inj₂ v) = refl
δdir uniti₊l v = refl
δdir swap₊ (inj₁ x) = refl
δdir swap₊ (inj₂ y) = refl
δdir assocl₊ (inj₁ v) = refl
δdir assocl₊ (inj₂ (inj₁ v)) = refl
δdir assocl₊ (inj₂ (inj₂ v)) = refl
δdir assocr₊ (inj₁ (inj₁ v)) = refl
δdir assocr₊ (inj₁ (inj₂ v)) = refl
δdir assocr₊ (inj₂ v) = refl
δdir unite⋆l (tt , v) = identˡᵈⁱʳ (dir𝕍 v)
δdir uniti⋆l v = sym (identˡᵈⁱʳ (dir𝕍 v))
δdir swap⋆ (x , y) = commᵈⁱʳ _ _
δdir assocl⋆ (v₁ , (v₂ , v₃)) = assoclᵈⁱʳ _ _ _
δdir assocr⋆ ((v₁ , v₂) , v₃) = sym (assoclᵈⁱʳ _ _ _)
δdir dist (inj₁ v₁ , v₃) = refl
δdir dist (inj₂ v₂ , v₃) = refl
δdir factor (inj₁ (v₁ , v₃)) = refl
δdir factor (inj₂ (v₂ , v₃)) = refl
-- Invariant of directions
dirInvariant : ∀ {st st'} → st ↦ st' → dirState st ×ᵈⁱʳ dirState𝕍 st ≡ dirState st' ×ᵈⁱʳ dirState𝕍 st'
dirInvariant {⟨ c ∣ v ∣ κ ⟩▷} (↦⃗₁ {b = b}) rewrite δdir c {b} v = refl
dirInvariant ↦⃗₂ = refl
dirInvariant ↦⃗₃ = refl
dirInvariant ↦⃗₄ = refl
dirInvariant ↦⃗₅ = refl
dirInvariant {⟨ c₁ ⊗ c₂ ∣ (x , y) ∣ κ ⟩▷} ↦⃗₆ rewrite assoclᵈⁱʳ (dir𝕍 x) (dir𝕍 y) (dirCtx κ) = refl
dirInvariant ↦⃗₇ = refl
dirInvariant {［ c₁ ∣ x ∣ ☐⊗[ c₂ , y ]• κ ］▷} ↦⃗₈ rewrite assoc-commᵈⁱʳ (dir𝕍 x) (dir𝕍 y) (dirCtx κ) = refl
dirInvariant {［ c₂ ∣ y ∣ [ c₁ , x ]⊗☐• κ ］▷} ↦⃗₉ rewrite assocl-commᵈⁱʳ (dir𝕍 y) (dir𝕍 x) (dirCtx κ) = refl
dirInvariant ↦⃗₁₀ = refl
dirInvariant ↦⃗₁₁ = refl
dirInvariant ↦⃗₁₂ = refl
dirInvariant {_} {⟨ c ∣ v ∣ κ ⟩◁} (↦⃖₁ {b = b}) rewrite δdir c {b} v = refl
dirInvariant ↦⃖₂ = refl
dirInvariant ↦⃖₃ = refl
dirInvariant ↦⃖₄ = refl
dirInvariant ↦⃖₅ = refl
dirInvariant {⟨ c₁ ∣ x ∣ ☐⊗[ c₂ , y ]• κ ⟩◁} ↦⃖₆ rewrite assoclᵈⁱʳ (dir𝕍 x) (dir𝕍 y) (dirCtx κ) = refl
dirInvariant ↦⃖₇ = refl
dirInvariant {⟨ c₂ ∣ y ∣ [ c₁ , x ]⊗☐• κ ⟩◁} ↦⃖₈ rewrite assoc-commᵈⁱʳ (dir𝕍 y) (dir𝕍 x) (dirCtx κ) = refl
dirInvariant {［ c₁ ⊗ c₂ ∣ (x , y) ∣ κ ］◁ } ↦⃖₉ rewrite assoclᵈⁱʳ (dir𝕍 y) (dir𝕍 x) (dirCtx κ) | commᵈⁱʳ (dir𝕍 y) (dir𝕍 x) = refl
dirInvariant ↦⃖₁₀ = refl
dirInvariant ↦⃖₁₁ = refl
dirInvariant ↦⃖₁₂ = refl
dirInvariant {［ η₊ ∣ inj₁ v ∣ κ ］◁} ↦η₁ with dir𝕍 v
... | ◁ with dirCtx κ
... | ◁ = refl
... | ▷ = refl
dirInvariant {［ η₊ ∣ inj₁ v ∣ κ ］◁} ↦η₁ | ▷ with dirCtx κ
... | ◁ = refl
... | ▷ = refl
dirInvariant {［ η₊ ∣ inj₂ (- v) ∣ κ ］◁} ↦η₂ with dir𝕍 v
... | ◁ with dirCtx κ
... | ◁ = refl
... | ▷ = refl
dirInvariant {［ η₊ ∣ inj₂ (- v) ∣ κ ］◁} ↦η₂ | ▷ with dirCtx κ
... | ◁ = refl
... | ▷ = refl
dirInvariant {⟨ ε₊ ∣ inj₁ v ∣ κ ⟩▷} ↦ε₁ with dir𝕍 v
... | ◁ with dirCtx κ
... | ◁ = refl
... | ▷ = refl
dirInvariant {⟨ ε₊ ∣ inj₁ v ∣ κ ⟩▷} ↦ε₁ | ▷ with dirCtx κ
... | ◁ = refl
... | ▷ = refl
dirInvariant {⟨ ε₊ ∣ inj₂ (- v) ∣ κ ⟩▷} ↦ε₂ with dir𝕍 v
... | ◁ with dirCtx κ
... | ◁ = refl
... | ▷ = refl
dirInvariant {⟨ ε₊ ∣ inj₂ (- v) ∣ κ ⟩▷} ↦ε₂ | ▷ with dirCtx κ
... | ◁ = refl
... | ▷ = refl
-- Reconstruct the whole combinator from context
getℂκ : ∀ {A B} → A ↔ B → Context {A} {B} → ∃[ C ] ∃[ D ] (C ↔ D)
getℂκ c ☐ = _ , _ , c
getℂκ c (☐⨾ c₂ • κ) = getℂκ (c ⨾ c₂) κ
getℂκ c (c₁ ⨾☐• κ) = getℂκ (c₁ ⨾ c) κ
getℂκ c (☐⊕ c₂ • κ) = getℂκ (c ⊕ c₂) κ
getℂκ c (c₁ ⊕☐• κ) = getℂκ (c₁ ⊕ c) κ
getℂκ c (☐⊗[ c₂ , x ]• κ) = getℂκ (c ⊗ c₂) κ
getℂκ c ([ c₁ , x ]⊗☐• κ) = getℂκ (c₁ ⊗ c) κ
getℂ : State → ∃[ A ] ∃[ B ] (A ↔ B)
getℂ ⟨ c ∣ _ ∣ κ ⟩▷ = getℂκ c κ
getℂ ［ c ∣ _ ∣ κ ］▷ = getℂκ c κ
getℂ ⟨ c ∣ _ ∣ κ ⟩◁ = getℂκ c κ
getℂ ［ c ∣ _ ∣ κ ］◁ = getℂκ c κ
-- The reconstructed combinator stays the same
ℂInvariant : ∀ {st st'} → st ↦ st' → getℂ st ≡ getℂ st'
ℂInvariant ↦⃗₁ = refl
ℂInvariant ↦⃗₂ = refl
ℂInvariant ↦⃗₃ = refl
ℂInvariant ↦⃗₄ = refl
ℂInvariant ↦⃗₅ = refl
ℂInvariant ↦⃗₆ = refl
ℂInvariant ↦⃗₇ = refl
ℂInvariant ↦⃗₈ = refl
ℂInvariant ↦⃗₉ = refl
ℂInvariant ↦⃗₁₀ = refl
ℂInvariant ↦⃗₁₁ = refl
ℂInvariant ↦⃗₁₂ = refl
ℂInvariant ↦⃖₁ = refl
ℂInvariant ↦⃖₂ = refl
ℂInvariant ↦⃖₃ = refl
ℂInvariant ↦⃖₄ = refl
ℂInvariant ↦⃖₅ = refl
ℂInvariant ↦⃖₆ = refl
ℂInvariant ↦⃖₇ = refl
ℂInvariant ↦⃖₈ = refl
ℂInvariant ↦⃖₉ = refl
ℂInvariant ↦⃖₁₀ = refl
ℂInvariant ↦⃖₁₁ = refl
ℂInvariant ↦⃖₁₂ = refl
ℂInvariant ↦η₁ = refl
ℂInvariant ↦η₂ = refl
ℂInvariant ↦ε₁ = refl
ℂInvariant ↦ε₂ = refl
ℂInvariant* : ∀ {st st'} → st ↦* st' → getℂ st ≡ getℂ st'
ℂInvariant* ◾ = refl
ℂInvariant* (r ∷ rs) = trans (ℂInvariant r) (ℂInvariant* rs)
-- Get the type of the deepest context
get𝕌 : ∀ {A B} → Context {A} {B} → 𝕌 × 𝕌
get𝕌 {A} {B} ☐ = A , B
get𝕌 (☐⨾ c₂ • κ) = get𝕌 κ
get𝕌 (c₁ ⨾☐• κ) = get𝕌 κ
get𝕌 (☐⊕ c₂ • κ) = get𝕌 κ
get𝕌 (c₁ ⊕☐• κ) = get𝕌 κ
get𝕌 (☐⊗[ c₂ , x ]• κ) = get𝕌 κ
get𝕌 ([ c₁ , x ]⊗☐• κ) = get𝕌 κ
get𝕌State : State → 𝕌 × 𝕌
get𝕌State ⟨ c ∣ v ∣ κ ⟩▷ = get𝕌 κ
get𝕌State ［ c ∣ v ∣ κ ］▷ = get𝕌 κ
get𝕌State ⟨ c ∣ v ∣ κ ⟩◁ = get𝕌 κ
get𝕌State ［ c ∣ v ∣ κ ］◁ = get𝕌 κ
-- Append a context to another context
appendκ : ∀ {A B} → (ctx : Context {A} {B}) → let (C , D) = get𝕌 ctx
in Context {C} {D} → Context {A} {B}
appendκ ☐ ctx = ctx
appendκ (☐⨾ c₂ • κ) ctx = ☐⨾ c₂ • appendκ κ ctx
appendκ (c₁ ⨾☐• κ) ctx = c₁ ⨾☐• appendκ κ ctx
appendκ (☐⊕ c₂ • κ) ctx = ☐⊕ c₂ • appendκ κ ctx
appendκ (c₁ ⊕☐• κ) ctx = c₁ ⊕☐• appendκ κ ctx
appendκ (☐⊗[ c₂ , x ]• κ) ctx = ☐⊗[ c₂ , x ]• appendκ κ ctx
appendκ ([ c₁ , x ]⊗☐• κ) ctx = [ c₁ , x ]⊗☐• appendκ κ ctx
appendκState : ∀ st → let (A , B) = get𝕌State st
in Context {A} {B} → State
appendκState ⟨ c ∣ v ∣ κ ⟩▷ ctx = ⟨ c ∣ v ∣ appendκ κ ctx ⟩▷
appendκState ［ c ∣ v ∣ κ ］▷ ctx = ［ c ∣ v ∣ appendκ κ ctx ］▷
appendκState ⟨ c ∣ v ∣ κ ⟩◁ ctx = ⟨ c ∣ v ∣ appendκ κ ctx ⟩◁
appendκState ［ c ∣ v ∣ κ ］◁ ctx = ［ c ∣ v ∣ appendκ κ ctx ］◁
-- The type of context does not change during execution
𝕌Invariant : ∀ {st st'} → st ↦ st' → get𝕌State st ≡ get𝕌State st'
𝕌Invariant ↦⃗₁ = refl
𝕌Invariant ↦⃗₂ = refl
𝕌Invariant ↦⃗₃ = refl
𝕌Invariant ↦⃗₄ = refl
𝕌Invariant ↦⃗₅ = refl
𝕌Invariant ↦⃗₆ = refl
𝕌Invariant ↦⃗₇ = refl
𝕌Invariant ↦⃗₈ = refl
𝕌Invariant ↦⃗₉ = refl
𝕌Invariant ↦⃗₁₀ = refl
𝕌Invariant ↦⃗₁₁ = refl
𝕌Invariant ↦⃗₁₂ = refl
𝕌Invariant ↦⃖₁ = refl
𝕌Invariant ↦⃖₂ = refl
𝕌Invariant ↦⃖₃ = refl
𝕌Invariant ↦⃖₄ = refl
𝕌Invariant ↦⃖₅ = refl
𝕌Invariant ↦⃖₆ = refl
𝕌Invariant ↦⃖₇ = refl
𝕌Invariant ↦⃖₈ = refl
𝕌Invariant ↦⃖₉ = refl
𝕌Invariant ↦⃖₁₀ = refl
𝕌Invariant ↦⃖₁₁ = refl
𝕌Invariant ↦⃖₁₂ = refl
𝕌Invariant ↦η₁ = refl
𝕌Invariant ↦η₂ = refl
𝕌Invariant ↦ε₁ = refl
𝕌Invariant ↦ε₂ = refl
𝕌Invariant* : ∀ {st st'} → st ↦* st' → get𝕌State st ≡ get𝕌State st'
𝕌Invariant* ◾ = refl
𝕌Invariant* (r ∷ rs) = trans (𝕌Invariant r) (𝕌Invariant* rs)
-- Appending context does not affect reductions
appendκ↦ : ∀ {st st'} → (r : st ↦ st') (eq : get𝕌State st ≡ get𝕌State st')
→ (κ : Context {proj₁ (get𝕌State st)} {proj₂ (get𝕌State st)})
→ appendκState st κ ↦ appendκState st' (subst (λ {(A , B) → Context {A} {B}}) eq κ)
appendκ↦ ↦⃗₁ refl ctx = ↦⃗₁
appendκ↦ ↦⃗₂ refl ctx = ↦⃗₂
appendκ↦ ↦⃗₃ refl ctx = ↦⃗₃
appendκ↦ ↦⃗₄ refl ctx = ↦⃗₄
appendκ↦ ↦⃗₅ refl ctx = ↦⃗₅
appendκ↦ ↦⃗₆ refl ctx = ↦⃗₆
appendκ↦ ↦⃗₇ refl ctx = ↦⃗₇
appendκ↦ ↦⃗₈ refl ctx = ↦⃗₈
appendκ↦ ↦⃗₉ refl ctx = ↦⃗₉
appendκ↦ ↦⃗₁₀ refl ctx = ↦⃗₁₀
appendκ↦ ↦⃗₁₁ refl ctx = ↦⃗₁₁
appendκ↦ ↦⃗₁₂ refl ctx = ↦⃗₁₂
appendκ↦ ↦⃖₁ refl ctx = ↦⃖₁
appendκ↦ ↦⃖₂ refl ctx = ↦⃖₂
appendκ↦ ↦⃖₃ refl ctx = ↦⃖₃
appendκ↦ ↦⃖₄ refl ctx = ↦⃖₄
appendκ↦ ↦⃖₅ refl ctx = ↦⃖₅
appendκ↦ ↦⃖₆ refl ctx = ↦⃖₆
appendκ↦ ↦⃖₇ refl ctx = ↦⃖₇
appendκ↦ ↦⃖₈ refl ctx = ↦⃖₈
appendκ↦ ↦⃖₉ refl ctx = ↦⃖₉
appendκ↦ ↦⃖₁₀ refl ctx = ↦⃖₁₀
appendκ↦ ↦⃖₁₁ refl ctx = ↦⃖₁₁
appendκ↦ ↦⃖₁₂ refl ctx = ↦⃖₁₂
appendκ↦ ↦η₁ refl ctx = ↦η₁
appendκ↦ ↦η₂ refl ctx = ↦η₂
appendκ↦ ↦ε₁ refl ctx = ↦ε₁
appendκ↦ ↦ε₂ refl ctx = ↦ε₂
appendκ↦* : ∀ {st st'} → (r : st ↦* st') (eq : get𝕌State st ≡ get𝕌State st')
→ (κ : Context {proj₁ (get𝕌State st)} {proj₂ (get𝕌State st)})
→ appendκState st κ ↦* appendκState st' (subst (λ {(A , B) → Context {A} {B}}) eq κ)
appendκ↦* ◾ refl ctx = ◾
appendκ↦* (↦⃗₁ {b = b} {v} {κ} ∷ rs) eq ctx = appendκ↦ (↦⃗₁ {b = b} {v} {κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃗₂ {v = v} {κ} ∷ rs) eq ctx = appendκ↦ (↦⃗₂ {v = v} {κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃗₃ {v = v} {κ} ∷ rs) eq ctx = appendκ↦ (↦⃗₃ {v = v} {κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃗₄ {x = x} {κ} ∷ rs) eq ctx = appendκ↦ (↦⃗₄ {x = x} {κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃗₅ {y = y} {κ} ∷ rs) eq ctx = appendκ↦ (↦⃗₅ {y = y} {κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃗₆ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃗₆ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃗₇ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃗₇ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃗₈ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃗₈ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃗₉ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃗₉ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃗₁₀ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃗₁₀ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃗₁₁ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃗₁₁ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃗₁₂ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃗₁₂ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃖₁ {b = b} {v} {κ} ∷ rs) eq ctx = appendκ↦ (↦⃖₁ {b = b} {v} {κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃖₂ {v = v} {κ} ∷ rs) eq ctx = appendκ↦ (↦⃖₂ {v = v} {κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃖₃ {v = v} {κ} ∷ rs) eq ctx = appendκ↦ (↦⃖₃ {v = v} {κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃖₄ {x = x} {κ} ∷ rs) eq ctx = appendκ↦ (↦⃖₄ {x = x} {κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃖₅ {y = y} {κ} ∷ rs) eq ctx = appendκ↦ (↦⃖₅ {y = y} {κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃖₆ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃖₆ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃖₇ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃖₇ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃖₈ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃖₈ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃖₉ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃖₉ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃖₁₀ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃖₁₀ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃖₁₁ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃖₁₁ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦⃖₁₂ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦⃖₁₂ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦η₁ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦η₁ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦η₂ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦η₂ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦ε₁ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦ε₁ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
appendκ↦* (↦ε₂ {κ = κ} ∷ rs) eq ctx = appendκ↦ (↦ε₂ {κ = κ}) refl ctx ∷ appendκ↦* rs eq ctx
|
algebraic-stack_agda0000_doc_8539 | ------------------------------------------------------------------------
-- Two logically equivalent axiomatisations of equality
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Equality where
open import Logical-equivalence hiding (id; _∘_)
open import Prelude
private
variable
ℓ : Level
A B C D : Type ℓ
P : A → Type ℓ
a a₁ a₂ a₃ b c p u v x x₁ x₂ y y₁ y₂ z : A
f g : (x : A) → P x
------------------------------------------------------------------------
-- Reflexive relations
record Reflexive-relation a : Type (lsuc a) where
no-eta-equality
infix 4 _≡_
field
-- "Equality".
_≡_ : {A : Type a} → A → A → Type a
-- Reflexivity.
refl : (x : A) → x ≡ x
-- Some definitions.
module Reflexive-relation′
(reflexive : ∀ ℓ → Reflexive-relation ℓ) where
private
open module R {ℓ} = Reflexive-relation (reflexive ℓ) public
-- Non-equality.
infix 4 _≢_
_≢_ : {A : Type a} → A → A → Type a
x ≢ y = ¬ (x ≡ y)
-- The property of having decidable equality.
Decidable-equality : Type ℓ → Type ℓ
Decidable-equality A = Decidable (_≡_ {A = A})
-- A type is contractible if it is inhabited and all elements are
-- equal.
Contractible : Type ℓ → Type ℓ
Contractible A = ∃ λ (x : A) → ∀ y → x ≡ y
-- The property of being a proposition.
Is-proposition : Type ℓ → Type ℓ
Is-proposition A = (x y : A) → x ≡ y
-- The property of being a set.
Is-set : Type ℓ → Type ℓ
Is-set A = {x y : A} → Is-proposition (x ≡ y)
-- Uniqueness of identity proofs (for a specific universe level).
Uniqueness-of-identity-proofs : ∀ ℓ → Type (lsuc ℓ)
Uniqueness-of-identity-proofs ℓ = {A : Type ℓ} → Is-set A
-- The K rule (without computational content).
K-rule : ∀ a p → Type (lsuc (a ⊔ p))
K-rule a p = {A : Type a} (P : {x : A} → x ≡ x → Type p) →
(∀ x → P (refl x)) →
∀ {x} (x≡x : x ≡ x) → P x≡x
-- Singleton x is a set which contains all elements which are equal
-- to x.
Singleton : {A : Type a} → A → Type a
Singleton x = ∃ λ y → y ≡ x
-- A variant of Singleton.
Other-singleton : {A : Type a} → A → Type a
Other-singleton x = ∃ λ y → x ≡ y
-- The inspect idiom.
inspect : (x : A) → Other-singleton x
inspect x = x , refl x
-- Extensionality for functions of a certain type.
Extensionality′ : (A : Type a) → (A → Type b) → Type (a ⊔ b)
Extensionality′ A B =
{f g : (x : A) → B x} → (∀ x → f x ≡ g x) → f ≡ g
-- Extensionality for functions at certain levels.
--
-- The definition is wrapped in a record type in order to avoid
-- certain problems related to Agda's handling of implicit
-- arguments.
record Extensionality (a b : Level) : Type (lsuc (a ⊔ b)) where
no-eta-equality
field
apply-ext : {A : Type a} {B : A → Type b} → Extensionality′ A B
open Extensionality public
-- Proofs of extensionality which behave well when applied to
-- reflexivity.
Well-behaved-extensionality :
(A : Type a) → (A → Type b) → Type (a ⊔ b)
Well-behaved-extensionality A B =
∃ λ (ext : Extensionality′ A B) →
∀ f → ext (λ x → refl (f x)) ≡ refl f
------------------------------------------------------------------------
-- Abstract definition of equality based on the J rule
-- Parametrised by a reflexive relation.
record Equality-with-J₀
a p (reflexive : ∀ ℓ → Reflexive-relation ℓ) :
Type (lsuc (a ⊔ p)) where
open Reflexive-relation′ reflexive
field
-- The J rule.
elim : ∀ {A : Type a} {x y}
(P : {x y : A} → x ≡ y → Type p) →
(∀ x → P (refl x)) →
(x≡y : x ≡ y) → P x≡y
-- The usual computational behaviour of the J rule.
elim-refl : ∀ {A : Type a} {x}
(P : {x y : A} → x ≡ y → Type p)
(r : ∀ x → P (refl x)) →
elim P r (refl x) ≡ r x
-- Extended variants of Reflexive-relation and Equality-with-J₀ with
-- some extra fields. These fields can be derived from
-- Equality-with-J₀ (see J₀⇒Equivalence-relation⁺ and J₀⇒J below), but
-- those derived definitions may not have the intended computational
-- behaviour (in particular, not when the paths of Cubical Agda are
-- used).
-- A variant of Reflexive-relation: equivalence relations with some
-- extra structure.
record Equivalence-relation⁺ a : Type (lsuc a) where
no-eta-equality
field
reflexive-relation : Reflexive-relation a
open Reflexive-relation reflexive-relation
field
-- Symmetry.
sym : {A : Type a} {x y : A} → x ≡ y → y ≡ x
sym-refl : {A : Type a} {x : A} → sym (refl x) ≡ refl x
-- Transitivity.
trans : {A : Type a} {x y z : A} → x ≡ y → y ≡ z → x ≡ z
trans-refl-refl : {A : Type a} {x : A} →
trans (refl x) (refl x) ≡ refl x
-- A variant of Equality-with-J₀.
record Equality-with-J
a b (e⁺ : ∀ ℓ → Equivalence-relation⁺ ℓ) :
Type (lsuc (a ⊔ b)) where
no-eta-equality
private
open module R {ℓ} = Equivalence-relation⁺ (e⁺ ℓ)
open module R₀ {ℓ} = Reflexive-relation (reflexive-relation {ℓ})
field
equality-with-J₀ : Equality-with-J₀ a b (λ _ → reflexive-relation)
open Equality-with-J₀ equality-with-J₀
field
-- Congruence.
cong : {A : Type a} {B : Type b} {x y : A}
(f : A → B) → x ≡ y → f x ≡ f y
cong-refl : {A : Type a} {B : Type b} {x : A} (f : A → B) →
cong f (refl x) ≡ refl (f x)
-- Substitutivity.
subst : {A : Type a} {x y : A} (P : A → Type b) →
x ≡ y → P x → P y
subst-refl : ∀ {A : Type a} {x} (P : A → Type b) p →
subst P (refl x) p ≡ p
-- A dependent variant of cong.
dcong :
∀ {A : Type a} {P : A → Type b} {x y}
(f : (x : A) → P x) (x≡y : x ≡ y) →
subst P x≡y (f x) ≡ f y
dcong-refl :
∀ {A : Type a} {P : A → Type b} {x} (f : (x : A) → P x) →
dcong f (refl x) ≡ subst-refl _ _
-- Equivalence-relation⁺ can be derived from Equality-with-J₀.
J₀⇒Equivalence-relation⁺ :
∀ {ℓ reflexive} →
Equality-with-J₀ ℓ ℓ reflexive →
Equivalence-relation⁺ ℓ
J₀⇒Equivalence-relation⁺ {ℓ} {r} eq = record
{ reflexive-relation = r ℓ
; sym = sym
; sym-refl = sym-refl
; trans = trans
; trans-refl-refl = trans-refl-refl
}
where
open Reflexive-relation (r ℓ)
open Equality-with-J₀ eq
cong : (f : A → B) → x ≡ y → f x ≡ f y
cong f = elim (λ {u v} _ → f u ≡ f v) (λ x → refl (f x))
subst : (P : A → Type ℓ) → x ≡ y → P x → P y
subst P = elim (λ {u v} _ → P u → P v) (λ _ p → p)
subst-refl : (P : A → Type ℓ) (p : P x) → subst P (refl x) p ≡ p
subst-refl P p = cong (_$ p) $ elim-refl (λ {u} _ → P u → _) _
sym : x ≡ y → y ≡ x
sym {x = x} x≡y = subst (λ z → x ≡ z → z ≡ x) x≡y id x≡y
abstract
sym-refl : sym (refl x) ≡ refl x
sym-refl = cong (_$ _) $ subst-refl (λ z → _ ≡ z → z ≡ _) _
trans : x ≡ y → y ≡ z → x ≡ z
trans {x = x} = flip (subst (x ≡_))
abstract
trans-refl-refl : trans (refl x) (refl x) ≡ refl x
trans-refl-refl = subst-refl _ _
-- Equality-with-J (for arbitrary universe levels) can be derived from
-- Equality-with-J₀ (for arbitrary universe levels).
J₀⇒J :
∀ {reflexive} →
(eq : ∀ {a p} → Equality-with-J₀ a p reflexive) →
∀ {a p} → Equality-with-J a p (λ _ → J₀⇒Equivalence-relation⁺ eq)
J₀⇒J {r} eq {a} {b} = record
{ equality-with-J₀ = eq
; cong = cong
; cong-refl = cong-refl
; subst = subst
; subst-refl = subst-refl
; dcong = dcong
; dcong-refl = dcong-refl
}
where
open module R {ℓ} = Reflexive-relation (r ℓ)
open module E {a} {b} = Equality-with-J₀ (eq {a} {b})
cong : (f : A → B) → x ≡ y → f x ≡ f y
cong f = elim (λ {u v} _ → f u ≡ f v) (λ x → refl (f x))
abstract
cong-refl : (f : A → B) → cong f (refl x) ≡ refl (f x)
cong-refl _ = elim-refl _ _
subst : (P : A → Type b) → x ≡ y → P x → P y
subst P = elim (λ {u v} _ → P u → P v) (λ _ p → p)
subst-refl≡id : (P : A → Type b) → subst P (refl x) ≡ id
subst-refl≡id P = elim-refl (λ {u v} _ → P u → P v) (λ _ p → p)
subst-refl : ∀ (P : A → Type b) p → subst P (refl x) p ≡ p
subst-refl P p = cong (_$ p) (subst-refl≡id P)
dcong : (f : (x : A) → P x) (x≡y : x ≡ y) →
subst P x≡y (f x) ≡ f y
dcong {A = A} {P = P} f x≡y = elim
(λ {x y} (x≡y : x ≡ y) → (f : (x : A) → P x) →
subst P x≡y (f x) ≡ f y)
(λ _ _ → subst-refl _ _)
x≡y
f
abstract
dcong-refl : (f : (x : A) → P x) →
dcong f (refl x) ≡ subst-refl _ _
dcong-refl {P = P} f =
cong (_$ f) $ elim-refl (λ _ → (_ : ∀ x → P x) → _) _
-- Some derived properties.
module Equality-with-J′
{e⁺ : ∀ ℓ → Equivalence-relation⁺ ℓ}
(eq : ∀ {a p} → Equality-with-J a p e⁺)
where
private
open module E⁺ {ℓ} = Equivalence-relation⁺ (e⁺ ℓ) public
open module E {a b} = Equality-with-J (eq {a} {b}) public
hiding (subst; subst-refl)
open module E₀ {a p} = Equality-with-J₀ (equality-with-J₀ {a} {p})
public
open Reflexive-relation′ (λ ℓ → reflexive-relation {ℓ}) public
-- Substitutivity.
subst : (P : A → Type p) → x ≡ y → P x → P y
subst = E.subst
subst-refl : (P : A → Type p) (p : P x) → subst P (refl x) p ≡ p
subst-refl = E.subst-refl
-- Singleton types are contractible.
private
irr : (p : Singleton x) → (x , refl x) ≡ p
irr p =
elim (λ {u v} u≡v → (v , refl v) ≡ (u , u≡v))
(λ _ → refl _)
(proj₂ p)
singleton-contractible : (x : A) → Contractible (Singleton x)
singleton-contractible x = ((x , refl x) , irr)
abstract
-- "Evaluation rule" for singleton-contractible.
singleton-contractible-refl :
(x : A) →
proj₂ (singleton-contractible x) (x , refl x) ≡ refl (x , refl x)
singleton-contractible-refl _ = elim-refl _ _
------------------------------------------------------------------------
-- Abstract definition of equality based on substitutivity and
-- contractibility of singleton types
record Equality-with-substitutivity-and-contractibility
a p (reflexive : ∀ ℓ → Reflexive-relation ℓ) :
Type (lsuc (a ⊔ p)) where
no-eta-equality
open Reflexive-relation′ reflexive
field
-- Substitutivity.
subst : {A : Type a} {x y : A} (P : A → Type p) → x ≡ y → P x → P y
-- The usual computational behaviour of substitutivity.
subst-refl : {A : Type a} {x : A} (P : A → Type p) (p : P x) →
subst P (refl x) p ≡ p
-- Singleton types are contractible.
singleton-contractible :
{A : Type a} (x : A) → Contractible (Singleton x)
-- Some derived properties.
module Equality-with-substitutivity-and-contractibility′
{reflexive : ∀ ℓ → Reflexive-relation ℓ}
(eq : ∀ {a p} → Equality-with-substitutivity-and-contractibility
a p reflexive)
where
private
open Reflexive-relation′ reflexive public
open module E {a p} =
Equality-with-substitutivity-and-contractibility (eq {a} {p}) public
hiding (singleton-contractible)
open module E′ {a} =
Equality-with-substitutivity-and-contractibility (eq {a} {a}) public
using (singleton-contractible)
abstract
-- Congruence.
cong : (f : A → B) → x ≡ y → f x ≡ f y
cong {x = x} f x≡y =
subst (λ y → x ≡ y → f x ≡ f y) x≡y (λ _ → refl (f x)) x≡y
-- Symmetry.
sym : x ≡ y → y ≡ x
sym {x = x} x≡y = subst (λ z → x ≡ z → z ≡ x) x≡y id x≡y
abstract
-- "Evaluation rule" for sym.
sym-refl : sym (refl x) ≡ refl x
sym-refl {x = x} =
cong (λ f → f (refl x)) $
subst-refl (λ z → x ≡ z → z ≡ x) _
-- Transitivity.
trans : x ≡ y → y ≡ z → x ≡ z
trans {x = x} = flip (subst (_≡_ x))
abstract
-- "Evaluation rule" for trans.
trans-refl-refl : trans (refl x) (refl x) ≡ refl x
trans-refl-refl = subst-refl _ _
abstract
-- The J rule.
elim : (P : {x y : A} → x ≡ y → Type p) →
(∀ x → P (refl x)) →
(x≡y : x ≡ y) → P x≡y
elim {x = x} {y = y} P p x≡y =
let lemma = proj₂ (singleton-contractible y) in
subst (P ∘ proj₂)
(trans (sym (lemma (y , refl y))) (lemma (x , x≡y)))
(p y)
-- Transitivity and symmetry sometimes cancel each other out.
trans-sym : (x≡y : x ≡ y) → trans (sym x≡y) x≡y ≡ refl y
trans-sym =
elim (λ {x y} (x≡y : x ≡ y) → trans (sym x≡y) x≡y ≡ refl y)
(λ _ → trans (cong (λ p → trans p _) sym-refl)
trans-refl-refl)
-- "Evaluation rule" for elim.
elim-refl : (P : {x y : A} → x ≡ y → Type p)
(p : ∀ x → P (refl x)) →
elim P p (refl x) ≡ p x
elim-refl {x = x} _ _ =
let lemma = proj₂ (singleton-contractible x) (x , refl x) in
trans (cong (λ q → subst _ q _) (trans-sym lemma))
(subst-refl _ _)
------------------------------------------------------------------------
-- The two abstract definitions are logically equivalent
J⇒subst+contr :
∀ {reflexive} →
(∀ {a p} → Equality-with-J₀ a p reflexive) →
∀ {a p} → Equality-with-substitutivity-and-contractibility
a p reflexive
J⇒subst+contr eq = record
{ subst = subst
; subst-refl = subst-refl
; singleton-contractible = singleton-contractible
}
where open Equality-with-J′ (J₀⇒J eq)
subst+contr⇒J :
∀ {reflexive} →
(∀ {a p} → Equality-with-substitutivity-and-contractibility
a p reflexive) →
∀ {a p} → Equality-with-J₀ a p reflexive
subst+contr⇒J eq = record
{ elim = elim
; elim-refl = elim-refl
}
where open Equality-with-substitutivity-and-contractibility′ eq
------------------------------------------------------------------------
-- Some derived definitions and properties
module Derived-definitions-and-properties
{e⁺}
(equality-with-J : ∀ {a p} → Equality-with-J a p e⁺)
where
-- This module reexports most of the definitions and properties
-- introduced above.
open Equality-with-J′ equality-with-J public
private
variable
eq u≡v v≡w x≡y y≡z x₁≡x₂ : x ≡ y
-- Equational reasoning combinators.
infix -1 finally _∎
infixr -2 step-≡ _≡⟨⟩_
_∎ : (x : A) → x ≡ x
x ∎ = refl x
-- It can be easier for Agda to type-check typical equational
-- reasoning chains if the transitivity proof gets the equality
-- arguments in the opposite order, because then the y argument is
-- (perhaps more) known once the proof of x ≡ y is type-checked.
--
-- The idea behind this optimisation came up in discussions with Ulf
-- Norell.
step-≡ : ∀ x → y ≡ z → x ≡ y → x ≡ z
step-≡ _ = flip trans
syntax step-≡ x y≡z x≡y = x ≡⟨ x≡y ⟩ y≡z
_≡⟨⟩_ : ∀ x → x ≡ y → x ≡ y
_ ≡⟨⟩ x≡y = x≡y
finally : (x y : A) → x ≡ y → x ≡ y
finally _ _ x≡y = x≡y
syntax finally x y x≡y = x ≡⟨ x≡y ⟩∎ y ∎
-- A minor variant of Christine Paulin-Mohring's version of the J
-- rule.
--
-- This definition is based on Martin Hofmann's (see the addendum
-- to Thomas Streicher's Habilitation thesis). Note that it is
-- also very similar to the definition of
-- Equality-with-substitutivity-and-contractibility.elim.
elim₁ : (P : ∀ {x} → x ≡ y → Type p) →
P (refl y) →
(x≡y : x ≡ y) → P x≡y
elim₁ {y = y} {x = x} P p x≡y =
subst (P ∘ proj₂)
(proj₂ (singleton-contractible y) (x , x≡y))
p
abstract
-- "Evaluation rule" for elim₁.
elim₁-refl : (P : ∀ {x} → x ≡ y → Type p) (p : P (refl y)) →
elim₁ P p (refl y) ≡ p
elim₁-refl {y = y} P p =
subst (P ∘ proj₂)
(proj₂ (singleton-contractible y) (y , refl y))
p ≡⟨ cong (λ q → subst (P ∘ proj₂) q _) (singleton-contractible-refl _) ⟩
subst (P ∘ proj₂) (refl (y , refl y)) p ≡⟨ subst-refl _ _ ⟩∎
p ∎
-- A variant of singleton-contractible.
private
irr : (p : Other-singleton x) → (x , refl x) ≡ p
irr p =
elim (λ {u v} u≡v → (u , refl u) ≡ (v , u≡v))
(λ _ → refl _)
(proj₂ p)
other-singleton-contractible :
(x : A) → Contractible (Other-singleton x)
other-singleton-contractible x = ((x , refl x) , irr)
abstract
-- "Evaluation rule" for other-singleton-contractible.
other-singleton-contractible-refl :
(x : A) →
proj₂ (other-singleton-contractible x) (x , refl x) ≡
refl (x , refl x)
other-singleton-contractible-refl _ = elim-refl _ _
-- Christine Paulin-Mohring's version of the J rule.
elim¹ : (P : ∀ {y} → x ≡ y → Type p) →
P (refl x) →
(x≡y : x ≡ y) → P x≡y
elim¹ {x = x} {y = y} P p x≡y =
subst (P ∘ proj₂)
(proj₂ (other-singleton-contractible x) (y , x≡y))
p
abstract
-- "Evaluation rule" for elim¹.
elim¹-refl : (P : ∀ {y} → x ≡ y → Type p) (p : P (refl x)) →
elim¹ P p (refl x) ≡ p
elim¹-refl {x = x} P p =
subst (P ∘ proj₂)
(proj₂ (other-singleton-contractible x) (x , refl x)) p ≡⟨ cong (λ q → subst (P ∘ proj₂) q _)
(other-singleton-contractible-refl _) ⟩
subst (P ∘ proj₂) (refl (x , refl x)) p ≡⟨ subst-refl _ _ ⟩∎
p ∎
-- Every conceivable alternative implementation of cong (for two
-- specific types) is pointwise equal to cong.
monomorphic-cong-canonical :
(cong′ : {x y : A} (f : A → B) → x ≡ y → f x ≡ f y) →
({x : A} (f : A → B) → cong′ f (refl x) ≡ refl (f x)) →
cong′ f x≡y ≡ cong f x≡y
monomorphic-cong-canonical {f = f} cong′ cong′-refl = elim
(λ x≡y → cong′ f x≡y ≡ cong f x≡y)
(λ x →
cong′ f (refl x) ≡⟨ cong′-refl _ ⟩
refl (f x) ≡⟨ sym $ cong-refl _ ⟩∎
cong f (refl x) ∎)
_
-- Every conceivable alternative implementation of cong (for
-- arbitrary types) is pointwise equal to cong.
cong-canonical :
(cong′ :
∀ {a b} {A : Type a} {B : Type b} {x y : A}
(f : A → B) → x ≡ y → f x ≡ f y) →
(∀ {a b} {A : Type a} {B : Type b} {x : A}
(f : A → B) → cong′ f (refl x) ≡ refl (f x)) →
cong′ f x≡y ≡ cong f x≡y
cong-canonical cong′ cong′-refl =
monomorphic-cong-canonical cong′ cong′-refl
-- A generalisation of dcong.
dcong′ :
(f : (x : A) → x ≡ y → P x) (x≡y : x ≡ y) →
subst P x≡y (f x x≡y) ≡ f y (refl y)
dcong′ {y = y} {P = P} f x≡y = elim₁
(λ {x} (x≡y : x ≡ y) →
(f : ∀ x → x ≡ y → P x) →
subst P x≡y (f x x≡y) ≡ f y (refl y))
(λ f → subst P (refl y) (f y (refl y)) ≡⟨ subst-refl _ _ ⟩∎
f y (refl y) ∎)
x≡y f
abstract
-- "Evaluation rule" for dcong′.
dcong′-refl :
(f : (x : A) → x ≡ y → P x) →
dcong′ f (refl y) ≡ subst-refl _ _
dcong′-refl {y = y} {P = P} f =
cong (_$ f) $ elim₁-refl (λ _ → (f : ∀ x → x ≡ y → P x) → _) _
-- Binary congruence.
cong₂ : (f : A → B → C) → x ≡ y → u ≡ v → f x u ≡ f y v
cong₂ {x = x} {y = y} {u = u} {v = v} f x≡y u≡v =
f x u ≡⟨ cong (flip f u) x≡y ⟩
f y u ≡⟨ cong (f y) u≡v ⟩∎
f y v ∎
abstract
-- "Evaluation rule" for cong₂.
cong₂-refl : (f : A → B → C) →
cong₂ f (refl x) (refl y) ≡ refl (f x y)
cong₂-refl {x = x} {y = y} f =
trans (cong (flip f y) (refl x)) (cong (f x) (refl y)) ≡⟨ cong₂ trans (cong-refl _) (cong-refl _) ⟩
trans (refl (f x y)) (refl (f x y)) ≡⟨ trans-refl-refl ⟩∎
refl (f x y) ∎
-- The K rule is logically equivalent to uniqueness of identity
-- proofs (at least for certain combinations of levels).
K⇔UIP : K-rule ℓ ℓ ⇔ Uniqueness-of-identity-proofs ℓ
K⇔UIP = record
{ from = λ UIP P r {x} x≡x → subst P (UIP (refl x) x≡x) (r x)
; to = λ K →
elim (λ p → ∀ q → p ≡ q)
(λ x → K (λ {x} p → refl x ≡ p) (λ x → refl (refl x)))
}
abstract
-- Extensionality at given levels works at lower levels as well.
lower-extensionality :
∀ â b̂ → Extensionality (a ⊔ â) (b ⊔ b̂) → Extensionality a b
apply-ext (lower-extensionality â b̂ ext) f≡g =
cong (λ h → lower ∘ h ∘ lift) $
apply-ext ext
{A = ↑ â _} {B = ↑ b̂ ∘ _} (cong lift ∘ f≡g ∘ lower)
-- Extensionality for explicit function types works for implicit
-- function types as well.
implicit-extensionality :
Extensionality a b →
{A : Type a} {B : A → Type b} {f g : {x : A} → B x} →
(∀ x → f {x} ≡ g {x}) → (λ {x} → f {x}) ≡ g
implicit-extensionality ext f≡g =
cong (λ f {x} → f x) $ apply-ext ext f≡g
-- A bunch of lemmas that can be used to rearrange equalities.
abstract
trans-reflʳ : (x≡y : x ≡ y) → trans x≡y (refl y) ≡ x≡y
trans-reflʳ =
elim (λ {u v} u≡v → trans u≡v (refl v) ≡ u≡v)
(λ _ → trans-refl-refl)
trans-reflˡ : (x≡y : x ≡ y) → trans (refl x) x≡y ≡ x≡y
trans-reflˡ =
elim (λ {u v} u≡v → trans (refl u) u≡v ≡ u≡v)
(λ _ → trans-refl-refl)
trans-assoc : (x≡y : x ≡ y) (y≡z : y ≡ z) (z≡u : z ≡ u) →
trans (trans x≡y y≡z) z≡u ≡ trans x≡y (trans y≡z z≡u)
trans-assoc =
elim (λ x≡y → ∀ y≡z z≡u → trans (trans x≡y y≡z) z≡u ≡
trans x≡y (trans y≡z z≡u))
(λ y y≡z z≡u →
trans (trans (refl y) y≡z) z≡u ≡⟨ cong₂ trans (trans-reflˡ _) (refl _) ⟩
trans y≡z z≡u ≡⟨ sym $ trans-reflˡ _ ⟩∎
trans (refl y) (trans y≡z z≡u) ∎)
sym-sym : (x≡y : x ≡ y) → sym (sym x≡y) ≡ x≡y
sym-sym = elim (λ {u v} u≡v → sym (sym u≡v) ≡ u≡v)
(λ x → sym (sym (refl x)) ≡⟨ cong sym sym-refl ⟩
sym (refl x) ≡⟨ sym-refl ⟩∎
refl x ∎)
sym-trans : (x≡y : x ≡ y) (y≡z : y ≡ z) →
sym (trans x≡y y≡z) ≡ trans (sym y≡z) (sym x≡y)
sym-trans =
elim (λ x≡y → ∀ y≡z → sym (trans x≡y y≡z) ≡ trans (sym y≡z) (sym x≡y))
(λ y y≡z → sym (trans (refl y) y≡z) ≡⟨ cong sym (trans-reflˡ _) ⟩
sym y≡z ≡⟨ sym $ trans-reflʳ _ ⟩
trans (sym y≡z) (refl y) ≡⟨ cong (trans (sym y≡z)) (sym sym-refl) ⟩∎
trans (sym y≡z) (sym (refl y)) ∎)
trans-symˡ : (p : x ≡ y) → trans (sym p) p ≡ refl y
trans-symˡ =
elim (λ p → trans (sym p) p ≡ refl _)
(λ x → trans (sym (refl x)) (refl x) ≡⟨ trans-reflʳ _ ⟩
sym (refl x) ≡⟨ sym-refl ⟩∎
refl x ∎)
trans-symʳ : (p : x ≡ y) → trans p (sym p) ≡ refl _
trans-symʳ =
elim (λ p → trans p (sym p) ≡ refl _)
(λ x → trans (refl x) (sym (refl x)) ≡⟨ trans-reflˡ _ ⟩
sym (refl x) ≡⟨ sym-refl ⟩∎
refl x ∎)
cong-trans : (f : A → B) (x≡y : x ≡ y) (y≡z : y ≡ z) →
cong f (trans x≡y y≡z) ≡ trans (cong f x≡y) (cong f y≡z)
cong-trans f =
elim (λ x≡y → ∀ y≡z → cong f (trans x≡y y≡z) ≡
trans (cong f x≡y) (cong f y≡z))
(λ y y≡z → cong f (trans (refl y) y≡z) ≡⟨ cong (cong f) (trans-reflˡ _) ⟩
cong f y≡z ≡⟨ sym $ trans-reflˡ _ ⟩
trans (refl (f y)) (cong f y≡z) ≡⟨ cong₂ trans (sym (cong-refl _)) (refl _) ⟩∎
trans (cong f (refl y)) (cong f y≡z) ∎)
cong-id : (x≡y : x ≡ y) → x≡y ≡ cong id x≡y
cong-id = elim (λ u≡v → u≡v ≡ cong id u≡v)
(λ x → refl x ≡⟨ sym (cong-refl _) ⟩∎
cong id (refl x) ∎)
cong-const : (x≡y : x ≡ y) → cong (const z) x≡y ≡ refl z
cong-const {z = z} =
elim (λ u≡v → cong (const z) u≡v ≡ refl z)
(λ x → cong (const z) (refl x) ≡⟨ cong-refl _ ⟩∎
refl z ∎)
cong-∘ : (f : B → C) (g : A → B) (x≡y : x ≡ y) →
cong f (cong g x≡y) ≡ cong (f ∘ g) x≡y
cong-∘ f g = elim (λ x≡y → cong f (cong g x≡y) ≡ cong (f ∘ g) x≡y)
(λ x → cong f (cong g (refl x)) ≡⟨ cong (cong f) (cong-refl _) ⟩
cong f (refl (g x)) ≡⟨ cong-refl _ ⟩
refl (f (g x)) ≡⟨ sym (cong-refl _) ⟩∎
cong (f ∘ g) (refl x) ∎)
cong-uncurry-cong₂-, :
{x≡y : x ≡ y} {u≡v : u ≡ v} →
cong (uncurry f) (cong₂ _,_ x≡y u≡v) ≡ cong₂ f x≡y u≡v
cong-uncurry-cong₂-, {y = y} {u = u} {f = f} {x≡y = x≡y} {u≡v} =
cong (uncurry f)
(trans (cong (flip _,_ u) x≡y) (cong (_,_ y) u≡v)) ≡⟨ cong-trans _ _ _ ⟩
trans (cong (uncurry f) (cong (flip _,_ u) x≡y))
(cong (uncurry f) (cong (_,_ y) u≡v)) ≡⟨ cong₂ trans (cong-∘ _ _ _) (cong-∘ _ _ _) ⟩∎
trans (cong (flip f u) x≡y) (cong (f y) u≡v) ∎
cong-proj₁-cong₂-, :
(x≡y : x ≡ y) (u≡v : u ≡ v) →
cong proj₁ (cong₂ _,_ x≡y u≡v) ≡ x≡y
cong-proj₁-cong₂-, {y = y} x≡y u≡v =
cong proj₁ (cong₂ _,_ x≡y u≡v) ≡⟨ cong-uncurry-cong₂-, ⟩
cong₂ const x≡y u≡v ≡⟨⟩
trans (cong id x≡y) (cong (const y) u≡v) ≡⟨ cong₂ trans (sym $ cong-id _) (cong-const _) ⟩
trans x≡y (refl y) ≡⟨ trans-reflʳ _ ⟩∎
x≡y ∎
cong-proj₂-cong₂-, :
(x≡y : x ≡ y) (u≡v : u ≡ v) →
cong proj₂ (cong₂ _,_ x≡y u≡v) ≡ u≡v
cong-proj₂-cong₂-, {u = u} x≡y u≡v =
cong proj₂ (cong₂ _,_ x≡y u≡v) ≡⟨ cong-uncurry-cong₂-, ⟩
cong₂ (const id) x≡y u≡v ≡⟨⟩
trans (cong (const u) x≡y) (cong id u≡v) ≡⟨ cong₂ trans (cong-const _) (sym $ cong-id _) ⟩
trans (refl u) u≡v ≡⟨ trans-reflˡ _ ⟩∎
u≡v ∎
cong₂-reflˡ : {u≡v : u ≡ v}
(f : A → B → C) →
cong₂ f (refl x) u≡v ≡ cong (f x) u≡v
cong₂-reflˡ {u = u} {x = x} {u≡v = u≡v} f =
trans (cong (flip f u) (refl x)) (cong (f x) u≡v) ≡⟨ cong₂ trans (cong-refl _) (refl _) ⟩
trans (refl (f x u)) (cong (f x) u≡v) ≡⟨ trans-reflˡ _ ⟩∎
cong (f x) u≡v ∎
cong₂-reflʳ : (f : A → B → C) {x≡y : x ≡ y} →
cong₂ f x≡y (refl u) ≡ cong (flip f u) x≡y
cong₂-reflʳ {y = y} {u = u} f {x≡y} =
trans (cong (flip f u) x≡y) (cong (f y) (refl u)) ≡⟨ cong (trans _) (cong-refl _) ⟩
trans (cong (flip f u) x≡y) (refl (f y u)) ≡⟨ trans-reflʳ _ ⟩∎
cong (flip f u) x≡y ∎
cong-sym : (f : A → B) (x≡y : x ≡ y) →
cong f (sym x≡y) ≡ sym (cong f x≡y)
cong-sym f = elim (λ x≡y → cong f (sym x≡y) ≡ sym (cong f x≡y))
(λ x → cong f (sym (refl x)) ≡⟨ cong (cong f) sym-refl ⟩
cong f (refl x) ≡⟨ cong-refl _ ⟩
refl (f x) ≡⟨ sym sym-refl ⟩
sym (refl (f x)) ≡⟨ cong sym $ sym (cong-refl _) ⟩∎
sym (cong f (refl x)) ∎)
cong₂-sym :
cong₂ f (sym x≡y) (sym u≡v) ≡ sym (cong₂ f x≡y u≡v)
cong₂-sym {f = f} {x≡y = x≡y} {u≡v = u≡v} = elim¹
(λ u≡v → cong₂ f (sym x≡y) (sym u≡v) ≡ sym (cong₂ f x≡y u≡v))
(cong₂ f (sym x≡y) (sym (refl _)) ≡⟨ cong (cong₂ _ _) sym-refl ⟩
cong₂ f (sym x≡y) (refl _) ≡⟨ cong₂-reflʳ _ ⟩
cong (flip f _) (sym x≡y) ≡⟨ cong-sym _ _ ⟩
sym (cong (flip f _) x≡y) ≡⟨ cong sym $ sym $ cong₂-reflʳ _ ⟩∎
sym (cong₂ f x≡y (refl _)) ∎)
u≡v
cong₂-trans :
{f : A → B → C} →
cong₂ f (trans x≡y y≡z) (trans u≡v v≡w) ≡
trans (cong₂ f x≡y u≡v) (cong₂ f y≡z v≡w)
cong₂-trans
{x≡y = x≡y} {y≡z = y≡z} {u≡v = u≡v} {v≡w = v≡w} {f = f} =
elim₁
(λ x≡y →
cong₂ f (trans x≡y y≡z) (trans u≡v v≡w) ≡
trans (cong₂ f x≡y u≡v) (cong₂ f y≡z v≡w))
(elim₁
(λ u≡v →
cong₂ f (trans (refl _) y≡z) (trans u≡v v≡w) ≡
trans (cong₂ f (refl _) u≡v) (cong₂ f y≡z v≡w))
(cong₂ f (trans (refl _) y≡z) (trans (refl _) v≡w) ≡⟨ cong₂ (cong₂ f) (trans-reflˡ _) (trans-reflˡ _) ⟩
cong₂ f y≡z v≡w ≡⟨ sym $
trans (cong (flip trans _) $ cong₂-refl _) $
trans-reflˡ _ ⟩∎
trans (cong₂ f (refl _) (refl _)) (cong₂ f y≡z v≡w) ∎)
u≡v)
x≡y
cong₂-∘ˡ :
{f : B → C → D} {g : A → B} {x≡y : x ≡ y} {u≡v : u ≡ v} →
cong₂ (f ∘ g) x≡y u≡v ≡ cong₂ f (cong g x≡y) u≡v
cong₂-∘ˡ {y = y} {u = u} {f = f} {g = g} {x≡y = x≡y} {u≡v} =
trans (cong (flip (f ∘ g) u) x≡y) (cong (f (g y)) u≡v) ≡⟨ cong (flip trans _) $ sym $ cong-∘ _ _ _ ⟩∎
trans (cong (flip f u) (cong g x≡y)) (cong (f (g y)) u≡v) ∎
cong₂-∘ʳ :
{x≡y : x ≡ y} {u≡v : u ≡ v} →
cong₂ (λ x → f x ∘ g) x≡y u≡v ≡ cong₂ f x≡y (cong g u≡v)
cong₂-∘ʳ {y = y} {u = u} {f = f} {g = g} {x≡y = x≡y} {u≡v} =
trans (cong (flip f (g u)) x≡y) (cong (f y ∘ g) u≡v) ≡⟨ cong (trans _) $ sym $ cong-∘ _ _ _ ⟩∎
trans (cong (flip f (g u)) x≡y) (cong (f y) (cong g u≡v)) ∎
cong₂-cong-cong :
(f : A → B) (g : A → C) (h : B → C → D) →
cong₂ h (cong f eq) (cong g eq) ≡
cong (λ x → h (f x) (g x)) eq
cong₂-cong-cong f g h = elim¹
(λ eq → cong₂ h (cong f eq) (cong g eq) ≡
cong (λ x → h (f x) (g x)) eq)
(cong₂ h (cong f (refl _)) (cong g (refl _)) ≡⟨ cong₂ (cong₂ h) (cong-refl _) (cong-refl _) ⟩
cong₂ h (refl _) (refl _) ≡⟨ cong₂-refl h ⟩
refl _ ≡⟨ sym $ cong-refl _ ⟩∎
cong (λ x → h (f x) (g x)) (refl _) ∎)
_
cong-≡id :
{f : A → A}
(f≡id : f ≡ id) →
cong (λ g → g (f x)) f≡id ≡
cong (λ g → f (g x)) f≡id
cong-≡id = elim₁
(λ {f} p → cong (λ g → g (f _)) p ≡ cong (λ g → f (g _)) p)
(refl _)
cong-≡id-≡-≡id :
(f≡id : ∀ x → f x ≡ x) →
cong f (f≡id x) ≡ f≡id (f x)
cong-≡id-≡-≡id {f = f} {x = x} f≡id =
cong f (f≡id x) ≡⟨ elim¹
(λ {y} (p : f x ≡ y) →
cong f p ≡ trans (f≡id (f x)) (trans p (sym (f≡id y)))) (
cong f (refl _) ≡⟨ cong-refl _ ⟩
refl _ ≡⟨ sym $ trans-symʳ _ ⟩
trans (f≡id (f x)) (sym (f≡id (f x))) ≡⟨ cong (trans (f≡id (f x))) $ sym $ trans-reflˡ _ ⟩∎
trans (f≡id (f x)) (trans (refl _) (sym (f≡id (f x)))) ∎)
(f≡id x)⟩
trans (f≡id (f x)) (trans (f≡id x) (sym (f≡id x))) ≡⟨ cong (trans (f≡id (f x))) $ trans-symʳ _ ⟩
trans (f≡id (f x)) (refl _) ≡⟨ trans-reflʳ _ ⟩
f≡id (f x) ∎
elim-∘ :
(P Q : ∀ {x y} → x ≡ y → Type p)
(f : ∀ {x y} {x≡y : x ≡ y} → P x≡y → Q x≡y)
(r : ∀ x → P (refl x)) {x≡y : x ≡ y} →
f (elim P r x≡y) ≡ elim Q (f ∘ r) x≡y
elim-∘ {x = x} P Q f r {x≡y} = elim¹
(λ x≡y → f (elim P r x≡y) ≡
elim Q (f ∘ r) x≡y)
(f (elim P r (refl x)) ≡⟨ cong f $ elim-refl _ _ ⟩
f (r x) ≡⟨ sym $ elim-refl _ _ ⟩∎
elim Q (f ∘ r) (refl x) ∎)
x≡y
elim-cong :
(P : B → B → Type p) (f : A → B)
(r : ∀ x → P x x) {x≡y : x ≡ y} →
elim (λ {x y} _ → P x y) r (cong f x≡y) ≡
elim (λ {x y} _ → P (f x) (f y)) (r ∘ f) x≡y
elim-cong {x = x} P f r {x≡y} = elim¹
(λ x≡y → elim (λ {x y} _ → P x y) r (cong f x≡y) ≡
elim (λ {x y} _ → P (f x) (f y)) (r ∘ f) x≡y)
(elim (λ {x y} _ → P x y) r (cong f (refl x)) ≡⟨ cong (elim (λ {x y} _ → P x y) _) $ cong-refl _ ⟩
elim (λ {x y} _ → P x y) r (refl (f x)) ≡⟨ elim-refl _ _ ⟩
r (f x) ≡⟨ sym $ elim-refl _ _ ⟩∎
elim (λ {x y} _ → P (f x) (f y)) (r ∘ f) (refl x) ∎)
x≡y
subst-const : ∀ (x₁≡x₂ : x₁ ≡ x₂) {b} →
subst (const B) x₁≡x₂ b ≡ b
subst-const {B = B} x₁≡x₂ {b} =
elim¹ (λ x₁≡x₂ → subst (const B) x₁≡x₂ b ≡ b)
(subst-refl _ _)
x₁≡x₂
abstract
-- One can express sym in terms of subst.
sym-subst : sym x≡y ≡ subst (λ z → x ≡ z → z ≡ x) x≡y id x≡y
sym-subst = elim
(λ {x} x≡y → sym x≡y ≡ subst (λ z → x ≡ z → z ≡ x) x≡y id x≡y)
(λ x →
sym (refl x) ≡⟨ sym-refl ⟩
refl x ≡⟨ cong (_$ refl x) $ sym $ subst-refl (λ z → x ≡ z → _) _ ⟩∎
subst (λ z → x ≡ z → z ≡ x) (refl x) id (refl x) ∎)
_
-- One can express trans in terms of subst (in several ways).
trans-subst :
{x≡y : x ≡ y} {y≡z : y ≡ z} →
trans x≡y y≡z ≡ subst (x ≡_) y≡z x≡y
trans-subst {z = z} = elim
(λ {x y} x≡y → (y≡z : y ≡ z) → trans x≡y y≡z ≡ subst (x ≡_) y≡z x≡y)
(λ y → elim
(λ {y} y≡z → trans (refl y) y≡z ≡ subst (y ≡_) y≡z (refl y))
(λ x →
trans (refl x) (refl x) ≡⟨ trans-refl-refl ⟩
refl x ≡⟨ sym $ subst-refl _ _ ⟩∎
subst (x ≡_) (refl x) (refl x) ∎))
_
_
subst-trans :
(x≡y : x ≡ y) {y≡z : y ≡ z} →
subst (_≡ z) (sym x≡y) y≡z ≡ trans x≡y y≡z
subst-trans {y = y} {z} x≡y {y≡z} =
elim₁ (λ x≡y → subst (λ x → x ≡ z) (sym x≡y) y≡z ≡
trans x≡y y≡z)
(subst (λ x → x ≡ z) (sym (refl y)) y≡z ≡⟨ cong (λ eq → subst (λ x → x ≡ z) eq _) sym-refl ⟩
subst (λ x → x ≡ z) (refl y) y≡z ≡⟨ subst-refl _ _ ⟩
y≡z ≡⟨ sym $ trans-reflˡ _ ⟩∎
trans (refl y) y≡z ∎)
x≡y
subst-trans-sym :
{y≡x : y ≡ x} {y≡z : y ≡ z} →
subst (_≡ z) y≡x y≡z ≡ trans (sym y≡x) y≡z
subst-trans-sym {z = z} {y≡x = y≡x} {y≡z = y≡z} =
subst (_≡ z) y≡x y≡z ≡⟨ cong (flip (subst (_≡ z)) _) $ sym $ sym-sym _ ⟩
subst (_≡ z) (sym (sym y≡x)) y≡z ≡⟨ subst-trans _ ⟩∎
trans (sym y≡x) y≡z ∎
-- One can express subst in terms of elim.
subst-elim :
subst P x≡y p ≡ elim (λ {u v} _ → P u → P v) (λ _ → id) x≡y p
subst-elim {P = P} = elim
(λ x≡y → ∀ p →
subst P x≡y p ≡ elim (λ {u v} _ → P u → P v) (λ _ → id) x≡y p)
(λ x p →
subst P (refl x) p ≡⟨ subst-refl _ _ ⟩
p ≡⟨ cong (_$ p) $ sym $ elim-refl (λ {u} _ → P u → _) _ ⟩∎
elim (λ {u v} _ → P u → P v) (λ _ → id) (refl x) p ∎)
_
_
subst-∘ : (P : B → Type p) (f : A → B) (x≡y : x ≡ y) {p : P (f x)} →
subst (P ∘ f) x≡y p ≡ subst P (cong f x≡y) p
subst-∘ P f _ {p} = elim¹
(λ x≡y → subst (P ∘ f) x≡y p ≡ subst P (cong f x≡y) p)
(subst (P ∘ f) (refl _) p ≡⟨ subst-refl _ _ ⟩
p ≡⟨ sym $ subst-refl _ _ ⟩
subst P (refl _) p ≡⟨ cong (flip (subst _) _) $ sym $ cong-refl _ ⟩∎
subst P (cong f (refl _)) p ∎)
_
subst-↑ : (P : A → Type p) {p : ↑ ℓ (P x)} →
subst (↑ ℓ ∘ P) x≡y p ≡ lift (subst P x≡y (lower p))
subst-↑ {ℓ = ℓ} P {p} = elim¹
(λ x≡y → subst (↑ ℓ ∘ P) x≡y p ≡ lift (subst P x≡y (lower p)))
(subst (↑ ℓ ∘ P) (refl _) p ≡⟨ subst-refl _ _ ⟩
p ≡⟨ cong lift $ sym $ subst-refl _ _ ⟩∎
lift (subst P (refl _) (lower p)) ∎)
_
-- A fusion law for subst.
subst-subst :
(P : A → Type p) (x≡y : x ≡ y) (y≡z : y ≡ z) (p : P x) →
subst P y≡z (subst P x≡y p) ≡ subst P (trans x≡y y≡z) p
subst-subst P x≡y y≡z p =
elim (λ {x y} x≡y → ∀ {z} (y≡z : y ≡ z) p →
subst P y≡z (subst P x≡y p) ≡ subst P (trans x≡y y≡z) p)
(λ x y≡z p →
subst P y≡z (subst P (refl x) p) ≡⟨ cong (subst P _) $ subst-refl _ _ ⟩
subst P y≡z p ≡⟨ cong (λ q → subst P q _) (sym $ trans-reflˡ _) ⟩∎
subst P (trans (refl x) y≡z) p ∎)
x≡y y≡z p
-- "Computation rules" for subst-subst.
subst-subst-reflˡ :
∀ (P : A → Type p) {p} →
subst-subst P (refl x) x≡y p ≡
cong₂ (flip (subst P)) (subst-refl _ _) (sym $ trans-reflˡ x≡y)
subst-subst-reflˡ P =
cong (λ f → f _ _) $
elim-refl (λ {x y} x≡y → ∀ {z} (y≡z : y ≡ z) p →
subst P y≡z (subst P x≡y p) ≡ _)
_
subst-subst-refl-refl :
∀ (P : A → Type p) {p} →
subst-subst P (refl x) (refl x) p ≡
cong₂ (flip (subst P)) (subst-refl _ _) (sym trans-refl-refl)
subst-subst-refl-refl {x = x} P {p} =
subst-subst P (refl x) (refl x) p ≡⟨ subst-subst-reflˡ _ ⟩
cong₂ (flip (subst P)) (subst-refl _ _)
(sym $ trans-reflˡ (refl x)) ≡⟨ cong (cong₂ (flip (subst P)) (subst-refl _ _) ∘ sym) $
elim-refl _ _ ⟩∎
cong₂ (flip (subst P)) (subst-refl _ _) (sym trans-refl-refl) ∎
-- Substitutivity and symmetry sometimes cancel each other out.
subst-subst-sym :
(P : A → Type p) (x≡y : x ≡ y) (p : P y) →
subst P x≡y (subst P (sym x≡y) p) ≡ p
subst-subst-sym P =
elim¹
(λ x≡y → ∀ p → subst P x≡y (subst P (sym x≡y) p) ≡ p)
(λ p →
subst P (refl _) (subst P (sym (refl _)) p) ≡⟨ subst-refl _ _ ⟩
subst P (sym (refl _)) p ≡⟨ cong (flip (subst P) _) sym-refl ⟩
subst P (refl _) p ≡⟨ subst-refl _ _ ⟩∎
p ∎)
subst-sym-subst :
(P : A → Type p) {x≡y : x ≡ y} {p : P x} →
subst P (sym x≡y) (subst P x≡y p) ≡ p
subst-sym-subst P {x≡y = x≡y} {p = p} =
elim¹
(λ x≡y → ∀ p → subst P (sym x≡y) (subst P x≡y p) ≡ p)
(λ p →
subst P (sym (refl _)) (subst P (refl _) p) ≡⟨ cong (flip (subst P) _) sym-refl ⟩
subst P (refl _) (subst P (refl _) p) ≡⟨ subst-refl _ _ ⟩
subst P (refl _) p ≡⟨ subst-refl _ _ ⟩∎
p ∎)
x≡y p
-- Some "computation rules".
subst-subst-sym-refl :
(P : A → Type p) {p : P x} →
subst-subst-sym P (refl x) p ≡
trans (subst-refl _ _)
(trans (cong (flip (subst P) _) sym-refl)
(subst-refl _ _))
subst-subst-sym-refl P {p = p} =
cong (_$ _) $
elim¹-refl
(λ x≡y → ∀ p → subst P x≡y (subst P (sym x≡y) p) ≡ p)
_
subst-sym-subst-refl :
(P : A → Type p) {p : P x} →
subst-sym-subst P {x≡y = refl x} {p = p} ≡
trans (cong (flip (subst P) _) sym-refl)
(trans (subst-refl _ _) (subst-refl _ _))
subst-sym-subst-refl P =
cong (_$ _) $
elim¹-refl
(λ x≡y → ∀ p → subst P (sym x≡y) (subst P x≡y p) ≡ p)
_
-- Some corollaries and variants.
trans-[trans-sym]- : (a≡b : a ≡ b) (c≡b : c ≡ b) →
trans (trans a≡b (sym c≡b)) c≡b ≡ a≡b
trans-[trans-sym]- a≡b c≡b =
trans (trans a≡b (sym c≡b)) c≡b ≡⟨ trans-subst ⟩
subst (_ ≡_) c≡b (trans a≡b (sym c≡b)) ≡⟨ cong (subst _ _) trans-subst ⟩
subst (_ ≡_) c≡b (subst (_ ≡_) (sym c≡b) a≡b) ≡⟨ subst-subst-sym _ _ _ ⟩∎
a≡b ∎
trans-[trans]-sym : (a≡b : a ≡ b) (b≡c : b ≡ c) →
trans (trans a≡b b≡c) (sym b≡c) ≡ a≡b
trans-[trans]-sym a≡b b≡c =
trans (trans a≡b b≡c) (sym b≡c) ≡⟨ sym $ cong (λ eq → trans (trans _ eq) (sym b≡c)) $ sym-sym _ ⟩
trans (trans a≡b (sym (sym b≡c))) (sym b≡c) ≡⟨ trans-[trans-sym]- _ _ ⟩∎
a≡b ∎
trans--[trans-sym] : (b≡a : b ≡ a) (b≡c : b ≡ c) →
trans b≡a (trans (sym b≡a) b≡c) ≡ b≡c
trans--[trans-sym] b≡a b≡c =
trans b≡a (trans (sym b≡a) b≡c) ≡⟨ sym $ trans-assoc _ _ _ ⟩
trans (trans b≡a (sym b≡a)) b≡c ≡⟨ cong (flip trans _) $ trans-symʳ _ ⟩
trans (refl _) b≡c ≡⟨ trans-reflˡ _ ⟩∎
b≡c ∎
trans-sym-[trans] : (a≡b : a ≡ b) (b≡c : b ≡ c) →
trans (sym a≡b) (trans a≡b b≡c) ≡ b≡c
trans-sym-[trans] a≡b b≡c =
trans (sym a≡b) (trans a≡b b≡c) ≡⟨ cong (λ p → trans (sym _) (trans p _)) $ sym $ sym-sym _ ⟩
trans (sym a≡b) (trans (sym (sym a≡b)) b≡c) ≡⟨ trans--[trans-sym] _ _ ⟩∎
b≡c ∎
-- The lemmas subst-refl and subst-const can cancel each other
-- out.
subst-refl-subst-const :
trans (sym $ subst-refl (λ _ → B) b) (subst-const (refl x)) ≡
refl b
subst-refl-subst-const {b = b} {x = x} =
trans (sym $ subst-refl _ _)
(elim¹ (λ eq → subst (λ _ → _) eq b ≡ b)
(subst-refl _ _)
(refl _)) ≡⟨ cong (trans _) (elim¹-refl _ _) ⟩
trans (sym $ subst-refl _ _) (subst-refl _ _) ≡⟨ trans-symˡ _ ⟩∎
refl _ ∎
-- In non-dependent cases one can express dcong using subst-const
-- and cong.
--
-- This is (similar to) Lemma 2.3.8 in the HoTT book.
dcong-subst-const-cong :
(f : A → B) (x≡y : x ≡ y) →
dcong f x≡y ≡
(subst (const B) x≡y (f x) ≡⟨ subst-const _ ⟩
f x ≡⟨ cong f x≡y ⟩∎
f y ∎)
dcong-subst-const-cong f = elim
(λ {x y} x≡y → dcong f x≡y ≡
trans (subst-const x≡y) (cong f x≡y))
(λ x →
dcong f (refl x) ≡⟨ dcong-refl _ ⟩
subst-refl _ _ ≡⟨ sym $ trans-reflʳ _ ⟩
trans (subst-refl _ _) (refl (f x)) ≡⟨ cong₂ trans
(sym $ elim¹-refl _ _)
(sym $ cong-refl _) ⟩∎
trans (subst-const _) (cong f (refl x)) ∎)
-- A corollary.
dcong≡→cong≡ :
{x≡y : x ≡ y} {fx≡fy : f x ≡ f y} →
dcong f x≡y ≡ trans (subst-const _) fx≡fy →
cong f x≡y ≡ fx≡fy
dcong≡→cong≡ {f = f} {x≡y = x≡y} {fx≡fy} hyp =
cong f x≡y ≡⟨ sym $ trans-sym-[trans] _ _ ⟩
trans (sym $ subst-const _) (trans (subst-const _) $ cong f x≡y) ≡⟨ cong (trans (sym $ subst-const _)) $ sym $
dcong-subst-const-cong _ _ ⟩
trans (sym $ subst-const _) (dcong f x≡y) ≡⟨ cong (trans (sym $ subst-const _)) hyp ⟩
trans (sym $ subst-const _) (trans (subst-const _) fx≡fy) ≡⟨ trans-sym-[trans] _ _ ⟩∎
fx≡fy ∎
-- A kind of symmetry for "dependent paths".
dsym :
{x≡y : x ≡ y} {P : A → Type p} {p : P x} {q : P y} →
subst P x≡y p ≡ q → subst P (sym x≡y) q ≡ p
dsym {x≡y = x≡y} {P = P} p≡q = elim
(λ {x y} x≡y →
∀ {p : P x} {q : P y} →
subst P x≡y p ≡ q →
subst P (sym x≡y) q ≡ p)
(λ _ {p q} p≡q →
subst P (sym (refl _)) q ≡⟨ cong (flip (subst P) _) sym-refl ⟩
subst P (refl _) q ≡⟨ subst-refl _ _ ⟩
q ≡⟨ sym p≡q ⟩
subst P (refl _) p ≡⟨ subst-refl _ _ ⟩∎
p ∎)
x≡y
p≡q
-- A "computation rule" for dsym.
dsym-subst-refl :
{P : A → Type p} {p : P x} →
dsym (subst-refl P p) ≡
trans (cong (flip (subst P) _) sym-refl) (subst-refl _ _)
dsym-subst-refl {P = P} =
dsym (subst-refl _ _) ≡⟨ cong (λ f → f (subst-refl _ _)) $
elim-refl
(λ {x y} x≡y →
∀ {p : P x} {q : P y} →
subst P x≡y p ≡ q →
subst P (sym x≡y) q ≡ p)
_ ⟩
trans (cong (flip (subst P) _) sym-refl)
(trans (subst-refl _ _)
(trans (sym (subst-refl P _)) (subst-refl _ _))) ≡⟨ cong (trans (cong (flip (subst P) _) sym-refl)) $ trans--[trans-sym] _ _ ⟩∎
trans (cong (flip (subst P) _) sym-refl) (subst-refl _ _) ∎
-- A kind of transitivity for "dependent paths".
--
-- This lemma is suggested in the HoTT book (first edition,
-- Exercise 6.1).
dtrans :
{x≡y : x ≡ y} {y≡z : y ≡ z}
(P : A → Type p) {p : P x} {q : P y} {r : P z} →
subst P x≡y p ≡ q →
subst P y≡z q ≡ r →
subst P (trans x≡y y≡z) p ≡ r
dtrans {x≡y = x≡y} {y≡z = y≡z} P {p = p} {q = q} {r = r} p≡q q≡r =
subst P (trans x≡y y≡z) p ≡⟨ sym $ subst-subst _ _ _ _ ⟩
subst P y≡z (subst P x≡y p) ≡⟨ cong (subst P y≡z) p≡q ⟩
subst P y≡z q ≡⟨ q≡r ⟩∎
r ∎
-- "Computation rules" for dtrans.
dtrans-reflˡ :
{x≡y : x ≡ y} {y≡z : y ≡ z}
{P : A → Type p} {p : P x} {r : P z}
{p≡r : subst P y≡z (subst P x≡y p) ≡ r} →
dtrans P (refl _) p≡r ≡
trans (sym $ subst-subst _ _ _ _) p≡r
dtrans-reflˡ {y≡z = y≡z} {P = P} {p≡r = p≡r} =
trans (sym $ subst-subst _ _ _ _)
(trans (cong (subst P y≡z) (refl _)) p≡r) ≡⟨ cong (trans (sym $ subst-subst _ _ _ _) ∘ flip trans _) $ cong-refl _ ⟩
trans (sym $ subst-subst _ _ _ _) (trans (refl _) p≡r) ≡⟨ cong (trans (sym $ subst-subst _ _ _ _)) $ trans-reflˡ _ ⟩∎
trans (sym $ subst-subst _ _ _ _) p≡r ∎
dtrans-reflʳ :
{x≡y : x ≡ y} {y≡z : y ≡ z}
{P : A → Type p} {p : P x} {q : P y}
{p≡q : subst P x≡y p ≡ q} →
dtrans P p≡q (refl (subst P y≡z q)) ≡
trans (sym $ subst-subst _ _ _ _) (cong (subst P y≡z) p≡q)
dtrans-reflʳ {x≡y = x≡y} {y≡z = y≡z} {P = P} {p≡q = p≡q} =
trans (sym $ subst-subst _ _ _ _)
(trans (cong (subst P y≡z) p≡q) (refl _)) ≡⟨ cong (trans _) $ trans-reflʳ _ ⟩∎
trans (sym $ subst-subst _ _ _ _) (cong (subst P y≡z) p≡q) ∎
dtrans-subst-reflˡ :
{x≡y : x ≡ y} {P : A → Type p} {p : P x} {q : P y}
{p≡q : subst P x≡y p ≡ q} →
dtrans P (subst-refl _ _) p≡q ≡
trans (cong (flip (subst P) _) (trans-reflˡ _)) p≡q
dtrans-subst-reflˡ {x≡y = x≡y} {P = P} {p≡q = p≡q} =
trans (sym $ subst-subst _ _ _ _)
(trans (cong (subst P x≡y) (subst-refl _ _)) p≡q) ≡⟨ cong (λ eq → trans (sym eq)
(trans (cong (subst P x≡y) (subst-refl _ _)) _)) $
subst-subst-reflˡ _ ⟩
trans (sym $ trans (cong (subst P _) (subst-refl _ _))
(cong (flip (subst P) _) (sym $ trans-reflˡ _)))
(trans (cong (subst P _) (subst-refl _ _)) p≡q) ≡⟨ cong (flip trans _) $ sym-trans _ _ ⟩
trans (trans
(sym $ cong (flip (subst P) _) (sym $ trans-reflˡ _))
(sym $ cong (subst P _) (subst-refl _ _)))
(trans (cong (subst P _) (subst-refl _ _)) p≡q) ≡⟨ trans-assoc _ _ _ ⟩
trans (sym $ cong (flip (subst P) _) (sym $ trans-reflˡ _))
(trans (sym $ cong (subst P _) (subst-refl _ _))
(trans (cong (subst P _) (subst-refl _ _)) p≡q)) ≡⟨ cong (trans _) $ trans-sym-[trans] _ _ ⟩
trans (sym $ cong (flip (subst P) _) (sym $ trans-reflˡ _)) p≡q ≡⟨ cong (flip trans _ ∘ sym) $ cong-sym _ _ ⟩
trans (sym $ sym $ cong (flip (subst P) _) (trans-reflˡ _)) p≡q ≡⟨ cong (flip trans _) $ sym-sym _ ⟩∎
trans (cong (flip (subst P) _) (trans-reflˡ _)) p≡q ∎
dtrans-subst-reflʳ :
{x≡y : x ≡ y} {P : A → Type p} {p : P x} {q : P y}
{p≡q : subst P x≡y p ≡ q} →
dtrans P p≡q (subst-refl _ _) ≡
trans (cong (flip (subst P) _) (trans-reflʳ _)) p≡q
dtrans-subst-reflʳ {x≡y = x≡y} {P = P} {p = p} {p≡q = p≡q} = elim¹
(λ x≡y → ∀ {q} (p≡q : subst P x≡y p ≡ q) →
dtrans P p≡q (subst-refl _ _) ≡
trans (cong (flip (subst P) _) (trans-reflʳ _)) p≡q)
(λ p≡q →
trans (sym $ subst-subst _ _ _ _)
(trans (cong (subst P (refl _)) p≡q) (subst-refl _ _)) ≡⟨ cong (λ eq → trans (sym eq) (trans (cong (subst P (refl _)) _)
(subst-refl _ _))) $
subst-subst-refl-refl _ ⟩
trans (sym $ cong₂ (flip (subst P)) (subst-refl _ _) $
sym trans-refl-refl)
(trans (cong (subst P (refl _)) p≡q) (subst-refl _ _)) ≡⟨⟩
trans (sym $ trans (cong (subst P _) (subst-refl _ _))
(cong (flip (subst P) _) (sym trans-refl-refl)))
(trans (cong (subst P (refl _)) p≡q) (subst-refl _ _)) ≡⟨ cong (flip trans _) $ sym-trans _ _ ⟩
trans (trans (sym $ cong (flip (subst P) _)
(sym trans-refl-refl))
(sym $ cong (subst P _) (subst-refl _ _)))
(trans (cong (subst P (refl _)) p≡q) (subst-refl _ _)) ≡⟨ lemma₁ p≡q ⟩
trans (cong (flip (subst P) _) trans-refl-refl) p≡q ≡⟨ cong (λ eq → trans (cong (flip (subst P) _) eq) _) $ sym $
elim-refl _ _ ⟩∎
trans (cong (flip (subst P) _) (trans-reflʳ _)) p≡q ∎)
x≡y
p≡q
where
lemma₂ :
cong (subst P (refl _)) (subst-refl P p) ≡
cong id (subst-refl P (subst P (refl _) p))
lemma₂ =
cong (subst P (refl _)) (subst-refl P p) ≡⟨ cong-≡id-≡-≡id (subst-refl P) ⟩
subst-refl P (subst P (refl _) p) ≡⟨ cong-id _ ⟩∎
cong id (subst-refl P (subst P (refl _) p)) ∎
lemma₁ :
∀ {q} (p≡q : subst P (refl _) p ≡ q) →
trans (trans (sym $ cong (flip (subst P) _)
(sym trans-refl-refl))
(sym $ cong (subst P (refl _)) (subst-refl _ _)))
(trans (cong (subst P (refl _)) p≡q) (subst-refl _ _)) ≡
trans (cong (flip (subst P) _) trans-refl-refl) p≡q
lemma₁ = elim¹
(λ p≡q →
trans (trans (sym $ cong (flip (subst P) _)
(sym trans-refl-refl))
(sym $ cong (subst P (refl _)) (subst-refl _ _)))
(trans (cong (subst P (refl _)) p≡q) (subst-refl _ _)) ≡
trans (cong (flip (subst P) _) trans-refl-refl) p≡q)
(trans (trans (sym $ cong (flip (subst P) _)
(sym trans-refl-refl))
(sym $ cong (subst P (refl _)) (subst-refl _ _)))
(trans (cong (subst P (refl _)) (refl _)) (subst-refl _ _)) ≡⟨ cong (λ eq → trans (trans (sym $ cong (flip (subst P) _)
(sym trans-refl-refl))
(sym $ cong (subst P _) (subst-refl _ _)))
(trans eq (subst-refl _ _))) $
cong-refl (subst P (refl _)) ⟩
trans (trans (sym $ cong (flip (subst P) _)
(sym trans-refl-refl))
(sym $ cong (subst P (refl _)) (subst-refl _ _)))
(trans (refl _) (subst-refl _ _)) ≡⟨ cong (trans _) $ trans-reflˡ _ ⟩
trans (trans (sym $ cong (flip (subst P) _)
(sym trans-refl-refl))
(sym $ cong (subst P (refl _)) (subst-refl _ _)))
(subst-refl _ _) ≡⟨ cong (λ eq → trans (trans (sym $ cong (flip (subst P) _) _) (sym eq))
(subst-refl _ _))
lemma₂ ⟩
trans (trans (sym $ cong (flip (subst P) _)
(sym trans-refl-refl))
(sym $ cong id (subst-refl _ _)))
(subst-refl _ _) ≡⟨ cong (λ eq → trans (trans (sym $ cong (flip (subst P) _)
(sym trans-refl-refl)) (sym eq))
(subst-refl _ _)) $ sym $
cong-id _ ⟩
trans (trans (sym $ cong (flip (subst P) _)
(sym trans-refl-refl))
(sym $ subst-refl _ _))
(subst-refl _ _) ≡⟨ trans-[trans-sym]- _ _ ⟩
sym (cong (flip (subst P) _) (sym trans-refl-refl)) ≡⟨ cong sym $ cong-sym _ _ ⟩
sym (sym (cong (flip (subst P) _) trans-refl-refl)) ≡⟨ sym-sym _ ⟩
cong (flip (subst P) _) trans-refl-refl ≡⟨ sym $ trans-reflʳ _ ⟩∎
trans (cong (flip (subst P) _) trans-refl-refl) (refl _) ∎)
-- A lemma relating dcong, trans and dtrans.
--
-- This lemma is suggested in the HoTT book (first edition,
-- Exercise 6.1).
dcong-trans :
{f : (x : A) → P x} {x≡y : x ≡ y} {y≡z : y ≡ z} →
dcong f (trans x≡y y≡z) ≡ dtrans P (dcong f x≡y) (dcong f y≡z)
dcong-trans {P = P} {f = f} {x≡y = x≡y} {y≡z = y≡z} = elim₁
(λ x≡y → dcong f (trans x≡y y≡z) ≡ dtrans P (dcong f x≡y) (dcong f y≡z))
(dcong f (trans (refl _) y≡z) ≡⟨ elim₁ (λ {p} eq → dcong f p ≡
trans (cong (flip (subst P) _) eq) (dcong f y≡z)) (
dcong f y≡z ≡⟨ sym $ trans-reflˡ _ ⟩
trans (refl _) (dcong f y≡z) ≡⟨ cong (flip trans _) $ sym $ cong-refl _ ⟩∎
trans (cong (flip (subst P) _) (refl _)) (dcong f y≡z) ∎)
(trans-reflˡ _) ⟩
trans (cong (flip (subst P) _) (trans-reflˡ _)) (dcong f y≡z) ≡⟨ sym dtrans-subst-reflˡ ⟩
dtrans P (subst-refl _ _) (dcong f y≡z) ≡⟨ cong (λ eq → dtrans P eq (dcong f y≡z)) $ sym $ dcong-refl f ⟩∎
dtrans P (dcong f (refl _)) (dcong f y≡z) ∎)
x≡y
-- An equality between pairs can be proved using a pair of
-- equalities.
Σ-≡,≡→≡ : {B : A → Type b} {p₁ p₂ : Σ A B} →
(p : proj₁ p₁ ≡ proj₁ p₂) →
subst B p (proj₂ p₁) ≡ proj₂ p₂ →
p₁ ≡ p₂
Σ-≡,≡→≡ {B = B} p q = elim
(λ {x₁ y₁} (p : x₁ ≡ y₁) → ∀ {x₂ y₂} →
subst B p x₂ ≡ y₂ → (x₁ , x₂) ≡ (y₁ , y₂))
(λ z₁ {x₂} {y₂} x₂≡y₂ → cong (_,_ z₁) (
x₂ ≡⟨ sym $ subst-refl _ _ ⟩
subst B (refl z₁) x₂ ≡⟨ x₂≡y₂ ⟩∎
y₂ ∎))
p q
-- The uncurried form of Σ-≡,≡→≡ has an inverse, Σ-≡,≡←≡. (For a
-- proof, see Bijection.Σ-≡,≡↔≡.)
Σ-≡,≡←≡ : {B : A → Type b} {p₁ p₂ : Σ A B} →
p₁ ≡ p₂ →
∃ λ (p : proj₁ p₁ ≡ proj₁ p₂) →
subst B p (proj₂ p₁) ≡ proj₂ p₂
Σ-≡,≡←≡ {A = A} {B = B} = elim
(λ {p₁ p₂ : Σ A B} _ →
∃ λ (p : proj₁ p₁ ≡ proj₁ p₂) → subst B p (proj₂ p₁) ≡ proj₂ p₂)
(λ p → refl _ , subst-refl _ _)
abstract
-- "Evaluation rules" for Σ-≡,≡→≡.
Σ-≡,≡→≡-reflˡ :
∀ {B : A → Type b} {y₁ y₂} →
(y₁≡y₂ : subst B (refl x) y₁ ≡ y₂) →
Σ-≡,≡→≡ (refl x) y₁≡y₂ ≡
cong (x ,_) (trans (sym $ subst-refl _ _) y₁≡y₂)
Σ-≡,≡→≡-reflˡ {B = B} y₁≡y₂ =
cong (λ f → f y₁≡y₂) $
elim-refl (λ {x₁ y₁} (p : x₁ ≡ y₁) → ∀ {x₂ y₂} →
subst B p x₂ ≡ y₂ → (x₁ , x₂) ≡ (y₁ , y₂))
_
Σ-≡,≡→≡-refl-refl :
∀ {B : A → Type b} {y} →
Σ-≡,≡→≡ (refl x) (refl (subst B (refl x) y)) ≡
cong (x ,_) (sym (subst-refl _ _))
Σ-≡,≡→≡-refl-refl {x = x} =
Σ-≡,≡→≡ (refl x) (refl _) ≡⟨ Σ-≡,≡→≡-reflˡ (refl _) ⟩
cong (x ,_) (trans (sym $ subst-refl _ _) (refl _)) ≡⟨ cong (cong (x ,_)) (trans-reflʳ _) ⟩∎
cong (x ,_) (sym (subst-refl _ _)) ∎
Σ-≡,≡→≡-refl-subst-refl :
{B : A → Type b} {p : Σ A B} →
Σ-≡,≡→≡ (refl _) (subst-refl _ _) ≡ refl p
Σ-≡,≡→≡-refl-subst-refl {B = B} =
Σ-≡,≡→≡ (refl _) (subst-refl B _) ≡⟨ Σ-≡,≡→≡-reflˡ _ ⟩
cong (_ ,_) (trans (sym $ subst-refl _ _) (subst-refl _ _)) ≡⟨ cong (cong _) (trans-symˡ _) ⟩
cong (_ ,_) (refl _) ≡⟨ cong-refl _ ⟩∎
refl _ ∎
Σ-≡,≡→≡-refl-subst-const :
{p : A × B} →
Σ-≡,≡→≡ (refl _) (subst-const _) ≡ refl p
Σ-≡,≡→≡-refl-subst-const =
Σ-≡,≡→≡ (refl _) (subst-const _) ≡⟨ Σ-≡,≡→≡-reflˡ _ ⟩
cong (_ ,_) (trans (sym $ subst-refl _ _) (subst-const _)) ≡⟨ cong (cong _) subst-refl-subst-const ⟩
cong (_ ,_) (refl _) ≡⟨ cong-refl _ ⟩∎
refl _ ∎
-- "Evaluation rule" for Σ-≡,≡←≡.
Σ-≡,≡←≡-refl :
{B : A → Type b} {p : Σ A B} →
Σ-≡,≡←≡ (refl p) ≡ (refl _ , subst-refl _ _)
Σ-≡,≡←≡-refl = elim-refl _ _
-- Proof transformation rules for Σ-≡,≡→≡.
proj₁-Σ-≡,≡→≡ :
∀ {B : A → Type b} {y₁ y₂}
(x₁≡x₂ : x₁ ≡ x₂) (y₁≡y₂ : subst B x₁≡x₂ y₁ ≡ y₂) →
cong proj₁ (Σ-≡,≡→≡ x₁≡x₂ y₁≡y₂) ≡ x₁≡x₂
proj₁-Σ-≡,≡→≡ {B = B} {y₁ = y₁} x₁≡x₂ y₁≡y₂ = elim¹
(λ x₁≡x₂ → ∀ {y₂} (y₁≡y₂ : subst B x₁≡x₂ y₁ ≡ y₂) →
cong proj₁ (Σ-≡,≡→≡ x₁≡x₂ y₁≡y₂) ≡ x₁≡x₂)
(λ y₁≡y₂ →
cong proj₁ (Σ-≡,≡→≡ (refl _) y₁≡y₂) ≡⟨ cong (cong proj₁) $ Σ-≡,≡→≡-reflˡ _ ⟩
cong proj₁ (cong (_,_ _) (trans (sym $ subst-refl _ _) y₁≡y₂)) ≡⟨ cong-∘ _ (_,_ _) _ ⟩
cong (const _) (trans (sym $ subst-refl _ _) y₁≡y₂) ≡⟨ cong-const _ ⟩∎
refl _ ∎)
x₁≡x₂ y₁≡y₂
Σ-≡,≡→≡-cong :
{B : A → Type b} {p₁ p₂ : Σ A B}
{q₁ q₂ : proj₁ p₁ ≡ proj₁ p₂}
(q₁≡q₂ : q₁ ≡ q₂)
{r₁ : subst B q₁ (proj₂ p₁) ≡ proj₂ p₂}
{r₂ : subst B q₂ (proj₂ p₁) ≡ proj₂ p₂}
(r₁≡r₂ : (subst B q₂ (proj₂ p₁) ≡⟨ cong (flip (subst B) _) (sym q₁≡q₂) ⟩
subst B q₁ (proj₂ p₁) ≡⟨ r₁ ⟩∎
proj₂ p₂ ∎)
≡
r₂) →
Σ-≡,≡→≡ q₁ r₁ ≡ Σ-≡,≡→≡ q₂ r₂
Σ-≡,≡→≡-cong {B = B} = elim
(λ {q₁ q₂} q₁≡q₂ →
∀ {r₁ r₂}
(r₁≡r₂ : trans (cong (flip (subst B) _) (sym q₁≡q₂)) r₁ ≡ r₂) →
Σ-≡,≡→≡ q₁ r₁ ≡ Σ-≡,≡→≡ q₂ r₂)
(λ q {r₁ r₂} r₁≡r₂ → cong (Σ-≡,≡→≡ q) (
r₁ ≡⟨ sym $ trans-reflˡ _ ⟩
trans (refl (subst B q _)) r₁ ≡⟨ cong (flip trans _) $ sym $ cong-refl _ ⟩
trans (cong (flip (subst B) _) (refl q)) r₁ ≡⟨ cong (λ e → trans (cong (flip (subst B) _) e) _) $ sym sym-refl ⟩
trans (cong (flip (subst B) _) (sym (refl q))) r₁ ≡⟨ r₁≡r₂ ⟩∎
r₂ ∎))
trans-Σ-≡,≡→≡ :
{B : A → Type b} {p₁ p₂ p₃ : Σ A B} →
(q₁₂ : proj₁ p₁ ≡ proj₁ p₂) (q₂₃ : proj₁ p₂ ≡ proj₁ p₃)
(r₁₂ : subst B q₁₂ (proj₂ p₁) ≡ proj₂ p₂)
(r₂₃ : subst B q₂₃ (proj₂ p₂) ≡ proj₂ p₃) →
trans (Σ-≡,≡→≡ q₁₂ r₁₂) (Σ-≡,≡→≡ q₂₃ r₂₃) ≡
Σ-≡,≡→≡ (trans q₁₂ q₂₃)
(subst B (trans q₁₂ q₂₃) (proj₂ p₁) ≡⟨ sym $ subst-subst _ _ _ _ ⟩
subst B q₂₃ (subst B q₁₂ (proj₂ p₁)) ≡⟨ cong (subst _ _) r₁₂ ⟩
subst B q₂₃ (proj₂ p₂) ≡⟨ r₂₃ ⟩∎
proj₂ p₃ ∎)
trans-Σ-≡,≡→≡ {B = B} q₁₂ q₂₃ r₁₂ r₂₃ = elim
(λ {p₂₁ p₃₁} q₂₃ → ∀ {p₁₁} (q₁₂ : p₁₁ ≡ p₂₁)
{p₁₂ p₂₂} (r₁₂ : subst B q₁₂ p₁₂ ≡ p₂₂)
{p₃₂} (r₂₃ : subst B q₂₃ p₂₂ ≡ p₃₂) →
trans (Σ-≡,≡→≡ q₁₂ r₁₂) (Σ-≡,≡→≡ q₂₃ r₂₃) ≡
Σ-≡,≡→≡ (trans q₁₂ q₂₃)
(trans (sym $ subst-subst _ _ _ _)
(trans (cong (subst _ _) r₁₂) r₂₃)))
(λ x → elim₁
(λ q₁₂ →
∀ {p₁₂ p₂₂} (r₁₂ : subst B q₁₂ p₁₂ ≡ p₂₂)
{p₃₂} (r₂₃ : subst B (refl _) p₂₂ ≡ p₃₂) →
trans (Σ-≡,≡→≡ q₁₂ r₁₂) (Σ-≡,≡→≡ (refl _) r₂₃) ≡
Σ-≡,≡→≡ (trans q₁₂ (refl _))
(trans (sym $ subst-subst _ _ _ _)
(trans (cong (subst _ _) r₁₂) r₂₃)))
(λ {y} → elim¹
(λ {p₂₂} r₁₂ →
∀ {p₃₂} (r₂₃ : subst B (refl _) p₂₂ ≡ p₃₂) →
trans (Σ-≡,≡→≡ (refl _) r₁₂) (Σ-≡,≡→≡ (refl _) r₂₃) ≡
Σ-≡,≡→≡ (trans (refl _) (refl _))
(trans (sym $ subst-subst _ _ _ _)
(trans (cong (subst _ _) r₁₂) r₂₃)))
(elim¹
(λ r₂₃ →
trans (Σ-≡,≡→≡ (refl _) (refl _))
(Σ-≡,≡→≡ (refl _) r₂₃) ≡
Σ-≡,≡→≡ (trans (refl _) (refl _))
(trans (sym $ subst-subst _ _ _ _)
(trans (cong (subst _ _) (refl _))
r₂₃)))
(let lemma₁ =
sym (cong (subst B _) (subst-refl _ _)) ≡⟨ sym $ trans-sym-[trans] _ _ ⟩
trans (sym $ cong (flip (subst B) _)
trans-refl-refl)
(trans (cong (flip (subst B) _)
trans-refl-refl)
(sym (cong (subst B _)
(subst-refl _ _)))) ≡⟨ cong (flip trans _) $ sym $ cong-sym _ _ ⟩∎
trans (cong (flip (subst B) _)
(sym trans-refl-refl))
(trans (cong (flip (subst B) _)
trans-refl-refl)
(sym (cong (subst B _)
(subst-refl _ _)))) ∎
lemma₂ =
trans (cong (flip (subst B) _) trans-refl-refl)
(sym (cong (subst B _) (subst-refl _ _))) ≡⟨ cong (λ e → trans (cong (flip (subst B) _) e)
(sym $ cong (subst B _) (subst-refl _ _))) $
sym $ sym-sym _ ⟩
trans (cong (flip (subst B) _)
(sym $ sym trans-refl-refl))
(sym (cong (subst B _) (subst-refl _ _))) ≡⟨ cong (flip trans _) $ cong-sym _ _ ⟩
trans (sym (cong (flip (subst B) _)
(sym trans-refl-refl)))
(sym (cong (subst B _) (subst-refl _ _))) ≡⟨ sym $ sym-trans _ _ ⟩
sym (trans (cong (subst B _) (subst-refl _ _))
(cong (flip (subst B) _)
(sym trans-refl-refl))) ≡⟨⟩
sym (cong₂ (flip (subst B)) (subst-refl _ _)
(sym trans-refl-refl)) ≡⟨ cong sym $ sym $ subst-subst-refl-refl _ ⟩
sym (subst-subst _ _ _ _) ≡⟨ sym $ trans-reflʳ _ ⟩
trans (sym $ subst-subst _ _ _ _) (refl _) ≡⟨ cong (trans (sym $ subst-subst _ _ _ _)) $ sym trans-refl-refl ⟩
trans (sym $ subst-subst _ _ _ _)
(trans (refl _) (refl _)) ≡⟨ cong (λ x → trans (sym $ subst-subst _ _ _ _) (trans x (refl _))) $
sym $ cong-refl _ ⟩∎
trans (sym $ subst-subst _ _ _ _)
(trans (cong (subst _ _) (refl _)) (refl _)) ∎
in
trans (Σ-≡,≡→≡ (refl _) (refl _))
(Σ-≡,≡→≡ (refl _) (refl _)) ≡⟨ cong₂ trans Σ-≡,≡→≡-refl-refl Σ-≡,≡→≡-refl-refl ⟩
trans (cong (_ ,_) (sym (subst-refl _ _)))
(cong (_ ,_) (sym (subst-refl B _))) ≡⟨ sym $ cong-trans _ _ _ ⟩
cong (_ ,_) (trans (sym (subst-refl _ _))
(sym (subst-refl _ _))) ≡⟨ cong (cong (_ ,_) ∘ trans (sym (subst-refl _ _)) ∘ sym) $ sym $
cong-≡id-≡-≡id (subst-refl B) ⟩
cong (_ ,_)
(trans (sym (subst-refl _ _))
(sym (cong (subst B _) (subst-refl _ _)))) ≡⟨ sym $ Σ-≡,≡→≡-reflˡ _ ⟩
Σ-≡,≡→≡ (refl _)
(sym (cong (subst B _) (subst-refl _ _))) ≡⟨ cong (Σ-≡,≡→≡ _) lemma₁ ⟩
Σ-≡,≡→≡ (refl _)
(trans (cong (flip (subst B) _) (sym trans-refl-refl))
(trans (cong (flip (subst B) _) trans-refl-refl)
(sym (cong (subst B _) (subst-refl _ _))))) ≡⟨ sym $ Σ-≡,≡→≡-cong _ (refl _) ⟩
Σ-≡,≡→≡ (trans (refl _) (refl _))
(trans (cong (flip (subst B) _) trans-refl-refl)
(sym (cong (subst B _) (subst-refl _ _)))) ≡⟨ cong (Σ-≡,≡→≡ (trans (refl _) (refl _))) lemma₂ ⟩∎
Σ-≡,≡→≡ (trans (refl _) (refl _))
(trans (sym $ subst-subst _ _ _ _)
(trans (cong (subst _ _) (refl _))
(refl _))) ∎))))
q₂₃ q₁₂ r₁₂ r₂₃
Σ-≡,≡→≡-subst-const :
{p₁ p₂ : A × B} →
(p : proj₁ p₁ ≡ proj₁ p₂) (q : proj₂ p₁ ≡ proj₂ p₂) →
Σ-≡,≡→≡ p (trans (subst-const _) q) ≡ cong₂ _,_ p q
Σ-≡,≡→≡-subst-const p q = elim
(λ {x₁ y₁} (p : x₁ ≡ y₁) →
Σ-≡,≡→≡ p (trans (subst-const _) q) ≡ cong₂ _,_ p q)
(λ x →
let lemma =
trans (sym $ subst-refl _ _) (trans (subst-const _) q) ≡⟨ sym $ trans-assoc _ _ _ ⟩
trans (trans (sym $ subst-refl _ _) (subst-const _)) q ≡⟨ cong₂ trans subst-refl-subst-const (refl _) ⟩
trans (refl _) q ≡⟨ trans-reflˡ _ ⟩∎
q ∎ in
Σ-≡,≡→≡ (refl x) (trans (subst-const _) q) ≡⟨ Σ-≡,≡→≡-reflˡ _ ⟩
cong (x ,_) (trans (sym $ subst-refl _ _)
(trans (subst-const _) q)) ≡⟨ cong (cong (x ,_)) lemma ⟩
cong (x ,_) q ≡⟨ sym $ cong₂-reflˡ _,_ ⟩∎
cong₂ _,_ (refl x) q ∎)
p
Σ-≡,≡→≡-subst-const-refl :
Σ-≡,≡→≡ x₁≡x₂ (subst-const _) ≡ cong₂ _,_ x₁≡x₂ (refl y)
Σ-≡,≡→≡-subst-const-refl {x₁≡x₂ = x₁≡x₂} {y = y} =
Σ-≡,≡→≡ x₁≡x₂ (subst-const _) ≡⟨ cong (Σ-≡,≡→≡ x₁≡x₂) $ sym $ trans-reflʳ _ ⟩
Σ-≡,≡→≡ x₁≡x₂ (trans (subst-const _) (refl _)) ≡⟨ Σ-≡,≡→≡-subst-const _ _ ⟩∎
cong₂ _,_ x₁≡x₂ (refl y) ∎
-- Proof simplification rule for Σ-≡,≡←≡.
proj₁-Σ-≡,≡←≡ :
{B : A → Type b} {p₁ p₂ : Σ A B}
(p₁≡p₂ : p₁ ≡ p₂) →
proj₁ (Σ-≡,≡←≡ p₁≡p₂) ≡ cong proj₁ p₁≡p₂
proj₁-Σ-≡,≡←≡ = elim
(λ p₁≡p₂ → proj₁ (Σ-≡,≡←≡ p₁≡p₂) ≡ cong proj₁ p₁≡p₂)
(λ p →
proj₁ (Σ-≡,≡←≡ (refl p)) ≡⟨ cong proj₁ $ Σ-≡,≡←≡-refl ⟩
refl (proj₁ p) ≡⟨ sym $ cong-refl _ ⟩∎
cong proj₁ (refl p) ∎)
-- A binary variant of subst.
subst₂ : ∀ {B : A → Type b} (P : Σ A B → Type p) {x₁ x₂ y₁ y₂} →
(x₁≡x₂ : x₁ ≡ x₂) → subst B x₁≡x₂ y₁ ≡ y₂ →
P (x₁ , y₁) → P (x₂ , y₂)
subst₂ P x₁≡x₂ y₁≡y₂ = subst P (Σ-≡,≡→≡ x₁≡x₂ y₁≡y₂)
abstract
-- "Evaluation rule" for subst₂.
subst₂-refl-refl :
∀ {B : A → Type b} (P : Σ A B → Type p) {y p} →
subst₂ P (refl _) (refl _) p ≡
subst (curry P x) (sym $ subst-refl B y) p
subst₂-refl-refl {x = x} P {p = p} =
subst P (Σ-≡,≡→≡ (refl _) (refl _)) p ≡⟨ cong (λ eq₁ → subst P eq₁ _) Σ-≡,≡→≡-refl-refl ⟩
subst P (cong (x ,_) (sym (subst-refl _ _))) p ≡⟨ sym $ subst-∘ _ _ _ ⟩∎
subst (curry P x) (sym $ subst-refl _ _) p ∎
-- The subst function can be "pushed" inside pairs.
push-subst-pair :
∀ (B : A → Type b) (C : Σ A B → Type c) {p} →
subst (λ x → Σ (B x) (curry C x)) y≡z p ≡
(subst B y≡z (proj₁ p) , subst₂ C y≡z (refl _) (proj₂ p))
push-subst-pair {y≡z = y≡z} B C {p} = elim¹
(λ y≡z →
subst (λ x → Σ (B x) (curry C x)) y≡z p ≡
(subst B y≡z (proj₁ p) , subst₂ C y≡z (refl _) (proj₂ p)))
(subst (λ x → Σ (B x) (curry C x)) (refl _) p ≡⟨ subst-refl _ _ ⟩
p ≡⟨ Σ-≡,≡→≡ (sym (subst-refl _ _)) (sym (subst₂-refl-refl _)) ⟩∎
(subst B (refl _) (proj₁ p) ,
subst₂ C (refl _) (refl _) (proj₂ p)) ∎)
y≡z
-- A proof transformation rule for push-subst-pair.
proj₁-push-subst-pair-refl :
∀ {A : Type a} {y : A} (B : A → Type b) (C : Σ A B → Type c) {p} →
cong proj₁ (push-subst-pair {y≡z = refl y} B C {p = p}) ≡
trans (cong proj₁ (subst-refl (λ _ → Σ _ _) _))
(sym $ subst-refl _ _)
proj₁-push-subst-pair-refl B C =
cong proj₁ (push-subst-pair _ _) ≡⟨ cong (cong proj₁) $
elim¹-refl
(λ y≡z →
subst (λ x → Σ (B x) (curry C x)) y≡z _ ≡
(subst B y≡z _ , subst₂ C y≡z (refl _) _))
_ ⟩
cong proj₁
(trans (subst-refl (λ _ → Σ _ _) _)
(Σ-≡,≡→≡ (sym $ subst-refl B _) (sym (subst₂-refl-refl _)))) ≡⟨ cong-trans _ _ _ ⟩
trans (cong proj₁ (subst-refl _ _))
(cong proj₁
(Σ-≡,≡→≡ (sym $ subst-refl _ _) (sym (subst₂-refl-refl _)))) ≡⟨ cong (trans _) $
proj₁-Σ-≡,≡→≡ _ _ ⟩∎
trans (cong proj₁ (subst-refl _ _)) (sym $ subst-refl _ _) ∎
-- Corollaries of push-subst-pair.
push-subst-pair′ :
∀ (B : A → Type b) (C : Σ A B → Type c) {p p₁} →
(p₁≡p₁ : subst B y≡z (proj₁ p) ≡ p₁) →
subst (λ x → Σ (B x) (curry C x)) y≡z p ≡
(p₁ , subst₂ C y≡z p₁≡p₁ (proj₂ p))
push-subst-pair′ {y≡z = y≡z} B C {p} =
elim¹ (λ {p₁} p₁≡p₁ →
subst (λ x → Σ (B x) (curry C x)) y≡z p ≡
(p₁ , subst₂ C y≡z p₁≡p₁ (proj₂ p)))
(push-subst-pair _ _)
push-subst-pair-× :
∀ {y≡z : y ≡ z} (B : Type b) (C : A × B → Type c) {p} →
subst (λ x → Σ B (curry C x)) y≡z p ≡
(proj₁ p , subst (λ x → C (x , proj₁ p)) y≡z (proj₂ p))
push-subst-pair-× {y≡z = y≡z} B C {p} =
subst (λ x → Σ B (curry C x)) y≡z p ≡⟨ push-subst-pair′ _ C (subst-const _) ⟩
(proj₁ p , subst₂ C y≡z (subst-const _) (proj₂ p)) ≡⟨ cong (_ ,_) $
elim¹
(λ y≡z → subst₂ C y≡z (subst-const y≡z) (proj₂ p) ≡
subst (λ x → C (x , proj₁ p)) y≡z (proj₂ p))
(
subst₂ C (refl _) (subst-const _) (proj₂ p) ≡⟨⟩
subst C (Σ-≡,≡→≡ (refl _) (subst-const _)) (proj₂ p) ≡⟨ cong (λ eq → subst C eq _) Σ-≡,≡→≡-refl-subst-const ⟩
subst C (refl _) (proj₂ p) ≡⟨ subst-refl _ _ ⟩
proj₂ p ≡⟨ sym $ subst-refl _ _ ⟩∎
subst (λ x → C (x , _)) (refl _) (proj₂ p) ∎)
y≡z ⟩
(proj₁ p , subst (λ x → C (x , _)) y≡z (proj₂ p)) ∎
-- A proof simplification rule for subst₂.
subst₂-proj₁ :
∀ {B : A → Type b} {y₁ y₂}
{x₁≡x₂ : x₁ ≡ x₂} {y₁≡y₂ : subst B x₁≡x₂ y₁ ≡ y₂}
(P : A → Type p) {p} →
subst₂ {B = B} (P ∘ proj₁) x₁≡x₂ y₁≡y₂ p ≡ subst P x₁≡x₂ p
subst₂-proj₁ {x₁≡x₂ = x₁≡x₂} {y₁≡y₂} P {p} =
subst₂ (P ∘ proj₁) x₁≡x₂ y₁≡y₂ p ≡⟨ subst-∘ _ _ _ ⟩
subst P (cong proj₁ (Σ-≡,≡→≡ x₁≡x₂ y₁≡y₂)) p ≡⟨ cong (λ eq → subst P eq _) (proj₁-Σ-≡,≡→≡ _ _) ⟩∎
subst P x₁≡x₂ p ∎
-- The subst function can be "pushed" inside non-dependent pairs.
push-subst-, :
∀ (B : A → Type b) (C : A → Type c) {p} →
subst (λ x → B x × C x) y≡z p ≡
(subst B y≡z (proj₁ p) , subst C y≡z (proj₂ p))
push-subst-, {y≡z = y≡z} B C {x , y} =
subst (λ x → B x × C x) y≡z (x , y) ≡⟨ push-subst-pair _ _ ⟩
(subst B y≡z x , subst (C ∘ proj₁) (Σ-≡,≡→≡ y≡z (refl _)) y) ≡⟨ cong (_,_ _) $ subst₂-proj₁ _ ⟩∎
(subst B y≡z x , subst C y≡z y) ∎
-- A proof transformation rule for push-subst-,.
proj₁-push-subst-,-refl :
∀ {A : Type a} {y : A} (B : A → Type b) (C : A → Type c) {p} →
cong proj₁ (push-subst-, {y≡z = refl y} B C {p = p}) ≡
trans (cong proj₁ (subst-refl (λ _ → _ × _) _))
(sym $ subst-refl _ _)
proj₁-push-subst-,-refl _ _ =
cong proj₁ (trans (push-subst-pair _ _)
(cong (_,_ _) $ subst₂-proj₁ _)) ≡⟨ cong-trans _ _ _ ⟩
trans (cong proj₁ (push-subst-pair _ _))
(cong proj₁ (cong (_,_ _) $ subst₂-proj₁ _)) ≡⟨ cong (trans _) $
cong-∘ _ _ _ ⟩
trans (cong proj₁ (push-subst-pair _ _))
(cong (const _) $ subst₂-proj₁ _) ≡⟨ trans (cong (trans _) (cong-const _)) $
trans-reflʳ _ ⟩
cong proj₁ (push-subst-pair _ _) ≡⟨ proj₁-push-subst-pair-refl _ _ ⟩∎
trans (cong proj₁ (subst-refl _ _)) (sym $ subst-refl _ _) ∎
-- The subst function can be "pushed" inside inj₁ and inj₂.
push-subst-inj₁ :
∀ (B : A → Type b) (C : A → Type c) {x} →
subst (λ x → B x ⊎ C x) y≡z (inj₁ x) ≡ inj₁ (subst B y≡z x)
push-subst-inj₁ {y≡z = y≡z} B C {x} = elim¹
(λ y≡z → subst (λ x → B x ⊎ C x) y≡z (inj₁ x) ≡
inj₁ (subst B y≡z x))
(subst (λ x → B x ⊎ C x) (refl _) (inj₁ x) ≡⟨ subst-refl _ _ ⟩
inj₁ x ≡⟨ cong inj₁ $ sym $ subst-refl _ _ ⟩∎
inj₁ (subst B (refl _) x) ∎)
y≡z
push-subst-inj₂ :
∀ (B : A → Type b) (C : A → Type c) {x} →
subst (λ x → B x ⊎ C x) y≡z (inj₂ x) ≡ inj₂ (subst C y≡z x)
push-subst-inj₂ {y≡z = y≡z} B C {x} = elim¹
(λ y≡z → subst (λ x → B x ⊎ C x) y≡z (inj₂ x) ≡
inj₂ (subst C y≡z x))
(subst (λ x → B x ⊎ C x) (refl _) (inj₂ x) ≡⟨ subst-refl _ _ ⟩
inj₂ x ≡⟨ cong inj₂ $ sym $ subst-refl _ _ ⟩∎
inj₂ (subst C (refl _) x) ∎)
y≡z
-- The subst function can be "pushed" inside applications.
push-subst-application :
{B : A → Type b}
(x₁≡x₂ : x₁ ≡ x₂) (C : (x : A) → B x → Type c)
{f : (x : A) → B x} {g : (y : B x₁) → C x₁ y} →
subst (λ x → C x (f x)) x₁≡x₂ (g (f x₁)) ≡
subst (λ x → (y : B x) → C x y) x₁≡x₂ g (f x₂)
push-subst-application {x₁ = x₁} x₁≡x₂ C {f} {g} = elim¹
(λ {x₂} x₁≡x₂ →
subst (λ x → C x (f x)) x₁≡x₂ (g (f x₁)) ≡
subst (λ x → ∀ y → C x y) x₁≡x₂ g (f x₂))
(subst (λ x → C x (f x)) (refl _) (g (f x₁)) ≡⟨ subst-refl _ _ ⟩
g (f x₁) ≡⟨ cong (_$ f x₁) $ sym $ subst-refl (λ x → ∀ y → C x y) _ ⟩∎
subst (λ x → ∀ y → C x y) (refl _) g (f x₁) ∎)
x₁≡x₂
push-subst-implicit-application :
{B : A → Type b}
(x₁≡x₂ : x₁ ≡ x₂) (C : (x : A) → B x → Type c)
{f : (x : A) → B x} {g : {y : B x₁} → C x₁ y} →
subst (λ x → C x (f x)) x₁≡x₂ (g {y = f x₁}) ≡
subst (λ x → {y : B x} → C x y) x₁≡x₂ g {y = f x₂}
push-subst-implicit-application {x₁ = x₁} x₁≡x₂ C {f} {g} = elim¹
(λ {x₂} x₁≡x₂ →
subst (λ x → C x (f x)) x₁≡x₂ (g {y = f x₁}) ≡
subst (λ x → ∀ {y} → C x y) x₁≡x₂ g {y = f x₂})
(subst (λ x → C x (f x)) (refl _) (g {y = f x₁}) ≡⟨ subst-refl _ _ ⟩
g {y = f x₁} ≡⟨ cong (λ g → g {y = f x₁}) $ sym $ subst-refl (λ x → ∀ {y} → C x y) _ ⟩∎
subst (λ x → ∀ {y} → C x y) (refl _) g {y = f x₁} ∎)
x₁≡x₂
subst-∀-sym :
∀ {B : A → Type b} {y : B x₁}
{C : (x : A) → B x → Type c} {f : (y : B x₂) → C x₂ y}
{x₁≡x₂ : x₁ ≡ x₂} →
subst (λ x → (y : B x) → C x y) (sym x₁≡x₂) f y ≡
subst (uncurry C) (sym $ Σ-≡,≡→≡ x₁≡x₂ (refl _))
(f (subst B x₁≡x₂ y))
subst-∀-sym {B = B} {C = C} {x₁≡x₂ = x₁≡x₂} = elim
(λ {x₁ x₂} x₁≡x₂ →
{y : B x₁} (f : (y : B x₂) → C x₂ y) →
subst (λ x → (y : B x) → C x y) (sym x₁≡x₂) f y ≡
subst (uncurry C) (sym $ Σ-≡,≡→≡ x₁≡x₂ (refl _))
(f (subst B x₁≡x₂ y)))
(λ x {y} f →
let lemma =
cong (x ,_) (subst-refl B y) ≡⟨ cong (cong (x ,_)) $ sym $ sym-sym _ ⟩
cong (x ,_) (sym $ sym $ subst-refl B y) ≡⟨ cong-sym _ _ ⟩
sym $ cong (x ,_) (sym $ subst-refl B y) ≡⟨ cong sym $ sym Σ-≡,≡→≡-refl-refl ⟩∎
sym $ Σ-≡,≡→≡ (refl x) (refl _) ∎
in
subst (λ x → (y : B x) → C x y) (sym (refl x)) f y ≡⟨ cong (λ eq → subst (λ x → (y : B x) → C x y) eq _ _) sym-refl ⟩
subst (λ x → (y : B x) → C x y) (refl x) f y ≡⟨ cong (_$ y) $ subst-refl (λ x → (_ : B x) → _) _ ⟩
f y ≡⟨ sym $ dcong f _ ⟩
subst (C x) (subst-refl B _) (f (subst B (refl x) y)) ≡⟨ subst-∘ _ _ _ ⟩
subst (uncurry C) (cong (x ,_) (subst-refl B y))
(f (subst B (refl x) y)) ≡⟨ cong (λ eq → subst (uncurry C) eq (f (subst B (refl x) y))) lemma ⟩∎
subst (uncurry C) (sym $ Σ-≡,≡→≡ (refl x) (refl _))
(f (subst B (refl x) y)) ∎)
x₁≡x₂ _
subst-∀ :
∀ {B : A → Type b} {y : B x₂}
{C : (x : A) → B x → Type c} {f : (y : B x₁) → C x₁ y}
{x₁≡x₂ : x₁ ≡ x₂} →
subst (λ x → (y : B x) → C x y) x₁≡x₂ f y ≡
subst (uncurry C) (sym $ Σ-≡,≡→≡ (sym x₁≡x₂) (refl _))
(f (subst B (sym x₁≡x₂) y))
subst-∀ {B = B} {y = y} {C = C} {f = f} {x₁≡x₂ = x₁≡x₂} =
subst (λ x → (y : B x) → C x y) x₁≡x₂ f y ≡⟨ cong (λ eq → subst (λ x → (y : B x) → C x y) eq _ _) $ sym $ sym-sym _ ⟩
subst (λ x → (y : B x) → C x y) (sym (sym x₁≡x₂)) f y ≡⟨ subst-∀-sym ⟩∎
subst (uncurry C) (sym $ Σ-≡,≡→≡ (sym x₁≡x₂) (refl _))
(f (subst B (sym x₁≡x₂) y)) ∎
subst-→ :
{B : A → Type b} {y : B x₂} {C : A → Type c} {f : B x₁ → C x₁} →
subst (λ x → B x → C x) x₁≡x₂ f y ≡
subst C x₁≡x₂ (f (subst B (sym x₁≡x₂) y))
subst-→ {x₁≡x₂ = x₁≡x₂} {B = B} {y = y} {C} {f} =
subst (λ x → B x → C x) x₁≡x₂ f y ≡⟨ cong (λ eq → subst (λ x → B x → C x) eq f y) $ sym $
sym-sym _ ⟩
subst (λ x → B x → C x) (sym $ sym x₁≡x₂) f y ≡⟨ subst-∀-sym ⟩
subst (C ∘ proj₁) (sym $ Σ-≡,≡→≡ (sym x₁≡x₂) (refl _))
(f (subst B (sym x₁≡x₂) y)) ≡⟨ subst-∘ _ _ _ ⟩
subst C (cong proj₁ $ sym $ Σ-≡,≡→≡ (sym x₁≡x₂) (refl _))
(f (subst B (sym x₁≡x₂) y)) ≡⟨ cong (λ eq → subst C eq (f (subst B (sym x₁≡x₂) y))) $
cong-sym _ _ ⟩
subst C (sym $ cong proj₁ $ Σ-≡,≡→≡ (sym x₁≡x₂) (refl _))
(f (subst B (sym x₁≡x₂) y)) ≡⟨ cong (λ eq → subst C (sym eq) (f (subst B (sym x₁≡x₂) y))) $
proj₁-Σ-≡,≡→≡ _ _ ⟩
subst C (sym $ sym x₁≡x₂) (f (subst B (sym x₁≡x₂) y)) ≡⟨ cong (λ eq → subst C eq (f (subst B (sym x₁≡x₂) y))) $
sym-sym _ ⟩∎
subst C x₁≡x₂ (f (subst B (sym x₁≡x₂) y)) ∎
subst-→-domain :
(B : A → Type b) {f : B x → C} (x≡y : x ≡ y) {u : B y} →
subst (λ x → B x → C) x≡y f u ≡ f (subst B (sym x≡y) u)
subst-→-domain {C = C} B x≡y {u = u} = elim₁
(λ {x} x≡y → (f : B x → C) →
subst (λ x → B x → C) x≡y f u ≡
f (subst B (sym x≡y) u))
(λ f →
subst (λ x → B x → C) (refl _) f u ≡⟨ cong (_$ u) $ subst-refl (λ x → B x → _) _ ⟩
f u ≡⟨ cong f $ sym $ subst-refl _ _ ⟩
f (subst B (refl _) u) ≡⟨ cong (λ p → f (subst B p u)) $ sym sym-refl ⟩∎
f (subst B (sym (refl _)) u) ∎)
x≡y _
-- A "computation rule".
subst-→-domain-refl :
{B : A → Type b} {f : B x → C} {u : B x} →
subst-→-domain B {f = f} (refl x) {u = u} ≡
trans (cong (_$ u) (subst-refl (λ x → B x → _) _))
(trans (cong f (sym (subst-refl _ _)))
(cong (f ∘ flip (subst B) u) (sym sym-refl)))
subst-→-domain-refl {C = C} {B = B} {u = u} =
cong (_$ _) $
elim₁-refl
(λ {x} x≡y → (f : B x → C) →
subst (λ x → B x → C) x≡y f u ≡
f (subst B (sym x≡y) u))
_
-- The following lemma is Proposition 2 from "Generalizations of
-- Hedberg's Theorem" by Kraus, Escardó, Coquand and Altenkirch.
subst-in-terms-of-trans-and-cong :
{x≡y : x ≡ y} {fx≡gx : f x ≡ g x} →
subst (λ z → f z ≡ g z) x≡y fx≡gx ≡
trans (sym (cong f x≡y)) (trans fx≡gx (cong g x≡y))
subst-in-terms-of-trans-and-cong {f = f} {g = g} = elim
(λ {x y} x≡y →
(fx≡gx : f x ≡ g x) →
subst (λ z → f z ≡ g z) x≡y fx≡gx ≡
trans (sym (cong f x≡y)) (trans fx≡gx (cong g x≡y)))
(λ x fx≡gx →
subst (λ z → f z ≡ g z) (refl x) fx≡gx ≡⟨ subst-refl _ _ ⟩
fx≡gx ≡⟨ sym $ trans-reflˡ _ ⟩
trans (refl (f x)) fx≡gx ≡⟨ sym $ cong₂ trans sym-refl (trans-reflʳ _) ⟩
trans (sym (refl (f x))) (trans fx≡gx (refl (g x))) ≡⟨ sym $ cong₂ (λ p q → trans (sym p) (trans _ q))
(cong-refl _) (cong-refl _) ⟩∎
trans (sym (cong f (refl x))) (trans fx≡gx (cong g (refl x))) ∎ )
_
_
-- A variant of subst-in-terms-of-trans-and-cong that works for
-- dependent functions.
subst-in-terms-of-trans-and-dcong :
{f g : (x : A) → P x} {x≡y : x ≡ y} {fx≡gx : f x ≡ g x} →
subst (λ z → f z ≡ g z) x≡y fx≡gx ≡
trans (sym (dcong f x≡y))
(trans (cong (subst P x≡y) fx≡gx) (dcong g x≡y))
subst-in-terms-of-trans-and-dcong {P = P} {f = f} {g = g} = elim
(λ {x y} x≡y →
(fx≡gx : f x ≡ g x) →
subst (λ z → f z ≡ g z) x≡y fx≡gx ≡
trans (sym (dcong f x≡y))
(trans (cong (subst P x≡y) fx≡gx) (dcong g x≡y)))
(λ x fx≡gx →
subst (λ z → f z ≡ g z) (refl x) fx≡gx ≡⟨ subst-refl _ _ ⟩
fx≡gx ≡⟨ elim¹
(λ {gx} eq →
eq ≡
trans (sym (subst-refl P (f x)))
(trans (cong (subst P (refl x)) eq)
(subst-refl P gx)))
(
refl (f x) ≡⟨ sym $ trans-symˡ _ ⟩
trans (sym (subst-refl P (f x)))
(subst-refl P (f x)) ≡⟨ cong (trans _) $
trans (sym $ trans-reflˡ _) $
cong (flip trans _) $
sym $ cong-refl _ ⟩∎
trans (sym (subst-refl P (f x)))
(trans (cong (subst P (refl x)) (refl (f x)))
(subst-refl P (f x))) ∎)
fx≡gx ⟩
trans (sym (subst-refl P (f x)))
(trans (cong (subst P (refl x)) fx≡gx)
(subst-refl P (g x))) ≡⟨ sym $
cong₂ (λ p q → trans (sym p) (trans (cong (subst P (refl x)) fx≡gx) q))
(dcong-refl _)
(dcong-refl _) ⟩∎
trans (sym (dcong f (refl x)))
(trans (cong (subst P (refl x)) fx≡gx)
(dcong g (refl x))) ∎)
_
_
-- Sometimes cong can be "pushed" inside subst. The following
-- lemma provides one example.
cong-subst :
{B : A → Type b} {C : A → Type c}
{f : ∀ {x} → B x → C x} {g h : (x : A) → B x}
(eq₁ : x ≡ y) (eq₂ : g x ≡ h x) →
cong f (subst (λ x → g x ≡ h x) eq₁ eq₂) ≡
subst (λ x → f (g x) ≡ f (h x)) eq₁ (cong f eq₂)
cong-subst {f = f} {g} {h} = elim₁
(λ eq₁ → ∀ eq₂ →
cong f (subst (λ x → g x ≡ h x) eq₁ eq₂) ≡
subst (λ x → f (g x) ≡ f (h x)) eq₁ (cong f eq₂))
(λ eq₂ →
cong f (subst (λ x → g x ≡ h x) (refl _) eq₂) ≡⟨ cong (cong f) $ subst-refl _ _ ⟩
cong f eq₂ ≡⟨ sym $ subst-refl _ _ ⟩∎
subst (λ x → f (g x) ≡ f (h x)) (refl _) (cong f eq₂) ∎)
-- Some rearrangement lemmas for equalities between equalities.
[trans≡]≡[≡trans-symʳ] :
(p₁₂ : a₁ ≡ a₂) (p₁₃ : a₁ ≡ a₃) (p₂₃ : a₂ ≡ a₃) →
(trans p₁₂ p₂₃ ≡ p₁₃)
≡
(p₁₂ ≡ trans p₁₃ (sym p₂₃))
[trans≡]≡[≡trans-symʳ] p₁₂ p₁₃ p₂₃ = elim
(λ {a₂ a₃} p₂₃ →
∀ {a₁} (p₁₂ : a₁ ≡ a₂) (p₁₃ : a₁ ≡ a₃) →
(trans p₁₂ p₂₃ ≡ p₁₃)
≡
(p₁₂ ≡ trans p₁₃ (sym p₂₃)))
(λ a₂₃ p₁₂ p₁₃ →
trans p₁₂ (refl a₂₃) ≡ p₁₃ ≡⟨ cong₂ _≡_ (trans-reflʳ _) (sym $ trans-reflʳ _) ⟩
p₁₂ ≡ trans p₁₃ (refl a₂₃) ≡⟨ cong ((_ ≡_) ∘ trans _) (sym sym-refl) ⟩∎
p₁₂ ≡ trans p₁₃ (sym (refl a₂₃)) ∎)
p₂₃ p₁₂ p₁₃
[trans≡]≡[≡trans-symˡ] :
(p₁₂ : a₁ ≡ a₂) (p₁₃ : a₁ ≡ a₃) (p₂₃ : a₂ ≡ a₃) →
(trans p₁₂ p₂₃ ≡ p₁₃)
≡
(p₂₃ ≡ trans (sym p₁₂) p₁₃)
[trans≡]≡[≡trans-symˡ] p₁₂ = elim
(λ {a₁ a₂} p₁₂ →
∀ {a₃} (p₁₃ : a₁ ≡ a₃) (p₂₃ : a₂ ≡ a₃) →
(trans p₁₂ p₂₃ ≡ p₁₃)
≡
(p₂₃ ≡ trans (sym p₁₂) p₁₃))
(λ a₁₂ p₁₃ p₂₃ →
trans (refl a₁₂) p₂₃ ≡ p₁₃ ≡⟨ cong₂ _≡_ (trans-reflˡ _) (sym $ trans-reflˡ _) ⟩
p₂₃ ≡ trans (refl a₁₂) p₁₃ ≡⟨ cong ((_ ≡_) ∘ flip trans _) (sym sym-refl) ⟩∎
p₂₃ ≡ trans (sym (refl a₁₂)) p₁₃ ∎)
p₁₂
-- The following lemma is basically Theorem 2.11.5 from the HoTT
-- book (the book's lemma gives an equivalence between equality
-- types, rather than an equality between equality types).
[subst≡]≡[trans≡trans] :
{p : x ≡ y} {q : x ≡ x} {r : y ≡ y} →
(subst (λ z → z ≡ z) p q ≡ r)
≡
(trans q p ≡ trans p r)
[subst≡]≡[trans≡trans] {p = p} {q} {r} = elim
(λ {x y} p → {q : x ≡ x} {r : y ≡ y} →
(subst (λ z → z ≡ z) p q ≡ r)
≡
(trans q p ≡ trans p r))
(λ x {q r} →
subst (λ z → z ≡ z) (refl x) q ≡ r ≡⟨ cong (_≡ _) (subst-refl _ _) ⟩
q ≡ r ≡⟨ sym $ cong₂ _≡_ (trans-reflʳ _) (trans-reflˡ _) ⟩∎
trans q (refl x) ≡ trans (refl x) r ∎)
p
-- "Evaluation rule" for [subst≡]≡[trans≡trans].
[subst≡]≡[trans≡trans]-refl :
{q r : x ≡ x} →
[subst≡]≡[trans≡trans] {p = refl x} ≡
trans (cong (_≡ r) (subst-refl (λ z → z ≡ z) q))
(sym $ cong₂ _≡_ (trans-reflʳ q) (trans-reflˡ r))
[subst≡]≡[trans≡trans]-refl {q = q} {r = r} =
cong (λ f → f {q = q} {r = r}) $
elim-refl
(λ {x y} p → {q : x ≡ x} {r : y ≡ y} → _ ≡ (trans _ p ≡ _))
_
-- The proof trans is commutative when one of the arguments is f x for
-- a function f : (x : A) → x ≡ x.
trans-sometimes-commutative :
{p : x ≡ x} (f : (x : A) → x ≡ x) →
trans (f x) p ≡ trans p (f x)
trans-sometimes-commutative {x = x} {p = p} f =
let lemma =
subst (λ z → z ≡ z) p (f x) ≡⟨ dcong f p ⟩∎
f x ∎
in
trans (f x) p ≡⟨ subst id [subst≡]≡[trans≡trans] lemma ⟩∎
trans p (f x) ∎
-- Sometimes one can turn two ("modified") copies of a proof into
-- one.
trans-cong-cong :
(f : A → A → B) (p : x ≡ y) →
trans (cong (λ z → f z x) p)
(cong (λ z → f y z) p) ≡
cong (λ z → f z z) p
trans-cong-cong f = elim
(λ {x y} p → trans (cong (λ z → f z x) p)
(cong (λ z → f y z) p) ≡
cong (λ z → f z z) p)
(λ x → trans (cong (λ z → f z x) (refl x))
(cong (λ z → f x z) (refl x)) ≡⟨ cong₂ trans (cong-refl _) (cong-refl _) ⟩
trans (refl (f x x)) (refl (f x x)) ≡⟨ trans-refl-refl ⟩
refl (f x x) ≡⟨ sym $ cong-refl _ ⟩∎
cong (λ z → f z z) (refl x) ∎)
-- If f and g agree on a decidable subset of their common domain, then
-- cong f eq is equal to (modulo some uses of transitivity) cong g eq
-- for proofs eq between elements in this subset.
cong-respects-relevant-equality :
{f g : A → B}
(p : A → Bool) (f≡g : ∀ x → T (p x) → f x ≡ g x)
{px : T (p x)} {py : T (p y)} →
trans (cong f x≡y) (f≡g y py) ≡ trans (f≡g x px) (cong g x≡y)
cong-respects-relevant-equality {f = f} {g} p f≡g = elim
(λ {x y} x≡y →
{px : T (p x)} {py : T (p y)} →
trans (cong f x≡y) (f≡g y py) ≡ trans (f≡g x px) (cong g x≡y))
(λ x {px px′} →
trans (cong f (refl x)) (f≡g x px′) ≡⟨ cong (flip trans _) (cong-refl _) ⟩
trans (refl (f x)) (f≡g x px′) ≡⟨ trans-reflˡ _ ⟩
f≡g x px′ ≡⟨ cong (f≡g x) (T-irr (p x) px′ px) ⟩
f≡g x px ≡⟨ sym $ trans-reflʳ _ ⟩
trans (f≡g x px) (refl (g x)) ≡⟨ cong (trans _) (sym $ cong-refl _) ⟩∎
trans (f≡g x px) (cong g (refl x)) ∎)
_
where
T-irr : (b : Bool) → Is-proposition (T b)
T-irr true _ _ = refl _
T-irr false ()
-- A special case of cong-respects-relevant-equality.
--
-- The statement of this lemma is very similar to that of
-- Lemma 2.4.3 from the HoTT book.
naturality :
{x≡y : x ≡ y}
(f≡g : ∀ x → f x ≡ g x) →
trans (cong f x≡y) (f≡g y) ≡ trans (f≡g x) (cong g x≡y)
naturality f≡g =
cong-respects-relevant-equality (λ _ → true) (λ x _ → f≡g x)
-- If f z evaluates to z for a decidable set of values which
-- includes x and y, do we have
--
-- cong f x≡y ≡ x≡y
--
-- for any x≡y : x ≡ y? The equation above is not well-typed if f
-- is a variable, but the approximation below can be proved.
cong-roughly-id :
(f : A → A) (p : A → Bool)
(x≡y : x ≡ y) (px : T (p x)) (py : T (p y))
(f≡id : ∀ z → T (p z) → f z ≡ z) →
cong f x≡y ≡
trans (f≡id x px) (trans x≡y $ sym (f≡id y py))
cong-roughly-id {x = x} {y = y} f p x≡y px py f≡id =
let lemma =
trans (cong id x≡y) (sym (f≡id y py)) ≡⟨ cong-respects-relevant-equality p (λ x → sym ∘ f≡id x) ⟩∎
trans (sym (f≡id x px)) (cong f x≡y) ∎
in
cong f x≡y ≡⟨ sym $ subst (λ eq → eq → trans (f≡id x px)
(trans (cong id x≡y) (sym (f≡id y py))) ≡
cong f x≡y)
([trans≡]≡[≡trans-symˡ] _ _ _) id lemma ⟩
trans (f≡id x px) (trans (cong id x≡y) $ sym (f≡id y py)) ≡⟨ cong (λ eq → trans _ (trans eq _)) (sym $ cong-id _) ⟩∎
trans (f≡id x px) (trans x≡y $ sym (f≡id y py)) ∎
|
algebraic-stack_agda0000_doc_8540 | {-# OPTIONS -v tc.conv.irr:50 #-}
-- {-# OPTIONS -v tc.lhs.unify:50 #-}
module IndexInference where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
data Vec (A : Set) : Nat -> Set where
[] : Vec A zero
_::_ : {n : Nat} -> A -> Vec A n -> Vec A (suc n)
infixr 40 _::_
-- The length of the vector can be inferred from the pattern.
foo : Vec Nat _ -> Nat
foo (a :: b :: c :: []) = c
-- Andreas, 2012-09-13 an example with irrelevant components in index
pred : Nat → Nat
pred (zero ) = zero
pred (suc n) = n
data ⊥ : Set where
record ⊤ : Set where
NonZero : Nat → Set
NonZero zero = ⊥
NonZero (suc n) = ⊤
data Fin (n : Nat) : Set where
zero : .(NonZero n) → Fin n
suc : .(NonZero n) → Fin (pred n) → Fin n
data SubVec (A : Set)(n : Nat) : Fin n → Set where
[] : .{p : NonZero n} → SubVec A n (zero p)
_::_ : .{p : NonZero n}{k : Fin (pred n)} → A → SubVec A (pred n) k → SubVec A n (suc p k)
-- The length of the vector can be inferred from the pattern.
bar : {A : Set} → SubVec A (suc (suc (suc zero))) _ → A
bar (a :: []) = a
|
algebraic-stack_agda0000_doc_8541 | {-# OPTIONS --safe #-}
module Definition.Typed.Properties where
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.RedSteps
import Definition.Typed.Weakening as Twk
open import Tools.Empty using (⊥; ⊥-elim)
open import Tools.Product
open import Tools.Sum hiding (id ; sym)
import Tools.PropositionalEquality as PE
import Data.Fin as Fin
import Data.Nat as Nat
-- Escape context extraction
wfTerm : ∀ {Γ A t r} → Γ ⊢ t ∷ A ^ r → ⊢ Γ
wfTerm (univ <l ⊢Γ) = ⊢Γ
wfTerm (ℕⱼ ⊢Γ) = ⊢Γ
wfTerm (Emptyⱼ ⊢Γ) = ⊢Γ
wfTerm (Πⱼ <l ▹ <l' ▹ F ▹ G) = wfTerm F
wfTerm (∃ⱼ F ▹ G) = wfTerm F
wfTerm (var ⊢Γ x₁) = ⊢Γ
wfTerm (lamⱼ _ _ F t) with wfTerm t
wfTerm (lamⱼ _ _ F t) | ⊢Γ ∙ F′ = ⊢Γ
wfTerm (g ∘ⱼ a) = wfTerm a
wfTerm (⦅ F , G , t , u ⦆ⱼ) = wfTerm t
wfTerm (fstⱼ A B t) = wfTerm t
wfTerm (sndⱼ A B t) = wfTerm t
wfTerm (zeroⱼ ⊢Γ) = ⊢Γ
wfTerm (sucⱼ n) = wfTerm n
wfTerm (natrecⱼ F z s n) = wfTerm z
wfTerm (Emptyrecⱼ A e) = wfTerm e
wfTerm (Idⱼ A t u) = wfTerm t
wfTerm (Idreflⱼ t) = wfTerm t
wfTerm (transpⱼ A P t s u e) = wfTerm t
wfTerm (castⱼ A B e t) = wfTerm t
wfTerm (castreflⱼ A t) = wfTerm t
wfTerm (conv t A≡B) = wfTerm t
wf : ∀ {Γ A r} → Γ ⊢ A ^ r → ⊢ Γ
wf (Uⱼ ⊢Γ) = ⊢Γ
wf (univ A) = wfTerm A
mutual
wfEqTerm : ∀ {Γ A t u r} → Γ ⊢ t ≡ u ∷ A ^ r → ⊢ Γ
wfEqTerm (refl t) = wfTerm t
wfEqTerm (sym t≡u) = wfEqTerm t≡u
wfEqTerm (trans t≡u u≡r) = wfEqTerm t≡u
wfEqTerm (conv t≡u A≡B) = wfEqTerm t≡u
wfEqTerm (Π-cong _ _ F F≡H G≡E) = wfEqTerm F≡H
wfEqTerm (∃-cong F F≡H G≡E) = wfEqTerm F≡H
wfEqTerm (app-cong f≡g a≡b) = wfEqTerm f≡g
wfEqTerm (β-red _ _ F t a) = wfTerm a
wfEqTerm (η-eq _ _ F f g f0≡g0) = wfTerm f
wfEqTerm (suc-cong n) = wfEqTerm n
wfEqTerm (natrec-cong F≡F′ z≡z′ s≡s′ n≡n′) = wfEqTerm z≡z′
wfEqTerm (natrec-zero F z s) = wfTerm z
wfEqTerm (natrec-suc n F z s) = wfTerm n
wfEqTerm (Emptyrec-cong A≡A' _ _) = wfEq A≡A'
wfEqTerm (proof-irrelevance t u) = wfTerm t
wfEqTerm (Id-cong A t u) = wfEqTerm u
wfEqTerm (Id-Π _ _ A B t u) = wfTerm t
wfEqTerm (Id-ℕ-00 ⊢Γ) = ⊢Γ
wfEqTerm (Id-ℕ-SS m n) = wfTerm n
wfEqTerm (Id-U-ΠΠ A B A' B') = wfTerm A
wfEqTerm (Id-U-ℕℕ ⊢Γ) = ⊢Γ
wfEqTerm (Id-SProp A B) = wfTerm A
wfEqTerm (Id-ℕ-0S n) = wfTerm n
wfEqTerm (Id-ℕ-S0 n) = wfTerm n
wfEqTerm (Id-U-ℕΠ A B) = wfTerm A
wfEqTerm (Id-U-Πℕ A B) = wfTerm A
wfEqTerm (Id-U-ΠΠ!% eq A B A' B') = wfTerm A
wfEqTerm (cast-cong A B t _ _) = wfEqTerm t
wfEqTerm (cast-Π A B A' B' e f) = wfTerm f
wfEqTerm (cast-ℕ-0 e) = wfTerm e
wfEqTerm (cast-ℕ-S e n) = wfTerm n
wfEq : ∀ {Γ A B r} → Γ ⊢ A ≡ B ^ r → ⊢ Γ
wfEq (univ A≡B) = wfEqTerm A≡B
wfEq (refl A) = wf A
wfEq (sym A≡B) = wfEq A≡B
wfEq (trans A≡B B≡C) = wfEq A≡B
-- Reduction is a subset of conversion
subsetTerm : ∀ {Γ A t u l} → Γ ⊢ t ⇒ u ∷ A ^ l → Γ ⊢ t ≡ u ∷ A ^ [ ! , l ]
subset : ∀ {Γ A B r} → Γ ⊢ A ⇒ B ^ r → Γ ⊢ A ≡ B ^ r
subsetTerm (natrec-subst F z s n⇒n′) =
natrec-cong (refl F) (refl z) (refl s) (subsetTerm n⇒n′)
subsetTerm (natrec-zero F z s) = natrec-zero F z s
subsetTerm (natrec-suc n F z s) = natrec-suc n F z s
subsetTerm (app-subst {rA = !} t⇒u a) = app-cong (subsetTerm t⇒u) (refl a)
subsetTerm (app-subst {rA = %} t⇒u a) = app-cong (subsetTerm t⇒u) (proof-irrelevance a a)
subsetTerm (β-red l< l<' A t a) = β-red l< l<' A t a
subsetTerm (conv t⇒u A≡B) = conv (subsetTerm t⇒u) A≡B
subsetTerm (Id-subst A t u) = Id-cong (subsetTerm A) (refl t) (refl u)
subsetTerm (Id-ℕ-subst m n) = Id-cong (refl (ℕⱼ (wfTerm n))) (subsetTerm m) (refl n)
subsetTerm (Id-ℕ-0-subst n) = let ⊢Γ = wfEqTerm (subsetTerm n) in Id-cong (refl (ℕⱼ ⊢Γ)) (refl (zeroⱼ ⊢Γ)) (subsetTerm n)
subsetTerm (Id-ℕ-S-subst m n) = Id-cong (refl (ℕⱼ (wfTerm m))) (refl (sucⱼ m)) (subsetTerm n)
subsetTerm (Id-U-subst A B) = Id-cong (refl (univ 0<1 (wfTerm B))) (subsetTerm A) (refl B)
subsetTerm (Id-U-ℕ-subst B) = let ⊢Γ = wfEqTerm (subsetTerm B) in Id-cong (refl (univ 0<1 ⊢Γ)) (refl (ℕⱼ ⊢Γ)) (subsetTerm B)
subsetTerm (Id-U-Π-subst A P B) = Id-cong (refl (univ 0<1 (wfTerm A))) (refl (Πⱼ (≡is≤ PE.refl) ▹ (≡is≤ PE.refl) ▹ A ▹ P)) (subsetTerm B)
subsetTerm (Id-Π <l <l' A B t u) = Id-Π <l <l' A B t u
subsetTerm (Id-ℕ-00 ⊢Γ) = Id-ℕ-00 ⊢Γ
subsetTerm (Id-ℕ-SS m n) = Id-ℕ-SS m n
subsetTerm (Id-U-ΠΠ A B A' B') = Id-U-ΠΠ A B A' B'
subsetTerm (Id-U-ℕℕ ⊢Γ) = Id-U-ℕℕ ⊢Γ
subsetTerm (Id-SProp A B) = Id-SProp A B
subsetTerm (Id-ℕ-0S n) = Id-ℕ-0S n
subsetTerm (Id-ℕ-S0 n) = Id-ℕ-S0 n
subsetTerm (Id-U-ℕΠ A B) = Id-U-ℕΠ A B
subsetTerm (Id-U-Πℕ A B) = Id-U-Πℕ A B
subsetTerm (Id-U-ΠΠ!% eq A B A' B') = Id-U-ΠΠ!% eq A B A' B'
subsetTerm (cast-subst A B e t) = let ⊢Γ = wfEqTerm (subsetTerm A)
in cast-cong (subsetTerm A) (refl B) (refl t) e (conv e (univ (Id-cong (refl (univ 0<1 ⊢Γ)) (subsetTerm A) (refl B))))
subsetTerm (cast-ℕ-subst B e t) = let ⊢Γ = wfEqTerm (subsetTerm B)
in cast-cong (refl (ℕⱼ (wfTerm t))) (subsetTerm B) (refl t) e (conv e (univ (Id-cong (refl (univ 0<1 ⊢Γ)) (refl (ℕⱼ ⊢Γ)) (subsetTerm B))))
subsetTerm (cast-Π-subst A P B e t) = let ⊢Γ = wfTerm A
in cast-cong (refl (Πⱼ (≡is≤ PE.refl) ▹ (≡is≤ PE.refl) ▹ A ▹ P)) (subsetTerm B) (refl t) e
(conv e (univ (Id-cong (refl (univ 0<1 ⊢Γ)) (refl (Πⱼ ≡is≤ PE.refl ▹ ≡is≤ PE.refl ▹ A ▹ P)) (subsetTerm B) )))
subsetTerm (cast-Π A B A' B' e f) = cast-Π A B A' B' e f
subsetTerm (cast-ℕ-0 e) = cast-ℕ-0 e
subsetTerm (cast-ℕ-S e n) = cast-ℕ-S e n
subsetTerm (cast-ℕ-cong e n) = let ⊢Γ = wfTerm e
⊢ℕ = ℕⱼ ⊢Γ
in cast-cong (refl ⊢ℕ) (refl ⊢ℕ) (subsetTerm n) e e
subset (univ A⇒B) = univ (subsetTerm A⇒B)
subset*Term : ∀ {Γ A t u l } → Γ ⊢ t ⇒* u ∷ A ^ l → Γ ⊢ t ≡ u ∷ A ^ [ ! , l ]
subset*Term (id t) = refl t
subset*Term (t⇒t′ ⇨ t⇒*u) = trans (subsetTerm t⇒t′) (subset*Term t⇒*u)
subset* : ∀ {Γ A B r} → Γ ⊢ A ⇒* B ^ r → Γ ⊢ A ≡ B ^ r
subset* (id A) = refl A
subset* (A⇒A′ ⇨ A′⇒*B) = trans (subset A⇒A′) (subset* A′⇒*B)
-- Transitivity of reduction
transTerm⇒* : ∀ {Γ A t u v l } → Γ ⊢ t ⇒* u ∷ A ^ l → Γ ⊢ u ⇒* v ∷ A ^ l → Γ ⊢ t ⇒* v ∷ A ^ l
transTerm⇒* (id x) y = y
transTerm⇒* (x ⇨ x₁) y = x ⇨ transTerm⇒* x₁ y
trans⇒* : ∀ {Γ A B C r} → Γ ⊢ A ⇒* B ^ r → Γ ⊢ B ⇒* C ^ r → Γ ⊢ A ⇒* C ^ r
trans⇒* (id x) y = y
trans⇒* (x ⇨ x₁) y = x ⇨ trans⇒* x₁ y
transTerm:⇒:* : ∀ {Γ A t u v l } → Γ ⊢ t :⇒*: u ∷ A ^ l → Γ ⊢ u :⇒*: v ∷ A ^ l → Γ ⊢ t :⇒*: v ∷ A ^ l
transTerm:⇒:* [[ ⊢t , ⊢u , d ]] [[ ⊢t₁ , ⊢u₁ , d₁ ]] = [[ ⊢t , ⊢u₁ , (transTerm⇒* d d₁) ]]
conv⇒* : ∀ {Γ A B l t u} → Γ ⊢ t ⇒* u ∷ A ^ l → Γ ⊢ A ≡ B ^ [ ! , l ] → Γ ⊢ t ⇒* u ∷ B ^ l
conv⇒* (id x) e = id (conv x e)
conv⇒* (x ⇨ D) e = conv x e ⇨ conv⇒* D e
conv:⇒*: : ∀ {Γ A B l t u} → Γ ⊢ t :⇒*: u ∷ A ^ l → Γ ⊢ A ≡ B ^ [ ! , l ] → Γ ⊢ t :⇒*: u ∷ B ^ l
conv:⇒*: [[ ⊢t , ⊢u , d ]] e = [[ (conv ⊢t e) , (conv ⊢u e) , (conv⇒* d e) ]]
-- Can extract left-part of a reduction
redFirstTerm : ∀ {Γ t u A l } → Γ ⊢ t ⇒ u ∷ A ^ l → Γ ⊢ t ∷ A ^ [ ! , l ]
redFirst : ∀ {Γ A B r} → Γ ⊢ A ⇒ B ^ r → Γ ⊢ A ^ r
redFirstTerm (conv t⇒u A≡B) = conv (redFirstTerm t⇒u) A≡B
redFirstTerm (app-subst t⇒u a) = (redFirstTerm t⇒u) ∘ⱼ a
redFirstTerm (β-red {lA = lA} {lB = lB} lA< lB< ⊢A ⊢t ⊢a) = (lamⱼ lA< lB< ⊢A ⊢t) ∘ⱼ ⊢a
redFirstTerm (natrec-subst F z s n⇒n′) = natrecⱼ F z s (redFirstTerm n⇒n′)
redFirstTerm (natrec-zero F z s) = natrecⱼ F z s (zeroⱼ (wfTerm z))
redFirstTerm (natrec-suc n F z s) = natrecⱼ F z s (sucⱼ n)
redFirstTerm (Id-subst A t u) = Idⱼ (redFirstTerm A) t u
redFirstTerm (Id-ℕ-subst m n) = Idⱼ (ℕⱼ (wfTerm n)) (redFirstTerm m) n
redFirstTerm (Id-ℕ-0-subst n) = Idⱼ (ℕⱼ (wfEqTerm (subsetTerm n))) (zeroⱼ (wfEqTerm (subsetTerm n))) (redFirstTerm n)
redFirstTerm (Id-ℕ-S-subst m n) = Idⱼ (ℕⱼ (wfTerm m)) (sucⱼ m) (redFirstTerm n)
redFirstTerm (Id-U-subst A B) = Idⱼ (univ 0<1 (wfTerm B)) (redFirstTerm A) B
redFirstTerm (Id-U-ℕ-subst B) = let ⊢Γ = (wfEqTerm (subsetTerm B)) in Idⱼ (univ 0<1 ⊢Γ) (ℕⱼ ⊢Γ) (redFirstTerm B)
redFirstTerm (Id-U-Π-subst A P B) = Idⱼ (univ 0<1 (wfTerm A)) (Πⱼ (≡is≤ PE.refl) ▹ (≡is≤ PE.refl) ▹ A ▹ P) (redFirstTerm B)
redFirstTerm (Id-Π {rA = rA} <l <l' A B t u) = Idⱼ (Πⱼ <l ▹ <l' ▹ A ▹ B) t u
redFirstTerm (Id-ℕ-00 ⊢Γ) = Idⱼ (ℕⱼ ⊢Γ) (zeroⱼ ⊢Γ) (zeroⱼ ⊢Γ)
redFirstTerm (Id-ℕ-SS m n) = Idⱼ (ℕⱼ (wfTerm m)) (sucⱼ m) (sucⱼ n)
redFirstTerm (Id-U-ΠΠ A B A' B') = Idⱼ (univ 0<1 (wfTerm A)) (Πⱼ (≡is≤ PE.refl) ▹ (≡is≤ PE.refl) ▹ A ▹ B) (Πⱼ (≡is≤ PE.refl) ▹ (≡is≤ PE.refl) ▹ A' ▹ B')
redFirstTerm (Id-U-ℕℕ ⊢Γ) = Idⱼ (univ 0<1 ⊢Γ) (ℕⱼ ⊢Γ) (ℕⱼ ⊢Γ)
redFirstTerm (Id-SProp A B) = Idⱼ (univ 0<1 (wfTerm A)) A B
redFirstTerm (Id-ℕ-0S n) = Idⱼ (ℕⱼ (wfTerm n)) (zeroⱼ (wfTerm n)) (sucⱼ n)
redFirstTerm (Id-ℕ-S0 n) = Idⱼ (ℕⱼ (wfTerm n)) (sucⱼ n) (zeroⱼ (wfTerm n))
redFirstTerm (Id-U-ℕΠ A B) = Idⱼ (univ 0<1 (wfTerm A)) (ℕⱼ (wfTerm A)) (Πⱼ (≡is≤ PE.refl) ▹ (≡is≤ PE.refl) ▹ A ▹ B)
redFirstTerm (Id-U-Πℕ A B) = Idⱼ (univ 0<1 (wfTerm A)) (Πⱼ (≡is≤ PE.refl) ▹ (≡is≤ PE.refl) ▹ A ▹ B) (ℕⱼ (wfTerm A))
redFirstTerm (Id-U-ΠΠ!% eq A B A' B') = Idⱼ (univ 0<1 (wfTerm A)) (Πⱼ (≡is≤ PE.refl) ▹ (≡is≤ PE.refl) ▹ A ▹ B) (Πⱼ (≡is≤ PE.refl) ▹ (≡is≤ PE.refl) ▹ A' ▹ B')
redFirstTerm (cast-subst A B e t) = castⱼ (redFirstTerm A) B e t
redFirstTerm (cast-ℕ-subst B e t) = castⱼ (ℕⱼ (wfTerm t)) (redFirstTerm B) e t
redFirstTerm (cast-Π-subst A P B e t) = castⱼ (Πⱼ (≡is≤ PE.refl) ▹ (≡is≤ PE.refl) ▹ A ▹ P) (redFirstTerm B) e t
redFirstTerm (cast-Π A B A' B' e f) = castⱼ (Πⱼ (≡is≤ PE.refl) ▹ (≡is≤ PE.refl) ▹ A ▹ B) (Πⱼ (≡is≤ PE.refl) ▹ (≡is≤ PE.refl) ▹ A' ▹ B') e f
redFirstTerm (cast-ℕ-0 e) = castⱼ (ℕⱼ (wfTerm e)) (ℕⱼ (wfTerm e)) e (zeroⱼ (wfTerm e))
redFirstTerm (cast-ℕ-S e n) = castⱼ (ℕⱼ (wfTerm e)) (ℕⱼ (wfTerm e)) e (sucⱼ n)
redFirstTerm (cast-ℕ-cong e n) = castⱼ (ℕⱼ (wfTerm e)) (ℕⱼ (wfTerm e)) e (redFirstTerm n)
redFirst (univ A⇒B) = univ (redFirstTerm A⇒B)
redFirst*Term : ∀ {Γ t u A l} → Γ ⊢ t ⇒* u ∷ A ^ l → Γ ⊢ t ∷ A ^ [ ! , l ]
redFirst*Term (id t) = t
redFirst*Term (t⇒t′ ⇨ t′⇒*u) = redFirstTerm t⇒t′
redFirst* : ∀ {Γ A B r} → Γ ⊢ A ⇒* B ^ r → Γ ⊢ A ^ r
redFirst* (id A) = A
redFirst* (A⇒A′ ⇨ A′⇒*B) = redFirst A⇒A′
-- Neutral types are always small
-- tyNe : ∀ {Γ t r} → Γ ⊢ t ^ r → Neutral t → Γ ⊢ t ∷ (Univ r) ^ !
-- tyNe (univ x) tn = x
-- tyNe (Idⱼ A x y) tn = Idⱼ A x y
-- Neutrals do not weak head reduce
neRedTerm : ∀ {Γ t u l A} (d : Γ ⊢ t ⇒ u ∷ A ^ l) (n : Neutral t) → ⊥
neRed : ∀ {Γ t u r} (d : Γ ⊢ t ⇒ u ^ r) (n : Neutral t) → ⊥
whnfRedTerm : ∀ {Γ t u A l} (d : Γ ⊢ t ⇒ u ∷ A ^ l) (w : Whnf t) → ⊥
whnfRed : ∀ {Γ A B r} (d : Γ ⊢ A ⇒ B ^ r) (w : Whnf A) → ⊥
neRedTerm (conv d x) n = neRedTerm d n
neRedTerm (app-subst d x) (∘ₙ n) = neRedTerm d n
neRedTerm (β-red _ _ x x₁ x₂) (∘ₙ ())
neRedTerm (natrec-zero x x₁ x₂) (natrecₙ ())
neRedTerm (natrec-suc x x₁ x₂ x₃) (natrecₙ ())
neRedTerm (natrec-subst x x₁ x₂ tr) (natrecₙ tn) = neRedTerm tr tn
neRedTerm (Id-subst tr x y) (Idₙ tn) = neRedTerm tr tn
neRedTerm (Id-ℕ-subst tr x) (Idℕₙ tn) = neRedTerm tr tn
neRedTerm (Id-ℕ-0-subst tr) (Idℕ0ₙ tn) = neRedTerm tr tn
neRedTerm (Id-ℕ-S-subst x tr) (IdℕSₙ tn) = neRedTerm tr tn
neRedTerm (Id-U-subst tr x) (IdUₙ tn) = neRedTerm tr tn
neRedTerm (Id-U-ℕ-subst tr) (IdUℕₙ tn) = neRedTerm tr tn
neRedTerm (Id-U-Π-subst A B tr) (IdUΠₙ tn) = neRedTerm tr tn
neRedTerm (Id-subst tr x y) (Idℕₙ tn) = whnfRedTerm tr ℕₙ
neRedTerm (Id-subst tr x y) (Idℕ0ₙ tn) = whnfRedTerm tr ℕₙ
neRedTerm (Id-subst tr x y) (IdℕSₙ tn) = whnfRedTerm tr ℕₙ
neRedTerm (Id-subst tr x y) (IdUₙ tn) = whnfRedTerm tr Uₙ
neRedTerm (Id-subst tr x y) (IdUℕₙ tn) = whnfRedTerm tr Uₙ
neRedTerm (Id-subst tr x y) (IdUΠₙ tn) = whnfRedTerm tr Uₙ
neRedTerm (Id-ℕ-subst tr x) (Idℕ0ₙ tn) = whnfRedTerm tr zeroₙ
neRedTerm (Id-ℕ-subst tr x) (IdℕSₙ tn) = whnfRedTerm tr sucₙ
neRedTerm (Id-U-subst tr x) (IdUℕₙ tn) = whnfRedTerm tr ℕₙ
neRedTerm (Id-U-subst tr x) (IdUΠₙ tn) = whnfRedTerm tr Πₙ
neRedTerm (Id-Π _ _ A B t u) (Idₙ ())
neRedTerm (Id-ℕ-00 tr) (Idₙ ())
neRedTerm (Id-ℕ-00 tr) (Idℕₙ ())
neRedTerm (Id-ℕ-00 tr) (Idℕ0ₙ ())
neRedTerm (Id-ℕ-SS x tr) (Idₙ ())
neRedTerm (Id-ℕ-SS x tr) (Idℕₙ ())
neRedTerm (Id-U-ΠΠ A B A' B') (Idₙ ())
neRedTerm (Id-U-ΠΠ A B A' B') (IdUₙ ())
neRedTerm (Id-U-ΠΠ A B A' B') (IdUΠₙ ())
neRedTerm (Id-U-ℕℕ x) (Idₙ ())
neRedTerm (Id-U-ℕℕ x) (IdUₙ ())
neRedTerm (Id-U-ℕℕ x) (IdUℕₙ ())
neRedTerm (Id-SProp A B) (Idₙ ())
neRedTerm (Id-ℕ-0S x) (Idₙ ())
neRedTerm (Id-ℕ-S0 x) (Idₙ ())
neRedTerm (Id-U-ℕΠ A B) (Idₙ ())
neRedTerm (Id-U-Πℕ A B) (Idₙ ())
neRedTerm (Id-U-ΠΠ!% eq A B A' B') (Idₙ ())
neRedTerm (cast-subst tr B e x) (castₙ tn) = neRedTerm tr tn
neRedTerm (cast-ℕ-subst tr e x) (castℕₙ tn) = neRedTerm tr tn
neRedTerm (cast-Π-subst A B tr e x) (castΠₙ tn) = neRedTerm tr tn
neRedTerm (cast-Π-subst A B tr e x) (castΠℕₙ) = whnfRedTerm tr ℕₙ
neRedTerm (cast-subst tr x x₁ x₂) (castℕₙ tn) = whnfRedTerm tr ℕₙ
neRedTerm (cast-subst tr x x₁ x₂) (castΠₙ tn) = whnfRedTerm tr Πₙ
neRedTerm (cast-subst tr x x₁ x₂) (castℕℕₙ tn) = whnfRedTerm tr ℕₙ
neRedTerm (cast-subst tr x x₁ x₂) (castℕΠₙ) = whnfRedTerm tr ℕₙ
neRedTerm (cast-subst tr x x₁ x₂) (castΠℕₙ) = whnfRedTerm tr Πₙ
neRedTerm (cast-ℕ-subst tr x x₁) (castℕℕₙ tn) = whnfRedTerm tr ℕₙ
neRedTerm (cast-ℕ-subst tr x x₁) (castℕΠₙ) = whnfRedTerm tr Πₙ
neRedTerm (cast-Π A B A' B' e f) (castₙ ())
neRedTerm (cast-Π A B A' B' e f) (castΠₙ ())
neRedTerm (cast-ℕ-0 x) (castₙ ())
neRedTerm (cast-ℕ-0 x) (castℕₙ ())
neRedTerm (cast-ℕ-0 x) (castℕℕₙ ())
neRedTerm (cast-ℕ-S x x₁) (castₙ ())
neRedTerm (cast-ℕ-S x x₁) (castℕₙ ())
neRedTerm (cast-ℕ-S x x₁) (castℕℕₙ ())
neRedTerm (cast-ℕ-cong x x₁) (castₙ ())
neRedTerm (cast-ℕ-cong x x₁) (castℕₙ ())
neRedTerm (cast-ℕ-cong x x₁) (castℕℕₙ t) = neRedTerm x₁ t
neRedTerm (cast-subst d x x₁ x₂) castΠΠ%!ₙ = whnfRedTerm d Πₙ
neRedTerm (cast-subst d x x₁ x₂) castΠΠ!%ₙ = whnfRedTerm d Πₙ
neRedTerm (cast-Π-subst x x₁ d x₂ x₃) castΠΠ%!ₙ = whnfRedTerm d Πₙ
neRedTerm (cast-Π-subst x x₁ d x₂ x₃) castΠΠ!%ₙ = whnfRedTerm d Πₙ
neRed (univ x) N = neRedTerm x N
whnfRedTerm (conv d x) w = whnfRedTerm d w
whnfRedTerm (app-subst d x) (ne (∘ₙ x₁)) = neRedTerm d x₁
whnfRedTerm (β-red _ _ x x₁ x₂) (ne (∘ₙ ()))
whnfRedTerm (natrec-subst x x₁ x₂ d) (ne (natrecₙ x₃)) = neRedTerm d x₃
whnfRedTerm (natrec-zero x x₁ x₂) (ne (natrecₙ ()))
whnfRedTerm (natrec-suc x x₁ x₂ x₃) (ne (natrecₙ ()))
whnfRedTerm (Id-subst d x x₁) (ne (Idₙ x₂)) = neRedTerm d x₂
whnfRedTerm (Id-subst d x x₁) (ne (Idℕₙ x₂)) = whnfRedTerm d ℕₙ
whnfRedTerm (Id-subst d x x₁) (ne (Idℕ0ₙ x₂)) = whnfRedTerm d ℕₙ
whnfRedTerm (Id-subst d x x₁) (ne (IdℕSₙ x₂)) = whnfRedTerm d ℕₙ
whnfRedTerm (Id-subst d x x₁) (ne (IdUₙ x₂)) = whnfRedTerm d Uₙ
whnfRedTerm (Id-subst d x x₁) (ne (IdUℕₙ x₂)) = whnfRedTerm d Uₙ
whnfRedTerm (Id-subst d x x₁) (ne (IdUΠₙ x₂)) = whnfRedTerm d Uₙ
whnfRedTerm (Id-ℕ-subst d x) (ne (Idℕₙ x₁)) = neRedTerm d x₁
whnfRedTerm (Id-ℕ-subst d x) (ne (Idℕ0ₙ x₁)) = whnfRedTerm d zeroₙ
whnfRedTerm (Id-ℕ-subst d x) (ne (IdℕSₙ x₁)) = whnfRedTerm d sucₙ
whnfRedTerm (Id-ℕ-0-subst d) (ne (Idℕ0ₙ x)) = neRedTerm d x
whnfRedTerm (Id-ℕ-S-subst x d) (ne (IdℕSₙ x₁)) = neRedTerm d x₁
whnfRedTerm (Id-U-subst d x) (ne (IdUₙ x₁)) = neRedTerm d x₁
whnfRedTerm (Id-U-subst d x) (ne (IdUℕₙ x₁)) = whnfRedTerm d ℕₙ
whnfRedTerm (Id-U-subst d x) (ne (IdUΠₙ x₁)) = whnfRedTerm d Πₙ
whnfRedTerm (Id-U-ℕ-subst d) (ne (IdUℕₙ x)) = neRedTerm d x
whnfRedTerm (Id-U-Π-subst x x₁ d) (ne (IdUΠₙ x₂)) = neRedTerm d x₂
whnfRedTerm (Id-Π _ _ x x₁ x₂ x₃) (ne (Idₙ ()))
whnfRedTerm (Id-ℕ-00 x) (ne (Idₙ ()))
whnfRedTerm (Id-ℕ-00 x) (ne (Idℕₙ ()))
whnfRedTerm (Id-ℕ-00 x) (ne (Idℕ0ₙ ()))
whnfRedTerm (Id-ℕ-SS x x₁) (ne (Idₙ ()))
whnfRedTerm (Id-ℕ-SS x x₁) (ne (Idℕₙ ()))
whnfRedTerm (Id-ℕ-SS x x₁) (ne (IdℕSₙ ()))
whnfRedTerm (Id-U-ΠΠ x x₁ x₂ x₃) (ne (Idₙ ()))
whnfRedTerm (Id-U-ΠΠ x x₁ x₂ x₃) (ne (IdUₙ ()))
whnfRedTerm (Id-U-ΠΠ x x₁ x₂ x₃) (ne (IdUΠₙ ()))
whnfRedTerm (Id-U-ℕℕ x) (ne (Idₙ ()))
whnfRedTerm (Id-U-ℕℕ x) (ne (IdUₙ ()))
whnfRedTerm (Id-U-ℕℕ x) (ne (IdUℕₙ ()))
whnfRedTerm (Id-SProp x x₁) (ne (Idₙ ()))
whnfRedTerm (Id-ℕ-0S x) (ne (Idₙ ()))
whnfRedTerm (Id-ℕ-S0 x) (ne (Idₙ ()))
whnfRedTerm (Id-U-ℕΠ A B) (ne (Idₙ ()))
whnfRedTerm (Id-U-Πℕ A B) (ne (Idₙ ()))
whnfRedTerm (Id-U-ΠΠ!% eq A B A' B') (ne (Idₙ ()))
whnfRedTerm (cast-subst d x x₁ x₂) (ne (castₙ x₃)) = neRedTerm d x₃
whnfRedTerm (cast-subst d x x₁ x₂) (ne (castℕₙ x₃)) = whnfRedTerm d ℕₙ
whnfRedTerm (cast-subst d x x₁ x₂) (ne (castΠₙ x₃)) = whnfRedTerm d Πₙ
whnfRedTerm (cast-subst d x x₁ x₂) (ne (castℕℕₙ x₃)) = whnfRedTerm d ℕₙ
whnfRedTerm (cast-subst d x x₁ x₂) (ne castℕΠₙ) = whnfRedTerm d ℕₙ
whnfRedTerm (cast-subst d x x₁ x₂) (ne castΠℕₙ) = whnfRedTerm d Πₙ
whnfRedTerm (cast-ℕ-subst d x x₁) (ne (castℕₙ x₂)) = neRedTerm d x₂
whnfRedTerm (cast-ℕ-subst d x x₁) (ne (castℕℕₙ x₂)) = whnfRedTerm d ℕₙ
whnfRedTerm (cast-ℕ-subst d x x₁) (ne castℕΠₙ) = whnfRedTerm d Πₙ
whnfRedTerm (cast-Π-subst x x₁ d x₂ x₃) (ne (castΠₙ x₄)) = neRedTerm d x₄
whnfRedTerm (cast-Π-subst x x₁ d x₂ x₃) (ne castΠℕₙ) = whnfRedTerm d ℕₙ
whnfRedTerm (cast-Π x x₁ x₂ x₃ x₄ x₅) (ne (castₙ ()))
whnfRedTerm (cast-Π x x₁ x₂ x₃ x₄ x₅) (ne (castΠₙ ()))
whnfRedTerm (cast-ℕ-0 x) (ne (castₙ ()))
whnfRedTerm (cast-ℕ-0 x) (ne (castℕₙ ()))
whnfRedTerm (cast-ℕ-0 x) (ne (castℕℕₙ ()))
whnfRedTerm (cast-ℕ-S x x₁) (ne (castₙ ()))
whnfRedTerm (cast-ℕ-S x x₁) (ne (castℕₙ ()))
whnfRedTerm (cast-ℕ-S x x₁) (ne (castℕℕₙ ()))
whnfRedTerm (cast-ℕ-cong x x₁) (ne (castₙ ()))
whnfRedTerm (cast-ℕ-cong x x₁) (ne (castℕₙ ()))
whnfRedTerm (cast-ℕ-cong x x₁) (ne (castℕℕₙ t)) = neRedTerm x₁ t
whnfRedTerm (cast-subst d x x₁ x₂) (ne castΠΠ%!ₙ) = whnfRedTerm d Πₙ
whnfRedTerm (cast-subst d x x₁ x₂) (ne castΠΠ!%ₙ) = whnfRedTerm d Πₙ
whnfRedTerm (cast-Π-subst x x₁ d x₂ x₃) (ne castΠΠ%!ₙ) = whnfRedTerm d Πₙ
whnfRedTerm (cast-Π-subst x x₁ d x₂ x₃) (ne castΠΠ!%ₙ) = whnfRedTerm d Πₙ
whnfRed (univ x) w = whnfRedTerm x w
whnfRed*Term : ∀ {Γ t u A l} (d : Γ ⊢ t ⇒* u ∷ A ^ l) (w : Whnf t) → t PE.≡ u
whnfRed*Term (id x) Uₙ = PE.refl
whnfRed*Term (id x) Πₙ = PE.refl
whnfRed*Term (id x) ∃ₙ = PE.refl
whnfRed*Term (id x) ℕₙ = PE.refl
whnfRed*Term (id x) Emptyₙ = PE.refl
whnfRed*Term (id x) lamₙ = PE.refl
whnfRed*Term (id x) zeroₙ = PE.refl
whnfRed*Term (id x) sucₙ = PE.refl
whnfRed*Term (id x) (ne x₁) = PE.refl
whnfRed*Term (conv x x₁ ⇨ d) w = ⊥-elim (whnfRedTerm x w)
whnfRed*Term (x ⇨ d) (ne x₁) = ⊥-elim (neRedTerm x x₁)
whnfRed* : ∀ {Γ A B r} (d : Γ ⊢ A ⇒* B ^ r) (w : Whnf A) → A PE.≡ B
whnfRed* (id x) w = PE.refl
whnfRed* (x ⇨ d) w = ⊥-elim (whnfRed x w)
-- Whr is deterministic
-- somehow the cases (cast-Π, cast-Π) and (Id-U-ΠΠ, Id-U-ΠΠ) fail if
-- we do not introduce a dummy relevance rA'. This is why we need the two
-- auxiliary functions.
whrDetTerm-aux1 : ∀{Γ t u F lF A A' rA lA lB rA' l B B' e f}
→ (d : t PE.≡ cast l (Π A ^ rA ° lA ▹ B ° lB ° l) (Π A' ^ rA' ° lA ▹ B' ° lB ° l) e f)
→ (d′ : Γ ⊢ t ⇒ u ∷ F ^ lF)
→ (lam A' ▹ (let a = cast l (wk1 A') (wk1 A) (Idsym (Univ rA l) (wk1 A) (wk1 A') (fst (wk1 e))) (var 0) in cast l (B [ a ]↑) B' ((snd (wk1 e)) ∘ (var 0) ^ ¹) ((wk1 f) ∘ a ^ l)) ^ l) PE.≡ u
whrDetTerm-aux1 d (conv d' x) = whrDetTerm-aux1 d d'
whrDetTerm-aux1 PE.refl (cast-subst d' x x₁ x₂) = ⊥-elim (whnfRedTerm d' Πₙ)
whrDetTerm-aux1 PE.refl (cast-Π-subst x x₁ d' x₂ x₃) = ⊥-elim (whnfRedTerm d' Πₙ)
whrDetTerm-aux1 PE.refl (cast-Π x x₁ x₂ x₃ x₄ x₅) = PE.refl
whrDetTerm-aux2 : ∀{Γ t u F lF A rA B A' rA' B'}
→ (rA≡rA' : rA PE.≡ rA')
→ (d : t PE.≡ Id (U ⁰) (Π A ^ rA ° ⁰ ▹ B ° ⁰ ° ⁰) (Π A' ^ rA' ° ⁰ ▹ B' ° ⁰ ° ⁰))
→ (d' : Γ ⊢ t ⇒ u ∷ F ^ lF)
→ (∃ (Id (Univ rA ⁰) A A') ▹ (Π (wk1 A') ^ rA ° ⁰ ▹ Id (U ⁰) ((wk (lift (step id)) B) [ cast ⁰ (wk1 (wk1 A')) (wk1 (wk1 A)) (Idsym (Univ rA ⁰) (wk1 (wk1 A)) (wk1 (wk1 A')) (var 1)) (var 0) ]↑) (wk (lift (step id)) B') ° ¹ ° ¹ ) ) PE.≡ u
whrDetTerm-aux2 eq d (conv d' x) = whrDetTerm-aux2 eq d d'
whrDetTerm-aux2 _ PE.refl (Id-subst d' x x₁) = ⊥-elim (whnfRedTerm d' Uₙ)
whrDetTerm-aux2 _ PE.refl (Id-U-subst d' x) = ⊥-elim (whnfRedTerm d' Πₙ)
whrDetTerm-aux2 _ PE.refl (Id-U-Π-subst x x₁ d') = ⊥-elim (whnfRedTerm d' Πₙ)
whrDetTerm-aux2 _ PE.refl (Id-U-ΠΠ x x₁ x₂ x₃) = PE.refl
whrDetTerm-aux2 PE.refl PE.refl (Id-U-ΠΠ!% eq A B A' B') = ⊥-elim (eq PE.refl)
whrDetTerm : ∀{Γ t u A l u′ A′ l′} (d : Γ ⊢ t ⇒ u ∷ A ^ l) (d′ : Γ ⊢ t ⇒ u′ ∷ A′ ^ l′) → u PE.≡ u′
whrDet : ∀{Γ A B B′ r r'} (d : Γ ⊢ A ⇒ B ^ r) (d′ : Γ ⊢ A ⇒ B′ ^ r') → B PE.≡ B′
whrDetTerm (conv d x) d′ = whrDetTerm d d′
whrDetTerm (app-subst d x) (app-subst d′ x₁) rewrite whrDetTerm d d′ = PE.refl
whrDetTerm (app-subst d x) (β-red _ _ x₁ x₂ x₃) = ⊥-elim (whnfRedTerm d lamₙ)
whrDetTerm (β-red _ _ x x₁ x₂) (app-subst d' x₃) = ⊥-elim (whnfRedTerm d' lamₙ)
whrDetTerm (β-red _ _ x x₁ x₂) (β-red _ _ x₃ x₄ x₅) = PE.refl
whrDetTerm (natrec-subst x x₁ x₂ d) (natrec-subst x₃ x₄ x₅ d') rewrite whrDetTerm d d' = PE.refl
whrDetTerm (natrec-subst x x₁ x₂ d) (natrec-zero x₃ x₄ x₅) = ⊥-elim (whnfRedTerm d zeroₙ)
whrDetTerm (natrec-subst x x₁ x₂ d) (natrec-suc x₃ x₄ x₅ x₆) = ⊥-elim (whnfRedTerm d sucₙ)
whrDetTerm (natrec-zero x x₁ x₂) (natrec-subst x₃ x₄ x₅ d') = ⊥-elim (whnfRedTerm d' zeroₙ)
whrDetTerm (natrec-zero x x₁ x₂) (natrec-zero x₃ x₄ x₅) = PE.refl
whrDetTerm (natrec-suc x x₁ x₂ x₃) (natrec-subst x₄ x₅ x₆ d') = ⊥-elim (whnfRedTerm d' sucₙ)
whrDetTerm (natrec-suc x x₁ x₂ x₃) (natrec-suc x₄ x₅ x₆ x₇) = PE.refl
whrDetTerm (Id-subst d x x₁) (Id-subst d' x₂ x₃) rewrite whrDetTerm d d' = PE.refl
whrDetTerm (Id-subst d x x₁) (Id-ℕ-subst d' x₂) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (Id-subst d x x₁) (Id-ℕ-0-subst d') = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (Id-subst d x x₁) (Id-ℕ-S-subst x₂ d') = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (Id-subst d x x₁) (Id-U-subst d' x₂) = ⊥-elim (whnfRedTerm d Uₙ)
whrDetTerm (Id-subst d x x₁) (Id-U-ℕ-subst d') = ⊥-elim (whnfRedTerm d Uₙ)
whrDetTerm (Id-subst d x x₁) (Id-U-Π-subst x₂ x₃ d') = ⊥-elim (whnfRedTerm d Uₙ)
whrDetTerm (Id-subst d x x₁) (Id-Π _ _ x₂ x₃ x₄ x₅) = ⊥-elim (whnfRedTerm d Πₙ)
whrDetTerm (Id-subst d x x₁) (Id-ℕ-00 x₂) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (Id-subst d x x₁) (Id-ℕ-SS x₂ x₃) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (Id-subst d x x₁) (Id-U-ΠΠ x₂ x₃ x₄ x₅) = ⊥-elim (whnfRedTerm d Uₙ)
whrDetTerm (Id-subst d x x₁) (Id-U-ℕℕ x₂) = ⊥-elim (whnfRedTerm d Uₙ)
whrDetTerm (Id-subst d x x₁) (Id-SProp x₂ x₃) = ⊥-elim (whnfRedTerm d Uₙ)
whrDetTerm (Id-subst d x x₁) (Id-ℕ-0S x₂) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (Id-subst d x x₁) (Id-ℕ-S0 x₂) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (Id-subst d x x₁) (Id-U-ℕΠ x₂ x₃) = ⊥-elim (whnfRedTerm d Uₙ)
whrDetTerm (Id-subst d x x₁) (Id-U-Πℕ x₂ x₃) = ⊥-elim (whnfRedTerm d Uₙ)
whrDetTerm (Id-subst d x x₁) (Id-U-ΠΠ!% x₂ x₃ x₄ x₅ x₆) = ⊥-elim (whnfRedTerm d Uₙ)
whrDetTerm (Id-ℕ-subst d x) (Id-subst d' x₁ x₂) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (Id-ℕ-subst d x) (Id-ℕ-subst d' x₁) rewrite whrDetTerm d d' = PE.refl
whrDetTerm (Id-ℕ-subst d x) (Id-ℕ-0-subst d') = ⊥-elim (whnfRedTerm d zeroₙ)
whrDetTerm (Id-ℕ-subst d x) (Id-ℕ-S-subst x₁ d') = ⊥-elim (whnfRedTerm d sucₙ)
whrDetTerm (Id-ℕ-subst d x) (Id-ℕ-00 x₁) = ⊥-elim (whnfRedTerm d zeroₙ)
whrDetTerm (Id-ℕ-subst d x) (Id-ℕ-SS x₁ x₂) = ⊥-elim (whnfRedTerm d sucₙ)
whrDetTerm (Id-ℕ-subst d x) (Id-ℕ-0S x₁) = ⊥-elim (whnfRedTerm d zeroₙ)
whrDetTerm (Id-ℕ-subst d x) (Id-ℕ-S0 x₁) = ⊥-elim (whnfRedTerm d sucₙ)
whrDetTerm (Id-ℕ-0-subst d) (Id-subst d' x x₁) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (Id-ℕ-0-subst d) (Id-ℕ-subst d' x) = ⊥-elim (whnfRedTerm d' zeroₙ)
whrDetTerm (Id-ℕ-0-subst d) (Id-ℕ-0-subst d') rewrite whrDetTerm d d' = PE.refl
whrDetTerm (Id-ℕ-0-subst d) (Id-ℕ-00 x) = ⊥-elim (whnfRedTerm d zeroₙ)
whrDetTerm (Id-ℕ-0-subst d) (Id-ℕ-0S x) = ⊥-elim (whnfRedTerm d sucₙ)
whrDetTerm (Id-ℕ-S-subst x d) (Id-subst d' x₁ x₂) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (Id-ℕ-S-subst x d) (Id-ℕ-subst d' x₁) = ⊥-elim (whnfRedTerm d' sucₙ)
whrDetTerm (Id-ℕ-S-subst x d) (Id-ℕ-S-subst x₁ d') rewrite whrDetTerm d d' = PE.refl
whrDetTerm (Id-ℕ-S-subst x d) (Id-ℕ-SS x₁ x₂) = ⊥-elim (whnfRedTerm d sucₙ)
whrDetTerm (Id-ℕ-S-subst x d) (Id-ℕ-S0 x₁) = ⊥-elim (whnfRedTerm d zeroₙ)
whrDetTerm (Id-U-subst d x) (Id-subst d' x₁ x₂) = ⊥-elim (whnfRedTerm d' Uₙ)
whrDetTerm (Id-U-subst d x) (Id-U-subst d' x₁) rewrite whrDetTerm d d' = PE.refl
whrDetTerm (Id-U-subst d x) (Id-U-ℕ-subst d') = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (Id-U-subst d x) (Id-U-Π-subst x₁ x₂ d') = ⊥-elim (whnfRedTerm d Πₙ)
whrDetTerm (Id-U-subst d x) (Id-U-ΠΠ x₁ x₂ x₃ x₄) = ⊥-elim (whnfRedTerm d Πₙ)
whrDetTerm (Id-U-subst d x) (Id-U-ℕℕ x₁) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (Id-U-subst d x) (Id-U-ℕΠ x₁ x₂) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (Id-U-subst d x) (Id-U-Πℕ x₁ x₂) = ⊥-elim (whnfRedTerm d Πₙ)
whrDetTerm (Id-U-subst d x) (Id-U-ΠΠ!% x₁ x₂ x₃ x₄ x₅) = ⊥-elim (whnfRedTerm d Πₙ)
whrDetTerm (Id-U-ℕ-subst d) (Id-subst d' x x₁) = ⊥-elim (whnfRedTerm d' Uₙ)
whrDetTerm (Id-U-ℕ-subst d) (Id-U-subst d' x) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (Id-U-ℕ-subst d) (Id-U-ℕ-subst d') rewrite whrDetTerm d d' = PE.refl
whrDetTerm (Id-U-ℕ-subst d) (Id-U-ℕℕ x) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (Id-U-ℕ-subst d) (Id-U-ℕΠ x x₁) = ⊥-elim (whnfRedTerm d Πₙ)
whrDetTerm (Id-U-Π-subst x x₁ d) (Id-subst d' x₂ x₃) = ⊥-elim (whnfRedTerm d' Uₙ)
whrDetTerm (Id-U-Π-subst x x₁ d) (Id-U-subst d' x₂) = ⊥-elim (whnfRedTerm d' Πₙ)
whrDetTerm (Id-U-Π-subst x x₁ d) (Id-U-Π-subst x₂ x₃ d') rewrite whrDetTerm d d' = PE.refl
whrDetTerm (Id-U-Π-subst x x₁ d) (Id-U-ΠΠ x₂ x₃ x₄ x₅) = ⊥-elim (whnfRedTerm d Πₙ)
whrDetTerm (Id-U-Π-subst x x₁ d) (Id-U-Πℕ x₂ x₃) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (Id-U-Π-subst x x₁ d) (Id-U-ΠΠ!% x₂ x₃ x₄ x₅ x₆) = ⊥-elim (whnfRedTerm d Πₙ)
whrDetTerm (Id-Π _ _ x x₁ x₂ x₃) (Id-subst d' x₄ x₅) = ⊥-elim (whnfRedTerm d' Πₙ)
whrDetTerm (Id-Π _ _ x x₁ x₂ x₃) (Id-Π _ _ x₄ x₅ x₆ x₇) = PE.refl
whrDetTerm (Id-ℕ-00 x) (Id-subst d' x₁ x₂) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (Id-ℕ-00 x) (Id-ℕ-subst d' x₁) = ⊥-elim (whnfRedTerm d' zeroₙ)
whrDetTerm (Id-ℕ-00 x) (Id-ℕ-0-subst d') = ⊥-elim (whnfRedTerm d' zeroₙ)
whrDetTerm (Id-ℕ-00 x) (Id-ℕ-00 x₁) = PE.refl
whrDetTerm (Id-ℕ-SS x x₁) (Id-subst d' x₂ x₃) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (Id-ℕ-SS x x₁) (Id-ℕ-subst d' x₂) = ⊥-elim (whnfRedTerm d' sucₙ)
whrDetTerm (Id-ℕ-SS x x₁) (Id-ℕ-S-subst x₂ d') = ⊥-elim (whnfRedTerm d' sucₙ)
whrDetTerm (Id-ℕ-SS x x₁) (Id-ℕ-SS x₂ x₃) = PE.refl
whrDetTerm (Id-U-ΠΠ x x₁ x₂ x₃) d' = whrDetTerm-aux2 PE.refl PE.refl d'
whrDetTerm (Id-U-ℕℕ x) (Id-subst d' x₁ x₂) = ⊥-elim (whnfRedTerm d' Uₙ)
whrDetTerm (Id-U-ℕℕ x) (Id-U-subst d' x₁) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (Id-U-ℕℕ x) (Id-U-ℕ-subst d') = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (Id-U-ℕℕ x) (Id-U-ℕℕ x₁) = PE.refl
whrDetTerm (Id-SProp x x₁) (Id-subst d' x₂ x₃) = ⊥-elim (whnfRedTerm d' Uₙ)
whrDetTerm (Id-SProp x x₁) (Id-SProp x₂ x₃) = PE.refl
whrDetTerm (Id-ℕ-0S x) (Id-subst d' x₁ x₂) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (Id-ℕ-0S x) (Id-ℕ-subst d' x₁) = ⊥-elim (whnfRedTerm d' zeroₙ)
whrDetTerm (Id-ℕ-0S x) (Id-ℕ-0-subst d') = ⊥-elim (whnfRedTerm d' sucₙ)
whrDetTerm (Id-ℕ-0S x) (Id-ℕ-0S x₁) = PE.refl
whrDetTerm (Id-ℕ-S0 x) (Id-subst d' x₁ x₂) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (Id-ℕ-S0 x) (Id-ℕ-subst d' x₁) = ⊥-elim (whnfRedTerm d' sucₙ)
whrDetTerm (Id-ℕ-S0 x) (Id-ℕ-S-subst x₁ d') = ⊥-elim (whnfRedTerm d' zeroₙ)
whrDetTerm (Id-ℕ-S0 x) (Id-ℕ-S0 x₁) = PE.refl
whrDetTerm (Id-U-ℕΠ x x₁) (Id-subst d' x₂ x₃) = ⊥-elim (whnfRedTerm d' Uₙ)
whrDetTerm (Id-U-ℕΠ x x₁) (Id-U-subst d' x₂) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (Id-U-ℕΠ x x₁) (Id-U-ℕ-subst d') = ⊥-elim (whnfRedTerm d' Πₙ)
whrDetTerm (Id-U-ℕΠ x x₁) (Id-U-ℕΠ x₂ x₃) = PE.refl
whrDetTerm (Id-U-Πℕ x x₁) (Id-subst d' x₂ x₃) = ⊥-elim (whnfRedTerm d' Uₙ)
whrDetTerm (Id-U-Πℕ x x₁) (Id-U-subst d' x₂) = ⊥-elim (whnfRedTerm d' Πₙ)
whrDetTerm (Id-U-Πℕ x x₁) (Id-U-Π-subst x₂ x₃ d') = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (Id-U-Πℕ x x₁) (Id-U-Πℕ x₂ x₃) = PE.refl
whrDetTerm (Id-U-ΠΠ!% eq A B A' B') (Id-subst d' x x₁) = ⊥-elim (whnfRedTerm d' Uₙ)
whrDetTerm (Id-U-ΠΠ!% eq A B A' B') (Id-U-subst d' x) = ⊥-elim (whnfRedTerm d' Πₙ)
whrDetTerm (Id-U-ΠΠ!% eq A B A' B') (Id-U-Π-subst x x₁ d') = ⊥-elim (whnfRedTerm d' Πₙ)
whrDetTerm (Id-U-ΠΠ!% eq A B A' B') (Id-U-ΠΠ x x₁ x₂ x₃) = ⊥-elim (eq PE.refl)
whrDetTerm (Id-U-ΠΠ!% eq A B A' B') (Id-U-ΠΠ!% x x₁ x₂ x₃ x₄) = PE.refl
whrDetTerm (cast-subst d x x₁ x₂) (cast-subst d' x₃ x₄ x₅) rewrite whrDetTerm d d' = PE.refl
whrDetTerm (cast-subst d x x₁ x₂) (cast-ℕ-subst d' x₃ x₄) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (cast-subst d x x₁ x₂) (cast-Π-subst x₃ x₄ d' x₅ x₆) = ⊥-elim (whnfRedTerm d Πₙ)
whrDetTerm (cast-subst d x x₁ x₂) (cast-Π x₃ x₄ x₅ x₆ x₇ x₈) = ⊥-elim (whnfRedTerm d Πₙ)
whrDetTerm (cast-subst d x x₁ x₂) (cast-ℕ-0 x₃) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (cast-subst d x x₁ x₂) (cast-ℕ-S x₃ x₄) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (cast-ℕ-subst d x x₁) (cast-subst d' x₂ x₃ x₄) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (cast-ℕ-subst d x x₁) (cast-ℕ-subst d' x₂ x₃) rewrite whrDetTerm d d' = PE.refl
whrDetTerm (cast-ℕ-subst d x x₁) (cast-ℕ-0 x₂) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (cast-ℕ-subst d x x₁) (cast-ℕ-S x₂ x₃) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (cast-Π-subst x x₁ d x₂ x₃) (cast-subst d' x₄ x₅ x₆) = ⊥-elim (whnfRedTerm d' Πₙ)
whrDetTerm (cast-Π-subst x x₁ d x₂ x₃) (cast-Π-subst x₄ x₅ d' x₆ x₇) rewrite whrDetTerm d d' = PE.refl
whrDetTerm (cast-Π-subst x x₁ d x₂ x₃) (cast-Π x₄ x₅ x₆ x₇ x₈ x₉) = ⊥-elim (whnfRedTerm d Πₙ)
whrDetTerm (cast-Π x x₁ x₂ x₃ x₄ x₅) d' = whrDetTerm-aux1 (PE.refl) d'
whrDetTerm (cast-ℕ-0 x) (cast-subst d' x₁ x₂ x₃) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (cast-ℕ-0 x) (cast-ℕ-subst d' x₁ x₂) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (cast-ℕ-0 x) (cast-ℕ-0 x₁) = PE.refl
whrDetTerm (cast-ℕ-S x x₁) (cast-subst d' x₂ x₃ x₄) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (cast-ℕ-S x x₁) (cast-ℕ-subst d' x₂ x₃) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (cast-ℕ-S x x₁) (cast-ℕ-S x₂ x₃) = PE.refl
whrDetTerm (cast-ℕ-cong x x₁) (cast-subst d' x₂ x₃ x₄) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (cast-ℕ-cong x x₁) (cast-ℕ-subst d' x₂ x₃) = ⊥-elim (whnfRedTerm d' ℕₙ)
whrDetTerm (cast-ℕ-cong x x₁) (cast-ℕ-cong x₂ x₃) rewrite whrDetTerm x₁ x₃ = PE.refl --
whrDetTerm (cast-subst d x x₁ x₂) (cast-ℕ-cong x₃ d′) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (cast-ℕ-subst d x x₁) (cast-ℕ-cong x₂ d′) = ⊥-elim (whnfRedTerm d ℕₙ)
whrDetTerm (cast-ℕ-0 x) (cast-ℕ-cong x₁ d′) = ⊥-elim (whnfRedTerm d′ zeroₙ)
whrDetTerm (cast-ℕ-S x x₁) (cast-ℕ-cong x₂ d′) = ⊥-elim (whnfRedTerm d′ sucₙ)
whrDetTerm (cast-ℕ-cong x d) (cast-ℕ-0 x₁) = ⊥-elim (whnfRedTerm d zeroₙ)
whrDetTerm (cast-ℕ-cong x d) (cast-ℕ-S x₁ x₂) = ⊥-elim (whnfRedTerm d sucₙ)
{-# CATCHALL #-}
whrDetTerm d (conv d′ x₁) = whrDetTerm d d′
whrDet (univ x) (univ x₁) = whrDetTerm x x₁
whrDet↘Term : ∀{Γ t u A l u′} (d : Γ ⊢ t ↘ u ∷ A ^ l) (d′ : Γ ⊢ t ⇒* u′ ∷ A ^ l)
→ Γ ⊢ u′ ⇒* u ∷ A ^ l
whrDet↘Term (proj₁ , proj₂) (id x) = proj₁
whrDet↘Term (id x , proj₂) (x₁ ⇨ d′) = ⊥-elim (whnfRedTerm x₁ proj₂)
whrDet↘Term (x ⇨ proj₁ , proj₂) (x₁ ⇨ d′) =
whrDet↘Term (PE.subst (λ x₂ → _ ⊢ x₂ ↘ _ ∷ _ ^ _) (whrDetTerm x x₁) (proj₁ , proj₂)) d′
whrDet*Term : ∀{Γ t u A A' l u′ } (d : Γ ⊢ t ↘ u ∷ A ^ l) (d′ : Γ ⊢ t ↘ u′ ∷ A' ^ l) → u PE.≡ u′
whrDet*Term (id x , proj₂) (id x₁ , proj₄) = PE.refl
whrDet*Term (id x , proj₂) (x₁ ⇨ proj₃ , proj₄) = ⊥-elim (whnfRedTerm x₁ proj₂)
whrDet*Term (x ⇨ proj₁ , proj₂) (id x₁ , proj₄) = ⊥-elim (whnfRedTerm x proj₄)
whrDet*Term (x ⇨ proj₁ , proj₂) (x₁ ⇨ proj₃ , proj₄) =
whrDet*Term (proj₁ , proj₂) (PE.subst (λ x₂ → _ ⊢ x₂ ↘ _ ∷ _ ^ _)
(whrDetTerm x₁ x) (proj₃ , proj₄))
whrDet* : ∀{Γ A B B′ r r'} (d : Γ ⊢ A ↘ B ^ r) (d′ : Γ ⊢ A ↘ B′ ^ r') → B PE.≡ B′
whrDet* (id x , proj₂) (id x₁ , proj₄) = PE.refl
whrDet* (id x , proj₂) (x₁ ⇨ proj₃ , proj₄) = ⊥-elim (whnfRed x₁ proj₂)
whrDet* (x ⇨ proj₁ , proj₂) (id x₁ , proj₄) = ⊥-elim (whnfRed x proj₄)
whrDet* (A⇒A′ ⇨ A′⇒*B , whnfB) (A⇒A″ ⇨ A″⇒*B′ , whnfB′) =
whrDet* (A′⇒*B , whnfB) (PE.subst (λ x → _ ⊢ x ↘ _ ^ _ )
(whrDet A⇒A″ A⇒A′)
(A″⇒*B′ , whnfB′))
-- Identity of syntactic reduction
idRed:*: : ∀ {Γ A r} → Γ ⊢ A ^ r → Γ ⊢ A :⇒*: A ^ r
idRed:*: A = [[ A , A , id A ]]
idRedTerm:*: : ∀ {Γ A l t} → Γ ⊢ t ∷ A ^ [ ! , l ] → Γ ⊢ t :⇒*: t ∷ A ^ l
idRedTerm:*: t = [[ t , t , id t ]]
-- U cannot be a term
UnotInA : ∀ {A Γ r r'} → Γ ⊢ (Univ r ¹) ∷ A ^ r' → ⊥
UnotInA (conv U∷U x) = UnotInA U∷U
UnotInA[t] : ∀ {A B t a Γ r r' r'' r'''}
→ t [ a ] PE.≡ (Univ r ¹)
→ Γ ⊢ a ∷ A ^ r'
→ Γ ∙ A ^ r'' ⊢ t ∷ B ^ r'''
→ ⊥
UnotInA[t] () x₁ (univ 0<1 x₂)
UnotInA[t] () x₁ (ℕⱼ x₂)
UnotInA[t] () x₁ (Emptyⱼ x₂)
UnotInA[t] () x₁ (Πⱼ _ ▹ _ ▹ x₂ ▹ x₃)
UnotInA[t] x₁ x₂ (var x₃ here) rewrite x₁ = UnotInA x₂
UnotInA[t] () x₂ (var x₃ (there x₄))
UnotInA[t] () x₁ (lamⱼ _ _ x₂ x₃)
UnotInA[t] () x₁ (x₂ ∘ⱼ x₃)
UnotInA[t] () x₁ (zeroⱼ x₂)
UnotInA[t] () x₁ (sucⱼ x₂)
UnotInA[t] () x₁ (natrecⱼ x₂ x₃ x₄ x₅)
UnotInA[t] () x₁ (Emptyrecⱼ x₂ x₃)
UnotInA[t] x x₁ (conv x₂ x₃) = UnotInA[t] x x₁ x₂
redU*Term′ : ∀ {A B U′ l Γ r} → U′ PE.≡ (Univ r ¹) → Γ ⊢ A ⇒ U′ ∷ B ^ l → ⊥
redU*Term′ U′≡U (conv A⇒U x) = redU*Term′ U′≡U A⇒U
redU*Term′ () (app-subst A⇒U x)
redU*Term′ U′≡U (β-red _ _ x x₁ x₂) = UnotInA[t] U′≡U x₂ x₁
redU*Term′ () (natrec-subst x x₁ x₂ A⇒U)
redU*Term′ U′≡U (natrec-zero x x₁ x₂) rewrite U′≡U = UnotInA x₁
redU*Term′ () (natrec-suc x x₁ x₂ x₃)
redU*Term : ∀ {A B l Γ r} → Γ ⊢ A ⇒* (Univ r ¹) ∷ B ^ l → ⊥
redU*Term (id x) = UnotInA x
redU*Term (x ⇨ A⇒*U) = redU*Term A⇒*U
-- Nothing reduces to U
redU : ∀ {A Γ r l } → Γ ⊢ A ⇒ (Univ r ¹) ^ [ ! , l ] → ⊥
redU (univ x) = redU*Term′ PE.refl x
redU* : ∀ {A Γ r l } → Γ ⊢ A ⇒* (Univ r ¹) ^ [ ! , l ] → A PE.≡ (Univ r ¹)
redU* (id x) = PE.refl
redU* (x ⇨ A⇒*U) rewrite redU* A⇒*U = ⊥-elim (redU x)
-- convertibility for irrelevant terms implies typing
typeInversion : ∀ {t u A l Γ} → Γ ⊢ t ≡ u ∷ A ^ [ % , l ] → Γ ⊢ t ∷ A ^ [ % , l ]
typeInversion (conv X x) = let d = typeInversion X in conv d x
typeInversion (proof-irrelevance x x₁) = x
-- general version of reflexivity, symmetry and transitivity
genRefl : ∀ {A Γ t r l } → Γ ⊢ t ∷ A ^ [ r , l ] → Γ ⊢ t ≡ t ∷ A ^ [ r , l ]
genRefl {r = !} d = refl d
genRefl {r = %} d = proof-irrelevance d d
-- Judgmental instance of the equality relation
genSym : ∀ {k l A Γ r lA } → Γ ⊢ k ≡ l ∷ A ^ [ r , lA ] → Γ ⊢ l ≡ k ∷ A ^ [ r , lA ]
genSym {r = !} = sym
genSym {r = %} (proof-irrelevance x x₁) = proof-irrelevance x₁ x
genSym {r = %} (conv x x₁) = conv (genSym x) x₁
genTrans : ∀ {k l m A r Γ lA } → Γ ⊢ k ≡ l ∷ A ^ [ r , lA ] → Γ ⊢ l ≡ m ∷ A ^ [ r , lA ] → Γ ⊢ k ≡ m ∷ A ^ [ r , lA ]
genTrans {r = !} = trans
genTrans {r = %} (conv X x) (conv Y x₁) = conv (genTrans X (conv Y (trans x₁ (sym x)))) x
genTrans {r = %} (conv X x) (proof-irrelevance x₁ x₂) = proof-irrelevance (conv (typeInversion X) x) x₂
genTrans {r = %} (proof-irrelevance x x₁) (conv Y x₂) = proof-irrelevance x (conv (typeInversion (genSym Y)) x₂)
genTrans {r = %} (proof-irrelevance x x₁) (proof-irrelevance x₂ x₃) = proof-irrelevance x x₃
genVar : ∀ {x A Γ r l } → Γ ⊢ var x ∷ A ^ [ r , l ] → Γ ⊢ var x ≡ var x ∷ A ^ [ r , l ]
genVar {r = !} = refl
genVar {r = %} d = proof-irrelevance d d
toLevelInj : ∀ {l₁ l₁′ : TypeLevel} {l<₁ : l₁′ <∞ l₁} {l₂ l₂′ : TypeLevel} {l<₂ : l₂′ <∞ l₂} →
toLevel l₁′ PE.≡ toLevel l₂′ → l₁′ PE.≡ l₂′
toLevelInj {.(ι ¹)} {.(ι ⁰)} {emb<} {.(ι ¹)} {.(ι ⁰)} {emb<} e = PE.refl
toLevelInj {.∞} {.(ι ¹)} {∞<} {.(ι ¹)} {.(ι ⁰)} {emb<} ()
toLevelInj {.∞} {.(ι ¹)} {∞<} {.∞} {.(ι ¹)} {∞<} e = PE.refl
redSProp′ : ∀ {Γ A B l}
(D : Γ ⊢ A ⇒* B ∷ SProp l ^ next l )
→ Γ ⊢ A ⇒* B ^ [ % , ι l ]
redSProp′ (id x) = id (univ x)
redSProp′ (x ⇨ D) = univ x ⇨ redSProp′ D
redSProp : ∀ {Γ A B l}
(D : Γ ⊢ A :⇒*: B ∷ SProp l ^ next l )
→ Γ ⊢ A :⇒*: B ^ [ % , ι l ]
redSProp [[ ⊢t , ⊢u , d ]] = [[ (univ ⊢t) , (univ ⊢u) , redSProp′ d ]]
un-univ : ∀ {A r Γ l} → Γ ⊢ A ^ [ r , ι l ] → Γ ⊢ A ∷ Univ r l ^ [ ! , next l ]
un-univ (univ x) = x
un-univ≡ : ∀ {A B r Γ l} → Γ ⊢ A ≡ B ^ [ r , ι l ] → Γ ⊢ A ≡ B ∷ Univ r l ^ [ ! , next l ]
un-univ≡ (univ x) = x
un-univ≡ (refl x) = refl (un-univ x)
un-univ≡ (sym X) = sym (un-univ≡ X)
un-univ≡ (trans X Y) = trans (un-univ≡ X) (un-univ≡ Y)
univ-gen : ∀ {r Γ l} → (⊢Γ : ⊢ Γ) → Γ ⊢ Univ r l ^ [ ! , next l ]
univ-gen {l = ⁰} ⊢Γ = univ (univ 0<1 ⊢Γ )
univ-gen {l = ¹} ⊢Γ = Uⱼ ⊢Γ
un-univ⇒ : ∀ {l Γ A B r} → Γ ⊢ A ⇒ B ^ [ r , ι l ] → Γ ⊢ A ⇒ B ∷ Univ r l ^ next l
un-univ⇒ (univ x) = x
univ⇒* : ∀ {l Γ A B r} → Γ ⊢ A ⇒* B ∷ Univ r l ^ next l → Γ ⊢ A ⇒* B ^ [ r , ι l ]
univ⇒* (id x) = id (univ x)
univ⇒* (x ⇨ D) = univ x ⇨ univ⇒* D
un-univ⇒* : ∀ {l Γ A B r} → Γ ⊢ A ⇒* B ^ [ r , ι l ] → Γ ⊢ A ⇒* B ∷ Univ r l ^ next l
un-univ⇒* (id x) = id (un-univ x)
un-univ⇒* (x ⇨ D) = un-univ⇒ x ⇨ un-univ⇒* D
univ:⇒*: : ∀ {l Γ A B r} → Γ ⊢ A :⇒*: B ∷ Univ r l ^ next l → Γ ⊢ A :⇒*: B ^ [ r , ι l ]
univ:⇒*: [[ ⊢A , ⊢B , D ]] = [[ (univ ⊢A) , (univ ⊢B) , (univ⇒* D) ]]
un-univ:⇒*: : ∀ {l Γ A B r} → Γ ⊢ A :⇒*: B ^ [ r , ι l ] → Γ ⊢ A :⇒*: B ∷ Univ r l ^ next l
un-univ:⇒*: [[ ⊢A , ⊢B , D ]] = [[ (un-univ ⊢A) , (un-univ ⊢B) , (un-univ⇒* D) ]]
IdRed*Term′ : ∀ {Γ A B t u l}
(⊢t : Γ ⊢ t ∷ A ^ [ ! , ι l ])
(⊢u : Γ ⊢ u ∷ A ^ [ ! , ι l ])
(D : Γ ⊢ A ⇒* B ^ [ ! , ι l ])
→ Γ ⊢ Id A t u ⇒* Id B t u ∷ SProp l ^ next l
IdRed*Term′ ⊢t ⊢u (id (univ ⊢A)) = id (Idⱼ ⊢A ⊢t ⊢u)
IdRed*Term′ ⊢t ⊢u (univ d ⇨ D) = Id-subst d ⊢t ⊢u ⇨ IdRed*Term′ (conv ⊢t (subset (univ d))) (conv ⊢u (subset (univ d))) D
IdRed*Term : ∀ {Γ A B t u l}
(⊢t : Γ ⊢ t ∷ A ^ [ ! , ι l ])
(⊢u : Γ ⊢ u ∷ A ^ [ ! , ι l ])
(D : Γ ⊢ A :⇒*: B ^ [ ! , ι l ])
→ Γ ⊢ Id A t u :⇒*: Id B t u ∷ SProp l ^ next l
IdRed*Term {Γ} {A} {B} ⊢t ⊢u [[ univ ⊢A , univ ⊢B , D ]] =
[[ Idⱼ ⊢A ⊢t ⊢u , Idⱼ ⊢B (conv ⊢t (subset* D)) (conv ⊢u (subset* D)) ,
IdRed*Term′ ⊢t ⊢u D ]]
IdRed* : ∀ {Γ A B t u l}
(⊢t : Γ ⊢ t ∷ A ^ [ ! , ι l ])
(⊢u : Γ ⊢ u ∷ A ^ [ ! , ι l ])
(D : Γ ⊢ A ⇒* B ^ [ ! , ι l ])
→ Γ ⊢ Id A t u ⇒* Id B t u ^ [ % , ι l ]
IdRed* ⊢t ⊢u (id ⊢A) = id (univ (Idⱼ (un-univ ⊢A) ⊢t ⊢u))
IdRed* ⊢t ⊢u (d ⇨ D) = univ (Id-subst (un-univ⇒ d) ⊢t ⊢u) ⇨ IdRed* (conv ⊢t (subset d)) (conv ⊢u (subset d)) D
CastRed*Term′ : ∀ {Γ A B X e t}
(⊢X : Γ ⊢ X ^ [ ! , ι ⁰ ])
(⊢e : Γ ⊢ e ∷ Id (U ⁰) A X ^ [ % , next ⁰ ])
(⊢t : Γ ⊢ t ∷ A ^ [ ! , ι ⁰ ])
(D : Γ ⊢ A ⇒* B ^ [ ! , ι ⁰ ])
→ Γ ⊢ cast ⁰ A X e t ⇒* cast ⁰ B X e t ∷ X ^ ι ⁰
CastRed*Term′ (univ ⊢X) ⊢e ⊢t (id (univ ⊢A)) = id (castⱼ ⊢A ⊢X ⊢e ⊢t)
CastRed*Term′ (univ ⊢X) ⊢e ⊢t (univ d ⇨ D) = cast-subst d ⊢X ⊢e ⊢t ⇨
CastRed*Term′ (univ ⊢X) (conv ⊢e (univ (Id-cong (refl (univ 0<1 (wfTerm ⊢t))) (subsetTerm d) (refl ⊢X)) )) (conv ⊢t (subset (univ d))) D
CastRed*Term : ∀ {Γ A B X t e}
(⊢X : Γ ⊢ X ^ [ ! , ι ⁰ ])
(⊢e : Γ ⊢ e ∷ Id (U ⁰) A X ^ [ % , next ⁰ ])
(⊢t : Γ ⊢ t ∷ A ^ [ ! , ι ⁰ ])
(D : Γ ⊢ A :⇒*: B ∷ U ⁰ ^ next ⁰)
→ Γ ⊢ cast ⁰ A X e t :⇒*: cast ⁰ B X e t ∷ X ^ ι ⁰
CastRed*Term {Γ} {A} {B} (univ ⊢X) ⊢e ⊢t [[ ⊢A , ⊢B , D ]] =
[[ castⱼ ⊢A ⊢X ⊢e ⊢t , castⱼ ⊢B ⊢X (conv ⊢e (univ (Id-cong (refl (univ 0<1 (wfTerm ⊢t))) (subset*Term D) (refl ⊢X)) )) (conv ⊢t (univ (subset*Term D))) ,
CastRed*Term′ (univ ⊢X) ⊢e ⊢t (univ* D) ]]
CastRed*Termℕ′ : ∀ {Γ A B e t}
(⊢e : Γ ⊢ e ∷ Id (U ⁰) ℕ A ^ [ % , next ⁰ ])
(⊢t : Γ ⊢ t ∷ ℕ ^ [ ! , ι ⁰ ])
(D : Γ ⊢ A ⇒* B ^ [ ! , ι ⁰ ])
→ Γ ⊢ cast ⁰ ℕ A e t ⇒* cast ⁰ ℕ B e t ∷ A ^ ι ⁰
CastRed*Termℕ′ ⊢e ⊢t (id (univ ⊢A)) = id (castⱼ (ℕⱼ (wfTerm ⊢A)) ⊢A ⊢e ⊢t)
CastRed*Termℕ′ ⊢e ⊢t (univ d ⇨ D) = cast-ℕ-subst d ⊢e ⊢t ⇨
conv* (CastRed*Termℕ′ (conv ⊢e (univ (Id-cong (refl (univ 0<1 (wfTerm ⊢e))) (refl (ℕⱼ (wfTerm ⊢e))) (subsetTerm d))) ) ⊢t D)
(sym (subset (univ d)))
CastRed*Termℕ : ∀ {Γ A B e t}
(⊢e : Γ ⊢ e ∷ Id (U ⁰) ℕ A ^ [ % , next ⁰ ])
(⊢t : Γ ⊢ t ∷ ℕ ^ [ ! , ι ⁰ ])
(D : Γ ⊢ A :⇒*: B ^ [ ! , ι ⁰ ])
→ Γ ⊢ cast ⁰ ℕ A e t :⇒*: cast ⁰ ℕ B e t ∷ A ^ ι ⁰
CastRed*Termℕ ⊢e ⊢t [[ ⊢A , ⊢B , D ]] =
[[ castⱼ (ℕⱼ (wfTerm ⊢e)) (un-univ ⊢A) ⊢e ⊢t ,
conv (castⱼ (ℕⱼ (wfTerm ⊢e)) (un-univ ⊢B) (conv ⊢e (univ (Id-cong (refl (univ 0<1 (wfTerm ⊢e))) (refl (ℕⱼ (wfTerm ⊢e))) (subset*Term (un-univ⇒* D))))) ⊢t) (sym (subset* D)) ,
CastRed*Termℕ′ ⊢e ⊢t D ]]
CastRed*Termℕℕ′ : ∀ {Γ e t u}
(⊢e : Γ ⊢ e ∷ Id (U ⁰) ℕ ℕ ^ [ % , next ⁰ ])
(⊢t : Γ ⊢ t ⇒* u ∷ ℕ ^ ι ⁰ )
→ Γ ⊢ cast ⁰ ℕ ℕ e t ⇒* cast ⁰ ℕ ℕ e u ∷ ℕ ^ ι ⁰
CastRed*Termℕℕ′ ⊢e (id ⊢t) = id (castⱼ (ℕⱼ (wfTerm ⊢e)) (ℕⱼ (wfTerm ⊢e)) ⊢e ⊢t)
CastRed*Termℕℕ′ ⊢e (d ⇨ D) = cast-ℕ-cong ⊢e d ⇨ CastRed*Termℕℕ′ ⊢e D
CastRed*Termℕℕ : ∀ {Γ e t u}
(⊢e : Γ ⊢ e ∷ Id (U ⁰) ℕ ℕ ^ [ % , next ⁰ ])
(⊢t : Γ ⊢ t :⇒*: u ∷ ℕ ^ ι ⁰ )
→ Γ ⊢ cast ⁰ ℕ ℕ e t :⇒*: cast ⁰ ℕ ℕ e u ∷ ℕ ^ ι ⁰
CastRed*Termℕℕ ⊢e [[ ⊢t , ⊢u , D ]] =
[[ castⱼ (ℕⱼ (wfTerm ⊢e)) (ℕⱼ (wfTerm ⊢e)) ⊢e ⊢t ,
castⱼ (ℕⱼ (wfTerm ⊢e)) (ℕⱼ (wfTerm ⊢e)) ⊢e ⊢u ,
CastRed*Termℕℕ′ ⊢e D ]]
CastRed*Termℕsuc : ∀ {Γ e n}
(⊢e : Γ ⊢ e ∷ Id (U ⁰) ℕ ℕ ^ [ % , next ⁰ ])
(⊢n : Γ ⊢ n ∷ ℕ ^ [ ! , ι ⁰ ])
→ Γ ⊢ cast ⁰ ℕ ℕ e (suc n) :⇒*: suc (cast ⁰ ℕ ℕ e n) ∷ ℕ ^ ι ⁰
CastRed*Termℕsuc ⊢e ⊢n =
[[ castⱼ (ℕⱼ (wfTerm ⊢e)) (ℕⱼ (wfTerm ⊢e)) ⊢e (sucⱼ ⊢n) ,
sucⱼ (castⱼ (ℕⱼ (wfTerm ⊢e)) (ℕⱼ (wfTerm ⊢e)) ⊢e ⊢n) ,
cast-ℕ-S ⊢e ⊢n ⇨ id (sucⱼ (castⱼ (ℕⱼ (wfTerm ⊢e)) (ℕⱼ (wfTerm ⊢e)) ⊢e ⊢n)) ]]
CastRed*Termℕzero : ∀ {Γ e}
(⊢e : Γ ⊢ e ∷ Id (U ⁰) ℕ ℕ ^ [ % , next ⁰ ])
→ Γ ⊢ cast ⁰ ℕ ℕ e zero :⇒*: zero ∷ ℕ ^ ι ⁰
CastRed*Termℕzero ⊢e =
[[ castⱼ (ℕⱼ (wfTerm ⊢e)) (ℕⱼ (wfTerm ⊢e)) ⊢e (zeroⱼ (wfTerm ⊢e)) ,
zeroⱼ (wfTerm ⊢e) ,
cast-ℕ-0 ⊢e ⇨ id (zeroⱼ (wfTerm ⊢e)) ]]
CastRed*TermΠ′ : ∀ {Γ F rF G A B e t}
(⊢F : Γ ⊢ F ∷ (Univ rF ⁰) ^ [ ! , next ⁰ ])
(⊢G : Γ ∙ F ^ [ rF , ι ⁰ ] ⊢ G ∷ U ⁰ ^ [ ! , next ⁰ ])
(⊢e : Γ ⊢ e ∷ Id (U ⁰) (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) A ^ [ % , next ⁰ ])
(⊢t : Γ ⊢ t ∷ (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) ^ [ ! , ι ⁰ ])
(D : Γ ⊢ A ⇒* B ^ [ ! , ι ⁰ ])
→ Γ ⊢ cast ⁰ (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) A e t ⇒* cast ⁰ (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) B e t ∷ A ^ ι ⁰
CastRed*TermΠ′ ⊢F ⊢G ⊢e ⊢t (id (univ ⊢A)) = id (castⱼ (Πⱼ ≡is≤ PE.refl ▹ ≡is≤ PE.refl ▹ ⊢F ▹ ⊢G) ⊢A ⊢e ⊢t)
CastRed*TermΠ′ ⊢F ⊢G ⊢e ⊢t (univ d ⇨ D) = cast-Π-subst ⊢F ⊢G d ⊢e ⊢t ⇨
conv* (CastRed*TermΠ′ ⊢F ⊢G (conv ⊢e (univ (Id-cong (refl (univ 0<1 (wfTerm ⊢e))) (refl (Πⱼ ≡is≤ PE.refl ▹ ≡is≤ PE.refl ▹ ⊢F ▹ ⊢G)) (subsetTerm d))) ) ⊢t D)
(sym (subset (univ d)))
CastRed*TermΠ : ∀ {Γ F rF G A B e t}
(⊢F : Γ ⊢ F ∷ (Univ rF ⁰) ^ [ ! , next ⁰ ])
(⊢G : Γ ∙ F ^ [ rF , ι ⁰ ] ⊢ G ∷ U ⁰ ^ [ ! , next ⁰ ])
(⊢e : Γ ⊢ e ∷ Id (U ⁰) (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) A ^ [ % , next ⁰ ])
(⊢t : Γ ⊢ t ∷ (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) ^ [ ! , ι ⁰ ])
(D : Γ ⊢ A :⇒*: B ^ [ ! , ι ⁰ ])
→ Γ ⊢ cast ⁰ (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) A e t :⇒*: cast ⁰ (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) B e t ∷ A ^ ι ⁰
CastRed*TermΠ ⊢F ⊢G ⊢e ⊢t [[ ⊢A , ⊢B , D ]] =
let [Π] = Πⱼ ≡is≤ PE.refl ▹ ≡is≤ PE.refl ▹ ⊢F ▹ ⊢G
in [[ castⱼ [Π] (un-univ ⊢A) ⊢e ⊢t ,
conv (castⱼ [Π] (un-univ ⊢B) (conv ⊢e (univ (Id-cong (refl (univ 0<1 (wfTerm ⊢e))) (refl [Π]) (subset*Term (un-univ⇒* D))))) ⊢t) (sym (subset* D)) ,
CastRed*TermΠ′ ⊢F ⊢G ⊢e ⊢t D ]]
IdURed*Term′ : ∀ {Γ t t′ u}
(⊢t : Γ ⊢ t ∷ U ⁰ ^ [ ! , ι ¹ ])
(⊢t′ : Γ ⊢ t′ ∷ U ⁰ ^ [ ! , ι ¹ ])
(d : Γ ⊢ t ⇒* t′ ∷ U ⁰ ^ ι ¹)
(⊢u : Γ ⊢ u ∷ U ⁰ ^ [ ! , ι ¹ ])
→ Γ ⊢ Id (U ⁰) t u ⇒* Id (U ⁰) t′ u ∷ SProp ¹ ^ ∞
IdURed*Term′ ⊢t ⊢t′ (id x) ⊢u = id (Idⱼ (univ 0<1 (wfTerm ⊢t)) ⊢t ⊢u)
IdURed*Term′ ⊢t ⊢t′ (x ⇨ d) ⊢u = _⇨_ (Id-U-subst x ⊢u) (IdURed*Term′ (redFirst*Term d) ⊢t′ d ⊢u)
IdURed*Term : ∀ {Γ t t′ u}
(d : Γ ⊢ t :⇒*: t′ ∷ U ⁰ ^ ι ¹)
(⊢u : Γ ⊢ u ∷ U ⁰ ^ [ ! , ι ¹ ])
→ Γ ⊢ Id (U ⁰) t u :⇒*: Id (U ⁰) t′ u ∷ SProp ¹ ^ ∞
IdURed*Term [[ ⊢t , ⊢t′ , d ]] ⊢u = [[ Idⱼ (univ 0<1 (wfTerm ⊢u)) ⊢t ⊢u , Idⱼ (univ 0<1 (wfTerm ⊢u)) ⊢t′ ⊢u , IdURed*Term′ ⊢t ⊢t′ d ⊢u ]]
IdUΠRed*Term′ : ∀ {Γ F rF G t t′}
(⊢F : Γ ⊢ F ∷ Univ rF ⁰ ^ [ ! , ι ¹ ])
(⊢G : Γ ∙ F ^ [ rF , ι ⁰ ] ⊢ G ∷ U ⁰ ^ [ ! , ι ¹ ])
(⊢t : Γ ⊢ t ∷ U ⁰ ^ [ ! , ι ¹ ])
(⊢t′ : Γ ⊢ t′ ∷ U ⁰ ^ [ ! , ι ¹ ])
(d : Γ ⊢ t ⇒* t′ ∷ U ⁰ ^ ι ¹)
→ Γ ⊢ Id (U ⁰) (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) t ⇒* Id (U ⁰) (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) t′ ∷ SProp ¹ ^ ∞
IdUΠRed*Term′ ⊢F ⊢G ⊢t ⊢t′ (id x) = id (Idⱼ (univ 0<1 (wfTerm ⊢t)) (Πⱼ ≡is≤ PE.refl ▹ ≡is≤ PE.refl ▹ ⊢F ▹ ⊢G) ⊢t)
IdUΠRed*Term′ ⊢F ⊢G ⊢t ⊢t′ (x ⇨ d) = _⇨_ (Id-U-Π-subst ⊢F ⊢G x) (IdUΠRed*Term′ ⊢F ⊢G (redFirst*Term d) ⊢t′ d)
IdUΠRed*Term : ∀ {Γ F rF G t t′}
(⊢F : Γ ⊢ F ∷ Univ rF ⁰ ^ [ ! , ι ¹ ])
(⊢G : Γ ∙ F ^ [ rF , ι ⁰ ] ⊢ G ∷ U ⁰ ^ [ ! , ι ¹ ])
(d : Γ ⊢ t :⇒*: t′ ∷ U ⁰ ^ ι ¹)
→ Γ ⊢ Id (U ⁰) (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) t :⇒*: Id (U ⁰) (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) t′ ∷ SProp ¹ ^ ∞
IdUΠRed*Term ⊢F ⊢G [[ ⊢t , ⊢t′ , d ]] = [[ Idⱼ (univ 0<1 (wfTerm ⊢t)) (Πⱼ ≡is≤ PE.refl ▹ ≡is≤ PE.refl ▹ ⊢F ▹ ⊢G) ⊢t ,
Idⱼ (univ 0<1 (wfTerm ⊢t)) (Πⱼ ≡is≤ PE.refl ▹ ≡is≤ PE.refl ▹ ⊢F ▹ ⊢G) ⊢t′ ,
IdUΠRed*Term′ ⊢F ⊢G ⊢t ⊢t′ d ]]
IdℕRed*Term′ : ∀ {Γ t t′ u}
(⊢t : Γ ⊢ t ∷ ℕ ^ [ ! , ι ⁰ ])
(⊢t′ : Γ ⊢ t′ ∷ ℕ ^ [ ! , ι ⁰ ])
(d : Γ ⊢ t ⇒* t′ ∷ ℕ ^ ι ⁰)
(⊢u : Γ ⊢ u ∷ ℕ ^ [ ! , ι ⁰ ])
→ Γ ⊢ Id ℕ t u ⇒* Id ℕ t′ u ∷ SProp ⁰ ^ next ⁰
IdℕRed*Term′ ⊢t ⊢t′ (id x) ⊢u = id (Idⱼ (ℕⱼ (wfTerm ⊢u)) ⊢t ⊢u)
IdℕRed*Term′ ⊢t ⊢t′ (x ⇨ d) ⊢u = _⇨_ (Id-ℕ-subst x ⊢u) (IdℕRed*Term′ (redFirst*Term d) ⊢t′ d ⊢u)
Idℕ0Red*Term′ : ∀ {Γ t t′}
(⊢t : Γ ⊢ t ∷ ℕ ^ [ ! , ι ⁰ ])
(⊢t′ : Γ ⊢ t′ ∷ ℕ ^ [ ! , ι ⁰ ])
(d : Γ ⊢ t ⇒* t′ ∷ ℕ ^ ι ⁰)
→ Γ ⊢ Id ℕ zero t ⇒* Id ℕ zero t′ ∷ SProp ⁰ ^ next ⁰
Idℕ0Red*Term′ ⊢t ⊢t′ (id x) = id (Idⱼ (ℕⱼ (wfTerm ⊢t)) (zeroⱼ (wfTerm ⊢t)) ⊢t)
Idℕ0Red*Term′ ⊢t ⊢t′ (x ⇨ d) = Id-ℕ-0-subst x ⇨ Idℕ0Red*Term′ (redFirst*Term d) ⊢t′ d
IdℕSRed*Term′ : ∀ {Γ t u u′}
(⊢t : Γ ⊢ t ∷ ℕ ^ [ ! , ι ⁰ ])
(⊢u : Γ ⊢ u ∷ ℕ ^ [ ! , ι ⁰ ])
(⊢u′ : Γ ⊢ u′ ∷ ℕ ^ [ ! , ι ⁰ ])
(d : Γ ⊢ u ⇒* u′ ∷ ℕ ^ ι ⁰)
→ Γ ⊢ Id ℕ (suc t) u ⇒* Id ℕ (suc t) u′ ∷ SProp ⁰ ^ next ⁰
IdℕSRed*Term′ ⊢t ⊢u ⊢u′ (id x) = id (Idⱼ (ℕⱼ (wfTerm ⊢t)) (sucⱼ ⊢t) ⊢u)
IdℕSRed*Term′ ⊢t ⊢u ⊢u′ (x ⇨ d) = Id-ℕ-S-subst ⊢t x ⇨ IdℕSRed*Term′ ⊢t (redFirst*Term d) ⊢u′ d
IdUℕRed*Term′ : ∀ {Γ t t′}
(⊢t : Γ ⊢ t ∷ U ⁰ ^ [ ! , ι ¹ ])
(⊢t′ : Γ ⊢ t′ ∷ U ⁰ ^ [ ! , ι ¹ ])
(d : Γ ⊢ t ⇒* t′ ∷ U ⁰ ^ ι ¹)
→ Γ ⊢ Id (U ⁰) ℕ t ⇒* Id (U ⁰) ℕ t′ ∷ SProp ¹ ^ ∞
IdUℕRed*Term′ ⊢t ⊢t′ (id x) = id (Idⱼ (univ 0<1 (wfTerm ⊢t)) (ℕⱼ (wfTerm ⊢t) ) ⊢t)
IdUℕRed*Term′ ⊢t ⊢t′ (x ⇨ d) = _⇨_ (Id-U-ℕ-subst x) (IdUℕRed*Term′ (redFirst*Term d) ⊢t′ d)
IdUℕRed*Term : ∀ {Γ t t′}
(d : Γ ⊢ t :⇒*: t′ ∷ U ⁰ ^ ι ¹)
→ Γ ⊢ Id (U ⁰) ℕ t :⇒*: Id (U ⁰) ℕ t′ ∷ SProp ¹ ^ ∞
IdUℕRed*Term [[ ⊢t , ⊢t′ , d ]] = [[ Idⱼ (univ 0<1 (wfTerm ⊢t)) (ℕⱼ (wfTerm ⊢t) ) ⊢t ,
Idⱼ (univ 0<1 (wfTerm ⊢t)) (ℕⱼ (wfTerm ⊢t) ) ⊢t′ ,
IdUℕRed*Term′ ⊢t ⊢t′ d ]]
appRed* : ∀ {Γ a t u A B rA lA lB l}
(⊢a : Γ ⊢ a ∷ A ^ [ rA , ι lA ])
(D : Γ ⊢ t ⇒* u ∷ (Π A ^ rA ° lA ▹ B ° lB ° l) ^ ι l)
→ Γ ⊢ t ∘ a ^ l ⇒* u ∘ a ^ l ∷ B [ a ] ^ ι lB
appRed* ⊢a (id x) = id (x ∘ⱼ ⊢a)
appRed* ⊢a (x ⇨ D) = app-subst x ⊢a ⇨ appRed* ⊢a D
castΠRed* : ∀ {Γ F rF G A B e t}
(⊢F : Γ ⊢ F ^ [ rF , ι ⁰ ])
(⊢G : Γ ∙ F ^ [ rF , ι ⁰ ] ⊢ G ^ [ ! , ι ⁰ ])
(⊢e : Γ ⊢ e ∷ Id (U ⁰) (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) A ^ [ % , next ⁰ ])
(⊢t : Γ ⊢ t ∷ Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰ ^ [ ! , ι ⁰ ])
(D : Γ ⊢ A ⇒* B ^ [ ! , ι ⁰ ])
→ Γ ⊢ cast ⁰ (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) A e t ⇒* cast ⁰ (Π F ^ rF ° ⁰ ▹ G ° ⁰ ° ⁰) B e t ∷ A ^ ι ⁰
castΠRed* ⊢F ⊢G ⊢e ⊢t (id (univ ⊢A)) = id (castⱼ (Πⱼ ≡is≤ PE.refl ▹ ≡is≤ PE.refl ▹ un-univ ⊢F ▹ un-univ ⊢G) ⊢A ⊢e ⊢t)
castΠRed* ⊢F ⊢G ⊢e ⊢t ((univ d) ⇨ D) = cast-Π-subst (un-univ ⊢F) (un-univ ⊢G) d ⊢e ⊢t ⇨ conv* (castΠRed* ⊢F ⊢G (conv ⊢e (univ (Id-cong (refl (univ 0<1 (wf ⊢F))) (refl (Πⱼ ≡is≤ PE.refl ▹ ≡is≤ PE.refl ▹ un-univ ⊢F ▹ un-univ ⊢G)) (subsetTerm d)))) ⊢t D) (sym (subset (univ d)))
notredUterm* : ∀ {Γ r l l' A B} → Γ ⊢ Univ r l ⇒ A ∷ B ^ l' → ⊥
notredUterm* (conv D x) = notredUterm* D
notredU* : ∀ {Γ r l l' A} → Γ ⊢ Univ r l ⇒ A ^ [ ! , l' ] → ⊥
notredU* (univ x) = notredUterm* x
redU*gen : ∀ {Γ r l r' l' l''} → Γ ⊢ Univ r l ⇒* Univ r' l' ^ [ ! , l'' ] → Univ r l PE.≡ Univ r' l'
redU*gen (id x) = PE.refl
redU*gen (univ (conv x x₁) ⇨ D) = ⊥-elim (notredUterm* x)
-- Typing of Idsym
Idsymⱼ : ∀ {Γ A l x y e}
→ Γ ⊢ A ∷ U l ^ [ ! , next l ]
→ Γ ⊢ x ∷ A ^ [ ! , ι l ]
→ Γ ⊢ y ∷ A ^ [ ! , ι l ]
→ Γ ⊢ e ∷ Id A x y ^ [ % , ι l ]
→ Γ ⊢ Idsym A x y e ∷ Id A y x ^ [ % , ι l ]
Idsymⱼ {Γ} {A} {l} {x} {y} {e} ⊢A ⊢x ⊢y ⊢e =
let
⊢Γ = wfTerm ⊢A
⊢A = univ ⊢A
⊢P : Γ ∙ A ^ [ ! , ι l ] ⊢ Id (wk1 A) (var 0) (wk1 x) ^ [ % , ι l ]
⊢P = univ (Idⱼ (Twk.wkTerm (Twk.step Twk.id) (⊢Γ ∙ ⊢A) (un-univ ⊢A))
(var (⊢Γ ∙ ⊢A) here)
(Twk.wkTerm (Twk.step Twk.id) (⊢Γ ∙ ⊢A) ⊢x))
⊢refl : Γ ⊢ Idrefl A x ∷ Id (wk1 A) (var 0) (wk1 x) [ x ] ^ [ % , ι l ]
⊢refl = PE.subst₂ (λ X Y → Γ ⊢ Idrefl A x ∷ Id X x Y ^ [ % , ι l ])
(PE.sym (wk1-singleSubst A x)) (PE.sym (wk1-singleSubst x x))
(Idreflⱼ ⊢x)
in PE.subst₂ (λ X Y → Γ ⊢ Idsym A x y e ∷ Id X y Y ^ [ % , ι l ])
(wk1-singleSubst A y) (wk1-singleSubst x y)
(transpⱼ ⊢A ⊢P ⊢x ⊢refl ⊢y ⊢e)
▹▹ⱼ_▹_▹_▹_ : ∀ {Γ F rF lF G lG r l}
→ lF ≤ l
→ lG ≤ l
→ Γ ⊢ F ∷ (Univ rF lF) ^ [ ! , next lF ]
→ Γ ⊢ G ∷ (Univ r lG) ^ [ ! , next lG ]
→ Γ ⊢ F ^ rF ° lF ▹▹ G ° lG ° l ∷ (Univ r l) ^ [ ! , next l ]
▹▹ⱼ lF≤ ▹ lG≤ ▹ F ▹ G = Πⱼ lF≤ ▹ lG≤ ▹ F ▹ un-univ (Twk.wk (Twk.step Twk.id) ((wf (univ F)) ∙ (univ F)) (univ G))
××ⱼ_▹_ : ∀ {Γ F G l}
→ Γ ⊢ F ∷ SProp l ^ [ ! , next l ]
→ Γ ⊢ G ∷ SProp l ^ [ ! , next l ]
→ Γ ⊢ F ×× G ∷ SProp l ^ [ ! , next l ]
××ⱼ F ▹ G = ∃ⱼ F ▹ un-univ (Twk.wk (Twk.step Twk.id) ((wf (univ F)) ∙ (univ F)) (univ G))
|
algebraic-stack_agda0000_doc_8542 | {-# OPTIONS --cubical --safe #-}
module Data.Nat.Properties where
open import Data.Nat.Base
open import Agda.Builtin.Nat using () renaming (_<_ to _<ᴮ_; _==_ to _≡ᴮ_) public
open import Prelude
open import Cubical.Data.Nat using (caseNat; injSuc) public
open import Data.Nat.DivMod
mutual
_-1⊔_ : ℕ → ℕ → ℕ
zero -1⊔ n = n
suc m -1⊔ n = n ⊔ m
_⊔_ : ℕ → ℕ → ℕ
zero ⊔ m = m
suc n ⊔ m = suc (m -1⊔ n)
znots : ∀ {n} → zero ≢ suc n
znots z≡s = subst (caseNat ⊤ ⊥) z≡s tt
snotz : ∀ {n} → suc n ≢ zero
snotz s≡z = subst (caseNat ⊥ ⊤) s≡z tt
pred : ℕ → ℕ
pred (suc n) = n
pred zero = zero
sound-== : ∀ n m → T (n ≡ᴮ m) → n ≡ m
sound-== zero zero p i = zero
sound-== (suc n) (suc m) p i = suc (sound-== n m p i)
complete-== : ∀ n → T (n ≡ᴮ n)
complete-== zero = tt
complete-== (suc n) = complete-== n
open import Relation.Nullary.Discrete.FromBoolean
discreteℕ : Discrete ℕ
discreteℕ = from-bool-eq _≡ᴮ_ sound-== complete-==
isSetℕ : isSet ℕ
isSetℕ = Discrete→isSet discreteℕ
+-suc : ∀ x y → x + suc y ≡ suc (x + y)
+-suc zero y = refl
+-suc (suc x) y = cong suc (+-suc x y)
+-idʳ : ∀ x → x + 0 ≡ x
+-idʳ zero = refl
+-idʳ (suc x) = cong suc (+-idʳ x)
+-comm : ∀ x y → x + y ≡ y + x
+-comm x zero = +-idʳ x
+-comm x (suc y) = +-suc x y ; cong suc (+-comm x y)
infix 4 _<_
_<_ : ℕ → ℕ → Type
n < m = T (n <ᴮ m)
infix 4 _≤ᴮ_
_≤ᴮ_ : ℕ → ℕ → Bool
n ≤ᴮ m = not (m <ᴮ n)
infix 4 _≤_
_≤_ : ℕ → ℕ → Type
n ≤ m = T (n ≤ᴮ m)
infix 4 _≥ᴮ_
_≥ᴮ_ : ℕ → ℕ → Bool
_≥ᴮ_ = flip _≤ᴮ_
+-assoc : ∀ x y z → (x + y) + z ≡ x + (y + z)
+-assoc zero y z i = y + z
+-assoc (suc x) y z i = suc (+-assoc x y z i)
+-*-distrib : ∀ x y z → (x + y) * z ≡ x * z + y * z
+-*-distrib zero y z = refl
+-*-distrib (suc x) y z = cong (z +_) (+-*-distrib x y z) ; sym (+-assoc z (x * z) (y * z))
*-zeroʳ : ∀ x → x * zero ≡ zero
*-zeroʳ zero = refl
*-zeroʳ (suc x) = *-zeroʳ x
*-suc : ∀ x y → x + x * y ≡ x * suc y
*-suc zero y = refl
*-suc (suc x) y = cong suc (sym (+-assoc x y (x * y)) ; cong (_+ x * y) (+-comm x y) ; +-assoc y x (x * y) ; cong (y +_) (*-suc x y))
*-comm : ∀ x y → x * y ≡ y * x
*-comm zero y = sym (*-zeroʳ y)
*-comm (suc x) y = cong (y +_) (*-comm x y) ; *-suc y x
*-assoc : ∀ x y z → (x * y) * z ≡ x * (y * z)
*-assoc zero y z = refl
*-assoc (suc x) y z = +-*-distrib y (x * y) z ; cong (y * z +_) (*-assoc x y z)
open import Data.Nat.DivMod
open import Agda.Builtin.Nat using (div-helper)
div-helper′ : (m n j : ℕ) → ℕ
div-helper′ m zero j = zero
div-helper′ m (suc n) zero = suc (div-helper′ m n m)
div-helper′ m (suc n) (suc j) = div-helper′ m n j
div-helper-lemma : ∀ k m n j → div-helper k m n j ≡ k + div-helper′ m n j
div-helper-lemma k m zero j = sym (+-idʳ k)
div-helper-lemma k m (suc n) zero = div-helper-lemma (suc k) m n m ; sym (+-suc k (div-helper′ m n m))
div-helper-lemma k m (suc n) (suc j) = div-helper-lemma k m n j
Even : ℕ → Type
Even n = T (even n)
odd : ℕ → Bool
odd n = not (rem n 2 ≡ᴮ 0)
Odd : ℕ → Type
Odd n = T (odd n)
s≤s : ∀ n m → n ≤ m → suc n ≤ suc m
s≤s zero m p = tt
s≤s (suc n) m p = p
n≤s : ∀ n m → n ≤ m → n ≤ suc m
n≤s zero m p = tt
n≤s (suc zero) m p = tt
n≤s (suc (suc n)) zero p = p
n≤s (suc (suc n₁)) (suc n) p = n≤s (suc n₁) n p
div-≤ : ∀ n m → n ÷ suc m ≤ n
div-≤ n m = subst (_≤ n) (sym (div-helper-lemma 0 m n m)) (go m n m)
where
go : ∀ m n j → div-helper′ m n j ≤ n
go m zero j = tt
go m (suc n) zero = s≤s (div-helper′ m n m) n (go m n m)
go m (suc n) (suc j) = n≤s (div-helper′ m n j) n (go m n j)
≤-trans : ∀ x y z → x ≤ y → y ≤ z → x ≤ z
≤-trans zero y z p q = tt
≤-trans (suc n) zero zero p q = p
≤-trans (suc zero) zero (suc n) p q = tt
≤-trans (suc (suc n₁)) zero (suc n) p q = ≤-trans (suc n₁) zero n p tt
≤-trans (suc n) (suc zero) zero p q = q
≤-trans (suc zero) (suc zero) (suc n) p q = tt
≤-trans (suc (suc n₁)) (suc zero) (suc n) p q = ≤-trans (suc n₁) zero n p tt
≤-trans (suc n₁) (suc (suc n)) zero p q = q
≤-trans (suc zero) (suc (suc n₁)) (suc n) p q = tt
≤-trans (suc (suc n₁)) (suc (suc n₂)) (suc n) p q = ≤-trans (suc n₁) (suc n₂) n p q
p≤n : ∀ n m → suc n ≤ m → n ≤ m
p≤n zero m p = tt
p≤n (suc n) zero p = p
p≤n (suc zero) (suc n) p = tt
p≤n (suc (suc n₁)) (suc n) p = p≤n (suc n₁) n p
p≤p : ∀ n m → suc n ≤ suc m → n ≤ m
p≤p zero m p = tt
p≤p (suc n) m p = p
≤-refl : ∀ n → n ≤ n
≤-refl zero = tt
≤-refl (suc zero) = tt
≤-refl (suc (suc n)) = ≤-refl (suc n)
linearise : ∀ n m → n ≡ m → n ≡ m
linearise n m n≡m with discreteℕ n m
... | yes p = p
... | no ¬p = ⊥-elim (¬p n≡m)
|
algebraic-stack_agda0000_doc_8543 | ------------------------------------------------------------------------
-- Paths and extensionality
------------------------------------------------------------------------
{-# OPTIONS --erased-cubical --safe #-}
module Equality.Path where
import Bijection
open import Equality hiding (module Derived-definitions-and-properties)
open import Equality.Instances-related
import Equivalence
import Equivalence.Contractible-preimages
import Equivalence.Half-adjoint
import Function-universe
import H-level
import H-level.Closure
open import Logical-equivalence using (_⇔_)
import Preimage
open import Prelude
import Univalence-axiom
------------------------------------------------------------------------
-- The interval
open import Agda.Primitive.Cubical public
using (I; Partial; PartialP)
renaming (i0 to 0̲; i1 to 1̲;
IsOne to Is-one; itIsOne to is-one;
primINeg to -_; primIMin to min; primIMax to max;
primComp to comp; primHComp to hcomp;
primTransp to transport)
open import Agda.Builtin.Cubical.Sub public
renaming (Sub to _[_↦_]; inc to inˢ; primSubOut to outˢ)
------------------------------------------------------------------------
-- Some local generalisable variables
private
variable
a b c p q ℓ : Level
A : Type a
B : A → Type b
P : I → Type p
u v w x y z : A
f g h : (x : A) → B x
i j : I
n : ℕ
------------------------------------------------------------------------
-- Equality
-- Homogeneous and heterogeneous equality.
open import Agda.Builtin.Cubical.Path public
using (_≡_)
renaming (PathP to infix 4 [_]_≡_)
------------------------------------------------------------------------
-- Filling
-- The code in this section is based on code in the cubical library
-- written by Anders Mörtberg.
-- Filling for homogenous composition.
hfill :
{φ : I} (u : I → Partial φ A) (u₀ : A [ φ ↦ u 0̲ ]) →
outˢ u₀ ≡ hcomp u (outˢ u₀)
hfill {φ = φ} u u₀ = λ i →
hcomp (λ j → λ { (φ = 1̲) → u (min i j) is-one
; (i = 0̲) → outˢ u₀
})
(outˢ u₀)
-- Filling for heterogeneous composition.
--
-- Note that if p had been a constant level, then the final line of
-- the type signature could have been replaced by
-- [ P ] outˢ u₀ ≡ comp P u u₀.
fill :
{p : I → Level}
(P : ∀ i → Type (p i)) {φ : I}
(u : ∀ i → Partial φ (P i))
(u₀ : P 0̲ [ φ ↦ u 0̲ ]) →
∀ i → P i
fill P {φ} u u₀ i =
comp (λ j → P (min i j))
(λ j → λ { (φ = 1̲) → u (min i j) is-one
; (i = 0̲) → outˢ u₀
})
(outˢ u₀)
-- Filling for transport.
transport-fill :
(A : Type ℓ)
(φ : I)
(P : (i : I) → Type ℓ [ φ ↦ (λ _ → A) ])
(u₀ : outˢ (P 0̲)) →
[ (λ i → outˢ (P i)) ]
u₀ ≡ transport (λ i → outˢ (P i)) φ u₀
transport-fill _ φ P u₀ i =
transport (λ j → outˢ (P (min i j))) (max (- i) φ) u₀
------------------------------------------------------------------------
-- Path equality satisfies the axioms of Equality-with-J
-- Reflexivity.
refl : {@0 A : Type a} {x : A} → x ≡ x
refl {x = x} = λ _ → x
-- A family of instantiations of Reflexive-relation.
reflexive-relation : ∀ ℓ → Reflexive-relation ℓ
Reflexive-relation._≡_ (reflexive-relation _) = _≡_
Reflexive-relation.refl (reflexive-relation _) = λ _ → refl
-- Symmetry.
hsym : [ P ] x ≡ y → [ (λ i → P (- i)) ] y ≡ x
hsym x≡y = λ i → x≡y (- i)
-- Transitivity.
--
-- The proof htransʳ-reflʳ is based on code in Agda's reference manual
-- written by Anders Mörtberg.
--
-- The proof htrans is suggested in the HoTT book (first version,
-- Exercise 6.1).
htransʳ : [ P ] x ≡ y → y ≡ z → [ P ] x ≡ z
htransʳ {x = x} x≡y y≡z = λ i →
hcomp (λ { _ (i = 0̲) → x
; j (i = 1̲) → y≡z j
})
(x≡y i)
htransˡ : x ≡ y → [ P ] y ≡ z → [ P ] x ≡ z
htransˡ x≡y y≡z = hsym (htransʳ (hsym y≡z) (hsym x≡y))
htransʳ-reflʳ : (x≡y : [ P ] x ≡ y) → htransʳ x≡y refl ≡ x≡y
htransʳ-reflʳ {x = x} {y = y} x≡y = λ i j →
hfill (λ { _ (j = 0̲) → x
; _ (j = 1̲) → y
})
(inˢ (x≡y j))
(- i)
htransˡ-reflˡ : (x≡y : [ P ] x ≡ y) → htransˡ refl x≡y ≡ x≡y
htransˡ-reflˡ = htransʳ-reflʳ
htrans :
{x≡y : x ≡ y} {y≡z : y ≡ z}
(P : A → Type p) {p : P x} {q : P y} {r : P z} →
[ (λ i → P (x≡y i)) ] p ≡ q →
[ (λ i → P (y≡z i)) ] q ≡ r →
[ (λ i → P (htransˡ x≡y y≡z i)) ] p ≡ r
htrans {z = z} {x≡y = x≡y} {y≡z = y≡z} P {r = r} p≡q q≡r = λ i →
comp (λ j → P (eq j i))
(λ { j (i = 0̲) → p≡q (- j)
; j (i = 1̲) → r
})
(q≡r i)
where
eq : [ (λ i → x≡y (- i) ≡ z) ] y≡z ≡ htransˡ x≡y y≡z
eq = λ i j →
hfill (λ { i (j = 0̲) → x≡y (- i)
; _ (j = 1̲) → z
})
(inˢ (y≡z j))
i
-- Some equational reasoning combinators.
infix -1 finally finally-h
infixr -2 step-≡ step-≡h step-≡hh _≡⟨⟩_
step-≡ : ∀ x → [ P ] y ≡ z → x ≡ y → [ P ] x ≡ z
step-≡ _ = flip htransˡ
syntax step-≡ x y≡z x≡y = x ≡⟨ x≡y ⟩ y≡z
step-≡h : ∀ x → y ≡ z → [ P ] x ≡ y → [ P ] x ≡ z
step-≡h _ = flip htransʳ
syntax step-≡h x y≡z x≡y = x ≡⟨ x≡y ⟩h y≡z
step-≡hh :
{x≡y : x ≡ y} {y≡z : y ≡ z}
(P : A → Type p) (p : P x) {q : P y} {r : P z} →
[ (λ i → P (y≡z i)) ] q ≡ r →
[ (λ i → P (x≡y i)) ] p ≡ q →
[ (λ i → P (htransˡ x≡y y≡z i)) ] p ≡ r
step-≡hh P _ = flip (htrans P)
syntax step-≡hh P p q≡r p≡q = p ≡⟨ p≡q ⟩[ P ] q≡r
_≡⟨⟩_ : ∀ x → [ P ] x ≡ y → [ P ] x ≡ y
_ ≡⟨⟩ x≡y = x≡y
finally : (x y : A) → x ≡ y → x ≡ y
finally _ _ x≡y = x≡y
syntax finally x y x≡y = x ≡⟨ x≡y ⟩∎ y ∎
finally-h : ∀ x y → [ P ] x ≡ y → [ P ] x ≡ y
finally-h _ _ x≡y = x≡y
syntax finally-h x y x≡y = x ≡⟨ x≡y ⟩∎h y ∎
-- The J rule.
elim :
(P : {x y : A} → x ≡ y → Type p) →
(∀ x → P (refl {x = x})) →
(x≡y : x ≡ y) → P x≡y
elim {x = x} P p x≡y =
transport (λ i → P (λ j → x≡y (min i j))) 0̲ (p x)
-- Substitutivity.
hsubst :
∀ (Q : ∀ {i} → P i → Type q) →
[ P ] x ≡ y → Q x → Q y
hsubst Q x≡y p = transport (λ i → Q (x≡y i)) 0̲ p
subst : (P : A → Type p) → x ≡ y → P x → P y
subst P = hsubst P
-- Congruence.
--
-- The heterogeneous variant is based on code in the cubical library
-- written by Anders Mörtberg.
hcong :
(f : (x : A) → B x) (x≡y : x ≡ y) →
[ (λ i → B (x≡y i)) ] f x ≡ f y
hcong f x≡y = λ i → f (x≡y i)
cong : {B : Type b} (f : A → B) → x ≡ y → f x ≡ f y
cong f = hcong f
dcong :
(f : (x : A) → B x) (x≡y : x ≡ y) →
subst B x≡y (f x) ≡ f y
dcong {B = B} f x≡y = λ i →
transport (λ j → B (x≡y (max i j))) i (f (x≡y i))
-- Transporting along reflexivity amounts to doing nothing.
--
-- This definition is based on code in Agda's reference manual written
-- by Anders Mörtberg.
transport-refl : ∀ i → transport (λ i → refl {x = A} i) i ≡ id
transport-refl {A = A} i = λ j → transport (λ _ → A) (max i j)
-- A family of instantiations of Equivalence-relation⁺.
--
-- Note that htransˡ is used to implement trans. The reason htransˡ is
-- used, rather than htransʳ, is that htransˡ is also used to
-- implement the commonly used equational reasoning combinator step-≡,
-- and I'd like this combinator to match trans.
equivalence-relation⁺ : ∀ ℓ → Equivalence-relation⁺ ℓ
equivalence-relation⁺ _ = λ where
.Equivalence-relation⁺.reflexive-relation → reflexive-relation _
.Equivalence-relation⁺.sym → hsym
.Equivalence-relation⁺.sym-refl → refl
.Equivalence-relation⁺.trans → htransˡ
.Equivalence-relation⁺.trans-refl-refl → htransˡ-reflˡ _
-- A family of instantiations of Equality-with-J₀.
equality-with-J₀ : Equality-with-J₀ a p reflexive-relation
Equality-with-J₀.elim equality-with-J₀ = elim
Equality-with-J₀.elim-refl equality-with-J₀ = λ _ r →
cong (_$ r _) $ transport-refl 0̲
private
module Temporarily-local where
-- A family of instantiations of Equality-with-J.
equality-with-J : Equality-with-J a p equivalence-relation⁺
equality-with-J = λ where
.Equality-with-J.equality-with-J₀ → equality-with-J₀
.Equality-with-J.cong → cong
.Equality-with-J.cong-refl → λ _ → refl
.Equality-with-J.subst → subst
.Equality-with-J.subst-refl → λ _ p →
cong (_$ p) $ transport-refl 0̲
.Equality-with-J.dcong → dcong
.Equality-with-J.dcong-refl → λ _ → refl
-- Various derived definitions and properties.
open Equality.Derived-definitions-and-properties
Temporarily-local.equality-with-J public
hiding (_≡_; refl; elim; subst; cong; dcong;
step-≡; _≡⟨⟩_; finally;
reflexive-relation; equality-with-J₀)
------------------------------------------------------------------------
-- An extended variant of Equality-with-J
-- The following variant of Equality-with-J includes functions mapping
-- equalities to and from paths. The purpose of this definition is to
-- make it possible to instantiate these functions with identity
-- functions when paths are used as equalities (see
-- equality-with-paths below).
record Equality-with-paths
a b (e⁺ : ∀ ℓ → Equivalence-relation⁺ ℓ) :
Type (lsuc (a ⊔ b)) where
field
equality-with-J : Equality-with-J a b e⁺
private
module R =
Reflexive-relation
(Equivalence-relation⁺.reflexive-relation (e⁺ a))
field
-- A bijection between equality at level a and paths.
to-path : x R.≡ y → x ≡ y
from-path : x ≡ y → x R.≡ y
to-path∘from-path : (x≡y : x ≡ y) → to-path (from-path x≡y) R.≡ x≡y
from-path∘to-path :
(x≡y : x R.≡ y) → from-path (to-path x≡y) R.≡ x≡y
-- The bijection maps reflexivity to reflexivity.
to-path-refl : to-path (R.refl x) R.≡ refl
from-path-refl : from-path refl R.≡ R.refl x
-- A family of instantiations of Equality-with-paths.
equality-with-paths :
Equality-with-paths a p equivalence-relation⁺
equality-with-paths = λ where
.E.equality-with-J → Temporarily-local.equality-with-J
.E.to-path → id
.E.from-path → id
.E.to-path∘from-path → λ _ → refl
.E.from-path∘to-path → λ _ → refl
.E.to-path-refl → refl
.E.from-path-refl → refl
where
module E = Equality-with-paths
-- Equality-with-paths (for arbitrary universe levels) can be derived
-- from Equality-with-J (for arbitrary universe levels).
Equality-with-J⇒Equality-with-paths :
∀ {e⁺} →
(∀ {a p} → Equality-with-J a p e⁺) →
(∀ {a p} → Equality-with-paths a p e⁺)
Equality-with-J⇒Equality-with-paths eq = λ where
.E.equality-with-J → eq
.E.to-path → B._↔_.to (proj₁ ≡↔≡′)
.E.from-path → B._↔_.from (proj₁ ≡↔≡′)
.E.to-path∘from-path → B._↔_.right-inverse-of (proj₁ ≡↔≡′)
.E.from-path∘to-path → B._↔_.left-inverse-of (proj₁ ≡↔≡′)
.E.to-path-refl → B._↔_.from (proj₁ ≡↔≡′) (proj₁ (proj₂ ≡↔≡′))
.E.from-path-refl → proj₂ (proj₂ ≡↔≡′)
where
module E = Equality-with-paths
module B = Bijection eq
≡↔≡′ =
all-equality-types-isomorphic eq Temporarily-local.equality-with-J
-- Equality-with-paths (for arbitrary universe levels) can be derived
-- from Equality-with-J₀ (for arbitrary universe levels).
Equality-with-J₀⇒Equality-with-paths :
∀ {reflexive} →
(eq : ∀ {a p} → Equality-with-J₀ a p reflexive) →
∀ {a p} → Equality-with-paths a p (λ _ → J₀⇒Equivalence-relation⁺ eq)
Equality-with-J₀⇒Equality-with-paths eq =
Equality-with-J⇒Equality-with-paths (J₀⇒J eq)
module Derived-definitions-and-properties
{e⁺}
(equality-with-paths : ∀ {a p} → Equality-with-paths a p e⁺)
where
private
module EP {a} {p} =
Equality-with-paths (equality-with-paths {a = a} {p = p})
open EP public using (equality-with-J)
private
module E =
Equality.Derived-definitions-and-properties
equality-with-J
open Bijection equality-with-J
≡↔≡ : {A : Type a} {x y : A} → x E.≡ y ↔ x ≡ y
≡↔≡ {a = a} = record
{ surjection = record
{ logical-equivalence = record
{ to = EP.to-path {p = a}
; from = EP.from-path
}
; right-inverse-of = EP.to-path∘from-path
}
; left-inverse-of = EP.from-path∘to-path
}
-- The isomorphism maps reflexivity to reflexivity.
to-≡↔≡-refl : _↔_.to ≡↔≡ (E.refl x) E.≡ refl
to-≡↔≡-refl = EP.to-path-refl
from-≡↔≡-refl : _↔_.from ≡↔≡ refl E.≡ E.refl x
from-≡↔≡-refl = EP.from-path-refl
open E public
open Temporarily-local public
------------------------------------------------------------------------
-- Extensionality
open Equivalence equality-with-J using (Is-equivalence)
open H-level.Closure equality-with-J using (ext⁻¹)
-- Extensionality.
ext : Extensionality a b
apply-ext ext f≡g = λ i x → f≡g x i
⟨ext⟩ : Extensionality′ A B
⟨ext⟩ = apply-ext ext
-- The function ⟨ext⟩ is an equivalence.
ext-is-equivalence : Is-equivalence {A = ∀ x → f x ≡ g x} ⟨ext⟩
ext-is-equivalence =
ext⁻¹
, (λ _ → refl)
, (λ _ → refl)
, (λ _ → refl)
private
-- Equality rearrangement lemmas for ⟨ext⟩. All of these lemmas hold
-- definitionally.
ext-refl : ⟨ext⟩ (λ x → refl {x = f x}) ≡ refl
ext-refl = refl
ext-const :
(x≡y : x ≡ y) →
⟨ext⟩ (const {B = A} x≡y) ≡ cong const x≡y
ext-const _ = refl
cong-ext :
(f≡g : ∀ x → f x ≡ g x) →
cong (_$ x) (⟨ext⟩ f≡g) ≡ f≡g x
cong-ext _ = refl
subst-ext :
∀ {p} (f≡g : ∀ x → f x ≡ g x) →
subst (λ f → B (f x)) (⟨ext⟩ f≡g) p ≡ subst B (f≡g x) p
subst-ext _ = refl
elim-ext :
{f g : (x : A) → B x}
(P : B x → B x → Type p)
(p : (y : B x) → P y y)
(f≡g : ∀ x → f x ≡ g x) →
elim (λ {f g} _ → P (f x) (g x)) (p ∘ (_$ x)) (⟨ext⟩ f≡g) ≡
elim (λ {x y} _ → P x y) p (f≡g x)
elim-ext _ _ _ = refl
-- I based the statements of the following three lemmas on code in
-- the Lean Homotopy Type Theory Library with Jakob von Raumer and
-- Floris van Doorn listed as authors. The file was claimed to have
-- been ported from the Coq HoTT library. (The third lemma has later
-- been generalised.)
ext-sym :
(f≡g : ∀ x → f x ≡ g x) →
⟨ext⟩ (sym ∘ f≡g) ≡ sym (⟨ext⟩ f≡g)
ext-sym _ = refl
ext-trans :
(f≡g : ∀ x → f x ≡ g x) (g≡h : ∀ x → g x ≡ h x) →
⟨ext⟩ (λ x → trans (f≡g x) (g≡h x)) ≡
trans (⟨ext⟩ f≡g) (⟨ext⟩ g≡h)
ext-trans _ _ = refl
cong-post-∘-ext :
{B : A → Type b} {C : A → Type c} {f g : (x : A) → B x}
{h : ∀ {x} → B x → C x}
(f≡g : ∀ x → f x ≡ g x) →
cong (h ∘_) (⟨ext⟩ f≡g) ≡ ⟨ext⟩ (cong h ∘ f≡g)
cong-post-∘-ext _ = refl
cong-pre-∘-ext :
{B : Type b} {C : B → Type c} {f g : (x : B) → C x} {h : A → B}
(f≡g : ∀ x → f x ≡ g x) →
cong (_∘ h) (⟨ext⟩ f≡g) ≡ ⟨ext⟩ (f≡g ∘ h)
cong-pre-∘-ext _ = refl
------------------------------------------------------------------------
-- Some properties
open Bijection equality-with-J using (_↔_)
open Function-universe equality-with-J hiding (id; _∘_)
open H-level equality-with-J
open Univalence-axiom equality-with-J
-- There is a dependent path from reflexivity for x to any dependent
-- path starting in x.
refl≡ :
(x≡y : [ P ] x ≡ y) →
[ (λ i → [ (λ j → P (min i j)) ] x ≡ x≡y i) ] refl {x = x} ≡ x≡y
refl≡ x≡y = λ i j → x≡y (min i j)
-- Transporting in one direction and then back amounts to doing
-- nothing.
transport∘transport :
∀ {p : I → Level} (P : ∀ i → Type (p i)) {p} →
transport (λ i → P (- i)) 0̲ (transport P 0̲ p) ≡ p
transport∘transport P {p} = hsym λ i →
comp (λ j → P (min i (- j)))
(λ j → λ { (i = 0̲) → p
; (i = 1̲) → transport (λ k → P (- min j k)) (- j)
(transport P 0̲ p)
})
(transport (λ j → P (min i j)) (- i) p)
-- One form of transporting can be expressed using trans and sym.
transport-≡ :
{p : x ≡ y} {q : u ≡ v} (r : x ≡ u) →
transport (λ i → p i ≡ q i) 0̲ r ≡
trans (sym p) (trans r q)
transport-≡ {x = x} {p = p} {q = q} r = elim¹
(λ p → transport (λ i → p i ≡ q i) 0̲ r ≡
trans (sym p) (trans r q))
(transport (λ i → x ≡ q i) 0̲ r ≡⟨⟩
subst (x ≡_) q r ≡⟨ sym trans-subst ⟩
trans r q ≡⟨ sym $ trans-reflˡ _ ⟩
trans refl (trans r q) ≡⟨⟩
trans (sym refl) (trans r q) ∎)
p
-- The function htrans {x≡y = x≡y} {y≡z = y≡z} (const A) is pointwise
-- equal to trans.
--
-- Andrea Vezzosi helped me with this proof.
htrans-const :
(x≡y : x ≡ y) (y≡z : y ≡ z) (p : u ≡ v) {q : v ≡ w} →
htrans {x≡y = x≡y} {y≡z = y≡z} (const A) p q ≡ trans p q
htrans-const {A = A} {w = w} _ _ p {q = q} =
(λ i → comp (λ _ → A) (s i) (q i)) ≡⟨⟩
(λ i →
hcomp (λ j x → transport (λ _ → A) j (s i j x))
(transport (λ _ → A) 0̲ (q i))) ≡⟨ (λ k i → hcomp (λ j x → cong (_$ s i j x) (transport-refl j) k)
(cong (_$ q i) (transport-refl 0̲) k)) ⟩∎
(λ i → hcomp (s i) (q i)) ∎
where
s : ∀ i j → Partial (max i (- i)) A
s i = λ where
j (i = 0̲) → p (- j)
_ (i = 1̲) → w
-- The following two lemmas are due to Anders Mörtberg.
--
-- Previously Andrea Vezzosi and I had each proved the second lemma in
-- much more convoluted ways (starting from a logical equivalence
-- proved by Anders; I had also gotten some useful hints from Andrea
-- for my proof).
-- Heterogeneous equality can be expressed in terms of homogeneous
-- equality.
heterogeneous≡homogeneous :
{P : I → Type p} {p : P 0̲} {q : P 1̲} →
([ P ] p ≡ q) ≡ (transport P 0̲ p ≡ q)
heterogeneous≡homogeneous {P = P} {p = p} {q = q} = λ i →
[ (λ j → P (max i j)) ] transport (λ j → P (min i j)) (- i) p ≡ q
-- A variant of the previous lemma.
heterogeneous↔homogeneous :
(P : I → Type p) {p : P 0̲} {q : P 1̲} →
([ P ] p ≡ q) ↔ transport P 0̲ p ≡ q
heterogeneous↔homogeneous P =
subst
([ P ] _ ≡ _ ↔_)
heterogeneous≡homogeneous
(Bijection.id equality-with-J)
-- The function dcong is pointwise equal to an expression involving
-- hcong.
dcong≡hcong :
{B : A → Type b} {x≡y : x ≡ y} (f : (x : A) → B x) →
dcong f x≡y ≡
_↔_.to (heterogeneous↔homogeneous (λ i → B (x≡y i))) (hcong f x≡y)
dcong≡hcong {B = B} {x≡y = x≡y} f = elim
(λ x≡y →
dcong f x≡y ≡
_↔_.to (heterogeneous↔homogeneous (λ i → B (x≡y i))) (hcong f x≡y))
(λ x →
dcong f (refl {x = x}) ≡⟨⟩
(λ i → transport (λ _ → B x) i (f x)) ≡⟨ (λ i → comp
(λ j → transport (λ _ → B x) (- j) (f x) ≡ f x)
(λ { j (i = 0̲) → (λ k → transport (λ _ → B x) (max k (- j)) (f x))
; j (i = 1̲) → transport
(λ k → transport (λ _ → B x) (- min k j) (f x) ≡ f x)
0̲ refl
})
(transport (λ _ → f x ≡ f x) (- i) refl)) ⟩
transport (λ i → transport (λ _ → B x) (- i) (f x) ≡ f x) 0̲ refl ≡⟨ cong (transport (λ i → transport (λ _ → B x) (- i) (f x) ≡ f x) 0̲ ∘
(_$ refl)) $ sym $
transport-refl 0̲ ⟩
transport (λ i → transport (λ _ → B x) (- i) (f x) ≡ f x) 0̲
(transport (λ _ → f x ≡ f x) 0̲ refl) ≡⟨⟩
_↔_.to (heterogeneous↔homogeneous (λ i → B (refl {x = x} i)))
(hcong f (refl {x = x})) ∎)
x≡y
-- A "computation" rule.
from-heterogeneous↔homogeneous-const-refl :
(B : A → Type b) {x : A} {y : B x} →
_↔_.from (heterogeneous↔homogeneous λ _ → B x) refl ≡
sym (subst-refl B y)
from-heterogeneous↔homogeneous-const-refl B {x = x} {y = y} =
transport (λ _ → y ≡ transport (λ _ → B x) 0̲ y) 0̲
(transport
(λ i → transport (λ _ → B x) i y ≡ transport (λ _ → B x) 0̲ y) 0̲
(λ _ → transport (λ _ → B x) 0̲ y)) ≡⟨ cong (_$ transport
(λ i → transport (λ _ → B x) i y ≡
transport (λ _ → B x) 0̲ y) 0̲
(λ _ → transport (λ _ → B x) 0̲ y)) $
transport-refl 0̲ ⟩
transport
(λ i → transport (λ _ → B x) i y ≡ transport (λ _ → B x) 0̲ y) 0̲
(λ _ → transport (λ _ → B x) 0̲ y) ≡⟨ transport-≡ (λ _ → transport (λ _ → B x) 0̲ y) ⟩
trans (λ i → transport (λ _ → B x) (- i) y)
(trans (λ _ → transport (λ _ → B x) 0̲ y)
(λ _ → transport (λ _ → B x) 0̲ y)) ≡⟨ cong (trans (λ i → transport (λ _ → B x) (- i) y)) $
trans-symʳ (λ _ → transport (λ _ → B x) 0̲ y) ⟩
trans (λ i → transport (λ _ → B x) (- i) y) refl ≡⟨ trans-reflʳ _ ⟩∎
(λ i → transport (λ _ → B x) (- i) y) ∎
-- A direct proof of something with the same type as Σ-≡,≡→≡.
Σ-≡,≡→≡′ :
{p₁ p₂ : Σ A B} →
(p : proj₁ p₁ ≡ proj₁ p₂) →
subst B p (proj₂ p₁) ≡ proj₂ p₂ →
p₁ ≡ p₂
Σ-≡,≡→≡′ {B = B} {p₁ = _ , y₁} {p₂ = _ , y₂} p q i =
p i , lemma i
where
lemma : [ (λ i → B (p i)) ] y₁ ≡ y₂
lemma = _↔_.from (heterogeneous↔homogeneous _) q
-- Σ-≡,≡→≡ is pointwise equal to Σ-≡,≡→≡′.
Σ-≡,≡→≡≡Σ-≡,≡→≡′ :
{B : A → Type b}
{p₁ p₂ : Σ A B}
{p : proj₁ p₁ ≡ proj₁ p₂}
{q : subst B p (proj₂ p₁) ≡ proj₂ p₂} →
Σ-≡,≡→≡ {B = B} p q ≡ Σ-≡,≡→≡′ p q
Σ-≡,≡→≡≡Σ-≡,≡→≡′ {B = B} {p₁ = p₁} {p₂ = p₂} {p = p} {q = q} =
elim₁
(λ p →
∀ {p₁₂} (q : subst B p p₁₂ ≡ proj₂ p₂) →
Σ-≡,≡→≡ p q ≡ Σ-≡,≡→≡′ p q)
(λ q →
Σ-≡,≡→≡ refl q ≡⟨ Σ-≡,≡→≡-reflˡ q ⟩
cong (_ ,_) (trans (sym $ subst-refl B _) q) ≡⟨ cong (cong (_ ,_)) $
elim¹
(λ q →
trans (sym $ subst-refl B _) q ≡
_↔_.from (heterogeneous↔homogeneous _) q)
(
trans (sym $ subst-refl B _) refl ≡⟨ trans-reflʳ _ ⟩
sym (subst-refl B _) ≡⟨ sym $ from-heterogeneous↔homogeneous-const-refl B ⟩∎
_↔_.from (heterogeneous↔homogeneous _) refl ∎)
q ⟩
cong (_ ,_) (_↔_.from (heterogeneous↔homogeneous _) q) ≡⟨⟩
Σ-≡,≡→≡′ refl q ∎)
p q
-- All instances of an interval-indexed family are equal.
index-irrelevant : (P : I → Type p) → P i ≡ P j
index-irrelevant {i = i} {j = j} P =
λ k → P (max (min i (- k)) (min j k))
-- Positive h-levels of P i can be expressed in terms of the h-levels
-- of dependent paths over P.
H-level-suc↔H-level[]≡ :
{P : I → Type p} →
H-level (suc n) (P i) ↔ (∀ x y → H-level n ([ P ] x ≡ y))
H-level-suc↔H-level[]≡ {n = n} {i = i} {P = P} =
H-level (suc n) (P i) ↝⟨ H-level-cong ext _ (≡⇒≃ $ index-irrelevant P) ⟩
H-level (suc n) (P 1̲) ↝⟨ inverse $ ≡↔+ _ ext ⟩
((x y : P 1̲) → H-level n (x ≡ y)) ↝⟨ (Π-cong ext (≡⇒≃ $ index-irrelevant P) λ x → ∀-cong ext λ _ →
≡⇒↝ _ $ cong (λ x → H-level _ (x ≡ _)) (
x ≡⟨ sym $ transport∘transport (λ i → P (- i)) ⟩
transport P 0̲ (transport (λ i → P (- i)) 0̲ x) ≡⟨ cong (λ f → transport P 0̲ (transport (λ i → P (- i)) 0̲ (f x))) $ sym $
transport-refl 0̲ ⟩∎
transport P 0̲
(transport (λ i → P (- i)) 0̲ (transport (λ _ → P 1̲) 0̲ x)) ∎)) ⟩
((x : P 0̲) (y : P 1̲) → H-level n (transport P 0̲ x ≡ y)) ↝⟨ (∀-cong ext λ x → ∀-cong ext λ y → H-level-cong ext n $ inverse $
heterogeneous↔homogeneous P) ⟩□
((x : P 0̲) (y : P 1̲) → H-level n ([ P ] x ≡ y)) □
private
-- A simple lemma used below.
H-level-suc→H-level[]≡ :
∀ n → H-level (1 + n) (P 0̲) → H-level n ([ P ] x ≡ y)
H-level-suc→H-level[]≡ {P = P} {x = x} {y = y} n =
H-level (1 + n) (P 0̲) ↔⟨ H-level-suc↔H-level[]≡ ⟩
(∀ x y → H-level n ([ P ] x ≡ y)) ↝⟨ (λ f → f _ _) ⟩□
H-level n ([ P ] x ≡ y) □
-- A form of proof irrelevance for paths that are propositional at one
-- end-point.
heterogeneous-irrelevance₀ :
Is-proposition (P 0̲) → [ P ] x ≡ y
heterogeneous-irrelevance₀ {P = P} {x = x} {y = y} =
Is-proposition (P 0̲) ↝⟨ H-level-suc→H-level[]≡ _ ⟩
Contractible ([ P ] x ≡ y) ↝⟨ proj₁ ⟩□
[ P ] x ≡ y □
-- A form of UIP for squares that are sets on one corner.
heterogeneous-UIP₀₀ :
{P : I → I → Type p}
{x : ∀ i → P i 0̲} {y : ∀ i → P i 1̲}
{p : [ (λ j → P 0̲ j) ] x 0̲ ≡ y 0̲}
{q : [ (λ j → P 1̲ j) ] x 1̲ ≡ y 1̲} →
Is-set (P 0̲ 0̲) →
[ (λ i → [ (λ j → P i j) ] x i ≡ y i) ] p ≡ q
heterogeneous-UIP₀₀ {P = P} {x = x} {y = y} {p = p} {q = q} =
Is-set (P 0̲ 0̲) ↝⟨ H-level-suc→H-level[]≡ 1 ⟩
Is-proposition ([ (λ j → P 0̲ j) ] x 0̲ ≡ y 0̲) ↝⟨ H-level-suc→H-level[]≡ _ ⟩
Contractible ([ (λ i → [ (λ j → P i j) ] x i ≡ y i) ] p ≡ q) ↝⟨ proj₁ ⟩□
[ (λ i → [ (λ j → P i j) ] x i ≡ y i) ] p ≡ q □
-- A variant of heterogeneous-UIP₀₀, "one level up".
heterogeneous-UIP₃₀₀ :
{P : I → I → I → Type p}
{x : ∀ i j → P i j 0̲} {y : ∀ i j → P i j 1̲}
{p : ∀ i → [ (λ k → P i 0̲ k) ] x i 0̲ ≡ y i 0̲}
{q : ∀ i → [ (λ k → P i 1̲ k) ] x i 1̲ ≡ y i 1̲}
{r : [ (λ j → [ (λ k → P 0̲ j k) ] x 0̲ j ≡ y 0̲ j) ] p 0̲ ≡ q 0̲}
{s : [ (λ j → [ (λ k → P 1̲ j k) ] x 1̲ j ≡ y 1̲ j) ] p 1̲ ≡ q 1̲} →
H-level 3 (P 0̲ 0̲ 0̲) →
[ (λ i → [ (λ j → [ (λ k → P i j k) ] x i j ≡ y i j) ] p i ≡ q i) ]
r ≡ s
heterogeneous-UIP₃₀₀
{P = P} {x = x} {y = y} {p = p} {q = q} {r = r} {s = s} =
H-level 3 (P 0̲ 0̲ 0̲) ↝⟨ H-level-suc→H-level[]≡ 2 ⟩
Is-set ([ (λ k → P 0̲ 0̲ k) ] x 0̲ 0̲ ≡ y 0̲ 0̲) ↝⟨ H-level-suc→H-level[]≡ 1 ⟩
Is-proposition
([ (λ j → [ (λ k → P 0̲ j k) ] x 0̲ j ≡ y 0̲ j) ] p 0̲ ≡ q 0̲) ↝⟨ H-level-suc→H-level[]≡ _ ⟩
Contractible
([ (λ i → [ (λ j → [ (λ k → P i j k) ] x i j ≡ y i j) ] p i ≡ q i) ]
r ≡ s) ↝⟨ proj₁ ⟩□
[ (λ i → [ (λ j → [ (λ k → P i j k) ] x i j ≡ y i j) ] p i ≡ q i) ]
r ≡ s □
-- The following three lemmas can be used to implement the truncation
-- cases of (at least some) eliminators for (at least some) HITs. For
-- some examples, see H-level.Truncation.Propositional, Quotient and
-- Eilenberg-MacLane-space.
-- A variant of heterogeneous-irrelevance₀.
heterogeneous-irrelevance :
{P : A → Type p} →
(∀ x → Is-proposition (P x)) →
{x≡y : x ≡ y} {p₁ : P x} {p₂ : P y} →
[ (λ i → P (x≡y i)) ] p₁ ≡ p₂
heterogeneous-irrelevance {x = x} {P = P} P-prop {x≡y} {p₁} {p₂} =
$⟨ P-prop ⟩
(∀ x → Is-proposition (P x)) ↝⟨ _$ _ ⟩
Is-proposition (P x) ↝⟨ heterogeneous-irrelevance₀ ⟩□
[ (λ i → P (x≡y i)) ] p₁ ≡ p₂ □
-- A variant of heterogeneous-UIP₀₀.
--
-- The cubical library contains (or used to contain) a lemma with
-- basically the same type, but with a seemingly rather different
-- proof, implemented by Zesen Qian.
heterogeneous-UIP :
{P : A → Type p} →
(∀ x → Is-set (P x)) →
{eq₁ eq₂ : x ≡ y} (eq₃ : eq₁ ≡ eq₂) {p₁ : P x} {p₂ : P y}
(eq₄ : [ (λ j → P (eq₁ j)) ] p₁ ≡ p₂)
(eq₅ : [ (λ j → P (eq₂ j)) ] p₁ ≡ p₂) →
[ (λ i → [ (λ j → P (eq₃ i j)) ] p₁ ≡ p₂) ] eq₄ ≡ eq₅
heterogeneous-UIP {x = x} {P = P} P-set eq₃ {p₁} {p₂} eq₄ eq₅ =
$⟨ P-set ⟩
(∀ x → Is-set (P x)) ↝⟨ _$ _ ⟩
Is-set (P x) ↝⟨ heterogeneous-UIP₀₀ ⟩□
[ (λ i → [ (λ j → P (eq₃ i j)) ] p₁ ≡ p₂) ] eq₄ ≡ eq₅ □
-- A variant of heterogeneous-UIP, "one level up".
heterogeneous-UIP₃ :
{P : A → Type p} →
(∀ x → H-level 3 (P x)) →
{eq₁ eq₂ : x ≡ y} {eq₃ eq₄ : eq₁ ≡ eq₂}
(eq₅ : eq₃ ≡ eq₄)
{p₁ : P x} {p₂ : P y}
{eq₆ : [ (λ k → P (eq₁ k)) ] p₁ ≡ p₂}
{eq₇ : [ (λ k → P (eq₂ k)) ] p₁ ≡ p₂}
(eq₈ : [ (λ j → [ (λ k → P (eq₃ j k)) ] p₁ ≡ p₂) ] eq₆ ≡ eq₇)
(eq₉ : [ (λ j → [ (λ k → P (eq₄ j k)) ] p₁ ≡ p₂) ] eq₆ ≡ eq₇) →
[ (λ i → [ (λ j → [ (λ k → P (eq₅ i j k)) ] p₁ ≡ p₂) ] eq₆ ≡ eq₇) ]
eq₈ ≡ eq₉
heterogeneous-UIP₃
{x = x} {P = P}
P-groupoid eq₅ {p₁ = p₁} {p₂ = p₂} {eq₆ = eq₆} {eq₇ = eq₇} eq₈ eq₉ =
$⟨ P-groupoid ⟩
(∀ x → H-level 3 (P x)) ↝⟨ _$ _ ⟩
H-level 3 (P x) ↝⟨ heterogeneous-UIP₃₀₀ ⟩□
[ (λ i → [ (λ j → [ (λ k → P (eq₅ i j k)) ] p₁ ≡ p₂) ] eq₆ ≡ eq₇) ]
eq₈ ≡ eq₉ □
|
algebraic-stack_agda0000_doc_8512 | {-# OPTIONS --without-K #-}
open import lib.Basics
module lib.types.Sigma where
-- Cartesian product
_×_ : ∀ {i j} (A : Type i) (B : Type j) → Type (lmax i j)
A × B = Σ A (λ _ → B)
infixr 5 _×_
module _ {i j} {A : Type i} {B : A → Type j} where
pair : (a : A) (b : B a) → Σ A B
pair a b = (a , b)
-- pair= has already been defined
fst= : {ab a'b' : Σ A B} (p : ab == a'b') → (fst ab == fst a'b')
fst= = ap fst
snd= : {ab a'b' : Σ A B} (p : ab == a'b')
→ (snd ab == snd a'b' [ B ↓ fst= p ])
snd= {._} {_} idp = idp
fst=-β : {a a' : A} (p : a == a')
{b : B a} {b' : B a'} (q : b == b' [ B ↓ p ])
→ fst= (pair= p q) == p
fst=-β idp idp = idp
snd=-β : {a a' : A} (p : a == a')
{b : B a} {b' : B a'} (q : b == b' [ B ↓ p ])
→ snd= (pair= p q) == q [ (λ v → b == b' [ B ↓ v ]) ↓ fst=-β p q ]
snd=-β idp idp = idp
pair=-η : {ab a'b' : Σ A B} (p : ab == a'b')
→ p == pair= (fst= p) (snd= p)
pair=-η {._} {_} idp = idp
pair== : {a a' : A} {p p' : a == a'} (α : p == p')
{b : B a} {b' : B a'} {q : b == b' [ B ↓ p ]} {q' : b == b' [ B ↓ p' ]}
(β : q == q' [ (λ u → b == b' [ B ↓ u ]) ↓ α ])
→ pair= p q == pair= p' q'
pair== idp idp = idp
module _ {i j} {A : Type i} {B : Type j} where
fst×= : {ab a'b' : A × B} (p : ab == a'b') → (fst ab == fst a'b')
fst×= = ap fst
snd×= : {ab a'b' : A × B} (p : ab == a'b')
→ (snd ab == snd a'b')
snd×= = ap snd
fst×=-β : {a a' : A} (p : a == a')
{b b' : B} (q : b == b')
→ fst×= (pair×= p q) == p
fst×=-β idp idp = idp
snd×=-β : {a a' : A} (p : a == a')
{b b' : B} (q : b == b')
→ snd×= (pair×= p q) == q
snd×=-β idp idp = idp
pair×=-η : {ab a'b' : A × B} (p : ab == a'b')
→ p == pair×= (fst×= p) (snd×= p)
pair×=-η {._} {_} idp = idp
module _ {i j} {A : Type i} {B : A → Type j} where
=Σ : (x y : Σ A B) → Type (lmax i j)
=Σ (a , b) (a' , b') = Σ (a == a') (λ p → b == b' [ B ↓ p ])
=Σ-eqv : (x y : Σ A B) → (=Σ x y) ≃ (x == y)
=Σ-eqv x y =
equiv (λ pq → pair= (fst pq) (snd pq)) (λ p → fst= p , snd= p)
(λ p → ! (pair=-η p))
(λ pq → pair= (fst=-β (fst pq) (snd pq)) (snd=-β (fst pq) (snd pq)))
=Σ-path : (x y : Σ A B) → (=Σ x y) == (x == y)
=Σ-path x y = ua (=Σ-eqv x y)
Σ= : ∀ {i j} {A A' : Type i} (p : A == A') {B : A → Type j} {B' : A' → Type j}
(q : B == B' [ (λ X → (X → Type j)) ↓ p ]) → Σ A B == Σ A' B'
Σ= idp idp = idp
abstract
Σ-level : ∀ {i j} {n : ℕ₋₂} {A : Type i} {P : A → Type j}
→ (has-level n A → ((x : A) → has-level n (P x))
→ has-level n (Σ A P))
Σ-level {n = ⟨-2⟩} p q =
((fst p , (fst (q (fst p)))) ,
(λ y → pair= (snd p _) (from-transp! _ _ (snd (q _) _))))
Σ-level {n = S n} p q = λ x y → equiv-preserves-level (=Σ-eqv x y)
(Σ-level (p _ _)
(λ _ → equiv-preserves-level ((to-transp-equiv _ _)⁻¹) (q _ _ _)))
×-level : ∀ {i j} {n : ℕ₋₂} {A : Type i} {B : Type j}
→ (has-level n A → has-level n B → has-level n (A × B))
×-level pA pB = Σ-level pA (λ x → pB)
-- Equivalences in a Σ-type
equiv-Σ-fst : ∀ {i j k} {A : Type i} {B : Type j} (P : B → Type k) {h : A → B}
→ is-equiv h → (Σ A (P ∘ h)) ≃ (Σ B P)
equiv-Σ-fst {A = A} {B = B} P {h = h} e = equiv f g f-g g-f
where f : Σ A (P ∘ h) → Σ B P
f (a , r) = (h a , r)
g : Σ B P → Σ A (P ∘ h)
g (b , s) = (is-equiv.g e b , transport P (! (is-equiv.f-g e b)) s)
f-g : ∀ y → f (g y) == y
f-g (b , s) = pair= (is-equiv.f-g e b) (trans-↓ P (is-equiv.f-g e b) s)
g-f : ∀ x → g (f x) == x
g-f (a , r) =
pair= (is-equiv.g-f e a)
(transport (λ q → transport P (! q) r == r [ P ∘ h ↓ is-equiv.g-f e a ])
(is-equiv.adj e a)
(trans-ap-↓ P h (is-equiv.g-f e a) r) )
equiv-Σ-snd : ∀ {i j k} {A : Type i} {B : A → Type j} {C : A → Type k}
→ (∀ x → B x ≃ C x) → Σ A B ≃ Σ A C
equiv-Σ-snd {A = A} {B = B} {C = C} k = equiv f g f-g g-f
where f : Σ A B → Σ A C
f (a , b) = (a , fst (k a) b)
g : Σ A C → Σ A B
g (a , c) = (a , is-equiv.g (snd (k a)) c)
f-g : ∀ p → f (g p) == p
f-g (a , c) = pair= idp (is-equiv.f-g (snd (k a)) c)
g-f : ∀ p → g (f p) == p
g-f (a , b) = pair= idp (is-equiv.g-f (snd (k a)) b)
-- Two ways of simultaneously applying equivalences in each component.
module _ {i₀ i₁ j₀ j₁} {A₀ : Type i₀} {A₁ : Type i₁}
{B₀ : A₀ → Type j₀} {B₁ : A₁ → Type j₁} where
equiv-Σ : (u : A₀ ≃ A₁) (v : ∀ a → B₀ (<– u a) ≃ B₁ a) → Σ A₀ B₀ ≃ Σ A₁ B₁
equiv-Σ u v = Σ A₀ B₀ ≃⟨ equiv-Σ-fst _ (snd (u ⁻¹)) ⁻¹ ⟩
Σ A₁ (B₀ ∘ <– u) ≃⟨ equiv-Σ-snd v ⟩
Σ A₁ B₁ ≃∎
equiv-Σ' : (u : A₀ ≃ A₁) (v : ∀ a → B₀ a ≃ B₁ (–> u a)) → Σ A₀ B₀ ≃ Σ A₁ B₁
equiv-Σ' u v = Σ A₀ B₀ ≃⟨ equiv-Σ-snd v ⟩
Σ A₀ (B₁ ∘ –> u) ≃⟨ equiv-Σ-fst _ (snd u) ⟩
Σ A₁ B₁ ≃∎
-- Implementation of [_∙'_] on Σ
Σ-∙' : ∀ {i j} {A : Type i} {B : A → Type j}
{x y z : A} {p : x == y} {p' : y == z}
{u : B x} {v : B y} {w : B z}
(q : u == v [ B ↓ p ]) (r : v == w [ B ↓ p' ])
→ (pair= p q ∙' pair= p' r) == pair= (p ∙' p') (q ∙'ᵈ r)
Σ-∙' {p = idp} {p' = idp} q idp = idp
-- Implementation of [_∙_] on Σ
Σ-∙ : ∀ {i j} {A : Type i} {B : A → Type j}
{x y z : A} {p : x == y} {p' : y == z}
{u : B x} {v : B y} {w : B z}
(q : u == v [ B ↓ p ]) (r : v == w [ B ↓ p' ])
→ (pair= p q ∙ pair= p' r) == pair= (p ∙ p') (q ∙ᵈ r)
Σ-∙ {p = idp} {p' = idp} idp r = idp
-- Implementation of [!] on Σ
Σ-! : ∀ {i j} {A : Type i} {B : A → Type j}
{x y : A} {p : x == y}
{u : B x} {v : B y}
(q : u == v [ B ↓ p ])
→ ! (pair= p q) == pair= (! p) (!ᵈ q)
Σ-! {p = idp} idp = idp
-- Implementation of [_∙'_] on ×
×-∙' : ∀ {i j} {A : Type i} {B : Type j}
{x y z : A} (p : x == y) (p' : y == z)
{u v w : B} (q : u == v) (q' : v == w)
→ (pair×= p q ∙' pair×= p' q') == pair×= (p ∙' p') (q ∙' q')
×-∙' idp idp q idp = idp
-- Implementation of [_∙_] on ×
×-∙ : ∀ {i j} {A : Type i} {B : Type j}
{x y z : A} (p : x == y) (p' : y == z)
{u v w : B} (q : u == v) (q' : v == w)
→ (pair×= p q ∙ pair×= p' q') == pair×= (p ∙ p') (q ∙ q')
×-∙ idp idp idp r = idp
-- Implementation of [!] on ×
×-! : ∀ {i j} {A : Type i} {B : Type j}
{x y : A} (p : x == y) {u v : B} (q : u == v)
→ ! (pair×= p q) == pair×= (! p) (! q)
×-! idp idp = idp
-- Special case of [ap-,]
ap-cst,id : ∀ {i j} {A : Type i} (B : A → Type j)
{a : A} {x y : B a} (p : x == y)
→ ap (λ x → _,_ {B = B} a x) p == pair= idp p
ap-cst,id B idp = idp
-- hfiber fst == B
module _ {i j} {A : Type i} {B : A → Type j} where
private
to : ∀ a → hfiber (fst :> (Σ A B → A)) a → B a
to a ((.a , b) , idp) = b
from : ∀ (a : A) → B a → hfiber (fst :> (Σ A B → A)) a
from a b = (a , b) , idp
to-from : ∀ (a : A) (b : B a) → to a (from a b) == b
to-from a b = idp
from-to : ∀ a b′ → from a (to a b′) == b′
from-to a ((.a , b) , idp) = idp
hfiber-fst : ∀ a → hfiber (fst :> (Σ A B → A)) a ≃ B a
hfiber-fst a = to a , is-eq (to a) (from a) (to-from a) (from-to a)
{- Dependent paths in a Σ-type -}
module _ {i j k} {A : Type i} {B : A → Type j} {C : (a : A) → B a → Type k}
where
↓-Σ-in : {x x' : A} {p : x == x'} {r : B x} {r' : B x'}
{s : C x r} {s' : C x' r'}
(q : r == r' [ B ↓ p ])
→ s == s' [ uncurry C ↓ pair= p q ]
→ (r , s) == (r' , s') [ (λ x → Σ (B x) (C x)) ↓ p ]
↓-Σ-in {p = idp} idp t = pair= idp t
↓-Σ-fst : {x x' : A} {p : x == x'} {r : B x} {r' : B x'}
{s : C x r} {s' : C x' r'}
→ (r , s) == (r' , s') [ (λ x → Σ (B x) (C x)) ↓ p ]
→ r == r' [ B ↓ p ]
↓-Σ-fst {p = idp} u = fst= u
↓-Σ-snd : {x x' : A} {p : x == x'} {r : B x} {r' : B x'}
{s : C x r} {s' : C x' r'}
→ (u : (r , s) == (r' , s') [ (λ x → Σ (B x) (C x)) ↓ p ])
→ s == s' [ uncurry C ↓ pair= p (↓-Σ-fst u) ]
↓-Σ-snd {p = idp} idp = idp
↓-Σ-β-fst : {x x' : A} {p : x == x'} {r : B x} {r' : B x'}
{s : C x r} {s' : C x' r'}
(q : r == r' [ B ↓ p ])
(t : s == s' [ uncurry C ↓ pair= p q ])
→ ↓-Σ-fst (↓-Σ-in q t) == q
↓-Σ-β-fst {p = idp} idp idp = idp
↓-Σ-β-snd : {x x' : A} {p : x == x'} {r : B x} {r' : B x'}
{s : C x r} {s' : C x' r'}
(q : r == r' [ B ↓ p ])
(t : s == s' [ uncurry C ↓ pair= p q ])
→ ↓-Σ-snd (↓-Σ-in q t) == t
[ (λ q' → s == s' [ uncurry C ↓ pair= p q' ]) ↓ ↓-Σ-β-fst q t ]
↓-Σ-β-snd {p = idp} idp idp = idp
↓-Σ-η : {x x' : A} {p : x == x'} {r : B x} {r' : B x'}
{s : C x r} {s' : C x' r'}
(u : (r , s) == (r' , s') [ (λ x → Σ (B x) (C x)) ↓ p ])
→ ↓-Σ-in (↓-Σ-fst u) (↓-Σ-snd u) == u
↓-Σ-η {p = idp} idp = idp
{- Dependent paths in a ×-type -}
module _ {i j k} {A : Type i} {B : A → Type j} {C : A → Type k}
where
↓-×-in : {x x' : A} {p : x == x'} {r : B x} {r' : B x'}
{s : C x} {s' : C x'}
→ r == r' [ B ↓ p ]
→ s == s' [ C ↓ p ]
→ (r , s) == (r' , s') [ (λ x → B x × C x) ↓ p ]
↓-×-in {p = idp} q t = pair×= q t
module _ where
-- An orphan lemma.
↓-cst×app-in : ∀ {i j k} {A : Type i}
{B : Type j} {C : A → B → Type k}
{a₁ a₂ : A} (p : a₁ == a₂)
{b₁ b₂ : B} (q : b₁ == b₂)
{c₁ : C a₁ b₁}{c₂ : C a₂ b₂}
→ c₁ == c₂ [ uncurry C ↓ pair×= p q ]
→ (b₁ , c₁) == (b₂ , c₂) [ (λ x → Σ B (C x)) ↓ p ]
↓-cst×app-in idp idp idp = idp
{- pair= and pair×= where one argument is reflexivity -}
pair=-idp-l : ∀ {i j} {A : Type i} {B : A → Type j} (a : A) {b₁ b₂ : B a}
(q : b₁ == b₂) → pair= {B = B} idp q == ap (λ y → (a , y)) q
pair=-idp-l _ idp = idp
pair×=-idp-l : ∀ {i j} {A : Type i} {B : Type j} (a : A) {b₁ b₂ : B}
(q : b₁ == b₂) → pair×= idp q == ap (λ y → (a , y)) q
pair×=-idp-l _ idp = idp
pair×=-idp-r : ∀ {i j} {A : Type i} {B : Type j} {a₁ a₂ : A} (p : a₁ == a₂)
(b : B) → pair×= p idp == ap (λ x → (x , b)) p
pair×=-idp-r idp _ = idp
pair×=-split-l : ∀ {i j} {A : Type i} {B : Type j} {a₁ a₂ : A} (p : a₁ == a₂)
{b₁ b₂ : B} (q : b₁ == b₂)
→ pair×= p q == ap (λ a → (a , b₁)) p ∙ ap (λ b → (a₂ , b)) q
pair×=-split-l idp idp = idp
pair×=-split-r : ∀ {i j} {A : Type i} {B : Type j} {a₁ a₂ : A} (p : a₁ == a₂)
{b₁ b₂ : B} (q : b₁ == b₂)
→ pair×= p q == ap (λ b → (a₁ , b)) q ∙ ap (λ a → (a , b₂)) p
pair×=-split-r idp idp = idp
-- Commutativity of products and derivatives.
module _ {i j} {A : Type i} {B : Type j} where
×-comm : Σ A (λ _ → B) ≃ Σ B (λ _ → A)
×-comm = equiv (λ {(a , b) → (b , a)}) (λ {(b , a) → (a , b)}) (λ _ → idp) (λ _ → idp)
module _ {i j k} {A : Type i} {B : A → Type j} {C : A → Type k} where
Σ₂-×-comm : Σ (Σ A B) (λ ab → C (fst ab)) ≃ Σ (Σ A C) (λ ac → B (fst ac))
Σ₂-×-comm = Σ-assoc ⁻¹ ∘e equiv-Σ-snd (λ a → ×-comm) ∘e Σ-assoc
module _ {i j k} {A : Type i} {B : Type j} {C : A → B → Type k} where
Σ₁-×-comm : Σ A (λ a → Σ B (λ b → C a b)) ≃ Σ B (λ b → Σ A (λ a → C a b))
Σ₁-×-comm = Σ-assoc ∘e equiv-Σ-fst _ (snd ×-comm) ∘e Σ-assoc ⁻¹
|
algebraic-stack_agda0000_doc_8513 | {-# OPTIONS --without-K --exact-split --safe #-}
module 06-universes where
import 05-identity-types
open 05-identity-types public
--------------------------------------------------------------------------------
-- Section 6.3 Observational equality on the natural numbers
-- Definition 6.3.1
Eq-ℕ : ℕ → ℕ → UU lzero
Eq-ℕ zero-ℕ zero-ℕ = 𝟙
Eq-ℕ zero-ℕ (succ-ℕ n) = 𝟘
Eq-ℕ (succ-ℕ m) zero-ℕ = 𝟘
Eq-ℕ (succ-ℕ m) (succ-ℕ n) = Eq-ℕ m n
-- Lemma 6.3.2
refl-Eq-ℕ : (n : ℕ) → Eq-ℕ n n
refl-Eq-ℕ zero-ℕ = star
refl-Eq-ℕ (succ-ℕ n) = refl-Eq-ℕ n
-- Proposition 6.3.3
Eq-ℕ-eq : {x y : ℕ} → Id x y → Eq-ℕ x y
Eq-ℕ-eq {x} {.x} refl = refl-Eq-ℕ x
eq-Eq-ℕ : (x y : ℕ) → Eq-ℕ x y → Id x y
eq-Eq-ℕ zero-ℕ zero-ℕ e = refl
eq-Eq-ℕ (succ-ℕ x) (succ-ℕ y) e = ap succ-ℕ (eq-Eq-ℕ x y e)
--------------------------------------------------------------------------------
-- Section 6.4 Peano's seventh and eighth axioms
-- Theorem 6.4.1
is-injective-succ-ℕ : (x y : ℕ) → Id (succ-ℕ x) (succ-ℕ y) → Id x y
is-injective-succ-ℕ x y e = eq-Eq-ℕ x y (Eq-ℕ-eq e)
Peano-7 :
(x y : ℕ) →
((Id x y) → (Id (succ-ℕ x) (succ-ℕ y))) ×
((Id (succ-ℕ x) (succ-ℕ y)) → (Id x y))
Peano-7 x y = pair (ap succ-ℕ) (is-injective-succ-ℕ x y)
-- Theorem 6.4.2
Peano-8 :
(x : ℕ) → ¬ (Id zero-ℕ (succ-ℕ x))
Peano-8 x p = Eq-ℕ-eq p
--------------------------------------------------------------------------------
-- Exercises
-- Exercise 6.1
-- Exercise 6.1 (a)
is-injective-add-ℕ :
(k m n : ℕ) → Id (add-ℕ m k) (add-ℕ n k) → Id m n
is-injective-add-ℕ zero-ℕ m n = id
is-injective-add-ℕ (succ-ℕ k) m n p =
is-injective-add-ℕ k m n (is-injective-succ-ℕ (add-ℕ m k) (add-ℕ n k) p)
-- Exercise 6.1 (b)
is-injective-mul-ℕ :
(k m n : ℕ) → Id (mul-ℕ m (succ-ℕ k)) (mul-ℕ n (succ-ℕ k)) → Id m n
is-injective-mul-ℕ k zero-ℕ zero-ℕ p = refl
is-injective-mul-ℕ k (succ-ℕ m) (succ-ℕ n) p =
ap succ-ℕ
( is-injective-mul-ℕ k m n
( is-injective-add-ℕ
( succ-ℕ k)
( mul-ℕ m (succ-ℕ k))
( mul-ℕ n (succ-ℕ k))
( ( inv (left-successor-law-mul-ℕ m (succ-ℕ k))) ∙
( ( p) ∙
( left-successor-law-mul-ℕ n (succ-ℕ k))))))
-- Exercise 6.1 (c)
neq-add-ℕ :
(m n : ℕ) → ¬ (Id m (add-ℕ m (succ-ℕ n)))
neq-add-ℕ (succ-ℕ m) n p =
neq-add-ℕ m n
( ( is-injective-succ-ℕ m (add-ℕ (succ-ℕ m) n) p) ∙
( left-successor-law-add-ℕ m n))
-- Exercise 6.1 (d)
neq-mul-ℕ :
(m n : ℕ) → ¬ (Id (succ-ℕ m) (mul-ℕ (succ-ℕ m) (succ-ℕ (succ-ℕ n))))
neq-mul-ℕ m n p =
neq-add-ℕ
( succ-ℕ m)
( add-ℕ (mul-ℕ m (succ-ℕ n)) n)
( ( p) ∙
( ( right-successor-law-mul-ℕ (succ-ℕ m) (succ-ℕ n)) ∙
( ap (add-ℕ (succ-ℕ m)) (left-successor-law-mul-ℕ m (succ-ℕ n)))))
-- Exercise 6.2
-- Exercise 6.2 (a)
Eq-𝟚 : bool → bool → UU lzero
Eq-𝟚 true true = unit
Eq-𝟚 true false = empty
Eq-𝟚 false true = empty
Eq-𝟚 false false = unit
-- Exercise 6.2 (b)
reflexive-Eq-𝟚 : (x : bool) → Eq-𝟚 x x
reflexive-Eq-𝟚 true = star
reflexive-Eq-𝟚 false = star
Eq-eq-𝟚 :
{x y : bool} → Id x y → Eq-𝟚 x y
Eq-eq-𝟚 {x = x} refl = reflexive-Eq-𝟚 x
eq-Eq-𝟚 :
{x y : bool} → Eq-𝟚 x y → Id x y
eq-Eq-𝟚 {true} {true} star = refl
eq-Eq-𝟚 {false} {false} star = refl
-- Exercise 6.2 (c)
neq-neg-𝟚 : (b : bool) → ¬ (Id b (neg-𝟚 b))
neq-neg-𝟚 true = Eq-eq-𝟚
neq-neg-𝟚 false = Eq-eq-𝟚
neq-false-true-𝟚 :
¬ (Id false true)
neq-false-true-𝟚 = Eq-eq-𝟚
-- Exercise 6.3
-- Exercise 6.3 (a)
leq-ℕ : ℕ → ℕ → UU lzero
leq-ℕ zero-ℕ m = unit
leq-ℕ (succ-ℕ n) zero-ℕ = empty
leq-ℕ (succ-ℕ n) (succ-ℕ m) = leq-ℕ n m
_≤_ = leq-ℕ
-- Some trivialities that will be useful later
leq-zero-ℕ :
(n : ℕ) → leq-ℕ zero-ℕ n
leq-zero-ℕ n = star
eq-leq-zero-ℕ :
(x : ℕ) → leq-ℕ x zero-ℕ → Id zero-ℕ x
eq-leq-zero-ℕ zero-ℕ star = refl
succ-leq-ℕ : (n : ℕ) → leq-ℕ n (succ-ℕ n)
succ-leq-ℕ zero-ℕ = star
succ-leq-ℕ (succ-ℕ n) = succ-leq-ℕ n
concatenate-eq-leq-eq-ℕ :
{x1 x2 x3 x4 : ℕ} → Id x1 x2 → leq-ℕ x2 x3 → Id x3 x4 → leq-ℕ x1 x4
concatenate-eq-leq-eq-ℕ refl H refl = H
concatenate-leq-eq-ℕ :
(m : ℕ) {n n' : ℕ} → leq-ℕ m n → Id n n' → leq-ℕ m n'
concatenate-leq-eq-ℕ m H refl = H
concatenate-eq-leq-ℕ :
{m m' : ℕ} (n : ℕ) → Id m' m → leq-ℕ m n → leq-ℕ m' n
concatenate-eq-leq-ℕ n refl H = H
-- Exercise 6.3 (b)
reflexive-leq-ℕ : (n : ℕ) → leq-ℕ n n
reflexive-leq-ℕ zero-ℕ = star
reflexive-leq-ℕ (succ-ℕ n) = reflexive-leq-ℕ n
leq-eq-ℕ : (m n : ℕ) → Id m n → leq-ℕ m n
leq-eq-ℕ m .m refl = reflexive-leq-ℕ m
transitive-leq-ℕ :
(n m l : ℕ) → (n ≤ m) → (m ≤ l) → (n ≤ l)
transitive-leq-ℕ zero-ℕ m l p q = star
transitive-leq-ℕ (succ-ℕ n) (succ-ℕ m) (succ-ℕ l) p q =
transitive-leq-ℕ n m l p q
preserves-leq-succ-ℕ :
(m n : ℕ) → leq-ℕ m n → leq-ℕ m (succ-ℕ n)
preserves-leq-succ-ℕ m n p = transitive-leq-ℕ m n (succ-ℕ n) p (succ-leq-ℕ n)
anti-symmetric-leq-ℕ : (m n : ℕ) → leq-ℕ m n → leq-ℕ n m → Id m n
anti-symmetric-leq-ℕ zero-ℕ zero-ℕ p q = refl
anti-symmetric-leq-ℕ (succ-ℕ m) (succ-ℕ n) p q =
ap succ-ℕ (anti-symmetric-leq-ℕ m n p q)
-- Exercise 6.3 (c)
decide-leq-ℕ :
(m n : ℕ) → coprod (leq-ℕ m n) (leq-ℕ n m)
decide-leq-ℕ zero-ℕ zero-ℕ = inl star
decide-leq-ℕ zero-ℕ (succ-ℕ n) = inl star
decide-leq-ℕ (succ-ℕ m) zero-ℕ = inr star
decide-leq-ℕ (succ-ℕ m) (succ-ℕ n) = decide-leq-ℕ m n
-- Exercise 6.3 (d)
preserves-order-add-ℕ :
(k m n : ℕ) → leq-ℕ m n → leq-ℕ (add-ℕ m k) (add-ℕ n k)
preserves-order-add-ℕ zero-ℕ m n = id
preserves-order-add-ℕ (succ-ℕ k) m n = preserves-order-add-ℕ k m n
reflects-order-add-ℕ :
(k m n : ℕ) → leq-ℕ (add-ℕ m k) (add-ℕ n k) → leq-ℕ m n
reflects-order-add-ℕ zero-ℕ m n = id
reflects-order-add-ℕ (succ-ℕ k) m n = reflects-order-add-ℕ k m n
-- Exercise 6.3 (e)
preserves-order-mul-ℕ :
(k m n : ℕ) → leq-ℕ m n → leq-ℕ (mul-ℕ m k) (mul-ℕ n k)
preserves-order-mul-ℕ k zero-ℕ n p = star
preserves-order-mul-ℕ k (succ-ℕ m) (succ-ℕ n) p =
preserves-order-add-ℕ k
( mul-ℕ m k)
( mul-ℕ n k)
( preserves-order-mul-ℕ k m n p)
reflects-order-mul-ℕ :
(k m n : ℕ) → leq-ℕ (mul-ℕ m (succ-ℕ k)) (mul-ℕ n (succ-ℕ k)) → leq-ℕ m n
reflects-order-mul-ℕ k zero-ℕ n p = star
reflects-order-mul-ℕ k (succ-ℕ m) (succ-ℕ n) p =
reflects-order-mul-ℕ k m n
( reflects-order-add-ℕ
( succ-ℕ k)
( mul-ℕ m (succ-ℕ k))
( mul-ℕ n (succ-ℕ k))
( p))
-- Exercise 6.3 (f)
leq-min-ℕ :
(k m n : ℕ) → leq-ℕ k m → leq-ℕ k n → leq-ℕ k (min-ℕ m n)
leq-min-ℕ zero-ℕ zero-ℕ zero-ℕ H K = star
leq-min-ℕ zero-ℕ zero-ℕ (succ-ℕ n) H K = star
leq-min-ℕ zero-ℕ (succ-ℕ m) zero-ℕ H K = star
leq-min-ℕ zero-ℕ (succ-ℕ m) (succ-ℕ n) H K = star
leq-min-ℕ (succ-ℕ k) (succ-ℕ m) (succ-ℕ n) H K = leq-min-ℕ k m n H K
leq-left-leq-min-ℕ :
(k m n : ℕ) → leq-ℕ k (min-ℕ m n) → leq-ℕ k m
leq-left-leq-min-ℕ zero-ℕ zero-ℕ zero-ℕ H = star
leq-left-leq-min-ℕ zero-ℕ zero-ℕ (succ-ℕ n) H = star
leq-left-leq-min-ℕ zero-ℕ (succ-ℕ m) zero-ℕ H = star
leq-left-leq-min-ℕ zero-ℕ (succ-ℕ m) (succ-ℕ n) H = star
leq-left-leq-min-ℕ (succ-ℕ k) (succ-ℕ m) (succ-ℕ n) H =
leq-left-leq-min-ℕ k m n H
leq-right-leq-min-ℕ :
(k m n : ℕ) → leq-ℕ k (min-ℕ m n) → leq-ℕ k n
leq-right-leq-min-ℕ zero-ℕ zero-ℕ zero-ℕ H = star
leq-right-leq-min-ℕ zero-ℕ zero-ℕ (succ-ℕ n) H = star
leq-right-leq-min-ℕ zero-ℕ (succ-ℕ m) zero-ℕ H = star
leq-right-leq-min-ℕ zero-ℕ (succ-ℕ m) (succ-ℕ n) H = star
leq-right-leq-min-ℕ (succ-ℕ k) (succ-ℕ m) (succ-ℕ n) H =
leq-right-leq-min-ℕ k m n H
leq-max-ℕ :
(k m n : ℕ) → leq-ℕ m k → leq-ℕ n k → leq-ℕ (max-ℕ m n) k
leq-max-ℕ zero-ℕ zero-ℕ zero-ℕ H K = star
leq-max-ℕ (succ-ℕ k) zero-ℕ zero-ℕ H K = star
leq-max-ℕ (succ-ℕ k) zero-ℕ (succ-ℕ n) H K = K
leq-max-ℕ (succ-ℕ k) (succ-ℕ m) zero-ℕ H K = H
leq-max-ℕ (succ-ℕ k) (succ-ℕ m) (succ-ℕ n) H K = leq-max-ℕ k m n H K
leq-left-leq-max-ℕ :
(k m n : ℕ) → leq-ℕ (max-ℕ m n) k → leq-ℕ m k
leq-left-leq-max-ℕ k zero-ℕ zero-ℕ H = star
leq-left-leq-max-ℕ k zero-ℕ (succ-ℕ n) H = star
leq-left-leq-max-ℕ k (succ-ℕ m) zero-ℕ H = H
leq-left-leq-max-ℕ (succ-ℕ k) (succ-ℕ m) (succ-ℕ n) H =
leq-left-leq-max-ℕ k m n H
leq-right-leq-max-ℕ :
(k m n : ℕ) → leq-ℕ (max-ℕ m n) k → leq-ℕ n k
leq-right-leq-max-ℕ k zero-ℕ zero-ℕ H = star
leq-right-leq-max-ℕ k zero-ℕ (succ-ℕ n) H = H
leq-right-leq-max-ℕ k (succ-ℕ m) zero-ℕ H = star
leq-right-leq-max-ℕ (succ-ℕ k) (succ-ℕ m) (succ-ℕ n) H =
leq-right-leq-max-ℕ k m n H
-- Exercise 6.4
-- Exercise 6.4 (a)
-- We define a distance function on ℕ --
dist-ℕ : ℕ → ℕ → ℕ
dist-ℕ zero-ℕ n = n
dist-ℕ (succ-ℕ m) zero-ℕ = succ-ℕ m
dist-ℕ (succ-ℕ m) (succ-ℕ n) = dist-ℕ m n
dist-ℕ' : ℕ → ℕ → ℕ
dist-ℕ' m n = dist-ℕ n m
ap-dist-ℕ :
{m n m' n' : ℕ} → Id m m' → Id n n' → Id (dist-ℕ m n) (dist-ℕ m' n')
ap-dist-ℕ refl refl = refl
{- We show that two natural numbers are equal if and only if their distance is
zero. -}
eq-dist-ℕ :
(m n : ℕ) → Id zero-ℕ (dist-ℕ m n) → Id m n
eq-dist-ℕ zero-ℕ zero-ℕ p = refl
eq-dist-ℕ (succ-ℕ m) (succ-ℕ n) p = ap succ-ℕ (eq-dist-ℕ m n p)
dist-eq-ℕ' :
(n : ℕ) → Id zero-ℕ (dist-ℕ n n)
dist-eq-ℕ' zero-ℕ = refl
dist-eq-ℕ' (succ-ℕ n) = dist-eq-ℕ' n
dist-eq-ℕ :
(m n : ℕ) → Id m n → Id zero-ℕ (dist-ℕ m n)
dist-eq-ℕ m .m refl = dist-eq-ℕ' m
-- The distance function is symmetric --
symmetric-dist-ℕ :
(m n : ℕ) → Id (dist-ℕ m n) (dist-ℕ n m)
symmetric-dist-ℕ zero-ℕ zero-ℕ = refl
symmetric-dist-ℕ zero-ℕ (succ-ℕ n) = refl
symmetric-dist-ℕ (succ-ℕ m) zero-ℕ = refl
symmetric-dist-ℕ (succ-ℕ m) (succ-ℕ n) = symmetric-dist-ℕ m n
-- We compute the distance from zero --
left-zero-law-dist-ℕ :
(n : ℕ) → Id (dist-ℕ zero-ℕ n) n
left-zero-law-dist-ℕ zero-ℕ = refl
left-zero-law-dist-ℕ (succ-ℕ n) = refl
right-zero-law-dist-ℕ :
(n : ℕ) → Id (dist-ℕ n zero-ℕ) n
right-zero-law-dist-ℕ zero-ℕ = refl
right-zero-law-dist-ℕ (succ-ℕ n) = refl
-- We prove the triangle inequality --
ap-add-ℕ :
{m n m' n' : ℕ} → Id m m' → Id n n' → Id (add-ℕ m n) (add-ℕ m' n')
ap-add-ℕ refl refl = refl
triangle-inequality-dist-ℕ :
(m n k : ℕ) → leq-ℕ (dist-ℕ m n) (add-ℕ (dist-ℕ m k) (dist-ℕ k n))
triangle-inequality-dist-ℕ zero-ℕ zero-ℕ zero-ℕ = star
triangle-inequality-dist-ℕ zero-ℕ zero-ℕ (succ-ℕ k) = star
triangle-inequality-dist-ℕ zero-ℕ (succ-ℕ n) zero-ℕ =
tr ( leq-ℕ (succ-ℕ n))
( inv (left-unit-law-add-ℕ (succ-ℕ n)))
( reflexive-leq-ℕ (succ-ℕ n))
triangle-inequality-dist-ℕ zero-ℕ (succ-ℕ n) (succ-ℕ k) =
concatenate-eq-leq-eq-ℕ
( inv (ap succ-ℕ (left-zero-law-dist-ℕ n)))
( triangle-inequality-dist-ℕ zero-ℕ n k)
( ( ap (succ-ℕ ∘ (add-ℕ' (dist-ℕ k n))) (left-zero-law-dist-ℕ k)) ∙
( inv (left-successor-law-add-ℕ k (dist-ℕ k n))))
triangle-inequality-dist-ℕ (succ-ℕ m) zero-ℕ zero-ℕ = reflexive-leq-ℕ (succ-ℕ m)
triangle-inequality-dist-ℕ (succ-ℕ m) zero-ℕ (succ-ℕ k) =
concatenate-eq-leq-eq-ℕ
( inv (ap succ-ℕ (right-zero-law-dist-ℕ m)))
( triangle-inequality-dist-ℕ m zero-ℕ k)
( ap (succ-ℕ ∘ (add-ℕ (dist-ℕ m k))) (right-zero-law-dist-ℕ k))
triangle-inequality-dist-ℕ (succ-ℕ m) (succ-ℕ n) zero-ℕ =
concatenate-leq-eq-ℕ
( dist-ℕ m n)
( transitive-leq-ℕ
( dist-ℕ m n)
( succ-ℕ (add-ℕ (dist-ℕ m zero-ℕ) (dist-ℕ zero-ℕ n)))
( succ-ℕ (succ-ℕ (add-ℕ (dist-ℕ m zero-ℕ) (dist-ℕ zero-ℕ n))))
( transitive-leq-ℕ
( dist-ℕ m n)
( add-ℕ (dist-ℕ m zero-ℕ) (dist-ℕ zero-ℕ n))
( succ-ℕ (add-ℕ (dist-ℕ m zero-ℕ) (dist-ℕ zero-ℕ n)))
( triangle-inequality-dist-ℕ m n zero-ℕ)
( succ-leq-ℕ (add-ℕ (dist-ℕ m zero-ℕ) (dist-ℕ zero-ℕ n))))
( succ-leq-ℕ (succ-ℕ (add-ℕ (dist-ℕ m zero-ℕ) (dist-ℕ zero-ℕ n)))))
( ( ap (succ-ℕ ∘ succ-ℕ)
( ap-add-ℕ (right-zero-law-dist-ℕ m) (left-zero-law-dist-ℕ n))) ∙
( inv (left-successor-law-add-ℕ m (succ-ℕ n))))
triangle-inequality-dist-ℕ (succ-ℕ m) (succ-ℕ n) (succ-ℕ k) =
triangle-inequality-dist-ℕ m n k
-- We show that dist-ℕ x y is a solution to a simple equation.
leq-dist-ℕ :
(x y : ℕ) → leq-ℕ x y → Id (add-ℕ x (dist-ℕ x y)) y
leq-dist-ℕ zero-ℕ zero-ℕ H = refl
leq-dist-ℕ zero-ℕ (succ-ℕ y) star = left-unit-law-add-ℕ (succ-ℕ y)
leq-dist-ℕ (succ-ℕ x) (succ-ℕ y) H =
( left-successor-law-add-ℕ x (dist-ℕ x y)) ∙
( ap succ-ℕ (leq-dist-ℕ x y H))
rewrite-left-add-dist-ℕ :
(x y z : ℕ) → Id (add-ℕ x y) z → Id x (dist-ℕ y z)
rewrite-left-add-dist-ℕ zero-ℕ zero-ℕ .zero-ℕ refl = refl
rewrite-left-add-dist-ℕ zero-ℕ (succ-ℕ y) .(succ-ℕ (add-ℕ zero-ℕ y)) refl =
( dist-eq-ℕ' y) ∙
( inv (ap (dist-ℕ (succ-ℕ y)) (left-unit-law-add-ℕ (succ-ℕ y))))
rewrite-left-add-dist-ℕ (succ-ℕ x) zero-ℕ .(succ-ℕ x) refl = refl
rewrite-left-add-dist-ℕ
(succ-ℕ x) (succ-ℕ y) .(succ-ℕ (add-ℕ (succ-ℕ x) y)) refl =
rewrite-left-add-dist-ℕ (succ-ℕ x) y (add-ℕ (succ-ℕ x) y) refl
rewrite-left-dist-add-ℕ :
(x y z : ℕ) → leq-ℕ y z → Id x (dist-ℕ y z) → Id (add-ℕ x y) z
rewrite-left-dist-add-ℕ .(dist-ℕ y z) y z H refl =
( commutative-add-ℕ (dist-ℕ y z) y) ∙
( leq-dist-ℕ y z H)
rewrite-right-add-dist-ℕ :
(x y z : ℕ) → Id (add-ℕ x y) z → Id y (dist-ℕ x z)
rewrite-right-add-dist-ℕ x y z p =
rewrite-left-add-dist-ℕ y x z (commutative-add-ℕ y x ∙ p)
rewrite-right-dist-add-ℕ :
(x y z : ℕ) → leq-ℕ x z → Id y (dist-ℕ x z) → Id (add-ℕ x y) z
rewrite-right-dist-add-ℕ x .(dist-ℕ x z) z H refl =
leq-dist-ℕ x z H
-- We show that dist-ℕ is translation invariant
translation-invariant-dist-ℕ :
(k m n : ℕ) → Id (dist-ℕ (add-ℕ k m) (add-ℕ k n)) (dist-ℕ m n)
translation-invariant-dist-ℕ zero-ℕ m n =
ap-dist-ℕ (left-unit-law-add-ℕ m) (left-unit-law-add-ℕ n)
translation-invariant-dist-ℕ (succ-ℕ k) m n =
( ap-dist-ℕ (left-successor-law-add-ℕ k m) (left-successor-law-add-ℕ k n)) ∙
( translation-invariant-dist-ℕ k m n)
-- We show that dist-ℕ is linear with respect to scalar multiplication
linear-dist-ℕ :
(m n k : ℕ) → Id (dist-ℕ (mul-ℕ k m) (mul-ℕ k n)) (mul-ℕ k (dist-ℕ m n))
linear-dist-ℕ zero-ℕ zero-ℕ zero-ℕ = refl
linear-dist-ℕ zero-ℕ zero-ℕ (succ-ℕ k) = linear-dist-ℕ zero-ℕ zero-ℕ k
linear-dist-ℕ zero-ℕ (succ-ℕ n) zero-ℕ = refl
linear-dist-ℕ zero-ℕ (succ-ℕ n) (succ-ℕ k) =
ap (dist-ℕ' (mul-ℕ (succ-ℕ k) (succ-ℕ n))) (right-zero-law-mul-ℕ (succ-ℕ k))
linear-dist-ℕ (succ-ℕ m) zero-ℕ zero-ℕ = refl
linear-dist-ℕ (succ-ℕ m) zero-ℕ (succ-ℕ k) =
ap (dist-ℕ (mul-ℕ (succ-ℕ k) (succ-ℕ m))) (right-zero-law-mul-ℕ (succ-ℕ k))
linear-dist-ℕ (succ-ℕ m) (succ-ℕ n) zero-ℕ = refl
linear-dist-ℕ (succ-ℕ m) (succ-ℕ n) (succ-ℕ k) =
( ap-dist-ℕ
( right-successor-law-mul-ℕ (succ-ℕ k) m)
( right-successor-law-mul-ℕ (succ-ℕ k) n)) ∙
( ( translation-invariant-dist-ℕ
( succ-ℕ k)
( mul-ℕ (succ-ℕ k) m)
( mul-ℕ (succ-ℕ k) n)) ∙
( linear-dist-ℕ m n (succ-ℕ k)))
-- Exercise 6.6
{- In this exercise we were asked to define the relations ≤ and < on the
integers. As a criterion of correctness, we were then also asked to show
that the type of all integers l satisfying k ≤ l satisfy the induction
principle of the natural numbers. -}
diff-ℤ : ℤ → ℤ → ℤ
diff-ℤ k l = add-ℤ (neg-ℤ k) l
is-non-negative-ℤ : ℤ → UU lzero
is-non-negative-ℤ (inl x) = empty
is-non-negative-ℤ (inr k) = unit
leq-ℤ : ℤ → ℤ → UU lzero
leq-ℤ k l = is-non-negative-ℤ (diff-ℤ k l)
reflexive-leq-ℤ : (k : ℤ) → leq-ℤ k k
reflexive-leq-ℤ k =
tr is-non-negative-ℤ (inv (left-inverse-law-add-ℤ k)) star
is-non-negative-succ-ℤ :
(k : ℤ) → is-non-negative-ℤ k → is-non-negative-ℤ (succ-ℤ k)
is-non-negative-succ-ℤ (inr (inl star)) p = star
is-non-negative-succ-ℤ (inr (inr x)) p = star
is-non-negative-add-ℤ :
(k l : ℤ) →
is-non-negative-ℤ k → is-non-negative-ℤ l → is-non-negative-ℤ (add-ℤ k l)
is-non-negative-add-ℤ (inr (inl star)) (inr (inl star)) p q = star
is-non-negative-add-ℤ (inr (inl star)) (inr (inr n)) p q = star
is-non-negative-add-ℤ (inr (inr zero-ℕ)) (inr (inl star)) p q = star
is-non-negative-add-ℤ (inr (inr (succ-ℕ n))) (inr (inl star)) star star =
is-non-negative-succ-ℤ
( add-ℤ (inr (inr n)) (inr (inl star)))
( is-non-negative-add-ℤ (inr (inr n)) (inr (inl star)) star star)
is-non-negative-add-ℤ (inr (inr zero-ℕ)) (inr (inr m)) star star = star
is-non-negative-add-ℤ (inr (inr (succ-ℕ n))) (inr (inr m)) star star =
is-non-negative-succ-ℤ
( add-ℤ (inr (inr n)) (inr (inr m)))
( is-non-negative-add-ℤ (inr (inr n)) (inr (inr m)) star star)
triangle-diff-ℤ :
(k l m : ℤ) → Id (add-ℤ (diff-ℤ k l) (diff-ℤ l m)) (diff-ℤ k m)
triangle-diff-ℤ k l m =
( associative-add-ℤ (neg-ℤ k) l (diff-ℤ l m)) ∙
( ap
( add-ℤ (neg-ℤ k))
( ( inv (associative-add-ℤ l (neg-ℤ l) m)) ∙
( ( ap (λ x → add-ℤ x m) (right-inverse-law-add-ℤ l)) ∙
( left-unit-law-add-ℤ m))))
transitive-leq-ℤ : (k l m : ℤ) → leq-ℤ k l → leq-ℤ l m → leq-ℤ k m
transitive-leq-ℤ k l m p q =
tr is-non-negative-ℤ
( triangle-diff-ℤ k l m)
( is-non-negative-add-ℤ
( add-ℤ (neg-ℤ k) l)
( add-ℤ (neg-ℤ l) m)
( p)
( q))
succ-leq-ℤ : (k : ℤ) → leq-ℤ k (succ-ℤ k)
succ-leq-ℤ k =
tr is-non-negative-ℤ
( inv
( ( right-successor-law-add-ℤ (neg-ℤ k) k) ∙
( ap succ-ℤ (left-inverse-law-add-ℤ k))))
( star)
leq-ℤ-succ-leq-ℤ : (k l : ℤ) → leq-ℤ k l → leq-ℤ k (succ-ℤ l)
leq-ℤ-succ-leq-ℤ k l p = transitive-leq-ℤ k l (succ-ℤ l) p (succ-leq-ℤ l)
is-positive-ℤ : ℤ → UU lzero
is-positive-ℤ k = is-non-negative-ℤ (pred-ℤ k)
le-ℤ : ℤ → ℤ → UU lzero
le-ℤ (inl zero-ℕ) (inl x) = empty
le-ℤ (inl zero-ℕ) (inr y) = unit
le-ℤ (inl (succ-ℕ x)) (inl zero-ℕ) = unit
le-ℤ (inl (succ-ℕ x)) (inl (succ-ℕ y)) = le-ℤ (inl x) (inl y)
le-ℤ (inl (succ-ℕ x)) (inr y) = unit
le-ℤ (inr x) (inl y) = empty
le-ℤ (inr (inl star)) (inr (inl star)) = empty
le-ℤ (inr (inl star)) (inr (inr x)) = unit
le-ℤ (inr (inr x)) (inr (inl star)) = empty
le-ℤ (inr (inr zero-ℕ)) (inr (inr zero-ℕ)) = empty
le-ℤ (inr (inr zero-ℕ)) (inr (inr (succ-ℕ y))) = unit
le-ℤ (inr (inr (succ-ℕ x))) (inr (inr zero-ℕ)) = empty
le-ℤ (inr (inr (succ-ℕ x))) (inr (inr (succ-ℕ y))) =
le-ℤ (inr (inr x)) (inr (inr y))
-- Extra material
-- We show that ℕ is an ordered semi-ring
left-law-leq-add-ℕ : (k m n : ℕ) → leq-ℕ m n → leq-ℕ (add-ℕ m k) (add-ℕ n k)
left-law-leq-add-ℕ zero-ℕ m n = id
left-law-leq-add-ℕ (succ-ℕ k) m n H = left-law-leq-add-ℕ k m n H
right-law-leq-add-ℕ : (k m n : ℕ) → leq-ℕ m n → leq-ℕ (add-ℕ k m) (add-ℕ k n)
right-law-leq-add-ℕ k m n H =
concatenate-eq-leq-eq-ℕ
( commutative-add-ℕ k m)
( left-law-leq-add-ℕ k m n H)
( commutative-add-ℕ n k)
preserves-leq-add-ℕ :
{m m' n n' : ℕ} → leq-ℕ m m' → leq-ℕ n n' → leq-ℕ (add-ℕ m n) (add-ℕ m' n')
preserves-leq-add-ℕ {m} {m'} {n} {n'} H K =
transitive-leq-ℕ
( add-ℕ m n)
( add-ℕ m' n)
( add-ℕ m' n')
( left-law-leq-add-ℕ n m m' H)
( right-law-leq-add-ℕ m' n n' K)
{-
right-law-leq-mul-ℕ : (k m n : ℕ) → leq-ℕ m n → leq-ℕ (mul-ℕ k m) (mul-ℕ k n)
right-law-leq-mul-ℕ zero-ℕ m n H = star
right-law-leq-mul-ℕ (succ-ℕ k) m n H = {!!}
-}
{-
preserves-leq-add-ℕ
{ m = mul-ℕ k m}
{ m' = mul-ℕ k n}
( right-law-leq-mul-ℕ k m n H) H
left-law-leq-mul-ℕ : (k m n : ℕ) → leq-ℕ m n → leq-ℕ (mul-ℕ m k) (mul-ℕ n k)
left-law-leq-mul-ℕ k m n H =
concatenate-eq-leq-eq-ℕ
( commutative-mul-ℕ k m)
( commutative-mul-ℕ k n)
( right-law-leq-mul-ℕ k m n H)
-}
-- We show that ℤ is an ordered ring
{-
leq-add-ℤ : (m k l : ℤ) → leq-ℤ k l → leq-ℤ (add-ℤ m k) (add-ℤ m l)
leq-add-ℤ (inl zero-ℕ) k l H = {!!}
leq-add-ℤ (inl (succ-ℕ x)) k l H = {!!}
leq-add-ℤ (inr m) k l H = {!!}
-}
-- Section 5.5 Identity systems
succ-fam-Eq-ℕ :
{i : Level} (R : (m n : ℕ) → Eq-ℕ m n → UU i) →
(m n : ℕ) → Eq-ℕ m n → UU i
succ-fam-Eq-ℕ R m n e = R (succ-ℕ m) (succ-ℕ n) e
succ-refl-fam-Eq-ℕ :
{i : Level} (R : (m n : ℕ) → Eq-ℕ m n → UU i)
(ρ : (n : ℕ) → R n n (refl-Eq-ℕ n)) →
(n : ℕ) → (succ-fam-Eq-ℕ R n n (refl-Eq-ℕ n))
succ-refl-fam-Eq-ℕ R ρ n = ρ (succ-ℕ n)
path-ind-Eq-ℕ :
{i : Level} (R : (m n : ℕ) → Eq-ℕ m n → UU i)
( ρ : (n : ℕ) → R n n (refl-Eq-ℕ n)) →
( m n : ℕ) (e : Eq-ℕ m n) → R m n e
path-ind-Eq-ℕ R ρ zero-ℕ zero-ℕ star = ρ zero-ℕ
path-ind-Eq-ℕ R ρ zero-ℕ (succ-ℕ n) ()
path-ind-Eq-ℕ R ρ (succ-ℕ m) zero-ℕ ()
path-ind-Eq-ℕ R ρ (succ-ℕ m) (succ-ℕ n) e =
path-ind-Eq-ℕ
( λ m n e → R (succ-ℕ m) (succ-ℕ n) e)
( λ n → ρ (succ-ℕ n)) m n e
comp-path-ind-Eq-ℕ :
{i : Level} (R : (m n : ℕ) → Eq-ℕ m n → UU i)
( ρ : (n : ℕ) → R n n (refl-Eq-ℕ n)) →
( n : ℕ) → Id (path-ind-Eq-ℕ R ρ n n (refl-Eq-ℕ n)) (ρ n)
comp-path-ind-Eq-ℕ R ρ zero-ℕ = refl
comp-path-ind-Eq-ℕ R ρ (succ-ℕ n) =
comp-path-ind-Eq-ℕ
( λ m n e → R (succ-ℕ m) (succ-ℕ n) e)
( λ n → ρ (succ-ℕ n)) n
{-
-- Graphs
Gph : (i : Level) → UU (lsuc i)
Gph i = Σ (UU i) (λ X → (X → X → (UU i)))
-- Reflexive graphs
rGph : (i : Level) → UU (lsuc i)
rGph i = Σ (UU i) (λ X → Σ (X → X → (UU i)) (λ R → (x : X) → R x x))
-}
-- Exercise 3.7
{- With the construction of the divisibility relation we open the door to basic
number theory. -}
divides : (d n : ℕ) → UU lzero
divides d n = Σ ℕ (λ m → Eq-ℕ (mul-ℕ d m) n)
-- We prove some lemmas about inequalities --
leq-add-ℕ :
(m n : ℕ) → leq-ℕ m (add-ℕ m n)
leq-add-ℕ m zero-ℕ = reflexive-leq-ℕ m
leq-add-ℕ m (succ-ℕ n) =
transitive-leq-ℕ m (add-ℕ m n) (succ-ℕ (add-ℕ m n))
( leq-add-ℕ m n)
( succ-leq-ℕ (add-ℕ m n))
leq-add-ℕ' :
(m n : ℕ) → leq-ℕ m (add-ℕ n m)
leq-add-ℕ' m n =
concatenate-leq-eq-ℕ m (leq-add-ℕ m n) (commutative-add-ℕ m n)
leq-leq-add-ℕ :
(m n x : ℕ) → leq-ℕ (add-ℕ m x) (add-ℕ n x) → leq-ℕ m n
leq-leq-add-ℕ m n zero-ℕ H = H
leq-leq-add-ℕ m n (succ-ℕ x) H = leq-leq-add-ℕ m n x H
leq-leq-add-ℕ' :
(m n x : ℕ) → leq-ℕ (add-ℕ x m) (add-ℕ x n) → leq-ℕ m n
leq-leq-add-ℕ' m n x H =
leq-leq-add-ℕ m n x
( concatenate-eq-leq-eq-ℕ
( commutative-add-ℕ m x)
( H)
( commutative-add-ℕ x n))
leq-leq-mul-ℕ :
(m n x : ℕ) → leq-ℕ (mul-ℕ (succ-ℕ x) m) (mul-ℕ (succ-ℕ x) n) → leq-ℕ m n
leq-leq-mul-ℕ zero-ℕ zero-ℕ x H = star
leq-leq-mul-ℕ zero-ℕ (succ-ℕ n) x H = star
leq-leq-mul-ℕ (succ-ℕ m) zero-ℕ x H =
ex-falso
( concatenate-leq-eq-ℕ
( mul-ℕ (succ-ℕ x) (succ-ℕ m))
( H)
( right-zero-law-mul-ℕ (succ-ℕ x)))
leq-leq-mul-ℕ (succ-ℕ m) (succ-ℕ n) x H =
leq-leq-mul-ℕ m n x
( leq-leq-add-ℕ' (mul-ℕ (succ-ℕ x) m) (mul-ℕ (succ-ℕ x) n) (succ-ℕ x)
( concatenate-eq-leq-eq-ℕ
( inv (right-successor-law-mul-ℕ (succ-ℕ x) m))
( H)
( right-successor-law-mul-ℕ (succ-ℕ x) n)))
leq-leq-mul-ℕ' :
(m n x : ℕ) → leq-ℕ (mul-ℕ m (succ-ℕ x)) (mul-ℕ n (succ-ℕ x)) → leq-ℕ m n
leq-leq-mul-ℕ' m n x H =
leq-leq-mul-ℕ m n x
( concatenate-eq-leq-eq-ℕ
( commutative-mul-ℕ (succ-ℕ x) m)
( H)
( commutative-mul-ℕ n (succ-ℕ x)))
{-
succ-relation-ℕ :
{i : Level} (R : ℕ → ℕ → UU i) → ℕ → ℕ → UU i
succ-relation-ℕ R m n = R (succ-ℕ m) (succ-ℕ n)
succ-reflexivity-ℕ :
{i : Level} (R : ℕ → ℕ → UU i) (ρ : (n : ℕ) → R n n) →
(n : ℕ) → succ-relation-ℕ R n n
succ-reflexivity-ℕ R ρ n = ρ (succ-ℕ n)
{- In the book we suggest that first the order of the variables should be
swapped, in order to make the inductive hypothesis stronger. Agda's pattern
matching mechanism allows us to bypass this step and give a more direct
construction. -}
least-reflexive-Eq-ℕ :
{i : Level} (R : ℕ → ℕ → UU i) (ρ : (n : ℕ) → R n n) →
(m n : ℕ) → Eq-ℕ m n → R m n
least-reflexive-Eq-ℕ R ρ zero-ℕ zero-ℕ star = ρ zero-ℕ
least-reflexive-Eq-ℕ R ρ zero-ℕ (succ-ℕ n) ()
least-reflexive-Eq-ℕ R ρ (succ-ℕ m) zero-ℕ ()
least-reflexive-Eq-ℕ R ρ (succ-ℕ m) (succ-ℕ n) e =
least-reflexive-Eq-ℕ (succ-relation-ℕ R) (succ-reflexivity-ℕ R ρ) m n e
-}
-- The definition of <
le-ℕ : ℕ → ℕ → UU lzero
le-ℕ m zero-ℕ = empty
le-ℕ zero-ℕ (succ-ℕ m) = unit
le-ℕ (succ-ℕ n) (succ-ℕ m) = le-ℕ n m
_<_ = le-ℕ
anti-reflexive-le-ℕ : (n : ℕ) → ¬ (n < n)
anti-reflexive-le-ℕ zero-ℕ = ind-empty
anti-reflexive-le-ℕ (succ-ℕ n) = anti-reflexive-le-ℕ n
transitive-le-ℕ : (n m l : ℕ) → (le-ℕ n m) → (le-ℕ m l) → (le-ℕ n l)
transitive-le-ℕ zero-ℕ (succ-ℕ m) (succ-ℕ l) p q = star
transitive-le-ℕ (succ-ℕ n) (succ-ℕ m) (succ-ℕ l) p q =
transitive-le-ℕ n m l p q
succ-le-ℕ : (n : ℕ) → le-ℕ n (succ-ℕ n)
succ-le-ℕ zero-ℕ = star
succ-le-ℕ (succ-ℕ n) = succ-le-ℕ n
anti-symmetric-le-ℕ : (m n : ℕ) → le-ℕ m n → le-ℕ n m → Id m n
anti-symmetric-le-ℕ (succ-ℕ m) (succ-ℕ n) p q =
ap succ-ℕ (anti-symmetric-le-ℕ m n p q)
{-
--------------------------------------------------------------------------------
data Fin-Tree : UU lzero where
constr : (n : ℕ) → (Fin n → Fin-Tree) → Fin-Tree
root-Fin-Tree : Fin-Tree
root-Fin-Tree = constr zero-ℕ ex-falso
succ-Fin-Tree : Fin-Tree → Fin-Tree
succ-Fin-Tree t = constr one-ℕ (λ i → t)
map-assoc-coprod :
{l1 l2 l3 : Level} {A : UU l1} {B : UU l2} {C : UU l3} →
coprod (coprod A B) C → coprod A (coprod B C)
map-assoc-coprod (inl (inl x)) = inl x
map-assoc-coprod (inl (inr x)) = inr (inl x)
map-assoc-coprod (inr x) = inr (inr x)
map-coprod-Fin :
(m n : ℕ) → Fin (add-ℕ m n) → coprod (Fin m) (Fin n)
map-coprod-Fin m zero-ℕ = inl
map-coprod-Fin m (succ-ℕ n) =
map-assoc-coprod ∘ (functor-coprod (map-coprod-Fin m n) (id {A = unit}))
add-Fin-Tree : Fin-Tree → Fin-Tree → Fin-Tree
add-Fin-Tree (constr n x) (constr m y) =
constr (add-ℕ n m) ((ind-coprod (λ i → Fin-Tree) x y) ∘ (map-coprod-Fin n m))
--------------------------------------------------------------------------------
data labeled-Bin-Tree {l1 : Level} (A : UU l1) : UU l1 where
leaf : A → labeled-Bin-Tree A
constr : (bool → labeled-Bin-Tree A) → labeled-Bin-Tree A
mul-leaves-labeled-Bin-Tree :
{l1 : Level} {A : UU l1} (μ : A → (A → A)) →
labeled-Bin-Tree A → A
mul-leaves-labeled-Bin-Tree μ (leaf x) = x
mul-leaves-labeled-Bin-Tree μ (constr f) =
μ ( mul-leaves-labeled-Bin-Tree μ (f false))
( mul-leaves-labeled-Bin-Tree μ (f true))
pick-list : {l1 : Level} {A : UU l1} → ℕ → list A → coprod A unit
pick-list zero-ℕ nil = inr star
pick-list zero-ℕ (cons a x) = inl a
pick-list (succ-ℕ n) nil = inr star
pick-list (succ-ℕ n) (cons a x) = pick-list n x
-}
|
algebraic-stack_agda0000_doc_8514 | {-# OPTIONS --cubical --no-import-sorts --allow-unsolved-metas #-}
module Number.Instances.QuoQ.Definitions where
open import Agda.Primitive renaming (_⊔_ to ℓ-max; lsuc to ℓ-suc; lzero to ℓ-zero)
open import Cubical.Foundations.Everything renaming (_⁻¹ to _⁻¹ᵖ; assoc to ∙-assoc)
open import Cubical.Foundations.Logic renaming (inl to inlᵖ; inr to inrᵖ)
open import Cubical.Relation.Nullary.Base renaming (¬_ to ¬ᵗ_)
open import Cubical.Relation.Binary.Base
open import Cubical.Data.Sum.Base renaming (_⊎_ to infixr 4 _⊎_)
open import Cubical.Data.Sigma.Base renaming (_×_ to infixr 4 _×_)
open import Cubical.Data.Sigma
open import Cubical.Data.Bool as Bool using (Bool; not; true; false)
open import Cubical.Data.Empty renaming (elim to ⊥-elim; ⊥ to ⊥⊥) -- `⊥` and `elim`
open import Cubical.Foundations.Logic renaming (¬_ to ¬ᵖ_; inl to inlᵖ; inr to inrᵖ)
open import Function.Base using (it; _∋_; _$_)
open import Cubical.Foundations.Isomorphism
open import Cubical.HITs.PropositionalTruncation --.Properties
open import Utils using (!_; !!_)
open import MoreLogic.Reasoning
open import MoreLogic.Definitions
open import MoreLogic.Properties
open import MorePropAlgebra.Definitions hiding (_≤''_)
open import MorePropAlgebra.Structures
open import MorePropAlgebra.Bundles
open import MorePropAlgebra.Consequences
open import Number.Structures2
open import Number.Bundles2
open import Cubical.Data.NatPlusOne using (HasFromNat; 1+_; ℕ₊₁; ℕ₊₁→ℕ)
open import Cubical.HITs.SetQuotients as SetQuotient using () renaming (_/_ to _//_)
open import Cubical.Data.Nat.Literals
open import Cubical.Data.Bool
open import Number.Prelude.Nat
open import Number.Prelude.QuoInt
open import Cubical.HITs.Ints.QuoInt using (HasFromNat)
open import Cubical.HITs.Rationals.QuoQ using
( ℚ
; onCommonDenom
; onCommonDenomSym
; eq/
; _//_
; _∼_
)
renaming
( [_] to [_]ᶠ
; ℕ₊₁→ℤ to [1+_ⁿ]ᶻ
)
abstract
private
lemma1 : ∀ a b₁ b₂ c → (a ·ᶻ b₁) ·ᶻ (b₂ ·ᶻ c) ≡ (a ·ᶻ c) ·ᶻ (b₂ ·ᶻ b₁)
lemma1 a b₁ b₂ c =
(a ·ᶻ b₁) ·ᶻ (b₂ ·ᶻ c) ≡⟨ sym $ ·ᶻ-assoc a b₁ (b₂ ·ᶻ c) ⟩
a ·ᶻ (b₁ ·ᶻ (b₂ ·ᶻ c)) ≡⟨ (λ i → a ·ᶻ ·ᶻ-assoc b₁ b₂ c i) ⟩
a ·ᶻ ((b₁ ·ᶻ b₂) ·ᶻ c) ≡⟨ (λ i → a ·ᶻ ·ᶻ-comm (b₁ ·ᶻ b₂) c i) ⟩
a ·ᶻ (c ·ᶻ (b₁ ·ᶻ b₂)) ≡⟨ ·ᶻ-assoc a c (b₁ ·ᶻ b₂) ⟩
(a ·ᶻ c) ·ᶻ (b₁ ·ᶻ b₂) ≡⟨ (λ i → (a ·ᶻ c) ·ᶻ ·ᶻ-comm b₁ b₂ i) ⟩
(a ·ᶻ c) ·ᶻ (b₂ ·ᶻ b₁) ∎
·ᶻ-commʳ : ∀ a b c → (a ·ᶻ b) ·ᶻ c ≡ (a ·ᶻ c) ·ᶻ b
·ᶻ-commʳ a b c = (a ·ᶻ b) ·ᶻ c ≡⟨ sym $ ·ᶻ-assoc a b c ⟩
a ·ᶻ (b ·ᶻ c) ≡⟨ (λ i → a ·ᶻ ·ᶻ-comm b c i) ⟩
a ·ᶻ (c ·ᶻ b) ≡⟨ ·ᶻ-assoc a c b ⟩
(a ·ᶻ c) ·ᶻ b ∎
∼-preserves-<ᶻ : ∀ aᶻ aⁿ bᶻ bⁿ → (aᶻ , aⁿ) ∼ (bᶻ , bⁿ) → [ ((aᶻ <ᶻ 0) ⇒ (bᶻ <ᶻ 0)) ⊓ ((0 <ᶻ aᶻ) ⇒ (0 <ᶻ bᶻ)) ]
∼-preserves-<ᶻ aᶻ aⁿ bᶻ bⁿ r = γ where
aⁿᶻ = [1+ aⁿ ⁿ]ᶻ
bⁿᶻ = [1+ bⁿ ⁿ]ᶻ
0<aⁿᶻ : [ 0 <ᶻ aⁿᶻ ]
0<aⁿᶻ = ℕ₊₁.n aⁿ , +ⁿ-comm (ℕ₊₁.n aⁿ) 1
0<bⁿᶻ : [ 0 <ᶻ bⁿᶻ ]
0<bⁿᶻ = ℕ₊₁.n bⁿ , +ⁿ-comm (ℕ₊₁.n bⁿ) 1
γ : [ ((aᶻ <ᶻ 0) ⇒ (bᶻ <ᶻ 0)) ⊓ ((0 <ᶻ aᶻ) ⇒ (0 <ᶻ bᶻ)) ]
γ .fst aᶻ<0 = (
aᶻ <ᶻ 0 ⇒ᵖ⟨ ·ᶻ-preserves-<ᶻ aᶻ 0 bⁿᶻ 0<bⁿᶻ ⟩
aᶻ ·ᶻ bⁿᶻ <ᶻ 0 ·ᶻ bⁿᶻ ⇒ᵖ⟨ (subst (λ p → [ aᶻ ·ᶻ bⁿᶻ <ᶻ p ]) $ ·ᶻ-nullifiesˡ bⁿᶻ) ⟩
aᶻ ·ᶻ bⁿᶻ <ᶻ 0 ⇒ᵖ⟨ subst (λ p → [ p <ᶻ 0 ]) r ⟩
bᶻ ·ᶻ aⁿᶻ <ᶻ 0 ⇒ᵖ⟨ subst (λ p → [ bᶻ ·ᶻ aⁿᶻ <ᶻ p ]) (sym (·ᶻ-nullifiesˡ aⁿᶻ)) ⟩
bᶻ ·ᶻ aⁿᶻ <ᶻ 0 ·ᶻ aⁿᶻ ⇒ᵖ⟨ ·ᶻ-reflects-<ᶻ bᶻ 0 aⁿᶻ 0<aⁿᶻ ⟩
bᶻ <ᶻ 0 ◼ᵖ) .snd aᶻ<0
γ .snd 0<aᶻ = (
0 <ᶻ aᶻ ⇒ᵖ⟨ ·ᶻ-preserves-<ᶻ 0 aᶻ bⁿᶻ 0<bⁿᶻ ⟩
0 ·ᶻ bⁿᶻ <ᶻ aᶻ ·ᶻ bⁿᶻ ⇒ᵖ⟨ (subst (λ p → [ p <ᶻ aᶻ ·ᶻ bⁿᶻ ]) $ ·ᶻ-nullifiesˡ bⁿᶻ) ⟩
0 <ᶻ aᶻ ·ᶻ bⁿᶻ ⇒ᵖ⟨ subst (λ p → [ 0 <ᶻ p ]) r ⟩
0 <ᶻ bᶻ ·ᶻ aⁿᶻ ⇒ᵖ⟨ subst (λ p → [ p <ᶻ bᶻ ·ᶻ aⁿᶻ ]) (sym (·ᶻ-nullifiesˡ aⁿᶻ)) ⟩
0 ·ᶻ aⁿᶻ <ᶻ bᶻ ·ᶻ aⁿᶻ ⇒ᵖ⟨ ·ᶻ-reflects-<ᶻ 0 bᶻ aⁿᶻ 0<aⁿᶻ ⟩
0 <ᶻ bᶻ ◼ᵖ) .snd 0<aᶻ
-- < on ℤ × ℕ₊₁ in terms of < on ℤ
_<'_ : ℤ × ℕ₊₁ → ℤ × ℕ₊₁ → hProp ℓ-zero
(aᶻ , aⁿ) <' (bᶻ , bⁿ) =
let aⁿᶻ = [1+ aⁿ ⁿ]ᶻ
bⁿᶻ = [1+ bⁿ ⁿ]ᶻ
in (aᶻ ·ᶻ bⁿᶻ) <ᶻ (bᶻ ·ᶻ aⁿᶻ)
private
lem1 : ∀ x y z → [ 0 <ᶻ y ] → [ 0 <ᶻ z ] → (0 <ᶻ (x ·ᶻ y)) ≡ (0 <ᶻ (x ·ᶻ z))
lem1 x y z p q =
0 <ᶻ (x ·ᶻ y) ≡⟨ (λ i → ·ᶻ-nullifiesˡ y (~ i) <ᶻ x ·ᶻ y) ⟩
(0 ·ᶻ y) <ᶻ (x ·ᶻ y) ≡⟨ sym $ ·ᶻ-creates-<ᶻ-≡ 0 x y p ⟩
0 <ᶻ x ≡⟨ ·ᶻ-creates-<ᶻ-≡ 0 x z q ⟩
(0 ·ᶻ z) <ᶻ (x ·ᶻ z) ≡⟨ (λ i → ·ᶻ-nullifiesˡ z i <ᶻ x ·ᶻ z) ⟩
0 <ᶻ (x ·ᶻ z) ∎
<'-respects-∼ˡ : ∀ a b x → a ∼ b → a <' x ≡ b <' x
<'-respects-∼ˡ a@(aᶻ , aⁿ) b@(bᶻ , bⁿ) x@(xᶻ , xⁿ) a~b = γ where
aⁿᶻ = [1+ aⁿ ⁿ]ᶻ; 0<aⁿᶻ : [ 0 <ᶻ aⁿᶻ ]; 0<aⁿᶻ = 0<ᶻpos[suc] _
bⁿᶻ = [1+ bⁿ ⁿ]ᶻ; 0<bⁿᶻ : [ 0 <ᶻ bⁿᶻ ]; 0<bⁿᶻ = 0<ᶻpos[suc] _
xⁿᶻ = [1+ xⁿ ⁿ]ᶻ
p : aᶻ ·ᶻ bⁿᶻ ≡ bᶻ ·ᶻ aⁿᶻ
p = a~b
γ : ((aᶻ ·ᶻ xⁿᶻ) <ᶻ (xᶻ ·ᶻ aⁿᶻ)) ≡ ((bᶻ ·ᶻ xⁿᶻ) <ᶻ (xᶻ ·ᶻ bⁿᶻ))
γ = aᶻ ·ᶻ xⁿᶻ <ᶻ xᶻ ·ᶻ aⁿᶻ ≡⟨ ·ᶻ-creates-<ᶻ-≡ (aᶻ ·ᶻ xⁿᶻ) (xᶻ ·ᶻ aⁿᶻ) bⁿᶻ 0<bⁿᶻ ⟩
aᶻ ·ᶻ xⁿᶻ ·ᶻ bⁿᶻ <ᶻ xᶻ ·ᶻ aⁿᶻ ·ᶻ bⁿᶻ ≡⟨ (λ i → ·ᶻ-commʳ aᶻ xⁿᶻ bⁿᶻ i <ᶻ xᶻ ·ᶻ aⁿᶻ ·ᶻ bⁿᶻ) ⟩
aᶻ ·ᶻ bⁿᶻ ·ᶻ xⁿᶻ <ᶻ xᶻ ·ᶻ aⁿᶻ ·ᶻ bⁿᶻ ≡⟨ (λ i → p i ·ᶻ xⁿᶻ <ᶻ xᶻ ·ᶻ aⁿᶻ ·ᶻ bⁿᶻ) ⟩
bᶻ ·ᶻ aⁿᶻ ·ᶻ xⁿᶻ <ᶻ xᶻ ·ᶻ aⁿᶻ ·ᶻ bⁿᶻ ≡⟨ (λ i → ·ᶻ-commʳ bᶻ aⁿᶻ xⁿᶻ i <ᶻ ·ᶻ-commʳ xᶻ aⁿᶻ bⁿᶻ i) ⟩
bᶻ ·ᶻ xⁿᶻ ·ᶻ aⁿᶻ <ᶻ xᶻ ·ᶻ bⁿᶻ ·ᶻ aⁿᶻ ≡⟨ sym $ ·ᶻ-creates-<ᶻ-≡ (bᶻ ·ᶻ xⁿᶻ) (xᶻ ·ᶻ bⁿᶻ) aⁿᶻ 0<aⁿᶻ ⟩
bᶻ ·ᶻ xⁿᶻ <ᶻ xᶻ ·ᶻ bⁿᶻ ∎
<'-respects-∼ʳ : ∀ x a b → a ∼ b → x <' a ≡ x <' b
<'-respects-∼ʳ x@(xᶻ , xⁿ) a@(aᶻ , aⁿ) b@(bᶻ , bⁿ) a~b =
let aⁿᶻ = [1+ aⁿ ⁿ]ᶻ; 0<aⁿᶻ : [ 0 <ᶻ aⁿᶻ ]; 0<aⁿᶻ = 0<ᶻpos[suc] _
bⁿᶻ = [1+ bⁿ ⁿ]ᶻ; 0<bⁿᶻ : [ 0 <ᶻ bⁿᶻ ]; 0<bⁿᶻ = 0<ᶻpos[suc] _
xⁿᶻ = [1+ xⁿ ⁿ]ᶻ
p : aᶻ ·ᶻ bⁿᶻ ≡ bᶻ ·ᶻ aⁿᶻ
p = a~b
in xᶻ ·ᶻ aⁿᶻ <ᶻ aᶻ ·ᶻ xⁿᶻ ≡⟨ (λ i → xᶻ ·ᶻ aⁿᶻ <ᶻ ·ᶻ-comm aᶻ xⁿᶻ i) ⟩
xᶻ ·ᶻ aⁿᶻ <ᶻ xⁿᶻ ·ᶻ aᶻ ≡⟨ ·ᶻ-creates-<ᶻ-≡ (xᶻ ·ᶻ aⁿᶻ) (xⁿᶻ ·ᶻ aᶻ) bⁿᶻ 0<bⁿᶻ ⟩
xᶻ ·ᶻ aⁿᶻ ·ᶻ bⁿᶻ <ᶻ xⁿᶻ ·ᶻ aᶻ ·ᶻ bⁿᶻ ≡⟨ (λ i → xᶻ ·ᶻ aⁿᶻ ·ᶻ bⁿᶻ <ᶻ ·ᶻ-assoc xⁿᶻ aᶻ bⁿᶻ (~ i)) ⟩
xᶻ ·ᶻ aⁿᶻ ·ᶻ bⁿᶻ <ᶻ xⁿᶻ ·ᶻ (aᶻ ·ᶻ bⁿᶻ) ≡⟨ (λ i → xᶻ ·ᶻ aⁿᶻ ·ᶻ bⁿᶻ <ᶻ xⁿᶻ ·ᶻ (p i)) ⟩
xᶻ ·ᶻ aⁿᶻ ·ᶻ bⁿᶻ <ᶻ xⁿᶻ ·ᶻ (bᶻ ·ᶻ aⁿᶻ) ≡⟨ (λ i → ·ᶻ-commʳ xᶻ aⁿᶻ bⁿᶻ i <ᶻ ·ᶻ-assoc xⁿᶻ bᶻ aⁿᶻ i) ⟩
xᶻ ·ᶻ bⁿᶻ ·ᶻ aⁿᶻ <ᶻ xⁿᶻ ·ᶻ bᶻ ·ᶻ aⁿᶻ ≡⟨ sym $ ·ᶻ-creates-<ᶻ-≡ (xᶻ ·ᶻ bⁿᶻ) (xⁿᶻ ·ᶻ bᶻ) aⁿᶻ 0<aⁿᶻ ⟩
xᶻ ·ᶻ bⁿᶻ <ᶻ xⁿᶻ ·ᶻ bᶻ ≡⟨ (λ i → xᶻ ·ᶻ bⁿᶻ <ᶻ ·ᶻ-comm xⁿᶻ bᶻ i) ⟩
xᶻ ·ᶻ bⁿᶻ <ᶻ bᶻ ·ᶻ xⁿᶻ ∎
infixl 4 _<_
_<_ : hPropRel ℚ ℚ ℓ-zero
a < b = SetQuotient.rec2 {R = _∼_} {B = hProp ℓ-zero} isSetHProp _<'_ <'-respects-∼ˡ <'-respects-∼ʳ a b
_≤_ : hPropRel ℚ ℚ ℓ-zero
x ≤ y = ¬ᵖ (y < x)
min' : ℤ × ℕ₊₁ → ℤ × ℕ₊₁ → ℤ
min' (aᶻ , aⁿ) (bᶻ , bⁿ) =
let aⁿᶻ = [1+ aⁿ ⁿ]ᶻ
bⁿᶻ = [1+ bⁿ ⁿ]ᶻ
in minᶻ (aᶻ ·ᶻ bⁿᶻ) (bᶻ ·ᶻ aⁿᶻ)
max' : ℤ × ℕ₊₁ → ℤ × ℕ₊₁ → ℤ
max' (aᶻ , aⁿ) (bᶻ , bⁿ) =
let aⁿᶻ = [1+ aⁿ ⁿ]ᶻ
bⁿᶻ = [1+ bⁿ ⁿ]ᶻ
in maxᶻ (aᶻ ·ᶻ bⁿᶻ) (bᶻ ·ᶻ aⁿᶻ)
min'-sym : ∀ x y → min' x y ≡ min' y x
min'-sym (aᶻ , aⁿ) (bᶻ , bⁿ) = minᶻ-comm (aᶻ ·ᶻ [1+ bⁿ ⁿ]ᶻ) (bᶻ ·ᶻ [1+ aⁿ ⁿ]ᶻ)
max'-sym : ∀ x y → max' x y ≡ max' y x
max'-sym (aᶻ , aⁿ) (bᶻ , bⁿ) = maxᶻ-comm (aᶻ ·ᶻ [1+ bⁿ ⁿ]ᶻ) (bᶻ ·ᶻ [1+ aⁿ ⁿ]ᶻ)
min'-respects-∼ : (a@(aᶻ , aⁿ) b@(bᶻ , bⁿ) x@(xᶻ , xⁿ) : ℤ × ℕ₊₁)
→ a ∼ b
→ [1+ bⁿ ⁿ]ᶻ ·ᶻ min' a x ≡ [1+ aⁿ ⁿ]ᶻ ·ᶻ min' b x
min'-respects-∼ a@(aᶻ , aⁿ) b@(bᶻ , bⁿ) x@(xᶻ , xⁿ) a~b =
bⁿᶻ ·ᶻ minᶻ (aᶻ ·ᶻ xⁿᶻ) (xᶻ ·ᶻ aⁿᶻ) ≡⟨ ·ᶻ-minᶻ-distribˡ (aᶻ ·ᶻ xⁿᶻ) (xᶻ ·ᶻ aⁿᶻ) bⁿᶻ 0≤bⁿᶻ ⟩
minᶻ (bⁿᶻ ·ᶻ (aᶻ ·ᶻ xⁿᶻ)) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ)) ≡⟨ (λ i → minᶻ (·ᶻ-assoc bⁿᶻ aᶻ xⁿᶻ i) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ))) ⟩
minᶻ ((bⁿᶻ ·ᶻ aᶻ) ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ)) ≡⟨ (λ i → minᶻ ((·ᶻ-comm bⁿᶻ aᶻ i) ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ))) ⟩
minᶻ ((aᶻ ·ᶻ bⁿᶻ) ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ)) ≡⟨ (λ i → minᶻ (p i ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ))) ⟩
minᶻ ((bᶻ ·ᶻ aⁿᶻ) ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ)) ≡⟨ (λ i → minᶻ (·ᶻ-comm bᶻ aⁿᶻ i ·ᶻ xⁿᶻ) (·ᶻ-assoc bⁿᶻ xᶻ aⁿᶻ i)) ⟩
minᶻ ((aⁿᶻ ·ᶻ bᶻ) ·ᶻ xⁿᶻ) ((bⁿᶻ ·ᶻ xᶻ) ·ᶻ aⁿᶻ) ≡⟨ (λ i → minᶻ (·ᶻ-assoc aⁿᶻ bᶻ xⁿᶻ (~ i)) (·ᶻ-comm (bⁿᶻ ·ᶻ xᶻ) aⁿᶻ i)) ⟩
minᶻ (aⁿᶻ ·ᶻ (bᶻ ·ᶻ xⁿᶻ)) (aⁿᶻ ·ᶻ (bⁿᶻ ·ᶻ xᶻ)) ≡⟨ sym $ ·ᶻ-minᶻ-distribˡ (bᶻ ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ xᶻ) aⁿᶻ 0≤aⁿᶻ ⟩
aⁿᶻ ·ᶻ minᶻ (bᶻ ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ xᶻ) ≡⟨ (λ i → aⁿᶻ ·ᶻ minᶻ (bᶻ ·ᶻ xⁿᶻ) (·ᶻ-comm bⁿᶻ xᶻ i)) ⟩
aⁿᶻ ·ᶻ minᶻ (bᶻ ·ᶻ xⁿᶻ) (xᶻ ·ᶻ bⁿᶻ) ∎
where
aⁿᶻ = [1+ aⁿ ⁿ]ᶻ
bⁿᶻ = [1+ bⁿ ⁿ]ᶻ
xⁿᶻ = [1+ xⁿ ⁿ]ᶻ
p : aᶻ ·ᶻ bⁿᶻ ≡ bᶻ ·ᶻ aⁿᶻ
p = a~b
0≤aⁿᶻ : [ 0 ≤ᶻ aⁿᶻ ]
0≤aⁿᶻ (k , p) = snotzⁿ $ sym (+ⁿ-suc k _) ∙ p
0≤bⁿᶻ : [ 0 ≤ᶻ bⁿᶻ ]
0≤bⁿᶻ (k , p) = snotzⁿ $ sym (+ⁿ-suc k _) ∙ p
-- same proof as for min
max'-respects-∼ : (a@(aᶻ , aⁿ) b@(bᶻ , bⁿ) x@(xᶻ , xⁿ) : ℤ × ℕ₊₁)
→ a ∼ b
→ [1+ bⁿ ⁿ]ᶻ ·ᶻ max' a x ≡ [1+ aⁿ ⁿ]ᶻ ·ᶻ max' b x
max'-respects-∼ a@(aᶻ , aⁿ) b@(bᶻ , bⁿ) x@(xᶻ , xⁿ) a~b =
bⁿᶻ ·ᶻ maxᶻ (aᶻ ·ᶻ xⁿᶻ) (xᶻ ·ᶻ aⁿᶻ) ≡⟨ ·ᶻ-maxᶻ-distribˡ (aᶻ ·ᶻ xⁿᶻ) (xᶻ ·ᶻ aⁿᶻ) bⁿᶻ 0≤bⁿᶻ ⟩
maxᶻ (bⁿᶻ ·ᶻ (aᶻ ·ᶻ xⁿᶻ)) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ)) ≡⟨ (λ i → maxᶻ (·ᶻ-assoc bⁿᶻ aᶻ xⁿᶻ i) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ))) ⟩
maxᶻ ((bⁿᶻ ·ᶻ aᶻ) ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ)) ≡⟨ (λ i → maxᶻ ((·ᶻ-comm bⁿᶻ aᶻ i) ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ))) ⟩
maxᶻ ((aᶻ ·ᶻ bⁿᶻ) ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ)) ≡⟨ (λ i → maxᶻ (p i ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ))) ⟩
maxᶻ ((bᶻ ·ᶻ aⁿᶻ) ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ (xᶻ ·ᶻ aⁿᶻ)) ≡⟨ (λ i → maxᶻ (·ᶻ-comm bᶻ aⁿᶻ i ·ᶻ xⁿᶻ) (·ᶻ-assoc bⁿᶻ xᶻ aⁿᶻ i)) ⟩
maxᶻ ((aⁿᶻ ·ᶻ bᶻ) ·ᶻ xⁿᶻ) ((bⁿᶻ ·ᶻ xᶻ) ·ᶻ aⁿᶻ) ≡⟨ (λ i → maxᶻ (·ᶻ-assoc aⁿᶻ bᶻ xⁿᶻ (~ i)) (·ᶻ-comm (bⁿᶻ ·ᶻ xᶻ) aⁿᶻ i)) ⟩
maxᶻ (aⁿᶻ ·ᶻ (bᶻ ·ᶻ xⁿᶻ)) (aⁿᶻ ·ᶻ (bⁿᶻ ·ᶻ xᶻ)) ≡⟨ sym $ ·ᶻ-maxᶻ-distribˡ (bᶻ ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ xᶻ) aⁿᶻ 0≤aⁿᶻ ⟩
aⁿᶻ ·ᶻ maxᶻ (bᶻ ·ᶻ xⁿᶻ) (bⁿᶻ ·ᶻ xᶻ) ≡⟨ (λ i → aⁿᶻ ·ᶻ maxᶻ (bᶻ ·ᶻ xⁿᶻ) (·ᶻ-comm bⁿᶻ xᶻ i)) ⟩
aⁿᶻ ·ᶻ maxᶻ (bᶻ ·ᶻ xⁿᶻ) (xᶻ ·ᶻ bⁿᶻ) ∎
where
aⁿᶻ = [1+ aⁿ ⁿ]ᶻ
bⁿᶻ = [1+ bⁿ ⁿ]ᶻ
xⁿᶻ = [1+ xⁿ ⁿ]ᶻ
p : aᶻ ·ᶻ bⁿᶻ ≡ bᶻ ·ᶻ aⁿᶻ
p = a~b
0≤aⁿᶻ : [ 0 ≤ᶻ aⁿᶻ ]
0≤aⁿᶻ (k , p) = snotzⁿ $ sym (+ⁿ-suc k _) ∙ p
0≤bⁿᶻ : [ 0 ≤ᶻ bⁿᶻ ]
0≤bⁿᶻ (k , p) = snotzⁿ $ sym (+ⁿ-suc k _) ∙ p
min : ℚ → ℚ → ℚ
min a b = onCommonDenomSym min' min'-sym min'-respects-∼ a b
max : ℚ → ℚ → ℚ
max a b = onCommonDenomSym max' max'-sym max'-respects-∼ a b
-- injᶻⁿ⁺¹ : ∀ x → [ 0 <ᶻ x ] → Σ[ y ∈ ℕ₊₁ ] x ≡ [1+ y ⁿ]ᶻ
-- injᶻⁿ⁺¹ (signed spos zero) p = ⊥-elim {A = λ _ → Σ[ y ∈ ℕ₊₁ ] ℤ.posneg i0 ≡ [1+ y ⁿ]ᶻ} (¬-<ⁿ-zero p)
-- injᶻⁿ⁺¹ (signed sneg zero) p = ⊥-elim {A = λ _ → Σ[ y ∈ ℕ₊₁ ] ℤ.posneg i1 ≡ [1+ y ⁿ]ᶻ} (¬-<ⁿ-zero p)
-- injᶻⁿ⁺¹ (ℤ.posneg i) p = ⊥-elim {A = λ _ → Σ[ y ∈ ℕ₊₁ ] ℤ.posneg i ≡ [1+ y ⁿ]ᶻ} (¬-<ⁿ-zero p)
-- injᶻⁿ⁺¹ (signed spos (suc n)) p = 1+ n , refl
absᶻ⁺¹ : ℤ → ℕ₊₁
absᶻ⁺¹ (pos zero) = 1+ 0
absᶻ⁺¹ (neg zero) = 1+ 0
absᶻ⁺¹ (posneg i) = 1+ 0
absᶻ⁺¹ (pos (suc n)) = 1+ n
absᶻ⁺¹ (neg (suc n)) = 1+ n
-- absᶻ⁺¹-identity⁺ : ∀ x → [ 0 <ⁿ x ] → [1+ absᶻ⁺¹ (pos x) ⁿ]ᶻ ≡ pos x
-- absᶻ⁺¹-identity⁺ zero p = ⊥-elim {A = λ _ → [1+ absᶻ⁺¹ (pos zero) ⁿ]ᶻ ≡ pos zero} (<ⁿ-irrefl 0 p)
-- absᶻ⁺¹-identity⁺ (suc x) p = refl
--
-- absᶻ⁺¹-identity⁻ : ∀ x → [ 0 <ⁿ x ] → [1+ absᶻ⁺¹ (neg x) ⁿ]ᶻ ≡ pos x
-- absᶻ⁺¹-identity⁻ zero p = ⊥-elim {A = λ _ → [1+ absᶻ⁺¹ (neg zero) ⁿ]ᶻ ≡ pos zero} (<ⁿ-irrefl 0 p)
-- absᶻ⁺¹-identity⁻ (suc x) p = refl
absᶻ⁺¹-identity : ∀ x → [ x #ᶻ 0 ] → [1+ absᶻ⁺¹ x ⁿ]ᶻ ≡ pos (absᶻ x)
absᶻ⁺¹-identity (pos zero) p = ⊥-elim {A = λ _ → pos 1 ≡ pos 0} $ #ᶻ⇒≢ (posneg i0) p refl
absᶻ⁺¹-identity (neg zero) p = ⊥-elim {A = λ _ → pos 1 ≡ pos 0} $ #ᶻ⇒≢ (posneg i1) p posneg
absᶻ⁺¹-identity (posneg i) p = ⊥-elim {A = λ _ → pos 1 ≡ pos 0} $ #ᶻ⇒≢ (posneg i ) p (λ j → posneg (i ∧ j))
absᶻ⁺¹-identity (pos (suc n)) p = refl
absᶻ⁺¹-identity (neg (suc n)) p = refl
absᶻ⁺¹-identityⁿ : ∀ x → [ x #ᶻ 0 ] → suc (ℕ₊₁.n (absᶻ⁺¹ x)) ≡ absᶻ x
absᶻ⁺¹-identityⁿ x p i = absᶻ (absᶻ⁺¹-identity x p i)
sign' : ℤ × ℕ₊₁ → Sign
sign' (z , n) = signᶻ z
sign'-preserves-∼ : (a b : ℤ × ℕ₊₁) → a ∼ b → sign' a ≡ sign' b
sign'-preserves-∼ a@(aᶻ , aⁿ) b@(bᶻ , bⁿ) p = sym (lem aᶻ bⁿ) ∙ ψ ∙ lem bᶻ aⁿ where
a' = absᶻ aᶻ ·ⁿ suc (ℕ₊₁.n bⁿ)
b' = absᶻ bᶻ ·ⁿ suc (ℕ₊₁.n aⁿ)
γ : signed (signᶻ aᶻ ⊕ spos) a' ≡ signed (signᶻ bᶻ ⊕ spos) b'
γ = p
ψ : signᶻ (signed (signᶻ aᶻ ⊕ spos) a') ≡ signᶻ (signed (signᶻ bᶻ ⊕ spos) b')
ψ i = signᶻ (γ i)
lem : ∀ x y → signᶻ (signed (signᶻ x ⊕ spos) (absᶻ x ·ⁿ suc (ℕ₊₁.n y))) ≡ signᶻ x
lem (pos zero) y = refl
lem (neg zero) y = refl
lem (posneg i) y = refl
lem (pos (suc n)) y = refl
lem (neg (suc n)) y = refl
sign : ℚ → Sign
sign = SetQuotient.rec {R = _∼_} {B = Sign} Bool.isSetBool sign' sign'-preserves-∼
sign-signᶻ-identity : ∀ z n → sign [ z , n ]ᶠ ≡ signᶻ z
sign-signᶻ-identity z n = refl
|
algebraic-stack_agda0000_doc_8515 | -- TODO: Generalize and move to Structure.Categorical.Proofs
module Structure.Category.Proofs where
import Lvl
open import Data
open import Data.Tuple as Tuple using (_,_)
open import Functional using (const ; swap ; _$_)
open import Lang.Instance
open import Logic
open import Logic.Propositional
open import Logic.Predicate
open import Structure.Category
open import Structure.Categorical.Names
open import Structure.Categorical.Properties
import Structure.Operator.Properties as Properties
open import Structure.Operator
open import Structure.Relator.Equivalence
open import Structure.Relator.Properties
open import Structure.Setoid
open import Syntax.Function
open import Syntax.Transitivity
open import Type
module _
{ℓₒ ℓₘ ℓₑ : Lvl.Level}
{Obj : Type{ℓₒ}}
{Morphism : Obj → Obj → Type{ℓₘ}}
⦃ morphism-equiv : ∀{x y} → Equiv{ℓₑ}(Morphism x y) ⦄
(cat : Category(Morphism))
where
open Category(cat)
open Category.ArrowNotation(cat)
open Morphism.OperModule(\{x} → _∘_ {x})
open Morphism.IdModule(\{x} → _∘_ {x})(id)
private open module [≡]-Equivalence {x}{y} = Equivalence (Equiv-equivalence ⦃ morphism-equiv{x}{y} ⦄) using ()
private variable x y z : Obj
private variable f g h i : x ⟶ y
associate4-123-321 : (((f ∘ g) ∘ h) ∘ i ≡ f ∘ (g ∘ (h ∘ i)))
associate4-123-321 = Morphism.associativity(_∘_) 🝖 Morphism.associativity(_∘_)
associate4-123-213 : (((f ∘ g) ∘ h) ∘ i ≡ (f ∘ (g ∘ h)) ∘ i)
associate4-123-213 = congruence₂ₗ(_∘_)(_) (Morphism.associativity(_∘_))
associate4-321-231 : (f ∘ (g ∘ (h ∘ i)) ≡ f ∘ ((g ∘ h) ∘ i))
associate4-321-231 = congruence₂ᵣ(_∘_)(_) (symmetry(_≡_) (Morphism.associativity(_∘_)))
associate4-213-121 : ((f ∘ (g ∘ h)) ∘ i ≡ (f ∘ g) ∘ (h ∘ i))
associate4-213-121 = symmetry(_≡_) (congruence₂ₗ(_∘_)(_) (Morphism.associativity(_∘_))) 🝖 Morphism.associativity(_∘_)
associate4-231-213 : f ∘ ((g ∘ h) ∘ i) ≡ (f ∘ (g ∘ h)) ∘ i
associate4-231-213 = symmetry(_≡_) (Morphism.associativity(_∘_))
associate4-231-123 : f ∘ ((g ∘ h) ∘ i) ≡ ((f ∘ g) ∘ h) ∘ i
associate4-231-123 = associate4-231-213 🝖 symmetry(_≡_) associate4-123-213
associate4-231-121 : (f ∘ ((g ∘ h) ∘ i) ≡ (f ∘ g) ∘ (h ∘ i))
associate4-231-121 = congruence₂ᵣ(_∘_)(_) (Morphism.associativity(_∘_)) 🝖 symmetry(_≡_) (Morphism.associativity(_∘_))
id-automorphism : Automorphism(id{x})
∃.witness id-automorphism = id
∃.proof id-automorphism = intro(Morphism.identityₗ(_∘_)(id)) , intro(Morphism.identityᵣ(_∘_)(id))
inverse-isomorphism : (f : x ⟶ y) → ⦃ _ : Isomorphism(f) ⦄ → Isomorphism(inv f)
∃.witness (inverse-isomorphism f) = f
∃.proof (inverse-isomorphism f) = intro (inverseᵣ(f)(inv f)) , intro (inverseₗ(f)(inv f)) where
open Isomorphism(f)
module _ ⦃ op : ∀{x y z} → BinaryOperator(_∘_ {x}{y}{z}) ⦄ where
op-closed-under-isomorphism : ∀{A B C : Obj} → (f : B ⟶ C) → (g : A ⟶ B) → ⦃ _ : Isomorphism(f) ⦄ → ⦃ _ : Isomorphism(g) ⦄ → Isomorphism(f ∘ g)
∃.witness (op-closed-under-isomorphism f g) = inv g ∘ inv f
Tuple.left (∃.proof (op-closed-under-isomorphism f g)) = intro $
(inv g ∘ inv f) ∘ (f ∘ g) 🝖-[ associate4-213-121 ]-sym
(inv g ∘ (inv f ∘ f)) ∘ g 🝖-[ congruence₂ₗ(_∘_) ⦃ op ⦄ (g) (congruence₂ᵣ(_∘_) ⦃ op ⦄ (inv g) (Morphism.inverseₗ(_∘_)(id) (f)(inv f))) ]
(inv g ∘ id) ∘ g 🝖-[ congruence₂ₗ(_∘_) ⦃ op ⦄ (g) (Morphism.identityᵣ(_∘_)(id)) ]
inv g ∘ g 🝖-[ Morphism.inverseₗ(_∘_)(id) (g)(inv g) ]
id 🝖-end
where
open Isomorphism(f)
open Isomorphism(g)
Tuple.right (∃.proof (op-closed-under-isomorphism f g)) = intro $
(f ∘ g) ∘ (inv g ∘ inv f) 🝖-[ associate4-213-121 ]-sym
(f ∘ (g ∘ inv g)) ∘ inv f 🝖-[ congruence₂ₗ(_∘_) ⦃ op ⦄ (_) (congruence₂ᵣ(_∘_) ⦃ op ⦄ (_) (Morphism.inverseᵣ(_∘_)(id) (_)(_))) ]
(f ∘ id) ∘ inv f 🝖-[ congruence₂ₗ(_∘_) ⦃ op ⦄ (_) (Morphism.identityᵣ(_∘_)(id)) ]
f ∘ inv f 🝖-[ Morphism.inverseᵣ(_∘_)(id) (_)(_) ]
id 🝖-end
where
open Isomorphism(f)
open Isomorphism(g)
instance
Isomorphic-reflexivity : Reflexivity(Isomorphic)
∃.witness (Reflexivity.proof Isomorphic-reflexivity) = id
∃.proof (Reflexivity.proof Isomorphic-reflexivity) = id-automorphism
instance
Isomorphic-symmetry : Symmetry(Isomorphic)
∃.witness (Symmetry.proof Isomorphic-symmetry iso-xy) = inv(∃.witness iso-xy)
∃.proof (Symmetry.proof Isomorphic-symmetry iso-xy) = inverse-isomorphism(∃.witness iso-xy)
module _ ⦃ op : ∀{x y z} → BinaryOperator(_∘_ {x}{y}{z}) ⦄ where
instance
Isomorphic-transitivity : Transitivity(Isomorphic)
∃.witness (Transitivity.proof Isomorphic-transitivity ([∃]-intro xy) ([∃]-intro yz)) = yz ∘ xy
∃.proof (Transitivity.proof Isomorphic-transitivity ([∃]-intro xy) ([∃]-intro yz)) = op-closed-under-isomorphism ⦃ op ⦄ yz xy
instance
Isomorphic-equivalence : Equivalence(Isomorphic)
Isomorphic-equivalence = record{}
|
algebraic-stack_agda0000_doc_8516 | module OscarEverything where
open import OscarPrelude
open import HasSubstantiveDischarge
|
algebraic-stack_agda0000_doc_8517 | {-# OPTIONS --cubical --safe #-}
module Cardinality.Finite.SplitEnumerable.Instances where
open import Cardinality.Finite.SplitEnumerable
open import Cardinality.Finite.SplitEnumerable.Inductive
open import Cardinality.Finite.ManifestBishop using (_|Π|_)
open import Data.Fin
open import Prelude
open import Data.List.Membership
open import Data.Tuple
import Data.Unit.UniversePolymorphic as Poly
private
infixr 4 _?×_
data _?×_ (A : Type a) (B : Type b) : Type (a ℓ⊔ b) where
pair : A → B → A ?× B
instance
poly-inst : ∀ {a} → Poly.⊤ {a}
poly-inst = Poly.tt
module _ {a b} {A : Type a} (B : A → Type b) where
Im-Type : (xs : List A) → Type (a ℓ⊔ b)
Im-Type = foldr (λ x xs → ℰ! (B x) ?× xs) Poly.⊤
Tup-Im-Lookup : ∀ x (xs : List A) → x ∈ xs → Im-Type xs → ℰ! (B x)
Tup-Im-Lookup x (y ∷ xs) (f0 , y≡x ) (pair ℰ!⟨Bx⟩ _) = subst (ℰ! ∘ B) y≡x ℰ!⟨Bx⟩
Tup-Im-Lookup x (y ∷ xs) (fs n , x∈ys) (pair _ tup) = Tup-Im-Lookup x xs (n , x∈ys) tup
Tup-Im-Pi : (xs : ℰ! A) → Im-Type (xs .fst) → ∀ x → ℰ! (B x)
Tup-Im-Pi xs tup x = Tup-Im-Lookup x (xs .fst) (xs .snd x) tup
instance
inst-pair : ⦃ lhs : A ⦄ ⦃ rhs : B ⦄ → A ?× B
inst-pair ⦃ lhs ⦄ ⦃ rhs ⦄ = pair lhs rhs
instance
fin-sigma : ⦃ lhs : ℰ! A ⦄ {B : A → Type b} → ⦃ rhs : Im-Type B (lhs .fst) ⦄ → ℰ! (Σ A B)
fin-sigma ⦃ lhs ⦄ ⦃ rhs ⦄ = lhs |Σ| Tup-Im-Pi _ lhs rhs
instance
fin-pi : ⦃ lhs : ℰ! A ⦄ {B : A → Type b} → ⦃ rhs : Im-Type B (lhs .fst) ⦄ → (ℰ! ((x : A) → B x))
fin-pi ⦃ lhs ⦄ ⦃ rhs ⦄ = lhs |Π| Tup-Im-Pi _ lhs rhs
-- instance
-- fin-prod : ⦃ lhs : ℰ! A ⦄ ⦃ rhs : ℰ! B ⦄ → ℰ! (A × B)
-- fin-prod ⦃ lhs ⦄ ⦃ rhs ⦄ = lhs |×| rhs
-- instance
-- fin-fun : {A B : Type₀} ⦃ lhs : ℰ! A ⦄ ⦃ rhs : ℰ! B ⦄ → ℰ! (A → B)
-- fin-fun ⦃ lhs ⦄ ⦃ rhs ⦄ = lhs |Π| λ _ → rhs
instance
fin-sum : ⦃ lhs : ℰ! A ⦄ ⦃ rhs : ℰ! B ⦄ → ℰ! (A ⊎ B)
fin-sum ⦃ lhs ⦄ ⦃ rhs ⦄ = lhs |⊎| rhs
instance
fin-bool : ℰ! Bool
fin-bool = ℰ!⟨2⟩
instance
fin-top : ℰ! ⊤
fin-top = ℰ!⟨⊤⟩
instance
fin-bot : ℰ! ⊥
fin-bot = ℰ!⟨⊥⟩
instance
fin-fin : ∀ {n} → ℰ! (Fin n)
fin-fin = ℰ!⟨Fin⟩
|
algebraic-stack_agda0000_doc_8518 | -- 2012-03-08 Andreas
module _ where
{-# TERMINATING #-}
-- error: misplaced pragma
|
algebraic-stack_agda0000_doc_8519 | -- Andreas, 2014-01-16, issue 1406
-- Agda with K again is inconsistent with classical logic
-- {-# OPTIONS --cubical-compatible #-}
open import Common.Level
open import Common.Prelude
open import Common.Equality
cast : {A B : Set} (p : A ≡ B) (a : A) → B
cast refl a = a
data HEq {α} {A : Set α} (a : A) : {B : Set α} (b : B) → Set (lsuc α) where
refl : HEq a a
mkHet : {A B : Set} (eq : A ≡ B) (a : A) → HEq a (cast eq a)
mkHet refl a = refl
-- Type with a big forced index. (Allowed unless --cubical-compatible.)
-- This definition is allowed in Agda master since 2014-10-17
-- https://github.com/agda/agda/commit/9a4ebdd372dc0510e2d77e726fb0f4e6f56781e8
-- However, probably the consequences of this new feature have not
-- been grasped fully yet.
data SING : (F : Set → Set) → Set where
sing : (F : Set → Set) → SING F
-- The following theorem is the culprit.
-- It needs K.
-- It allows us to unify forced indices, which I think is wrong.
thm : ∀{F G : Set → Set} (a : SING F) (b : SING G) (p : HEq a b) → F ≡ G
thm (sing F) (sing .F) refl = refl
-- Note that a direct matching fails, as it generates heterogeneous constraints.
-- thm a .a refl = refl
-- However, by matching on the constructor sing, the forced index
-- is exposed to unification.
-- As a consequence of thm,
-- SING is injective which it clearly should not be.
SING-inj : ∀ (F G : Set → Set) (p : SING F ≡ SING G) → F ≡ G
SING-inj F G p = thm (sing F) _ (mkHet p (sing F))
-- The rest is an adaption of Chung-Kil Hur's proof (2010)
data Either {α} (A B : Set α) : Set α where
inl : A → Either A B
inr : B → Either A B
data Inv (A : Set) : Set1 where
inv : (F : Set → Set) (eq : SING F ≡ A) → Inv A
¬ : ∀{α} → Set α → Set α
¬ A = A → ⊥
-- Classical logic
postulate em : ∀{α} (A : Set α) → Either A (¬ A)
Cantor' : (A : Set) → Either (Inv A) (¬ (Inv A)) → Set
Cantor' A (inl (inv F eq)) = ¬ (F A)
Cantor' A (inr _) = ⊤
Cantor : Set → Set
Cantor A = Cantor' A (em (Inv A))
C : Set
C = SING Cantor
ic : Inv C
ic = inv Cantor refl
cast' : ∀{F G} → SING F ≡ SING G → ¬ (F C) → ¬ (G C)
cast' eq = subst (λ F → ¬ (F C)) (SING-inj _ _ eq)
-- Self application 1
diag : ¬ (Cantor C)
diag c with em (Inv C) | c
diag c | inl (inv F eq) | c' = cast' eq c' c
diag _ | inr f | _ = f ic
-- Self application 2
diag' : Cantor C
diag' with em (Inv C)
diag' | inl (inv F eq) = cast' (sym eq) diag
diag' | inr _ = _
absurd : ⊥
absurd = diag diag'
|
algebraic-stack_agda0000_doc_8520 | {-# OPTIONS --cubical-compatible #-}
------------------------------------------------------------------------
-- Universe levels
------------------------------------------------------------------------
module Common.Level where
open import Agda.Primitive public using (Level; lzero; lsuc; _⊔_)
-- Lifting.
record Lift {a ℓ} (A : Set a) : Set (a ⊔ ℓ) where
constructor lift
field lower : A
open Lift public
|
algebraic-stack_agda0000_doc_8521 | {- 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
-}
{-# OPTIONS --allow-unsolved-metas #-}
-- This module provides some scaffolding to define the handlers for our fake/simple "implementation"
-- and connect them to the interface of the SystemModel.
open import Optics.All
open import LibraBFT.Prelude
open import LibraBFT.Lemmas
open import LibraBFT.Base.ByteString
open import LibraBFT.Base.Encode
open import LibraBFT.Base.KVMap
open import LibraBFT.Base.PKCS
open import LibraBFT.Hash
open import LibraBFT.Impl.Base.Types
open import LibraBFT.Impl.Consensus.Types
open import LibraBFT.Impl.Util.Util
open import LibraBFT.Impl.Properties.Aux -- TODO-1: maybe Aux properties should be in this file?
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
module LibraBFT.Impl.Handle.Properties
(hash : BitString → Hash)
(hash-cr : ∀{x y} → hash x ≡ hash y → Collision hash x y ⊎ x ≡ y)
where
open import LibraBFT.Impl.Consensus.ChainedBFT.EventProcessor hash hash-cr
open import LibraBFT.Impl.Handle hash hash-cr
----- Properties that bridge the system model gap to the handler -----
msgsToSendWereSent1 : ∀ {pid ts pm vm} {st : EventProcessor}
→ send (V vm) ∈ proj₂ (peerStep pid (P pm) ts st)
→ ∃[ αs ] (SendVote vm αs ∈ LBFT-outs (handle pid (P pm) ts) st)
msgsToSendWereSent1 {pid} {ts} {pm} {vm} {st} send∈acts
with send∈acts
-- The fake handler sends only to node 0 (fakeAuthor), so this doesn't
-- need to be very general yet.
-- TODO-1: generalize this proof so it will work when the set of recipients is
-- not hard coded.
-- The system model allows any message sent to be received by any peer (so the list of
-- recipients it essentially ignored), meaning that our safety proofs will be for a slightly
-- stronger model. Progress proofs will require knowledge of recipients, though, so we will
-- keep the implementation model faithful to the implementation.
...| here refl = fakeAuthor ∷ [] , here refl
msgsToSendWereSent : ∀ {pid ts nm m} {st : EventProcessor}
→ m ∈ proj₂ (peerStepWrapper pid nm st)
→ ∃[ vm ] (m ≡ V vm × send (V vm) ∈ proj₂ (peerStep pid nm ts st))
msgsToSendWereSent {pid} {nm = nm} {m} {st} m∈outs
with nm
...| C _ = ⊥-elim (¬Any[] m∈outs)
...| V _ = ⊥-elim (¬Any[] m∈outs)
...| P pm
with m∈outs
...| here v∈outs
with m
...| P _ = ⊥-elim (P≢V v∈outs)
...| C _ = ⊥-elim (C≢V v∈outs)
...| V vm rewrite sym v∈outs = vm , refl , here refl
----- Properties that relate handler to system state -----
postulate -- TODO-2: this will be proved for the implementation, confirming that honest
-- participants only store QCs comprising votes that have actually been sent.
-- Votes stored in highesQuorumCert and highestCommitCert were sent before.
-- Note that some implementations might not ensure this, but LibraBFT does
-- because even the leader of the next round sends its own vote to itself,
-- as opposed to using it to construct a QC using its own unsent vote.
qcVotesSentB4 : ∀{e pid ps vs pk q vm}{st : SystemState e}
→ ReachableSystemState st
→ initialised st pid ≡ initd
→ ps ≡ peerStates st pid
→ q QC∈VoteMsg vm
→ vm ^∙ vmSyncInfo ≡ mkSyncInfo (ps ^∙ epHighestQC) (ps ^∙ epHighestCommitQC)
→ vs ∈ qcVotes q
→ MsgWithSig∈ pk (proj₂ vs) (msgPool st)
|
algebraic-stack_agda0000_doc_8522 | module utm where
open import turing
open import Data.Product
-- open import Data.Bool
open import Data.List
open import Data.Nat
open import logic
data utmStates : Set where
reads : utmStates
read0 : utmStates
read1 : utmStates
read2 : utmStates
read3 : utmStates
read4 : utmStates
read5 : utmStates
read6 : utmStates
loc0 : utmStates
loc1 : utmStates
loc2 : utmStates
loc3 : utmStates
loc4 : utmStates
loc5 : utmStates
loc6 : utmStates
fetch0 : utmStates
fetch1 : utmStates
fetch2 : utmStates
fetch3 : utmStates
fetch4 : utmStates
fetch5 : utmStates
fetch6 : utmStates
fetch7 : utmStates
print0 : utmStates
print1 : utmStates
print2 : utmStates
print3 : utmStates
print4 : utmStates
print5 : utmStates
print6 : utmStates
print7 : utmStates
mov0 : utmStates
mov1 : utmStates
mov2 : utmStates
mov3 : utmStates
mov4 : utmStates
mov5 : utmStates
mov6 : utmStates
tidy0 : utmStates
tidy1 : utmStates
halt : utmStates
data utmΣ : Set where
０ : utmΣ
１ : utmΣ
B : utmΣ
* : utmΣ
$ : utmΣ
^ : utmΣ
X : utmΣ
Y : utmΣ
Z : utmΣ
＠ : utmΣ
b : utmΣ
utmδ : utmStates → utmΣ → utmStates × (Write utmΣ) × Move
utmδ reads x = read0 , wnone , mnone
utmδ read0 * = read1 , write * , left
utmδ read0 x = read0 , write x , right
utmδ read1 x = read2 , write ＠ , right
utmδ read2 ^ = read3 , write ^ , right
utmδ read2 x = read2 , write x , right
utmδ read3 ０ = read4 , write ０ , left
utmδ read3 １ = read5 , write １ , left
utmδ read3 b = read6 , write b , left
utmδ read4 ＠ = loc0 , write ０ , right
utmδ read4 x = read4 , write x , left
utmδ read5 ＠ = loc0 , write １ , right
utmδ read5 x = read5 , write x , left
utmδ read6 ＠ = loc0 , write B , right
utmδ read6 x = read6 , write x , left
utmδ loc0 ０ = loc0 , write X , left
utmδ loc0 １ = loc0 , write Y , left
utmδ loc0 B = loc0 , write Z , left
utmδ loc0 $ = loc1 , write $ , right
utmδ loc0 x = loc0 , write x , left
utmδ loc1 X = loc2 , write ０ , right
utmδ loc1 Y = loc3 , write １ , right
utmδ loc1 Z = loc4 , write B , right
utmδ loc1 * = fetch0 , write * , right
utmδ loc1 x = loc1 , write x , right
utmδ loc2 ０ = loc5 , write X , right
utmδ loc2 １ = loc6 , write Y , right
utmδ loc2 B = loc6 , write Z , right
utmδ loc2 x = loc2 , write x , right
utmδ loc3 １ = loc5 , write Y , right
utmδ loc3 ０ = loc6 , write X , right
utmδ loc3 B = loc6 , write Z , right
utmδ loc3 x = loc3 , write x , right
utmδ loc4 B = loc5 , write Z , right
utmδ loc4 ０ = loc6 , write X , right
utmδ loc4 １ = loc6 , write Y , right
utmδ loc4 x = loc4 , write x , right
utmδ loc5 $ = loc1 , write $ , right
utmδ loc5 x = loc5 , write x , left
utmδ loc6 $ = halt , write $ , right
utmδ loc6 * = loc0 , write * , left
utmδ loc6 x = loc6 , write x , right
utmδ fetch0 ０ = fetch1 , write X , left
utmδ fetch0 １ = fetch2 , write Y , left
utmδ fetch0 B = fetch3 , write Z , left
utmδ fetch0 x = fetch0 , write x , right
utmδ fetch1 $ = fetch4 , write $ , right
utmδ fetch1 x = fetch1 , write x , left
utmδ fetch2 $ = fetch5 , write $ , right
utmδ fetch2 x = fetch2 , write x , left
utmδ fetch3 $ = fetch6 , write $ , right
utmδ fetch3 x = fetch3 , write x , left
utmδ fetch4 ０ = fetch7 , write X , right
utmδ fetch4 １ = fetch7 , write X , right
utmδ fetch4 B = fetch7 , write X , right
utmδ fetch4 * = print0 , write * , left
utmδ fetch4 x = fetch4 , write x , right
utmδ fetch5 ０ = fetch7 , write Y , right
utmδ fetch5 １ = fetch7 , write Y , right
utmδ fetch5 B = fetch7 , write Y , right
utmδ fetch5 * = print0 , write * , left
utmδ fetch5 x = fetch5 , write x , right
utmδ fetch6 ０ = fetch7 , write Z , right
utmδ fetch6 １ = fetch7 , write Z , right
utmδ fetch6 B = fetch7 , write Z , right
utmδ fetch6 * = print0 , write * , left
utmδ fetch6 x = fetch6 , write x , right
utmδ fetch7 * = fetch0 , write * , right
utmδ fetch7 x = fetch7 , write x , right
utmδ print0 X = print1 , write X , right
utmδ print0 Y = print2 , write Y , right
utmδ print0 Z = print3 , write Z , right
utmδ print1 ^ = print4 , write ^ , right
utmδ print1 x = print1 , write x , right
utmδ print2 ^ = print5 , write ^ , right
utmδ print2 x = print2 , write x , right
utmδ print3 ^ = print6 , write ^ , right
utmδ print3 x = print3 , write x , right
utmδ print4 x = print7 , write ０ , left
utmδ print5 x = print7 , write １ , left
utmδ print6 x = print7 , write B , left
utmδ print7 X = mov0 , write X , right
utmδ print7 Y = mov1 , write Y , right
utmδ print7 x = print7 , write x , left
utmδ mov0 ^ = mov2 , write ^ , left
utmδ mov0 x = mov0 , write x , right
utmδ mov1 ^ = mov3 , write ^ , right
utmδ mov1 x = mov1 , write x , right
utmδ mov2 ０ = mov4 , write ^ , right
utmδ mov2 １ = mov5 , write ^ , right
utmδ mov2 B = mov6 , write ^ , right
utmδ mov3 ０ = mov4 , write ^ , left
utmδ mov3 １ = mov5 , write ^ , left
utmδ mov3 B = mov6 , write ^ , left
utmδ mov4 ^ = tidy0 , write ０ , left
utmδ mov5 ^ = tidy0 , write １ , left
utmδ mov6 ^ = tidy0 , write B , left
utmδ tidy0 $ = tidy1 , write $ , left
utmδ tidy0 x = tidy0 , write x , left
utmδ tidy1 X = tidy1 , write ０ , left
utmδ tidy1 Y = tidy1 , write １ , left
utmδ tidy1 Z = tidy1 , write B , left
utmδ tidy1 $ = reads , write $ , right
utmδ tidy1 x = tidy1 , write x , left
utmδ _ x = halt , write x , mnone
U-TM : Turing utmStates utmΣ
U-TM = record {
tδ = utmδ
; tstart = read0
; tend = tend
; tnone = b
} where
tend : utmStates → Bool
tend halt = true
tend _ = false
-- Copyδ : CopyStates → ℕ → CopyStates × ( Write ℕ ) × Move
-- Copyδ s1 0 = H , wnone , mnone
-- Copyδ s1 1 = s2 , write 0 , right
-- Copyδ s2 0 = s3 , write 0 , right
-- Copyδ s2 1 = s2 , write 1 , right
-- Copyδ s3 0 = s4 , write 1 , left
-- Copyδ s3 1 = s3 , write 1 , right
-- Copyδ s4 0 = s5 , write 0 , left
-- Copyδ s4 1 = s4 , write 1 , left
-- Copyδ s5 0 = s1 , write 1 , right
-- Copyδ s5 1 = s5 , write 1 , left
-- Copyδ H _ = H , wnone , mnone
-- Copyδ _ (suc (suc _)) = H , wnone , mnone
Copyδ-encode : List utmΣ
Copyδ-encode =
０ ∷ ０ ∷ １ ∷ ０ ∷ １ ∷ １ ∷ ０ ∷ ０ ∷ ０ ∷ ０ ∷ -- s1 0 = H , wnone , mnone
* ∷ ０ ∷ ０ ∷ １ ∷ １ ∷ ０ ∷ １ ∷ ０ ∷ ０ ∷ ０ ∷ １ ∷ -- s1 1 = s2 , write 0 , right
* ∷ ０ ∷ １ ∷ ０ ∷ ０ ∷ ０ ∷ １ ∷ １ ∷ ０ ∷ ０ ∷ １ ∷ -- s2 0 = s3 , write 0 , right
* ∷ ０ ∷ １ ∷ ０ ∷ １ ∷ ０ ∷ １ ∷ ０ ∷ １ ∷ ０ ∷ １ ∷ -- s2 1 = s2 , write 1 , right
* ∷ ０ ∷ １ ∷ １ ∷ ０ ∷ １ ∷ ０ ∷ ０ ∷ １ ∷ ０ ∷ ０ ∷ -- s3 0 = s4 , write 1 , left
* ∷ ０ ∷ １ ∷ １ ∷ １ ∷ ０ ∷ １ ∷ １ ∷ １ ∷ ０ ∷ １ ∷ -- s3 1 = s3 , write 1 , right
* ∷ １ ∷ ０ ∷ ０ ∷ ０ ∷ １ ∷ ０ ∷ １ ∷ ０ ∷ ０ ∷ ０ ∷ -- s4 0 = s5 , write 0 , left
* ∷ １ ∷ ０ ∷ ０ ∷ １ ∷ １ ∷ ０ ∷ ０ ∷ １ ∷ ０ ∷ ０ ∷ -- s4 1 = s4 , write 1 , left
* ∷ １ ∷ ０ ∷ １ ∷ ０ ∷ ０ ∷ ０ ∷ １ ∷ １ ∷ ０ ∷ １ ∷ -- s5 0 = s1 , write 1 , right
* ∷ １ ∷ ０ ∷ １ ∷ １ ∷ １ ∷ ０ ∷ １ ∷ １ ∷ ０ ∷ ０ ∷ -- s5 1 = s5 , write 1 , left
[]
input-encode : List utmΣ
input-encode = １ ∷ １ ∷ ０ ∷ ０ ∷ ０ ∷ []
input+Copyδ : List utmΣ
input+Copyδ = ( $ ∷ ０ ∷ ０ ∷ ０ ∷ ０ ∷ * ∷ [] ) -- start state
++ Copyδ-encode
++ ( $ ∷ ^ ∷ input-encode )
short-input : List utmΣ
short-input = $ ∷ ０ ∷ ０ ∷ ０ ∷ * ∷
０ ∷ ０ ∷ ０ ∷ １ ∷ ０ ∷ １ ∷ １ ∷ * ∷
０ ∷ ０ ∷ １ ∷ ０ ∷ １ ∷ １ ∷ １ ∷ * ∷
０ ∷ １ ∷ B ∷ １ ∷ ０ ∷ １ ∷ ０ ∷ * ∷
１ ∷ ０ ∷ ０ ∷ ０ ∷ １ ∷ １ ∷ １ ∷ $ ∷
^ ∷ ０ ∷ ０ ∷ １ ∷ １ ∷ []
utm-test1 : List utmΣ → utmStates × ( List utmΣ ) × ( List utmΣ )
utm-test1 inp = Turing.taccept U-TM inp
{-# TERMINATING #-}
utm-test2 : ℕ → List utmΣ → utmStates × ( List utmΣ ) × ( List utmΣ )
utm-test2 n inp = loop n (Turing.tstart U-TM) inp []
where
loop : ℕ → utmStates → ( List utmΣ ) → ( List utmΣ ) → utmStates × ( List utmΣ ) × ( List utmΣ )
loop zero q L R = ( q , L , R )
loop (suc n) q L R with move {utmStates} {utmΣ} {０} {utmδ} q L R | q
... | nq , nL , nR | reads = loop n nq nL nR
... | nq , nL , nR | _ = loop (suc n) nq nL nR
t1 = utm-test2 20 short-input
t : (n : ℕ) → utmStates × ( List utmΣ ) × ( List utmΣ )
-- t n = utm-test2 n input+Copyδ
t n = utm-test2 n short-input
|
algebraic-stack_agda0000_doc_8523 | {-# OPTIONS --safe #-}
module Cubical.HITs.TypeQuotients where
open import Cubical.HITs.TypeQuotients.Base public
open import Cubical.HITs.TypeQuotients.Properties public
|
algebraic-stack_agda0000_doc_8524 |
data _≡_ {A : Set} (x : A) : A → Set where
refl : x ≡ x
cong : ∀ {A B : Set} (f : A → B) {x y : A} → x ≡ y → f x ≡ f y
cong f refl = refl
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
data Fin : ℕ → Set where
zero : {n : ℕ} → Fin (suc n)
suc : {n : ℕ} (i : Fin n) → Fin (suc n)
data _≤_ : ℕ → ℕ → Set where
zero : ∀ {n} → zero ≤ n
suc : ∀ {m n} (le : m ≤ n) → suc m ≤ suc n
_<_ : ℕ → ℕ → Set
m < n = suc m ≤ n
toℕ : ∀ {n} → Fin n → ℕ
toℕ zero = zero
toℕ (suc i) = suc (toℕ i)
fromℕ≤ : ∀ {m n} → m < n → Fin n
fromℕ≤ (suc zero) = zero
fromℕ≤ (suc (suc m≤n)) = suc (fromℕ≤ (suc m≤n))
-- If we treat constructors as inert this fails to solve. Not entirely sure why.
fromℕ≤-toℕ : ∀ {m} (i : Fin m) (i<m : toℕ i < m) → fromℕ≤ i<m ≡ i
fromℕ≤-toℕ zero (suc zero) = refl
fromℕ≤-toℕ (suc i) (suc (suc m≤n)) = cong suc (fromℕ≤-toℕ i (suc m≤n))
|
algebraic-stack_agda0000_doc_8525 | {-# OPTIONS --no-positivity-check #-}
module IIRDg where
import LF
import DefinitionalEquality
import IIRD
open LF
open DefinitionalEquality
open IIRD
mutual
data Ug {I : Set}{D : I -> Set1}(γ : OPg I D) : I -> Set where
introg : (a : Gu γ (Ug γ) (Tg γ)) -> Ug γ (Gi γ (Ug γ) (Tg γ) a)
Tg : {I : Set}{D : I -> Set1}(γ : OPg I D)(i : I) -> Ug γ i -> D i
Tg γ .(Gi γ (Ug γ) (Tg γ) a) (introg a) = Gt γ (Ug γ) (Tg γ) a
Arg : {I : Set}{D : I -> Set1}(γ : OPg I D) -> Set
Arg γ = Gu γ (Ug γ) (Tg γ)
index : {I : Set}{D : I -> Set1}(γ : OPg I D) -> Arg γ -> I
index γ a = Gi γ (Ug γ) (Tg γ) a
IH : {I : Set}{D : I -> Set1}(γ : OPg I D)(F : (i : I) -> Ug γ i -> Set1) -> Arg γ -> Set1
IH γ = KIH γ (Ug γ) (Tg γ)
-- Elimination rule
Rg : {I : Set}{D : I -> Set1}(γ : OPg I D)(F : (i : I) -> Ug γ i -> Set1) ->
(h : (a : Arg γ) -> IH γ F a -> F (index γ a) (introg a)) ->
(i : I)(u : Ug γ i) -> F i u
Rg γ F h .(index γ a) (introg a) = h a (Kmap γ (Ug γ) (Tg γ) F (Rg γ F h) a)
{-
-- We don't have general IIRDs so we have to postulate Ug/Tg
postulate
Ug : {I : Set}{D : I -> Set1} -> OPg I D -> I -> Set
Tg : {I : Set}{D : I -> Set1}(γ : OPg I D)(i : I) -> Ug γ i -> D i
introg : {I : Set}{D : I -> Set1}(γ : OPg I D)(a : Gu γ (Ug γ) (Tg γ)) ->
Ug γ (Gi γ (Ug γ) (Tg γ) a)
Tg-equality : {I : Set}{D : I -> Set1}(γ : OPg I D)(a : Gu γ (Ug γ) (Tg γ)) ->
Tg γ (Gi γ (Ug γ) (Tg γ) a) (introg γ a) ≡₁ Gt γ (Ug γ) (Tg γ) a
Rg : {I : Set}{D : I -> Set1}(γ : OPg I D)(F : (i : I) -> Ug γ i -> Set1)
(h : (a : Gu γ (Ug γ) (Tg γ)) -> KIH γ (Ug γ) (Tg γ) F a -> F (Gi γ (Ug γ) (Tg γ) a) (introg γ a))
(i : I)(u : Ug γ i) -> F i u
Rg-equality : {I : Set}{D : I -> Set1}(γ : OPg I D)(F : (i : I) -> Ug γ i -> Set1)
(h : (a : Gu γ (Ug γ) (Tg γ)) -> KIH γ (Ug γ) (Tg γ) F a -> F (Gi γ (Ug γ) (Tg γ) a) (introg γ a))
(a : Gu γ (Ug γ) (Tg γ)) ->
Rg γ F h (Gi γ (Ug γ) (Tg γ) a) (introg γ a)
≡₁ h a (Kmap γ (Ug γ) (Tg γ) F (Rg γ F h) a)
-- Helpers
ι★g : {I : Set}(i : I) -> OPg I (\_ -> One')
ι★g i = ι < i | ★' >'
-- Examples
module Martin-Löf-Identity where
IdOP : {A : Set} -> OPg (A * A) (\_ -> One')
IdOP {A} = σ A \a -> ι★g < a | a >
_==_ : {A : Set}(x y : A) -> Set
x == y = Ug IdOP < x | y >
refl : {A : Set}(x : A) -> x == x
refl x = introg IdOP < x | ★ >
-- We have to work slightly harder than desired since we don't have η for × and One.
private
-- F C is just uncurry C but dependent and at high universes.
F : {A : Set}(C : (x y : A) -> x == y -> Set1)(i : A * A) -> Ug IdOP i -> Set1
F C < x | y > p = C x y p
h' : {A : Set}(C : (x y : A) -> x == y -> Set1)
(h : (x : A) -> C x x (refl x))
(a : Gu IdOP (Ug IdOP) (Tg IdOP)) -> KIH IdOP (Ug IdOP) (Tg IdOP) (F C) a ->
F C (Gi IdOP (Ug IdOP) (Tg IdOP) a) (introg IdOP a)
h' C h < x | ★ > _ = h x
J : {A : Set}(C : (x y : A) -> x == y -> Set1)
(h : (x : A) -> C x x (refl x))
(x y : A)(p : x == y) -> C x y p
J {A} C h x y p = Rg IdOP (F C) (h' C h) < x | y > p
J-equality : {A : Set}(C : (x y : A) -> x == y -> Set1)
(h : (x : A) -> C x x (refl x))(x : A) ->
J C h x x (refl x) ≡₁ h x
J-equality {A} C h x = Rg-equality IdOP (F C) (h' C h) < x | ★ >
module Christine-Identity where
IdOP : {A : Set}(a : A) -> OPg A (\_ -> One')
IdOP {A} a = ι★g a
_==_ : {A : Set}(x y : A) -> Set
x == y = Ug (IdOP x) y
refl : {A : Set}(x : A) -> x == x
refl x = introg (IdOP x) ★
private
h' : {A : Set}(x : A)(C : (y : A) -> x == y -> Set1)
(h : C x (refl x))(a : Gu (IdOP x) (Ug (IdOP x)) (Tg (IdOP x))) ->
KIH (IdOP x) (Ug (IdOP x)) (Tg (IdOP x)) C a ->
C (Gi (IdOP x) (Ug (IdOP x)) (Tg (IdOP x)) a) (introg (IdOP x) a)
h' x C h ★ _ = h
H : {A : Set}(x : A)(C : (y : A) -> x == y -> Set1)
(h : C x (refl x))
(y : A)(p : x == y) -> C y p
H x C h y p = Rg (IdOP x) C (h' x C h) y p
H-equality : {A : Set}(x : A)(C : (y : A) -> x == y -> Set1)
(h : C x (refl x)) ->
H x C h x (refl x) ≡₁ h
H-equality x C h = Rg-equality (IdOP x) C (h' x C h) ★
open Christine-Identity
-}
|
algebraic-stack_agda0000_doc_8526 |
module Oscar.Category.Setoid where
open import Oscar.Builtin.Objectevel
open import Oscar.Property
record IsSetoid {𝔬} {𝔒 : Ø 𝔬} {𝔮} (_≋_ : 𝑴 1 𝔒 𝔮) : Ø 𝔬 ∙̂ 𝔮 where
field
reflexivity : ∀ x → x ≋ x
symmetry : ∀ {x y} → x ≋ y → y ≋ x
transitivity : ∀ {x y} → x ≋ y → ∀ {z} → y ≋ z → x ≋ z
open IsSetoid ⦃ … ⦄ public
record Setoid 𝔬 𝔮 : Ø ↑̂ (𝔬 ∙̂ 𝔮) where
constructor ↑_
infix 4 _≋_
field
{⋆} : Set 𝔬
_≋_ : ⋆ → ⋆ → Set 𝔮
⦃ isSetoid ⦄ : IsSetoid _≋_
open IsSetoid isSetoid public
|
algebraic-stack_agda0000_doc_8527 | module _ where
data Flat (A : Set) : Set where
flat : @♭ A → Flat A
-- the lambda cohesion annotation must match the domain.
into : {A : Set} → A → Flat A
into = λ (@♭ a) → flat a
|
algebraic-stack_agda0000_doc_16480 | {-# 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))) )
|
algebraic-stack_agda0000_doc_16481 | {-# 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))))
|
algebraic-stack_agda0000_doc_16482 |
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}
|
algebraic-stack_agda0000_doc_16483 | 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"
∷ []
|
algebraic-stack_agda0000_doc_16484 |
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
|
algebraic-stack_agda0000_doc_16485 | {-# 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
|
algebraic-stack_agda0000_doc_16486 | ------------------------------------------------------------------------
-- 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
|
algebraic-stack_agda0000_doc_16487 |
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)
|
algebraic-stack_agda0000_doc_16488 | -- 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
|
algebraic-stack_agda0000_doc_16489 | -- 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)
|
algebraic-stack_agda0000_doc_16490 | {-# 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
|
algebraic-stack_agda0000_doc_16491 | {-
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 {φ = φ}
|
algebraic-stack_agda0000_doc_16492 |
-- 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
|
algebraic-stack_agda0000_doc_16493 | {-# 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))
|
algebraic-stack_agda0000_doc_16494 | {-# 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
|
algebraic-stack_agda0000_doc_16495 | -- 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.
|
algebraic-stack_agda0000_doc_16464 | {-# OPTIONS --safe #-}
postulate F : Set → Set
{-# POLARITY F ++ #-}
|
algebraic-stack_agda0000_doc_16465 | {-# 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))
|
algebraic-stack_agda0000_doc_16466 | 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)))))))))))
|
algebraic-stack_agda0000_doc_16467 | -- 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 _≡_
|
algebraic-stack_agda0000_doc_16468 | 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
|
algebraic-stack_agda0000_doc_16469 | {-# 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
|
algebraic-stack_agda0000_doc_16470 |
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
|
algebraic-stack_agda0000_doc_16471 |
-- 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
|
algebraic-stack_agda0000_doc_16472 | {- 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))
|
algebraic-stack_agda0000_doc_16473 | 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₂ )
|
algebraic-stack_agda0000_doc_16474 | 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
|
algebraic-stack_agda0000_doc_16475 | 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′
|
algebraic-stack_agda0000_doc_16476 | 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)
|
algebraic-stack_agda0000_doc_16477 | 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 ε
|
algebraic-stack_agda0000_doc_16478 | 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)))
|
algebraic-stack_agda0000_doc_16479 | {-# 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]
}
|
algebraic-stack_agda0000_doc_16848 |
-- Linear monoidal closed structure for families
module SOAS.Families.Linear {T : Set} where
open import SOAS.Common
open import SOAS.Context {T}
open import SOAS.Sorting {T}
open import SOAS.Families.Core {T}
open import SOAS.Families.Isomorphism {T}
open import Categories.Category.Monoidal
open import Categories.Category.Monoidal.Closed
open import Categories.Functor.Bifunctor
-- | Monoidal tensor and unit
-- Linear tensor product that combines two families with two disjoint contexts
data _⊗_ (X Y : Family) : Ctx → Set where
merge : (Γ Δ : Ctx) → X Γ → Y Δ → (X ⊗ Y) (Δ ∔ Γ)
infixr 20 _⊗_
pattern _⊹_ {Γ}{Δ} t s = merge Γ Δ t s
infix 30 _⊹_
-- ⊗ is a bifunctor
⊗F : Bifunctor 𝔽amilies 𝔽amilies 𝔽amilies
⊗F = record
{ F₀ = λ (X , Y) → X ⊗ Y
; F₁ = λ{ {X , Y}{X′ , Y′} (f , g) (x ⊹ y) → (f x) ⊹ (g y)}
; identity = λ{ {X , Y}{Γ}{x ⊹ y} → refl }
; homomorphism = λ{ {X , Y}{X′ , Y′}{X″ , Y″}{f , g}{f′ , g′}{Γ}{x ⊹ y} → refl }
; F-resp-≈ = λ{ (p₁ , p₂) {.(Δ ∔ Γ)} {merge Γ Δ t s} → cong₂ (merge Γ Δ) p₁ p₂ }
}
_⊗̣_ : Familyₛ → Familyₛ → Familyₛ
_⊗̣_ = sorted₂ _⊗_
𝒚 : Ctx → Family
𝒚 Γ Δ = Γ ≡ Δ
-- Family which is only inhabited at the empty context
E : Family
E = 𝒚 ∅
-- Sorted family which is only inhabited at a singleton context
N : Familyₛ
N α = 𝒚 ⌈ α ⌋
-- | Monoidal exponential
-- Linear exponential between families
_⊸_ : Family → Family → Family
(X ⊸ Y) Γ = {Δ : Ctx} → X Δ → Y (Δ ∔ Γ)
infixr 15 _⊸_
-- Linear exponential between sorted families
_⊸∙_ : Familyₛ → Familyₛ → Familyₛ
_⊸∙_ = sorted₂ _⊸_
infixr 15 _⊸∙_
-- ⊸ is a bifunctor
⊸F : Bifunctor 𝔽am.op 𝔽amilies 𝔽amilies
⊸F = record
{ F₀ = λ (X , Y) → X ⊸ Y
; F₁ = λ{ {X , Y}{X′ , Y′} (f , g) e x → g (e (f x))}
; identity = refl
; homomorphism = refl
; F-resp-≈ = λ{ {X , Y}{X′ , Y′}{f , g} (p₁ , p₂) {Γ}{e} →
dext′ (trans (cong (g ∘ e) p₁) p₂) }
}
|
algebraic-stack_agda0000_doc_16849 | open import Nat
open import Prelude
open import contexts
module core where
-- types
data htyp : Set where
b : htyp
⦇-⦈ : htyp
_==>_ : htyp → htyp → htyp
-- arrow type constructors bind very tightly
infixr 25 _==>_
-- external expressions
data hexp : Set where
c : hexp
_·:_ : hexp → htyp → hexp
X : Nat → hexp
·λ : Nat → hexp → hexp
·λ_[_]_ : Nat → htyp → hexp → hexp
⦇-⦈[_] : Nat → hexp
⦇⌜_⌟⦈[_] : hexp → Nat → hexp
_∘_ : hexp → hexp → hexp
-- the type of type contexts, i.e. Γs in the judegments below
tctx : Set
tctx = htyp ctx
mutual
-- identity substitution, substitition environments
data env : Set where
Id : (Γ : tctx) → env
Subst : (d : ihexp) → (y : Nat) → env → env
-- internal expressions
data ihexp : Set where
c : ihexp
X : Nat → ihexp
·λ_[_]_ : Nat → htyp → ihexp → ihexp
⦇-⦈⟨_⟩ : (Nat × env) → ihexp
⦇⌜_⌟⦈⟨_⟩ : ihexp → (Nat × env) → ihexp
_∘_ : ihexp → ihexp → ihexp
_⟨_⇒_⟩ : ihexp → htyp → htyp → ihexp
_⟨_⇒⦇-⦈⇏_⟩ : ihexp → htyp → htyp → ihexp
-- convenient notation for chaining together two agreeable casts
_⟨_⇒_⇒_⟩ : ihexp → htyp → htyp → htyp → ihexp
d ⟨ t1 ⇒ t2 ⇒ t3 ⟩ = d ⟨ t1 ⇒ t2 ⟩ ⟨ t2 ⇒ t3 ⟩
-- type consistency
data _~_ : (t1 t2 : htyp) → Set where
TCRefl : {τ : htyp} → τ ~ τ
TCHole1 : {τ : htyp} → τ ~ ⦇-⦈
TCHole2 : {τ : htyp} → ⦇-⦈ ~ τ
TCArr : {τ1 τ2 τ1' τ2' : htyp} →
τ1 ~ τ1' →
τ2 ~ τ2' →
τ1 ==> τ2 ~ τ1' ==> τ2'
-- type inconsistency
data _~̸_ : (τ1 τ2 : htyp) → Set where
ICBaseArr1 : {τ1 τ2 : htyp} → b ~̸ τ1 ==> τ2
ICBaseArr2 : {τ1 τ2 : htyp} → τ1 ==> τ2 ~̸ b
ICArr1 : {τ1 τ2 τ3 τ4 : htyp} →
τ1 ~̸ τ3 →
τ1 ==> τ2 ~̸ τ3 ==> τ4
ICArr2 : {τ1 τ2 τ3 τ4 : htyp} →
τ2 ~̸ τ4 →
τ1 ==> τ2 ~̸ τ3 ==> τ4
--- matching for arrows
data _▸arr_ : htyp → htyp → Set where
MAHole : ⦇-⦈ ▸arr ⦇-⦈ ==> ⦇-⦈
MAArr : {τ1 τ2 : htyp} → τ1 ==> τ2 ▸arr τ1 ==> τ2
-- the type of hole contexts, i.e. Δs in the judgements
hctx : Set
hctx = (htyp ctx × htyp) ctx
-- notation for a triple to match the CMTT syntax
_::_[_] : Nat → htyp → tctx → (Nat × (tctx × htyp))
u :: τ [ Γ ] = u , (Γ , τ)
-- the hole name u does not appear in the term e
data hole-name-new : (e : hexp) (u : Nat) → Set where
HNConst : ∀{u} → hole-name-new c u
HNAsc : ∀{e τ u} →
hole-name-new e u →
hole-name-new (e ·: τ) u
HNVar : ∀{x u} → hole-name-new (X x) u
HNLam1 : ∀{x e u} →
hole-name-new e u →
hole-name-new (·λ x e) u
HNLam2 : ∀{x e u τ} →
hole-name-new e u →
hole-name-new (·λ x [ τ ] e) u
HNHole : ∀{u u'} →
u' ≠ u →
hole-name-new (⦇-⦈[ u' ]) u
HNNEHole : ∀{u u' e} →
u' ≠ u →
hole-name-new e u →
hole-name-new (⦇⌜ e ⌟⦈[ u' ]) u
HNAp : ∀{ u e1 e2 } →
hole-name-new e1 u →
hole-name-new e2 u →
hole-name-new (e1 ∘ e2) u
-- two terms that do not share any hole names
data holes-disjoint : (e1 : hexp) → (e2 : hexp) → Set where
HDConst : ∀{e} → holes-disjoint c e
HDAsc : ∀{e1 e2 τ} → holes-disjoint e1 e2 → holes-disjoint (e1 ·: τ) e2
HDVar : ∀{x e} → holes-disjoint (X x) e
HDLam1 : ∀{x e1 e2} → holes-disjoint e1 e2 → holes-disjoint (·λ x e1) e2
HDLam2 : ∀{x e1 e2 τ} → holes-disjoint e1 e2 → holes-disjoint (·λ x [ τ ] e1) e2
HDHole : ∀{u e2} → hole-name-new e2 u → holes-disjoint (⦇-⦈[ u ]) e2
HDNEHole : ∀{u e1 e2} → hole-name-new e2 u → holes-disjoint e1 e2 → holes-disjoint (⦇⌜ e1 ⌟⦈[ u ]) e2
HDAp : ∀{e1 e2 e3} → holes-disjoint e1 e3 → holes-disjoint e2 e3 → holes-disjoint (e1 ∘ e2) e3
-- bidirectional type checking judgements for hexp
mutual
-- synthesis
data _⊢_=>_ : (Γ : tctx) (e : hexp) (τ : htyp) → Set where
SConst : {Γ : tctx} → Γ ⊢ c => b
SAsc : {Γ : tctx} {e : hexp} {τ : htyp} →
Γ ⊢ e <= τ →
Γ ⊢ (e ·: τ) => τ
SVar : {Γ : tctx} {τ : htyp} {x : Nat} →
(x , τ) ∈ Γ →
Γ ⊢ X x => τ
SAp : {Γ : tctx} {e1 e2 : hexp} {τ τ1 τ2 : htyp} →
holes-disjoint e1 e2 →
Γ ⊢ e1 => τ1 →
τ1 ▸arr τ2 ==> τ →
Γ ⊢ e2 <= τ2 →
Γ ⊢ (e1 ∘ e2) => τ
SEHole : {Γ : tctx} {u : Nat} → Γ ⊢ ⦇-⦈[ u ] => ⦇-⦈
SNEHole : {Γ : tctx} {e : hexp} {τ : htyp} {u : Nat} →
hole-name-new e u →
Γ ⊢ e => τ →
Γ ⊢ ⦇⌜ e ⌟⦈[ u ] => ⦇-⦈
SLam : {Γ : tctx} {e : hexp} {τ1 τ2 : htyp} {x : Nat} →
x # Γ →
(Γ ,, (x , τ1)) ⊢ e => τ2 →
Γ ⊢ ·λ x [ τ1 ] e => τ1 ==> τ2
-- analysis
data _⊢_<=_ : (Γ : htyp ctx) (e : hexp) (τ : htyp) → Set where
ASubsume : {Γ : tctx} {e : hexp} {τ τ' : htyp} →
Γ ⊢ e => τ' →
τ ~ τ' →
Γ ⊢ e <= τ
ALam : {Γ : tctx} {e : hexp} {τ τ1 τ2 : htyp} {x : Nat} →
x # Γ →
τ ▸arr τ1 ==> τ2 →
(Γ ,, (x , τ1)) ⊢ e <= τ2 →
Γ ⊢ (·λ x e) <= τ
-- those types without holes
data _tcomplete : htyp → Set where
TCBase : b tcomplete
TCArr : ∀{τ1 τ2} → τ1 tcomplete → τ2 tcomplete → (τ1 ==> τ2) tcomplete
-- those external expressions without holes
data _ecomplete : hexp → Set where
ECConst : c ecomplete
ECAsc : ∀{τ e} → τ tcomplete → e ecomplete → (e ·: τ) ecomplete
ECVar : ∀{x} → (X x) ecomplete
ECLam1 : ∀{x e} → e ecomplete → (·λ x e) ecomplete
ECLam2 : ∀{x e τ} → e ecomplete → τ tcomplete → (·λ x [ τ ] e) ecomplete
ECAp : ∀{e1 e2} → e1 ecomplete → e2 ecomplete → (e1 ∘ e2) ecomplete
-- those internal expressions without holes
data _dcomplete : ihexp → Set where
DCVar : ∀{x} → (X x) dcomplete
DCConst : c dcomplete
DCLam : ∀{x τ d} → d dcomplete → τ tcomplete → (·λ x [ τ ] d) dcomplete
DCAp : ∀{d1 d2} → d1 dcomplete → d2 dcomplete → (d1 ∘ d2) dcomplete
DCCast : ∀{d τ1 τ2} → d dcomplete → τ1 tcomplete → τ2 tcomplete → (d ⟨ τ1 ⇒ τ2 ⟩) dcomplete
-- contexts that only produce complete types
_gcomplete : tctx → Set
Γ gcomplete = (x : Nat) (τ : htyp) → (x , τ) ∈ Γ → τ tcomplete
-- those internal expressions where every cast is the identity cast and
-- there are no failed casts
data cast-id : ihexp → Set where
CIConst : cast-id c
CIVar : ∀{x} → cast-id (X x)
CILam : ∀{x τ d} → cast-id d → cast-id (·λ x [ τ ] d)
CIHole : ∀{u} → cast-id (⦇-⦈⟨ u ⟩)
CINEHole : ∀{d u} → cast-id d → cast-id (⦇⌜ d ⌟⦈⟨ u ⟩)
CIAp : ∀{d1 d2} → cast-id d1 → cast-id d2 → cast-id (d1 ∘ d2)
CICast : ∀{d τ} → cast-id d → cast-id (d ⟨ τ ⇒ τ ⟩)
-- expansion
mutual
-- synthesis
data _⊢_⇒_~>_⊣_ : (Γ : tctx) (e : hexp) (τ : htyp) (d : ihexp) (Δ : hctx) → Set where
ESConst : ∀{Γ} → Γ ⊢ c ⇒ b ~> c ⊣ ∅
ESVar : ∀{Γ x τ} → (x , τ) ∈ Γ →
Γ ⊢ X x ⇒ τ ~> X x ⊣ ∅
ESLam : ∀{Γ x τ1 τ2 e d Δ } →
(x # Γ) →
(Γ ,, (x , τ1)) ⊢ e ⇒ τ2 ~> d ⊣ Δ →
Γ ⊢ ·λ x [ τ1 ] e ⇒ (τ1 ==> τ2) ~> ·λ x [ τ1 ] d ⊣ Δ
ESAp : ∀{Γ e1 τ τ1 τ1' τ2 τ2' d1 Δ1 e2 d2 Δ2 } →
holes-disjoint e1 e2 →
Δ1 ## Δ2 →
Γ ⊢ e1 => τ1 →
τ1 ▸arr τ2 ==> τ →
Γ ⊢ e1 ⇐ (τ2 ==> τ) ~> d1 :: τ1' ⊣ Δ1 →
Γ ⊢ e2 ⇐ τ2 ~> d2 :: τ2' ⊣ Δ2 →
Γ ⊢ e1 ∘ e2 ⇒ τ ~> (d1 ⟨ τ1' ⇒ τ2 ==> τ ⟩) ∘ (d2 ⟨ τ2' ⇒ τ2 ⟩) ⊣ (Δ1 ∪ Δ2)
ESEHole : ∀{ Γ u } →
Γ ⊢ ⦇-⦈[ u ] ⇒ ⦇-⦈ ~> ⦇-⦈⟨ u , Id Γ ⟩ ⊣ ■ (u :: ⦇-⦈ [ Γ ])
ESNEHole : ∀{ Γ e τ d u Δ } →
Δ ## (■ (u , Γ , ⦇-⦈)) →
Γ ⊢ e ⇒ τ ~> d ⊣ Δ →
Γ ⊢ ⦇⌜ e ⌟⦈[ u ] ⇒ ⦇-⦈ ~> ⦇⌜ d ⌟⦈⟨ u , Id Γ ⟩ ⊣ (Δ ,, u :: ⦇-⦈ [ Γ ])
ESAsc : ∀ {Γ e τ d τ' Δ} →
Γ ⊢ e ⇐ τ ~> d :: τ' ⊣ Δ →
Γ ⊢ (e ·: τ) ⇒ τ ~> d ⟨ τ' ⇒ τ ⟩ ⊣ Δ
-- analysis
data _⊢_⇐_~>_::_⊣_ : (Γ : tctx) (e : hexp) (τ : htyp) (d : ihexp) (τ' : htyp) (Δ : hctx) → Set where
EALam : ∀{Γ x τ τ1 τ2 e d τ2' Δ } →
(x # Γ) →
τ ▸arr τ1 ==> τ2 →
(Γ ,, (x , τ1)) ⊢ e ⇐ τ2 ~> d :: τ2' ⊣ Δ →
Γ ⊢ ·λ x e ⇐ τ ~> ·λ x [ τ1 ] d :: τ1 ==> τ2' ⊣ Δ
EASubsume : ∀{e Γ τ' d Δ τ} →
((u : Nat) → e ≠ ⦇-⦈[ u ]) →
((e' : hexp) (u : Nat) → e ≠ ⦇⌜ e' ⌟⦈[ u ]) →
Γ ⊢ e ⇒ τ' ~> d ⊣ Δ →
τ ~ τ' →
Γ ⊢ e ⇐ τ ~> d :: τ' ⊣ Δ
EAEHole : ∀{ Γ u τ } →
Γ ⊢ ⦇-⦈[ u ] ⇐ τ ~> ⦇-⦈⟨ u , Id Γ ⟩ :: τ ⊣ ■ (u :: τ [ Γ ])
EANEHole : ∀{ Γ e u τ d τ' Δ } →
Δ ## (■ (u , Γ , τ)) →
Γ ⊢ e ⇒ τ' ~> d ⊣ Δ →
Γ ⊢ ⦇⌜ e ⌟⦈[ u ] ⇐ τ ~> ⦇⌜ d ⌟⦈⟨ u , Id Γ ⟩ :: τ ⊣ (Δ ,, u :: τ [ Γ ])
-- ground types
data _ground : (τ : htyp) → Set where
GBase : b ground
GHole : ⦇-⦈ ==> ⦇-⦈ ground
mutual
-- substitution typing
data _,_⊢_:s:_ : hctx → tctx → env → tctx → Set where
STAId : ∀{Γ Γ' Δ} →
((x : Nat) (τ : htyp) → (x , τ) ∈ Γ' → (x , τ) ∈ Γ) →
Δ , Γ ⊢ Id Γ' :s: Γ'
STASubst : ∀{Γ Δ σ y Γ' d τ } →
Δ , Γ ,, (y , τ) ⊢ σ :s: Γ' →
Δ , Γ ⊢ d :: τ →
Δ , Γ ⊢ Subst d y σ :s: Γ'
-- type assignment
data _,_⊢_::_ : (Δ : hctx) (Γ : tctx) (d : ihexp) (τ : htyp) → Set where
TAConst : ∀{Δ Γ} → Δ , Γ ⊢ c :: b
TAVar : ∀{Δ Γ x τ} → (x , τ) ∈ Γ → Δ , Γ ⊢ X x :: τ
TALam : ∀{ Δ Γ x τ1 d τ2} →
x # Γ →
Δ , (Γ ,, (x , τ1)) ⊢ d :: τ2 →
Δ , Γ ⊢ ·λ x [ τ1 ] d :: (τ1 ==> τ2)
TAAp : ∀{ Δ Γ d1 d2 τ1 τ} →
Δ , Γ ⊢ d1 :: τ1 ==> τ →
Δ , Γ ⊢ d2 :: τ1 →
Δ , Γ ⊢ d1 ∘ d2 :: τ
TAEHole : ∀{ Δ Γ σ u Γ' τ} →
(u , (Γ' , τ)) ∈ Δ →
Δ , Γ ⊢ σ :s: Γ' →
Δ , Γ ⊢ ⦇-⦈⟨ u , σ ⟩ :: τ
TANEHole : ∀ { Δ Γ d τ' Γ' u σ τ } →
(u , (Γ' , τ)) ∈ Δ →
Δ , Γ ⊢ d :: τ' →
Δ , Γ ⊢ σ :s: Γ' →
Δ , Γ ⊢ ⦇⌜ d ⌟⦈⟨ u , σ ⟩ :: τ
TACast : ∀{ Δ Γ d τ1 τ2} →
Δ , Γ ⊢ d :: τ1 →
τ1 ~ τ2 →
Δ , Γ ⊢ d ⟨ τ1 ⇒ τ2 ⟩ :: τ2
TAFailedCast : ∀{Δ Γ d τ1 τ2} →
Δ , Γ ⊢ d :: τ1 →
τ1 ground →
τ2 ground →
τ1 ≠ τ2 →
Δ , Γ ⊢ d ⟨ τ1 ⇒⦇-⦈⇏ τ2 ⟩ :: τ2
-- substitution
[_/_]_ : ihexp → Nat → ihexp → ihexp
[ d / y ] c = c
[ d / y ] X x
with natEQ x y
[ d / y ] X .y | Inl refl = d
[ d / y ] X x | Inr neq = X x
[ d / y ] (·λ x [ x₁ ] d')
with natEQ x y
[ d / y ] (·λ .y [ τ ] d') | Inl refl = ·λ y [ τ ] d'
[ d / y ] (·λ x [ τ ] d') | Inr x₁ = ·λ x [ τ ] ( [ d / y ] d')
[ d / y ] ⦇-⦈⟨ u , σ ⟩ = ⦇-⦈⟨ u , Subst d y σ ⟩
[ d / y ] ⦇⌜ d' ⌟⦈⟨ u , σ ⟩ = ⦇⌜ [ d / y ] d' ⌟⦈⟨ u , Subst d y σ ⟩
[ d / y ] (d1 ∘ d2) = ([ d / y ] d1) ∘ ([ d / y ] d2)
[ d / y ] (d' ⟨ τ1 ⇒ τ2 ⟩ ) = ([ d / y ] d') ⟨ τ1 ⇒ τ2 ⟩
[ d / y ] (d' ⟨ τ1 ⇒⦇-⦈⇏ τ2 ⟩ ) = ([ d / y ] d') ⟨ τ1 ⇒⦇-⦈⇏ τ2 ⟩
-- applying an environment to an expression
apply-env : env → ihexp → ihexp
apply-env (Id Γ) d = d
apply-env (Subst d y σ) d' = [ d / y ] ( apply-env σ d')
-- values
data _val : (d : ihexp) → Set where
VConst : c val
VLam : ∀{x τ d} → (·λ x [ τ ] d) val
-- boxed values
data _boxedval : (d : ihexp) → Set where
BVVal : ∀{d} → d val → d boxedval
BVArrCast : ∀{ d τ1 τ2 τ3 τ4 } →
τ1 ==> τ2 ≠ τ3 ==> τ4 →
d boxedval →
d ⟨ (τ1 ==> τ2) ⇒ (τ3 ==> τ4) ⟩ boxedval
BVHoleCast : ∀{ τ d } → τ ground → d boxedval → d ⟨ τ ⇒ ⦇-⦈ ⟩ boxedval
mutual
-- indeterminate forms
data _indet : (d : ihexp) → Set where
IEHole : ∀{u σ} → ⦇-⦈⟨ u , σ ⟩ indet
INEHole : ∀{d u σ} → d final → ⦇⌜ d ⌟⦈⟨ u , σ ⟩ indet
IAp : ∀{d1 d2} → ((τ1 τ2 τ3 τ4 : htyp) (d1' : ihexp) →
d1 ≠ (d1' ⟨(τ1 ==> τ2) ⇒ (τ3 ==> τ4)⟩)) →
d1 indet →
d2 final →
(d1 ∘ d2) indet
ICastArr : ∀{d τ1 τ2 τ3 τ4} →
τ1 ==> τ2 ≠ τ3 ==> τ4 →
d indet →
d ⟨ (τ1 ==> τ2) ⇒ (τ3 ==> τ4) ⟩ indet
ICastGroundHole : ∀{ τ d } →
τ ground →
d indet →
d ⟨ τ ⇒ ⦇-⦈ ⟩ indet
ICastHoleGround : ∀ { d τ } →
((d' : ihexp) (τ' : htyp) → d ≠ (d' ⟨ τ' ⇒ ⦇-⦈ ⟩)) →
d indet →
τ ground →
d ⟨ ⦇-⦈ ⇒ τ ⟩ indet
IFailedCast : ∀{ d τ1 τ2 } →
d final →
τ1 ground →
τ2 ground →
τ1 ≠ τ2 →
d ⟨ τ1 ⇒⦇-⦈⇏ τ2 ⟩ indet
-- final expressions
data _final : (d : ihexp) → Set where
FBoxedVal : ∀{d} → d boxedval → d final
FIndet : ∀{d} → d indet → d final
-- contextual dynamics
-- evaluation contexts
data ectx : Set where
⊙ : ectx
_∘₁_ : ectx → ihexp → ectx
_∘₂_ : ihexp → ectx → ectx
⦇⌜_⌟⦈⟨_⟩ : ectx → (Nat × env ) → ectx
_⟨_⇒_⟩ : ectx → htyp → htyp → ectx
_⟨_⇒⦇-⦈⇏_⟩ : ectx → htyp → htyp → ectx
-- note: this judgement is redundant: in the absence of the premises in
-- the red brackets, all syntactically well formed ectxs are valid. with
-- finality premises, that's not true, and that would propagate through
-- additions to the calculus. so we leave it here for clarity but note
-- that, as written, in any use case its either trival to prove or
-- provides no additional information
--ε is an evaluation context
data _evalctx : (ε : ectx) → Set where
ECDot : ⊙ evalctx
ECAp1 : ∀{d ε} →
ε evalctx →
(ε ∘₁ d) evalctx
ECAp2 : ∀{d ε} →
-- d final → -- red brackets
ε evalctx →
(d ∘₂ ε) evalctx
ECNEHole : ∀{ε u σ} →
ε evalctx →
⦇⌜ ε ⌟⦈⟨ u , σ ⟩ evalctx
ECCast : ∀{ ε τ1 τ2} →
ε evalctx →
(ε ⟨ τ1 ⇒ τ2 ⟩) evalctx
ECFailedCast : ∀{ ε τ1 τ2 } →
ε evalctx →
ε ⟨ τ1 ⇒⦇-⦈⇏ τ2 ⟩ evalctx
-- d is the result of filling the hole in ε with d'
data _==_⟦_⟧ : (d : ihexp) (ε : ectx) (d' : ihexp) → Set where
FHOuter : ∀{d} → d == ⊙ ⟦ d ⟧
FHAp1 : ∀{d1 d1' d2 ε} →
d1 == ε ⟦ d1' ⟧ →
(d1 ∘ d2) == (ε ∘₁ d2) ⟦ d1' ⟧
FHAp2 : ∀{d1 d2 d2' ε} →
-- d1 final → -- red brackets
d2 == ε ⟦ d2' ⟧ →
(d1 ∘ d2) == (d1 ∘₂ ε) ⟦ d2' ⟧
FHNEHole : ∀{ d d' ε u σ} →
d == ε ⟦ d' ⟧ →
⦇⌜ d ⌟⦈⟨ (u , σ ) ⟩ == ⦇⌜ ε ⌟⦈⟨ (u , σ ) ⟩ ⟦ d' ⟧
FHCast : ∀{ d d' ε τ1 τ2 } →
d == ε ⟦ d' ⟧ →
d ⟨ τ1 ⇒ τ2 ⟩ == ε ⟨ τ1 ⇒ τ2 ⟩ ⟦ d' ⟧
FHFailedCast : ∀{ d d' ε τ1 τ2} →
d == ε ⟦ d' ⟧ →
(d ⟨ τ1 ⇒⦇-⦈⇏ τ2 ⟩) == (ε ⟨ τ1 ⇒⦇-⦈⇏ τ2 ⟩) ⟦ d' ⟧
-- matched ground types
data _▸gnd_ : htyp → htyp → Set where
MGArr : ∀{τ1 τ2} →
(τ1 ==> τ2) ≠ (⦇-⦈ ==> ⦇-⦈) →
(τ1 ==> τ2) ▸gnd (⦇-⦈ ==> ⦇-⦈)
-- instruction transition judgement
data _→>_ : (d d' : ihexp) → Set where
ITLam : ∀{ x τ d1 d2 } →
-- d2 final → -- red brackets
((·λ x [ τ ] d1) ∘ d2) →> ([ d2 / x ] d1)
ITCastID : ∀{d τ } →
-- d final → -- red brackets
(d ⟨ τ ⇒ τ ⟩) →> d
ITCastSucceed : ∀{d τ } →
-- d final → -- red brackets
τ ground →
(d ⟨ τ ⇒ ⦇-⦈ ⇒ τ ⟩) →> d
ITCastFail : ∀{ d τ1 τ2} →
-- d final → -- red brackets
τ1 ground →
τ2 ground →
τ1 ≠ τ2 →
(d ⟨ τ1 ⇒ ⦇-⦈ ⇒ τ2 ⟩) →> (d ⟨ τ1 ⇒⦇-⦈⇏ τ2 ⟩)
ITApCast : ∀{d1 d2 τ1 τ2 τ1' τ2' } →
-- d1 final → -- red brackets
-- d2 final → -- red brackets
((d1 ⟨ (τ1 ==> τ2) ⇒ (τ1' ==> τ2')⟩) ∘ d2) →> ((d1 ∘ (d2 ⟨ τ1' ⇒ τ1 ⟩)) ⟨ τ2 ⇒ τ2' ⟩)
ITGround : ∀{ d τ τ'} →
-- d final → -- red brackets
τ ▸gnd τ' →
(d ⟨ τ ⇒ ⦇-⦈ ⟩) →> (d ⟨ τ ⇒ τ' ⇒ ⦇-⦈ ⟩)
ITExpand : ∀{d τ τ' } →
-- d final → -- red brackets
τ ▸gnd τ' →
(d ⟨ ⦇-⦈ ⇒ τ ⟩) →> (d ⟨ ⦇-⦈ ⇒ τ' ⇒ τ ⟩)
-- single step (in contextual evaluation sense)
data _↦_ : (d d' : ihexp) → Set where
Step : ∀{ d d0 d' d0' ε} →
d == ε ⟦ d0 ⟧ →
d0 →> d0' →
d' == ε ⟦ d0' ⟧ →
d ↦ d'
-- reflexive transitive closure of single steps into multi steps
data _↦*_ : (d d' : ihexp) → Set where
MSRefl : ∀{d} → d ↦* d
MSStep : ∀{d d' d''} →
d ↦ d' →
d' ↦* d'' →
d ↦* d''
-- freshness
mutual
-- ... with respect to a hole context
data envfresh : Nat → env → Set where
EFId : ∀{x Γ} → x # Γ → envfresh x (Id Γ)
EFSubst : ∀{x d σ y} → fresh x d
→ envfresh x σ
→ x ≠ y
→ envfresh x (Subst d y σ)
-- ... for inernal expressions
data fresh : Nat → ihexp → Set where
FConst : ∀{x} → fresh x c
FVar : ∀{x y} → x ≠ y → fresh x (X y)
FLam : ∀{x y τ d} → x ≠ y → fresh x d → fresh x (·λ y [ τ ] d)
FHole : ∀{x u σ} → envfresh x σ → fresh x (⦇-⦈⟨ u , σ ⟩)
FNEHole : ∀{x d u σ} → envfresh x σ → fresh x d → fresh x (⦇⌜ d ⌟⦈⟨ u , σ ⟩)
FAp : ∀{x d1 d2} → fresh x d1 → fresh x d2 → fresh x (d1 ∘ d2)
FCast : ∀{x d τ1 τ2} → fresh x d → fresh x (d ⟨ τ1 ⇒ τ2 ⟩)
FFailedCast : ∀{x d τ1 τ2} → fresh x d → fresh x (d ⟨ τ1 ⇒⦇-⦈⇏ τ2 ⟩)
-- ... for external expressions
data freshh : Nat → hexp → Set where
FRHConst : ∀{x} → freshh x c
FRHAsc : ∀{x e τ} → freshh x e → freshh x (e ·: τ)
FRHVar : ∀{x y} → x ≠ y → freshh x (X y)
FRHLam1 : ∀{x y e} → x ≠ y → freshh x e → freshh x (·λ y e)
FRHLam2 : ∀{x τ e y} → x ≠ y → freshh x e → freshh x (·λ y [ τ ] e)
FRHEHole : ∀{x u} → freshh x (⦇-⦈[ u ])
FRHNEHole : ∀{x u e} → freshh x e → freshh x (⦇⌜ e ⌟⦈[ u ])
FRHAp : ∀{x e1 e2} → freshh x e1 → freshh x e2 → freshh x (e1 ∘ e2)
-- x is not used in a binding site in d
mutual
data unbound-in-σ : Nat → env → Set where
UBσId : ∀{x Γ} → unbound-in-σ x (Id Γ)
UBσSubst : ∀{x d y σ} → unbound-in x d
→ unbound-in-σ x σ
→ x ≠ y
→ unbound-in-σ x (Subst d y σ)
data unbound-in : (x : Nat) (d : ihexp) → Set where
UBConst : ∀{x} → unbound-in x c
UBVar : ∀{x y} → unbound-in x (X y)
UBLam2 : ∀{x d y τ} → x ≠ y
→ unbound-in x d
→ unbound-in x (·λ_[_]_ y τ d)
UBHole : ∀{x u σ} → unbound-in-σ x σ
→ unbound-in x (⦇-⦈⟨ u , σ ⟩)
UBNEHole : ∀{x u σ d }
→ unbound-in-σ x σ
→ unbound-in x d
→ unbound-in x (⦇⌜ d ⌟⦈⟨ u , σ ⟩)
UBAp : ∀{ x d1 d2 } →
unbound-in x d1 →
unbound-in x d2 →
unbound-in x (d1 ∘ d2)
UBCast : ∀{x d τ1 τ2} → unbound-in x d → unbound-in x (d ⟨ τ1 ⇒ τ2 ⟩)
UBFailedCast : ∀{x d τ1 τ2} → unbound-in x d → unbound-in x (d ⟨ τ1 ⇒⦇-⦈⇏ τ2 ⟩)
mutual
data binders-disjoint-σ : env → ihexp → Set where
BDσId : ∀{Γ d} → binders-disjoint-σ (Id Γ) d
BDσSubst : ∀{d1 d2 y σ} → binders-disjoint d1 d2
→ binders-disjoint-σ σ d2
→ binders-disjoint-σ (Subst d1 y σ) d2
-- two terms that do not share any binders
data binders-disjoint : (d1 : ihexp) → (d2 : ihexp) → Set where
BDConst : ∀{d} → binders-disjoint c d
BDVar : ∀{x d} → binders-disjoint (X x) d
BDLam : ∀{x τ d1 d2} → binders-disjoint d1 d2
→ unbound-in x d2
→ binders-disjoint (·λ_[_]_ x τ d1) d2
BDHole : ∀{u σ d2} → binders-disjoint-σ σ d2
→ binders-disjoint (⦇-⦈⟨ u , σ ⟩) d2
BDNEHole : ∀{u σ d1 d2} → binders-disjoint-σ σ d2
→ binders-disjoint d1 d2
→ binders-disjoint (⦇⌜ d1 ⌟⦈⟨ u , σ ⟩) d2
BDAp : ∀{d1 d2 d3} → binders-disjoint d1 d3
→ binders-disjoint d2 d3
→ binders-disjoint (d1 ∘ d2) d3
BDCast : ∀{d1 d2 τ1 τ2} → binders-disjoint d1 d2 → binders-disjoint (d1 ⟨ τ1 ⇒ τ2 ⟩) d2
BDFailedCast : ∀{d1 d2 τ1 τ2} → binders-disjoint d1 d2 → binders-disjoint (d1 ⟨ τ1 ⇒⦇-⦈⇏ τ2 ⟩) d2
mutual
-- each term has to be binders unique, and they have to be pairwise
-- disjoint with the collection of bound vars
data binders-unique-σ : env → Set where
BUσId : ∀{Γ} → binders-unique-σ (Id Γ)
BUσSubst : ∀{d y σ} → binders-unique d
→ binders-unique-σ σ
→ binders-disjoint-σ σ d
→ binders-unique-σ (Subst d y σ)
-- all the variable names in the term are unique
data binders-unique : ihexp → Set where
BUHole : binders-unique c
BUVar : ∀{x} → binders-unique (X x)
BULam : {x : Nat} {τ : htyp} {d : ihexp} → binders-unique d
→ unbound-in x d
→ binders-unique (·λ_[_]_ x τ d)
BUEHole : ∀{u σ} → binders-unique-σ σ
→ binders-unique (⦇-⦈⟨ u , σ ⟩)
BUNEHole : ∀{u σ d} → binders-unique d
→ binders-unique-σ σ
→ binders-unique (⦇⌜ d ⌟⦈⟨ u , σ ⟩)
BUAp : ∀{d1 d2} → binders-unique d1
→ binders-unique d2
→ binders-disjoint d1 d2
→ binders-unique (d1 ∘ d2)
BUCast : ∀{d τ1 τ2} → binders-unique d
→ binders-unique (d ⟨ τ1 ⇒ τ2 ⟩)
BUFailedCast : ∀{d τ1 τ2} → binders-unique d
→ binders-unique (d ⟨ τ1 ⇒⦇-⦈⇏ τ2 ⟩)
|
algebraic-stack_agda0000_doc_16850 | {-# OPTIONS --rewriting #-}
module Luau.TypeCheck where
open import Agda.Builtin.Equality using (_≡_)
open import FFI.Data.Maybe using (Maybe; just)
open import Luau.Syntax using (Expr; Stat; Block; BinaryOperator; yes; nil; addr; number; bool; string; val; var; var_∈_; _⟨_⟩∈_; function_is_end; _$_; block_is_end; binexp; local_←_; _∙_; done; return; name; +; -; *; /; <; >; ==; ~=; <=; >=; ··)
open import Luau.Var using (Var)
open import Luau.Addr using (Addr)
open import Luau.Heap using (Heap; Object; function_is_end) renaming (_[_] to _[_]ᴴ)
open import Luau.Type using (Type; nil; unknown; number; boolean; string; _⇒_; src; tgt)
open import Luau.VarCtxt using (VarCtxt; ∅; _⋒_; _↦_; _⊕_↦_; _⊝_) renaming (_[_] to _[_]ⱽ)
open import FFI.Data.Vector using (Vector)
open import FFI.Data.Maybe using (Maybe; just; nothing)
open import Properties.Product using (_×_; _,_)
orUnknown : Maybe Type → Type
orUnknown nothing = unknown
orUnknown (just T) = T
srcBinOp : BinaryOperator → Type
srcBinOp + = number
srcBinOp - = number
srcBinOp * = number
srcBinOp / = number
srcBinOp < = number
srcBinOp > = number
srcBinOp == = unknown
srcBinOp ~= = unknown
srcBinOp <= = number
srcBinOp >= = number
srcBinOp ·· = string
tgtBinOp : BinaryOperator → Type
tgtBinOp + = number
tgtBinOp - = number
tgtBinOp * = number
tgtBinOp / = number
tgtBinOp < = boolean
tgtBinOp > = boolean
tgtBinOp == = boolean
tgtBinOp ~= = boolean
tgtBinOp <= = boolean
tgtBinOp >= = boolean
tgtBinOp ·· = string
data _⊢ᴮ_∈_ : VarCtxt → Block yes → Type → Set
data _⊢ᴱ_∈_ : VarCtxt → Expr yes → Type → Set
data _⊢ᴮ_∈_ where
done : ∀ {Γ} →
---------------
Γ ⊢ᴮ done ∈ nil
return : ∀ {M B T U Γ} →
Γ ⊢ᴱ M ∈ T →
Γ ⊢ᴮ B ∈ U →
---------------------
Γ ⊢ᴮ return M ∙ B ∈ T
local : ∀ {x M B T U V Γ} →
Γ ⊢ᴱ M ∈ U →
(Γ ⊕ x ↦ T) ⊢ᴮ B ∈ V →
--------------------------------
Γ ⊢ᴮ local var x ∈ T ← M ∙ B ∈ V
function : ∀ {f x B C T U V W Γ} →
(Γ ⊕ x ↦ T) ⊢ᴮ C ∈ V →
(Γ ⊕ f ↦ (T ⇒ U)) ⊢ᴮ B ∈ W →
-------------------------------------------------
Γ ⊢ᴮ function f ⟨ var x ∈ T ⟩∈ U is C end ∙ B ∈ W
data _⊢ᴱ_∈_ where
nil : ∀ {Γ} →
--------------------
Γ ⊢ᴱ (val nil) ∈ nil
var : ∀ {x T Γ} →
T ≡ orUnknown(Γ [ x ]ⱽ) →
----------------
Γ ⊢ᴱ (var x) ∈ T
addr : ∀ {a Γ} T →
-----------------
Γ ⊢ᴱ val(addr a) ∈ T
number : ∀ {n Γ} →
---------------------------
Γ ⊢ᴱ val(number n) ∈ number
bool : ∀ {b Γ} →
--------------------------
Γ ⊢ᴱ val(bool b) ∈ boolean
string : ∀ {x Γ} →
---------------------------
Γ ⊢ᴱ val(string x) ∈ string
app : ∀ {M N T U Γ} →
Γ ⊢ᴱ M ∈ T →
Γ ⊢ᴱ N ∈ U →
----------------------
Γ ⊢ᴱ (M $ N) ∈ (tgt T)
function : ∀ {f x B T U V Γ} →
(Γ ⊕ x ↦ T) ⊢ᴮ B ∈ V →
-----------------------------------------------------
Γ ⊢ᴱ (function f ⟨ var x ∈ T ⟩∈ U is B end) ∈ (T ⇒ U)
block : ∀ {b B T U Γ} →
Γ ⊢ᴮ B ∈ U →
------------------------------------
Γ ⊢ᴱ (block var b ∈ T is B end) ∈ T
binexp : ∀ {op Γ M N T U} →
Γ ⊢ᴱ M ∈ T →
Γ ⊢ᴱ N ∈ U →
----------------------------------
Γ ⊢ᴱ (binexp M op N) ∈ tgtBinOp op
data ⊢ᴼ_ : Maybe(Object yes) → Set where
nothing :
---------
⊢ᴼ nothing
function : ∀ {f x T U V B} →
(x ↦ T) ⊢ᴮ B ∈ V →
----------------------------------------------
⊢ᴼ (just function f ⟨ var x ∈ T ⟩∈ U is B end)
⊢ᴴ_ : Heap yes → Set
⊢ᴴ H = ∀ a {O} → (H [ a ]ᴴ ≡ O) → (⊢ᴼ O)
_⊢ᴴᴱ_▷_∈_ : VarCtxt → Heap yes → Expr yes → Type → Set
(Γ ⊢ᴴᴱ H ▷ M ∈ T) = (⊢ᴴ H) × (Γ ⊢ᴱ M ∈ T)
_⊢ᴴᴮ_▷_∈_ : VarCtxt → Heap yes → Block yes → Type → Set
(Γ ⊢ᴴᴮ H ▷ B ∈ T) = (⊢ᴴ H) × (Γ ⊢ᴮ B ∈ T)
|
algebraic-stack_agda0000_doc_16851 | module Pi.Syntax where
open import Data.Empty
open import Data.Unit
open import Data.Sum
open import Data.Product
infixr 12 _×ᵤ_
infixr 11 _+ᵤ_
infixr 50 _⨾_
infixr 10 _↔_
infix 99 !_
-- Types
data 𝕌 : Set where
𝟘 : 𝕌
𝟙 : 𝕌
_+ᵤ_ : 𝕌 → 𝕌 → 𝕌
_×ᵤ_ : 𝕌 → 𝕌 → 𝕌
⟦_⟧ : (A : 𝕌) → Set
⟦ 𝟘 ⟧ = ⊥
⟦ 𝟙 ⟧ = ⊤
⟦ t₁ +ᵤ t₂ ⟧ = ⟦ t₁ ⟧ ⊎ ⟦ t₂ ⟧
⟦ t₁ ×ᵤ t₂ ⟧ = ⟦ t₁ ⟧ × ⟦ t₂ ⟧
-- Combinators
data _↔_ : 𝕌 → 𝕌 → Set where
unite₊l : {t : 𝕌} → 𝟘 +ᵤ t ↔ t
uniti₊l : {t : 𝕌} → t ↔ 𝟘 +ᵤ t
swap₊ : {t₁ t₂ : 𝕌} → t₁ +ᵤ t₂ ↔ t₂ +ᵤ t₁
assocl₊ : {t₁ t₂ t₃ : 𝕌} → t₁ +ᵤ (t₂ +ᵤ t₃) ↔ (t₁ +ᵤ t₂) +ᵤ t₃
assocr₊ : {t₁ t₂ t₃ : 𝕌} → (t₁ +ᵤ t₂) +ᵤ t₃ ↔ t₁ +ᵤ (t₂ +ᵤ t₃)
unite⋆l : {t : 𝕌} → 𝟙 ×ᵤ t ↔ t
uniti⋆l : {t : 𝕌} → t ↔ 𝟙 ×ᵤ t
swap⋆ : {t₁ t₂ : 𝕌} → t₁ ×ᵤ t₂ ↔ t₂ ×ᵤ t₁
assocl⋆ : {t₁ t₂ t₃ : 𝕌} → t₁ ×ᵤ (t₂ ×ᵤ t₃) ↔ (t₁ ×ᵤ t₂) ×ᵤ t₃
assocr⋆ : {t₁ t₂ t₃ : 𝕌} → (t₁ ×ᵤ t₂) ×ᵤ t₃ ↔ t₁ ×ᵤ (t₂ ×ᵤ t₃)
absorbr : {t : 𝕌} → 𝟘 ×ᵤ t ↔ 𝟘
factorzl : {t : 𝕌} → 𝟘 ↔ 𝟘 ×ᵤ t
dist : {t₁ t₂ t₃ : 𝕌} → (t₁ +ᵤ t₂) ×ᵤ t₃ ↔ (t₁ ×ᵤ t₃) +ᵤ (t₂ ×ᵤ t₃)
factor : {t₁ t₂ t₃ : 𝕌} → (t₁ ×ᵤ t₃) +ᵤ (t₂ ×ᵤ t₃) ↔ (t₁ +ᵤ t₂) ×ᵤ t₃
id↔ : {t : 𝕌} → t ↔ t
_⨾_ : {t₁ t₂ t₃ : 𝕌} → (t₁ ↔ t₂) → (t₂ ↔ t₃) → (t₁ ↔ t₃)
_⊕_ : {t₁ t₂ t₃ t₄ : 𝕌} → (t₁ ↔ t₃) → (t₂ ↔ t₄) → (t₁ +ᵤ t₂ ↔ t₃ +ᵤ t₄)
_⊗_ : {t₁ t₂ t₃ t₄ : 𝕌} → (t₁ ↔ t₃) → (t₂ ↔ t₄) → (t₁ ×ᵤ t₂ ↔ t₃ ×ᵤ t₄)
-- Some useful combinators
unite₊r : {t : 𝕌} → t +ᵤ 𝟘 ↔ t
unite₊r = swap₊ ⨾ unite₊l
uniti₊r : {t : 𝕌} → t ↔ t +ᵤ 𝟘
uniti₊r = uniti₊l ⨾ swap₊
unite⋆r : {t : 𝕌} → t ×ᵤ 𝟙 ↔ t
unite⋆r = swap⋆ ⨾ unite⋆l
uniti⋆r : {t : 𝕌} → t ↔ t ×ᵤ 𝟙
uniti⋆r = uniti⋆l ⨾ swap⋆
absorbl : {t : 𝕌} → t ×ᵤ 𝟘 ↔ 𝟘
absorbl = swap⋆ ⨾ absorbr
factorzr : {t : 𝕌} → 𝟘 ↔ t ×ᵤ 𝟘
factorzr = factorzl ⨾ swap⋆
distl : {t₁ t₂ t₃ : 𝕌} → t₁ ×ᵤ (t₂ +ᵤ t₃) ↔ (t₁ ×ᵤ t₂) +ᵤ (t₁ ×ᵤ t₃)
distl = swap⋆ ⨾ dist ⨾ (swap⋆ ⊕ swap⋆)
factorl : {t₁ t₂ t₃ : 𝕌 } → (t₁ ×ᵤ t₂) +ᵤ (t₁ ×ᵤ t₃) ↔ t₁ ×ᵤ (t₂ +ᵤ t₃)
factorl = (swap⋆ ⊕ swap⋆) ⨾ factor ⨾ swap⋆
-- Inverses of combinators
!_ : {A B : 𝕌} → A ↔ B → B ↔ A
! unite₊l = uniti₊l
! uniti₊l = unite₊l
! swap₊ = swap₊
! assocl₊ = assocr₊
! assocr₊ = assocl₊
! unite⋆l = uniti⋆l
! uniti⋆l = unite⋆l
! swap⋆ = swap⋆
! assocl⋆ = assocr⋆
! assocr⋆ = assocl⋆
! absorbr = factorzl
! factorzl = absorbr
! dist = factor
! factor = dist
! id↔ = id↔
! (c₁ ⨾ c₂) = ! c₂ ⨾ ! c₁
! (c₁ ⊕ c₂) = (! c₁) ⊕ (! c₂)
! (c₁ ⊗ c₂) = (! c₁) ⊗ (! c₂)
|
algebraic-stack_agda0000_doc_16852 | module Automata.Nondeterministic where
-- Standard libraries imports ----------------------------------------
open import Level using ()
renaming (zero to ℓ₀)
open import Data.Nat using (ℕ)
open import Data.Product using (_×_)
open import Data.Vec using (Vec ; [] ; _∷_)
open import Relation.Unary using (Pred)
open import Relation.Binary.PropositionalEquality using (_≡_)
----------------------------------------------------------------------
-- Thesis imports ----------------------------------------------------
open import Utilities.ExistsSyntax using (∃-syntax)
----------------------------------------------------------------------
record NDA (Σ : Set) : Set₁ where
constructor ⟨_,_,_,_⟩
field
Q : Set
S : Pred Q ℓ₀
F : Pred Q ℓ₀
Δ : Q → Σ → Pred Q ℓ₀
Δ* : Q → {n : ℕ} → Vec Σ n → Pred Q ℓ₀
Δ* q [] = q ≡_
Δ* q (x ∷ xs) q′ = ∃ q₀ ∶ Q • ((Δ q x q₀) × (Δ* q₀ xs q′))
Accepts : {n : ℕ} → Pred (Vec Σ n) ℓ₀
Accepts xs = ∃ q ∶ Q • (S q
× ∃ q′ ∶ Q • ((F q′)
× (Δ* q xs q′)))
-- :TODO: are these useful?
_-Reachable : ℕ → Q → Pred Q ℓ₀
_-Reachable n q q′ = ∃ xs ∶ Vec Σ n • (Δ* q xs q′)
Reachable : Q → Pred Q ℓ₀
Reachable q q′ = ∃ n ∶ ℕ • (n -Reachable) q q′
|
algebraic-stack_agda0000_doc_16853 | module ByteCount where
open import Agda.Builtin.Word
{-# FOREIGN GHC import Foreign.C.Types #-}
postulate
CSize : Set
mkCSize : Word64 → CSize
{-# COMPILE GHC CSize = type CSize #-}
{-# COMPILE GHC mkCSize = CSize #-}
ByteCount : Set
ByteCount = CSize
|
algebraic-stack_agda0000_doc_16854 | ------------------------------------------------------------------------
-- Primitive IO: simple bindings to Haskell types and functions
------------------------------------------------------------------------
module IO.Primitive where
open import Data.String hiding (Costring)
open import Data.Char
open import Foreign.Haskell
------------------------------------------------------------------------
-- The IO monad
postulate
IO : Set → Set
{-# COMPILED_TYPE IO IO #-}
infixl 1 _>>=_
postulate
return : ∀ {A} → A → IO A
_>>=_ : ∀ {A B} → IO A → (A → IO B) → IO B
{-# COMPILED return (\_ -> return :: a -> IO a) #-}
{-# COMPILED _>>=_ (\_ _ -> (>>=) :: IO a -> (a -> IO b) -> IO b) #-}
------------------------------------------------------------------------
-- Simple lazy IO (UTF8-based)
private
Costring = Colist Char
postulate
getContents : IO Costring
readFile : String → IO Costring
writeFile : String → Costring → IO Unit
putStr : Costring → IO Unit
putStrLn : Costring → IO Unit
{-# IMPORT System.IO.UTF8 #-}
{-# COMPILED getContents System.IO.UTF8.getContents #-}
{-# COMPILED readFile System.IO.UTF8.readFile #-}
{-# COMPILED writeFile System.IO.UTF8.writeFile #-}
{-# COMPILED putStr System.IO.UTF8.putStr #-}
{-# COMPILED putStrLn System.IO.UTF8.putStrLn #-}
|
algebraic-stack_agda0000_doc_16855 | {-# OPTIONS --cubical -van-extra-option-just-to-test-a-hack:0 #-}
|
algebraic-stack_agda0000_doc_16856 | open import Function using (_$_)
open import Relation.Nullary using (yes; no)
open import Relation.Binary using (Decidable; Irrelevant; Antisymmetric; Setoid)
open import AKS.Algebra.Bundles using (NonZeroCommutativeRing; Field)
module AKS.Algebra.Consequences {c ℓ} (R : NonZeroCommutativeRing c ℓ) where
open import AKS.Nat using (ℕ)
open import Algebra.Bundles using (CommutativeRing)
open NonZeroCommutativeRing R using (_+_; _*_; -_; _-_; 0#; 1#) renaming (Carrier to C)
open NonZeroCommutativeRing R using (_≈_; _≉_; setoid)
open Setoid setoid using (refl; sym)
open import Relation.Binary.Reasoning.Setoid setoid
open NonZeroCommutativeRing R using (isNonZeroCommutativeRing; commutativeRing)
open CommutativeRing commutativeRing using (+-identityʳ; +-assoc; +-comm; +-congʳ; +-congˡ; +-cong; -‿cong; -‿inverseʳ)
open CommutativeRing commutativeRing using (*-identityˡ; *-cong; *-congʳ; *-congˡ; *-assoc; *-comm; zeroʳ; zeroˡ; commutativeSemiring)
open import AKS.Algebra.Structures C _≈_ using (IsField; IsEuclideanDomain; module Modulus; module Divisibility; IsIntegralDomain; IsGCDDomain; IsUniqueFactorizationDomain)
open import AKS.Algebra.Divisibility commutativeSemiring using (module Euclidean)
open Modulus using (Remainder; 0≈)
open Divisibility _*_ using (_∣_; divides)
module Division⇒EuclideanDomain
(_≈?_ : Decidable _≈_)
(≈-irrelevant : Irrelevant _≈_)
(≉-irrelevant : Irrelevant _≉_)
(∣_∣ : ∀ n {n≉0 : n ≉ 0#} → ℕ)
(_div_ : ∀ (n m : C) {m≉0 : m ≉ 0#} → C)
(_mod_ : ∀ (n m : C) {m≉0 : m ≉ 0#} → C)
(division : ∀ n m {m≉0 : m ≉ 0#} → n ≈ m * (n div m) {m≉0} + (n mod m) {m≉0})
(modulus : ∀ n m {m≉0 : m ≉ 0#} → Remainder 0# ∣_∣ _mod_ n m {m≉0})
(div-cong : ∀ {x₁ x₂} {y₁ y₂} → x₁ ≈ x₂ → y₁ ≈ y₂ → ∀ {y₁≉0 y₂≉0} → (x₁ div y₁) {y₁≉0} ≈ (x₂ div y₂) {y₂≉0})
(mod-distribʳ-* : ∀ c a b {b≉0} {b*c≉0} → ((a * c) mod (b * c)) {b*c≉0} ≈ (a mod b) {b≉0} * c)
(*-cancelˡ : ∀ x {y z} → x ≉ 0# → x * y ≈ x * z → y ≈ z)
where
private
remainder : ∀ n m {m≉0 : m ≉ 0#} → (n mod m) {m≉0} ≈ n - m * (n div m) {m≉0}
remainder n m {m≉0} = begin
n mod m ≈⟨ sym (+-identityʳ (n mod m)) ⟩
n mod m + 0# ≈⟨ +-congˡ (sym (-‿inverseʳ (m * n div m))) ⟩
n mod m + (m * n div m - m * n div m) ≈⟨ sym (+-assoc (n mod m) (m * n div m) (- (m * n div m))) ⟩
(n mod m + m * n div m) - m * n div m ≈⟨ +-congʳ (+-comm (n mod m) (m * n div m)) ⟩
(m * n div m + n mod m) - m * n div m ≈⟨ +-congʳ (sym (division n m {m≉0})) ⟩
n - m * n div m ∎
mod-cong : ∀ {x₁ x₂} {y₁ y₂} → x₁ ≈ x₂ → y₁ ≈ y₂ → ∀ {y₁≉0 y₂≉0} → (x₁ mod y₁) {y₁≉0} ≈ (x₂ mod y₂) {y₂≉0}
mod-cong {x₁} {x₂} {y₁} {y₂} x₁≈x₂ y₁≈y₂ {y₁≉0} {y₂≉0} = begin
x₁ mod y₁ ≈⟨ remainder x₁ y₁ {y₁≉0} ⟩
x₁ - y₁ * x₁ div y₁ ≈⟨ +-cong x₁≈x₂ (-‿cong (*-cong y₁≈y₂ (div-cong x₁≈x₂ y₁≈y₂))) ⟩
x₂ - y₂ * x₂ div y₂ ≈⟨ sym (remainder x₂ y₂ {y₂≉0}) ⟩
x₂ mod y₂ ∎
open Euclidean ∣_∣ _div_ _mod_ _≈?_ ≈-irrelevant ≉-irrelevant division modulus mod-cong mod-distribʳ-* using (gcd; gcd-isGCD) public
isIntegralDomain : IsIntegralDomain _+_ _*_ -_ 0# 1#
isIntegralDomain = record { isNonZeroCommutativeRing = isNonZeroCommutativeRing; *-cancelˡ = *-cancelˡ }
isGCDDomain : IsGCDDomain _+_ _*_ -_ 0# 1# gcd
isGCDDomain = record { isIntegralDomain = isIntegralDomain; gcd-isGCD = gcd-isGCD }
isUniqueFactorizationDomain : IsUniqueFactorizationDomain _+_ _*_ -_ 0# 1# gcd
isUniqueFactorizationDomain = record { isGCDDomain = isGCDDomain }
isEuclideanDomain : IsEuclideanDomain _+_ _*_ -_ 0# 1# ∣_∣ _div_ _mod_ gcd
isEuclideanDomain = record
{ isUniqueFactorizationDomain = isUniqueFactorizationDomain
; division = division
; modulus = modulus
; div-cong = div-cong
; mod-cong = mod-cong
}
module Inverse⇒Field
(_≈?_ : Decidable _≈_)
(≈-irrelevant : Irrelevant _≈_)
(≉-irrelevant : Irrelevant _≉_)
(_/_ : ∀ (n m : C) {m≉0 : m ≉ 0#} → C)
(inverse : ∀ (n m : C) {m≉0 : m ≉ 0#} → n ≈ m * (n / m) {m≉0})
where
private
∣_∣ : ∀ n {n≉0 : n ≉ 0#} → ℕ
∣ _ ∣ = 0
_mod_ : ∀ (n m : C) {m≉0 : m ≉ 0#} → C
_ mod _ = 0#
division : ∀ n m {m≉0 : m ≉ 0#} → n ≈ m * (n / m) {m≉0} + (n mod m) {m≉0}
division n m {m≉0} = begin
n ≈⟨ inverse n m {m≉0} ⟩
m * (n / m) ≈⟨ sym (+-identityʳ (m * (n / m))) ⟩
m * (n / m) {m≉0} + (n mod m) {m≉0} ∎
modulus : ∀ n m {m≉0 : m ≉ 0#} → Remainder 0# ∣_∣ _mod_ n m {m≉0}
modulus _ _ = 0≈ refl
*-cancelˡ : ∀ x {y z} → x ≉ 0# → x * y ≈ x * z → y ≈ z
*-cancelˡ x {y} {z} x≢0 x*y≡x*z = begin
y ≈⟨ sym (*-identityˡ y) ⟩
1# * y ≈⟨ *-congʳ (inverse 1# x {x≢0}) ⟩
(x * (1# / x)) * y ≈⟨ *-congʳ (*-comm x (1# / x)) ⟩
((1# / x) * x) * y ≈⟨ *-assoc _ _ _ ⟩
(1# / x) * (x * y) ≈⟨ *-congˡ x*y≡x*z ⟩
(1# / x) * (x * z) ≈⟨ sym (*-assoc _ _ _) ⟩
((1# / x) * x) * z ≈⟨ *-congʳ (*-comm (1# / x) x) ⟩
(x * (1# / x)) * z ≈⟨ *-congʳ (sym (inverse 1# x {x≢0})) ⟩
1# * z ≈⟨ *-identityˡ z ⟩
z ∎
div-cong : ∀ {x₁ x₂} {y₁ y₂} → x₁ ≈ x₂ → y₁ ≈ y₂ → ∀ {y₁≉0 y₂≉0} → (x₁ / y₁) {y₁≉0} ≈ (x₂ / y₂) {y₂≉0}
div-cong {x₁} {x₂} {y₁} {y₂} x₁≈x₂ y₁≈y₂ {y₁≉0} {y₂≉0} = *-cancelˡ y₁ y₁≉0 $ begin
y₁ * (x₁ / y₁) ≈⟨ sym (inverse x₁ y₁) ⟩
x₁ ≈⟨ x₁≈x₂ ⟩
x₂ ≈⟨ inverse x₂ y₂ ⟩
y₂ * (x₂ / y₂) ≈⟨ *-congʳ (sym y₁≈y₂) ⟩
y₁ * (x₂ / y₂) ∎
mod-distribʳ-* : ∀ c a b {b≉0} {b*c≉0} → ((a * c) mod (b * c)) {b*c≉0} ≈ (a mod b) {b≉0} * c
mod-distribʳ-* c a b = sym (zeroˡ c)
open Division⇒EuclideanDomain _≈?_ ≈-irrelevant ≉-irrelevant ∣_∣ _/_ _mod_ division modulus div-cong mod-distribʳ-* *-cancelˡ using (gcd; isEuclideanDomain) public
isField : IsField _+_ _*_ -_ 0# 1# _/_ gcd
isField = record { isEuclideanDomain = isEuclideanDomain }
[field] : Field c ℓ
[field] = record { isField = isField }
|
algebraic-stack_agda0000_doc_16857 | ------------------------------------------------------------------------------
-- Natural numbers (PCF version)
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module LTC-PCF.Data.Nat where
open import LTC-PCF.Base
open import LTC-PCF.Data.Nat.Rec
open import LTC-PCF.Data.Nat.Type public
infixl 7 _*_
infixl 6 _+_ _∸_
------------------------------------------------------------------------------
-- Addition with recursion on the first argument.
_+_ : D → D → D
m + n = rec m n (lam (λ _ → lam succ₁))
-- Subtraction with recursion on the second argument.
_∸_ : D → D → D
m ∸ n = rec n m (lam (λ _ → lam pred₁))
-- Multiplication with recursion on the first argument.
_*_ : D → D → D
m * n = rec m zero (lam (λ _ → lam (λ x → n + x)))
|
algebraic-stack_agda0000_doc_16858 | {-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module CombiningProofs.Erasing where
postulate
D : Set
succ₁ : D → D
data N : D → Set where
nsucc₁ : ∀ {n} → N n → N (succ₁ n)
nsucc₂ : ∀ {n} → (Nn : N n) → N (succ₁ n)
-- The types of nsucc₁ and nsucc₂ are the same.
-- (18 April 2013)
-- $ dump-agdai Erasing
-- Qname: Erasing.N.nsucc₁
-- Type: El {getSort = Type (Max []), unEl = Pi []r{El {getSort = Type (Max []), unEl = Def Erasing.D []}} (Abs "n" El {getSort = Type (Max []), unEl = Pi []r(El {getSort = Type (Max []), unEl = Def Erasing.N [[]r(Var 0 [])]}) (NoAbs "_" El {getSort = Type (Max []), unEl = Def Erasing.N [[]r(Def Erasing.succ₁ [[]r(Var 0 [])])]})})}
-- Qname: Erasing.N.nsucc₂
-- Type: El {getSort = Type (Max []), unEl = Pi []r{El {getSort = Type (Max []), unEl = Def Erasing.D []}} (Abs "n" El {getSort = Type (Max []), unEl = Pi []r(El {getSort = Type (Max []), unEl = Def Erasing.N [[]r(Var 0 [])]}) (NoAbs "Nn" El {getSort = Type (Max []), unEl = Def Erasing.N [[]r(Def Erasing.succ₁ [[]r(Var 0 [])])]})})}
|
algebraic-stack_agda0000_doc_16859 | {-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Functions.Definition
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Order
open import Numbers.Naturals.Order.WellFounded
open import Semirings.Definition
open import Orders.Total.Definition
open import Orders.Partial.Definition
open import Orders.WellFounded.Definition
open import Orders.WellFounded.Induction
module Sets.CantorBijection.Order where
order : Rel (ℕ && ℕ)
order (a ,, b) (c ,, d) = ((a +N b) <N (c +N d)) || (((a +N b) ≡ (c +N d)) && (b <N d))
totalOrder : TotalOrder (ℕ && ℕ)
PartialOrder._<_ (TotalOrder.order totalOrder) = order
PartialOrder.irreflexive (TotalOrder.order totalOrder) {fst ,, snd} (inl x) = exFalso (TotalOrder.irreflexive ℕTotalOrder x)
PartialOrder.irreflexive (TotalOrder.order totalOrder) {fst ,, snd} (inr (_ ,, p)) = exFalso (TotalOrder.irreflexive ℕTotalOrder p)
PartialOrder.<Transitive (TotalOrder.order totalOrder) {x1 ,, x2} {y1 ,, y2} {z1 ,, z2} (inl pr1) (inl pr2) = inl (TotalOrder.<Transitive ℕTotalOrder pr1 pr2)
PartialOrder.<Transitive (TotalOrder.order totalOrder) {x1 ,, x2} {y1 ,, y2} {z1 ,, z2} (inl pr1) (inr (f1 ,, f2)) = inl (identityOfIndiscernablesRight _<N_ pr1 f1)
PartialOrder.<Transitive (TotalOrder.order totalOrder) {x1 ,, x2} {y1 ,, y2} {z1 ,, z2} (inr (f1 ,, f2)) (inl x) = inl (identityOfIndiscernablesLeft _<N_ x (equalityCommutative f1))
PartialOrder.<Transitive (TotalOrder.order totalOrder) {x1 ,, x2} {y1 ,, y2} {z1 ,, z2} (inr (f1 ,, f2)) (inr (fst ,, snd)) = inr (transitivity f1 fst ,, TotalOrder.<Transitive ℕTotalOrder f2 snd)
TotalOrder.totality totalOrder (a ,, b) (c ,, d) with TotalOrder.totality ℕTotalOrder (a +N b) (c +N d)
TotalOrder.totality totalOrder (a ,, b) (c ,, d) | inl (inl x) = inl (inl (inl x))
TotalOrder.totality totalOrder (a ,, b) (c ,, d) | inl (inr x) = inl (inr (inl x))
TotalOrder.totality totalOrder (a ,, b) (c ,, d) | inr eq with TotalOrder.totality ℕTotalOrder b d
TotalOrder.totality totalOrder (a ,, b) (c ,, d) | inr eq | inl (inl x) = inl (inl (inr (eq ,, x)))
TotalOrder.totality totalOrder (a ,, b) (c ,, d) | inr eq | inl (inr x) = inl (inr (inr (equalityCommutative eq ,, x)))
TotalOrder.totality totalOrder (a ,, b) (c ,, .b) | inr eq | inr refl rewrite canSubtractFromEqualityRight {a} {b} {c} eq = inr refl
leastElement : {y : ℕ && ℕ} → order y (0 ,, 0) → False
leastElement {zero ,, b} (inl ())
leastElement {zero ,, b} (inr ())
leastElement {succ a ,, b} (inl ())
leastElement {succ a ,, b} (inr ())
mustDescend : (a b t : ℕ) → order (a ,, b) (t ,, zero) → a +N b <N t
mustDescend a b zero ord = exFalso (leastElement ord)
mustDescend a b (succ t) (inl x) rewrite Semiring.sumZeroRight ℕSemiring t = x
orderWellfounded : WellFounded order
orderWellfounded (a ,, b) = access (go b a)
where
g0 : (c : ℕ) (y : ℕ && ℕ) → order y (c ,, 0) → Accessible order y
-- We want to induct on the second entry of x here, so we decompose so as to put that first.
g : (x : ℕ) → ((y : ℕ) → y <N x → (b : ℕ) (z : ℕ && ℕ) → order z (b ,, y) → Accessible order z) → (c : ℕ) (y : ℕ && ℕ) → order y (c ,, x) → Accessible order y
g0 = rec <NWellfounded (λ z → (x : ℕ && ℕ) (x₁ : order x (z ,, zero)) → Accessible order x) f
where
p : (a b : ℕ) → a ≡ b → (a ,, zero) ≡ (b ,, zero)
p a .a refl = refl
f : (x : ℕ) (x₁ : (x₂ : ℕ) (x₃ : x₂ <N x) (x₄ : ℕ && ℕ) (x₅ : order x₄ (x₂ ,, zero)) → Accessible order x₄) (x₂ : ℕ && ℕ) (x₃ : order x₂ (x ,, zero)) → Accessible order x₂
f zero pr y ord = exFalso (leastElement ord)
f (succ m) pr (fst ,, snd) (inl pr2) = h snd fst pr2
where
go : (x : ℕ) (x₁ : (x₂ : ℕ) (x₃ : x₂ <N x) (x₄ : ℕ) (x₅ : x₄ +N x₂ <N succ (m +N zero)) → Accessible order (x₄ ,, x₂)) (x₂ : ℕ) (x₃ : x₂ +N x <N succ (m +N zero)) → Accessible order (x₂ ,, x)
go bound pr2 toProve bounded with TotalOrder.totality ℕTotalOrder (toProve +N bound) (m +N 0)
... | inl (inl bl) = pr m (le 0 refl) (toProve ,, bound) (inl bl)
... | inl (inr bl) = exFalso (noIntegersBetweenXAndSuccX (m +N 0) bl bounded)
go zero pr2 toProve _ | inr bl rewrite Semiring.sumZeroRight ℕSemiring m | Semiring.sumZeroRight ℕSemiring toProve = access λ i i<z → pr m (le 0 refl) i (inl (mustDescend (_&&_.fst i) (_&&_.snd i) (m +N zero) (identityOfIndiscernablesLeft order (identityOfIndiscernablesRight order i<z (p toProve (m +N 0) (transitivity bl (equalityCommutative (Semiring.sumZeroRight ℕSemiring m))))) refl)))
go (succ bound) pr2 toProve _ | inr bl = access desc
where
desc : (i : ℕ && ℕ) → (order i (toProve ,, succ bound)) → Accessible order i
desc (i1 ,, i2) (inl ord) = pr m (le zero refl) (i1 ,, i2) (inl (identityOfIndiscernablesRight _<N_ ord bl))
desc (i1 ,, i2) (inr (ord1 ,, ord2)) = pr2 i2 ord2 i1 (le 0 (applyEquality succ (transitivity ord1 bl)))
h : (a : ℕ) (b : ℕ) (pr2 : b +N a <N succ m +N 0) → Accessible order (b ,, a)
h = rec <NWellfounded (λ z → (x2 : ℕ) (x1 : x2 +N z <N succ (m +N zero)) → Accessible order (x2 ,, z)) go
g zero _ = g0
g (succ x) pr zero (y1 ,, y2) (inl pr1) with TotalOrder.totality ℕTotalOrder (y1 +N y2) x
g (succ x) pr zero (y1 ,, y2) (inl pr1) | inl (inl y1+y2<x) = pr x (le 0 refl) zero (y1 ,, y2) (inl y1+y2<x)
g (succ x) pr zero (y1 ,, y2) (inl pr1) | inl (inr x<y1+y2) = exFalso (noIntegersBetweenXAndSuccX x x<y1+y2 pr1)
g (succ x) pr zero (y1 ,, y2) (inl pr1) | inr y1+y2=x = access (λ y y<zs → pr x (le 0 refl) zero y (ans y y<zs))
where
ans : (y : ℕ && ℕ) → order y (y1 ,, y2) → (_&&_.fst y +N _&&_.snd y <N x) || ((_&&_.fst y +N _&&_.snd y ≡ x) && (_&&_.snd y <N x))
ans (fst ,, snd) (inl x) rewrite y1+y2=x = inl x
ans (zero ,, snd) (inr (a1 ,, a2)) rewrite y1+y2=x | a1 = exFalso (bad x y1 y2 y1+y2=x a2)
where
bad : (x y1 y2 : ℕ) → y1 +N y2 ≡ x → x <N y2 → False
bad x zero y2 y1+y2=x x<y2 = TotalOrder.irreflexive ℕTotalOrder (identityOfIndiscernablesRight _<N_ x<y2 y1+y2=x)
bad x (succ y1) y2 y1+y2=x x<y2 rewrite equalityCommutative y1+y2=x = TotalOrder.irreflexive ℕTotalOrder (TotalOrder.<Transitive ℕTotalOrder x<y2 (identityOfIndiscernablesRight _<N_ (addingIncreases y2 y1) (Semiring.commutative ℕSemiring y2 (succ y1))))
ans (succ fst ,, snd) (inr (a1 ,, a2)) rewrite y1+y2=x = inr (a1 ,, le fst a1)
g (succ x) pr zero (zero ,, y2) (inr (fst ,, snd)) = exFalso (TotalOrder.irreflexive ℕTotalOrder (identityOfIndiscernablesLeft _<N_ snd fst))
g (succ x) pr zero (succ y1 ,, y2) (inr (fst ,, snd)) = pr y2 snd (succ (succ y1)) (succ y1 ,, y2) (inl (le 0 refl))
g (succ x) pr (succ c) y (inl z) = pr x (le 0 refl) (succ (succ c)) y (inl (identityOfIndiscernablesRight _<N_ z (applyEquality succ (transitivity (Semiring.commutative ℕSemiring c (succ x)) (applyEquality succ (Semiring.commutative ℕSemiring x c))))))
g (succ x) pr (succ c) y (inr (fst ,, snd)) with TotalOrder.totality ℕTotalOrder (_&&_.snd y) x
... | inl (inl bl) = pr x (le 0 refl) (succ (succ c)) y (inr (transitivity fst (applyEquality succ (transitivity (Semiring.commutative ℕSemiring c (succ x)) (applyEquality succ (Semiring.commutative ℕSemiring x c)))) ,, bl))
... | inl (inr bl) = exFalso (noIntegersBetweenXAndSuccX x bl snd)
g (succ x) pr (succ c) (y1 ,, .x) (inr (fst ,, _)) | inr refl with canSubtractFromEqualityRight {y1} {x} {succ (succ c)} (transitivity fst (applyEquality succ (transitivity (Semiring.commutative ℕSemiring c (succ x)) (applyEquality succ (Semiring.commutative ℕSemiring x c)))))
g (succ x) pr (succ c) (.(succ (succ c)) ,, .x) (inr (_ ,, _)) | inr refl | refl = pr x (le 0 refl) (succ (succ (succ c))) (succ (succ c) ,, x) (inl (le 0 refl))
go : (a : ℕ) → (b : ℕ) → (y : ℕ && ℕ) → order y (b ,, a) → Accessible order y
go = rec <NWellfounded (λ (a : ℕ) → (b : ℕ) → (y : ℕ && ℕ) → order y (b ,, a) → Accessible order y) g
|
algebraic-stack_agda0000_doc_16860 |
module Basic.Axiomatic.Partial where
open import Data.Bool hiding (not; if_then_else_; _∧_)
open import Data.Vec hiding ([_]; _++_; split)
open import Function
open import Relation.Binary.PropositionalEquality
open import Data.Product
import Level as L
open import Utils.Decidable
open import Basic.AST
open import Basic.BigStep
{-
Here we define a Hoare logic for partial correctness of While programs (chapter 6.2).
The most important point here is the choice of representation for predicates.
The book mention intensional and extensional approaches. In the intensional approach,
we define a separate assertion language. However, the assertion language has to be powerful
enough to be able to express useful properties of the program state, and it takes quite a bit
of work to define such a language. An advatange of the intensional approach is that we could reuse
the same assertion language to extend the object language in other ways.
The book uses the extensional approach, and so do we. We go a bit further than the book though:
the book has boolean predicates over the program state, while we have type theoretic
"(State n → Set)" predicates. This means that our predicates can be proof-relevant and contain data,
so they can express computations and transformations on states.
However, the higher-order nature of the "(State n → Set)" representation of predicates also makes
type inference quite hard. I attepmeted to do some correctness proofs with the Hoare logics, and
it's certainly feasible, but we would need a lot more machinery and lots of helper functions to
make it convenient enough.
It's interesting to note that manual proof-writing is generally easier with Hoare logics than with
raw semantics, but here in Agda it's the opposite: the proofs in raw semantics (see e. g. the
factorial proofs in Basic.SmallStep, Basic.BigStep and Extended.FunRetRec) are pretty neat convenient,
since Agda keeps track of the program state for us and hides lots of unnecessary details.
Side note: we could have made our definition universe polymorphic. It would be a trivial extension;
the reason we don't have it is that we don't need that much power of expression for any of our proofs.
Just using "Set" suffices.
-}
{-
Predicate combinators: these just lift conjunction and implication into the State environment.
-}
_∧_ :
∀ {α β γ}{A : Set α}
→ (A → Set β)
→ (A → Set γ)
→ (A → Set _)
_∧_ f g x = f x × g x
_==>_ :
∀ {α β γ}{A : Set α}
→ (A → Set β)
→ (A → Set γ)
→ Set _
_==>_ f g = ∀ {x} → f x → g x
infixr 4 _,_
data 〈_〉_〈_〉 {n} : (State n → Set) → St n → (State n → Set) → Set₁ where
skip :
∀ {P}
→ -----------------
〈 P 〉 skip 〈 P 〉
ass :
∀ {x a P}
→ ----------------------------------------------
〈 (λ s → P (s [ x ]≔ ⟦ a ⟧ᵉ s)) 〉 x := a 〈 P 〉
_,_ :
∀ {P Q R S₁ S₂} →
〈 P 〉 S₁ 〈 Q 〉 → 〈 Q 〉 S₂ 〈 R 〉
→ --------------------------------
〈 P 〉 S₁ , S₂ 〈 R 〉
if :
∀ {P Q b S₁ S₂} →
〈 (T ∘ ⟦ b ⟧ᵉ) ∧ P 〉 S₁ 〈 Q 〉 → 〈 (F ∘ ⟦ b ⟧ᵉ) ∧ P 〉 S₂ 〈 Q 〉
→ --------------------------------------------------------------
〈 P 〉 if b then S₁ else S₂ 〈 Q 〉
while :
∀ {P b S} →
〈 (T ∘ ⟦ b ⟧ᵉ) ∧ P 〉 S 〈 P 〉
→ ----------------------------------------
〈 P 〉 while b do S 〈 (F ∘ ⟦ b ⟧ᵉ) ∧ P 〉
cons :
∀ {P' Q' P Q S} →
P ==> P' → 〈 P' 〉 S 〈 Q' 〉 → Q' ==> Q
→ -----------------------------------------
〈 P 〉 S 〈 Q 〉
{-
A part of exercise 6.13 (associativity of statement composition with respect to our logic).
-}
split :
∀ {n P R}{S₁ S₂ : St n}
→ 〈 P 〉 S₁ , S₂ 〈 R 〉
→ ∃ λ Q
→ (〈 P 〉 S₁ 〈 Q 〉) × (〈 Q 〉 S₂ 〈 R 〉)
split (p , p₁) = _ , (p , p₁)
split (cons x p y) with split p
... | Q , (p1 , p2) = Q , (cons x p1 id , cons id p2 y)
ex-613a :
∀ {n P Q}{S₁ S₂ S₃ : St n}
→ 〈 P 〉 S₁ , (S₂ , S₃) 〈 Q 〉
→ 〈 P 〉 (S₁ , S₂) , S₃ 〈 Q 〉
ex-613a (p , p₁) with split p₁
... | _ , (p₁₁ , p₁₂) = (p , p₁₁) , p₁₂
ex-613a (cons x p x₁) = cons x (ex-613a p) x₁
ex-613b :
∀ {n P Q}{S₁ S₂ S₃ : St n}
→ 〈 P 〉 (S₁ , S₂) , S₃ 〈 Q 〉
→ 〈 P 〉 S₁ , (S₂ , S₃) 〈 Q 〉
ex-613b (p₁ , p₂) with split p₁
... | _ , (p₁₁ , p₁₂) = p₁₁ , (p₁₂ , p₂)
ex-613b (cons x p x₁) = cons x (ex-613b p) x₁
{-
Now we set out to prove soundess and completeness of our Hoare logic (see chapter 6.3).
Note that we express validity of a Hoare triple in terms of the weakest liberal precondition:
⊨ₚ { P } S { Q } := (P ==> wlp S Q)
This is just a notational conveneince, but for some reason I also find it pleasing to the eye.
-}
-- Weakest liberal precondition
------------------------------------------------------------
wlp : ∀ {n} → St n → (State n → Set) → State n → Set
wlp S Q s = ∀ {s'} → ⟨ S , s ⟩⟱ s' → Q s'
-- Soundness
------------------------------------------------------------
{-
This proof is the same as in the book, because it's rather simple and there's not
much choice.
-}
sound : ∀ {n}{S : St n}{P Q} → 〈 P 〉 S 〈 Q 〉 → (P ==> wlp S Q)
sound skip ps skip = ps
sound ass ps ass = ps
sound (p , p₁) ps (run , run₁) = sound p₁ (sound p ps run) run₁
sound (if p p₁) ps (if-true x run) = sound p (x , ps) run
sound (if p p₁) ps (if-false x run) = sound p₁ (x , ps) run
sound (while p) ps (while-true x run run₁) = sound (while p) (sound p (x , ps) run) run₁
sound (while p) ps (while-false x) = x , ps
sound (cons x p x₁) ps run = x₁ (sound p (x ps) run)
-- Completeness
------------------------------------------------------------
{-
This one differs from the book proof.
The book proves the following:
∀ S Q → 〈 wlp S Q 〉 S 〈 Q 〉
then uses "cons" and the definition of "wlp" to infer 〈 P 〉 S 〈 Q 〉 from (P ==> wlp S Q).
We instead prove completeness directly. Our job here is essentially to recurse on sub-statements,
while making the postcondition of that statement equal to the weakest precondition of the following
statement.
As a result, the proofs for the "if_then_else_" , composition and "while" cases are all
a bit simpler than the book proofs.
In the case of "while", the book makes an unnecessary twist. It uses the law of excluded middle
on "〈 while b do S , s' 〉⟶ s''" derivations, but there's actually no need for that. It would be
indeed ugly in Agda, where we would have to assume classical logic and destroy constructivity
in order to be able to write that proof.
-}
complete : ∀ {n}(S : St n){P Q} → (P ==> wlp S Q) → 〈 P 〉 S 〈 Q 〉
complete (x := a) f = cons (λ z → f z ass) ass id
complete skip f = cons (λ z → f z skip) skip id
complete (S , S₁){P}{Q} f =
complete S {P} {wlp S₁ Q} (λ ps runS runS₁ → f ps (runS , runS₁))
, complete S₁ id
complete (if b then S else S₁){P}{Q} f =
if (complete S {(T ∘ ⟦ b ⟧ᵉ) ∧ P} {Q} (λ {(pb , pP) → λ runS → f pP (if-true pb runS)}))
(complete S₁ {(F ∘ ⟦ b ⟧ᵉ) ∧ P} {Q} (λ {(pb , pP) → λ runS₁ → f pP (if-false pb runS₁)}))
complete (while b do S){P}{Q} f =
cons f
(while
(complete S {(T ∘ ⟦ b ⟧ᵉ) ∧ W} {W}
(λ {(pb , pw) → λ runS runW → pw (while-true pb runS runW)})))
(λ {(pb , pw) → pw (while-false pb)})
where W = wlp (while b do S) Q
|
algebraic-stack_agda0000_doc_16861 | {-# OPTIONS --without-K --safe #-}
module Categories.Category.Construction.LT-Models where
-- Given a fixed Lawvere Theory LT and a fixed category C,
-- the Functors [LT , C] form a category.
-- The proof is basically the same as that of Functors.
open import Level
open import Categories.Category.Core using (Category)
open import Categories.Category.Cartesian.Bundle using (CartesianCategory)
open import Categories.Category.Monoidal.Instance.Setoids using (Setoids-CartesianCategory)
open import Categories.NaturalTransformation
using (NaturalTransformation; _∘ᵥ_) renaming (id to idN)
open import Categories.NaturalTransformation.Equivalence using (_≃_; ≃-isEquivalence)
open import Categories.Theory.Lawvere using (LawvereTheory; ModelsOf_In_)
private
variable
o ℓ e o′ ℓ′ e′ : Level
-- The reason the proofs below are so easy is that _∘ᵥ_ 'computes' all the way down into
-- expressions in C, from which the properties follow.
LT-Models : LawvereTheory ℓ e → CartesianCategory o′ ℓ′ e′ → Category (ℓ ⊔ e ⊔ o′ ⊔ ℓ′ ⊔ e′) (ℓ ⊔ ℓ′ ⊔ e′) e′
LT-Models LT C = record
{ Obj = ModelsOf LT In C
; _⇒_ = λ m₁ m₂ → NaturalTransformation (ModelsOf_In_.mod m₁) (ModelsOf_In_.mod m₂)
; _≈_ = _≃_
; id = idN
; _∘_ = _∘ᵥ_
; assoc = assoc
; sym-assoc = sym-assoc
; identityˡ = identityˡ
; identityʳ = identityʳ
; identity² = identity²
; equiv = ≃-isEquivalence
; ∘-resp-≈ = λ eq eq′ → ∘-resp-≈ eq eq′
}
where
module C = CartesianCategory C using (U)
open Category C.U
LT-SetoidsModels : {ℓ′ e′ : Level} → LawvereTheory ℓ e → Category (ℓ ⊔ e ⊔ suc (ℓ′ ⊔ e′)) (ℓ ⊔ ℓ′ ⊔ e′) (ℓ′ ⊔ e′)
LT-SetoidsModels {ℓ′ = ℓ′} {e′} LT = LT-Models LT (Setoids-CartesianCategory ℓ′ e′)
|
algebraic-stack_agda0000_doc_16862 | module Auto-Modules where
open import Auto.Prelude hiding (cong; trans)
module NonemptySet (X : Set) (x : X) where
h0 : (P : X → Set) → (∀ x → P x) → Σ X P
h0 = {!!}
-- h0 = λ P h → Σ-i x (h x)
module WithRAA (RAA : ∀ A → ¬ (¬ A) → A) where
h1 : ∀ A → A ∨ ¬ A
h1 = {!!}
--h1 = λ A → RAA (A ∨ ((x : A) → ⊥)) (λ z → z (∨-i₂ (λ x → z (∨-i₁ x))))
module B where
h2 : ∀ A → A ∨ ¬ A
h2 = {!!}
module A (X : Set) (x : X) where
postulate AllSame : {x y : X} → x ≡ y
n0 : (P : X → Set) → Σ X P → ∀ x → P x
-- n0 = {!subst AllSame!} -- no solution found
n0 = λ P h x → subst P (Σ.wit h) x AllSame (Σ.prf h)
module B (X : Set) (x y : X) (P : X → Set) where
postulate p : P x
h3 : P x
h3 = {!p!}
-- h3 = p
module Setoid (X : Set)
(Eq : X → X → Set)
(refl : ∀ {x} → Eq x x)
(symm : ∀ {x₁ x₂} → Eq x₁ x₂ → Eq x₂ x₁)
(subst : ∀ {x₁ x₂} → (P : X → Set) → Eq x₁ x₂ → P x₁ → P x₂)
where
cong : ∀ {x₁ x₂} → (f : X → X) → Eq x₁ x₂ → Eq (f x₁) (f x₂)
cong = {!!} -- hole 4
-- cong = λ {x₁} {x₂} f z → subst (λ z₁ → Eq (f x₁) (f z₁)) z refl
trans : ∀ {x₁ x₂ x₃} → Eq x₁ x₂ → Eq x₂ x₃ → Eq x₁ x₃
trans = {!!} -- hole 5
-- trans = λ {x₁} {x₂} {x₃} z z₁ → subst (Eq x₁) z₁ z
|
algebraic-stack_agda0000_doc_16863 |
module Base where
data True : Set where
T : True
data False : Set where
infix 20 _*_
data _*_ (A : Set)(B : A -> Set) : Set where
<_,_> : (x : A) -> B x -> A * B
rel : Set -> Set1
rel A = A -> A -> Set
pred : Set -> Set1
pred A = A -> Set
Refl : {A : Set} -> rel A -> Set
Refl {A} R = {x : A} -> R x x
Sym : {A : Set} -> rel A -> Set
Sym {A} R = {x y : A} -> R x y -> R y x
Trans : {A : Set} -> rel A -> Set
Trans {A} R = {x y z : A} -> R x y -> R y z -> R x z
Map : {A : Set} -> rel A -> {B : Set} -> rel B -> pred (A -> B)
Map {A} _R_ _S_ f = {x y : A} -> x R y -> f x S f y
|
algebraic-stack_agda0000_doc_8944 | {-# OPTIONS --without-K #-}
open import HoTT.Base
open import HoTT.Equivalence
module HoTT.Identity.Universe {i} {A B : 𝒰 i} where
-- Axiom 2.10.3 - univalence
postulate
idtoeqv-equiv : isequiv (idtoeqv {A = A} {B = B})
=𝒰-equiv : (A == B) ≃ (A ≃ B)
=𝒰-equiv = idtoeqv , idtoeqv-equiv
module _ where
open qinv (isequiv→qinv idtoeqv-equiv)
abstract
ua : A ≃ B → A == B
ua = g
=𝒰-η : ua ∘ idtoeqv ~ id
=𝒰-η = η
=𝒰-β : idtoeqv ∘ ua ~ id
=𝒰-β = ε
_=𝒰_ = _≃_
|
algebraic-stack_agda0000_doc_8945 | module hott.types.int where
open import hott.functions
open import hott.core
import hott.types.nat as nat
open nat using (ℕ)
data ℤ : Type₀ where
zero : ℤ
+ve : ℕ → ℤ
-ve : ℕ → ℤ
fromNat : ℕ → ℤ
fromNat nat.zero = zero
fromNat (nat.succ n) = +ve n
neg : ℤ → ℤ
neg zero = zero
neg (+ve n) = -ve n
neg (-ve n) = +ve n
suc : ℤ → ℤ
suc zero = +ve 0
suc (+ve x) = +ve (nat.succ x)
suc (-ve 0) = zero
suc (-ve (nat.succ x)) = -ve x
pred : ℤ → ℤ
pred zero = -ve 0
pred (-ve x) = -ve (nat.succ x)
pred (+ve 0) = zero
pred (+ve (nat.succ x)) = +ve x
suc∘pred~id : suc ∘ pred ~ id
suc∘pred~id zero = refl
suc∘pred~id (+ve 0) = refl
suc∘pred~id (+ve (nat.succ x)) = refl
suc∘pred~id (-ve x) = refl
pred∘suc~id : pred ∘ suc ~ id
pred∘suc~id zero = refl
pred∘suc~id (+ve x) = refl
pred∘suc~id (-ve 0) = refl
pred∘suc~id (-ve (nat.succ x)) = refl
|
algebraic-stack_agda0000_doc_8946 | ------------------------------------------------------------------------
-- Second-order abstract syntax
--
-- Examples of the formalisation framework in use
------------------------------------------------------------------------
module Examples where
-- | Algebraic structures
-- Monoids
import Monoid.Signature
import Monoid.Syntax
import Monoid.Equality
-- Commutative monoids
import CommMonoid.Signature
import CommMonoid.Syntax
import CommMonoid.Equality
-- Groups
import Group.Signature
import Group.Syntax
import Group.Equality
-- Commutative groups
import CommGroup.Signature
import CommGroup.Syntax
import CommGroup.Equality
-- Group actions
import GroupAction.Signature
import GroupAction.Syntax
import GroupAction.Equality
-- Semirings
import Semiring.Signature
import Semiring.Syntax
import Semiring.Equality
-- Rings
import Ring.Signature
import Ring.Syntax
import Ring.Equality
-- Commutative rings
import CommRing.Signature
import CommRing.Syntax
import CommRing.Equality
-- | Logic
-- Propositional logic
import PropLog.Signature
import PropLog.Syntax
import PropLog.Equality
-- First-order logic (with example proofs)
import FOL.Signature
import FOL.Syntax
import FOL.Equality
-- | Computational calculi
-- Combinatory logic
import Combinatory.Signature
import Combinatory.Syntax
import Combinatory.Equality
-- Untyped λ-calculus
import UTLC.Signature
import UTLC.Syntax
import UTLC.Equality
-- Simply-typed λ-calculus (with operational semantics and environment model)
import STLC.Signature
import STLC.Syntax
import STLC.Equality
import STLC.Model
-- Typed λ-calculus with product and sum types, and naturals (with example derivation)
import TLC.Signature
import TLC.Syntax
import TLC.Equality
-- PCF
import PCF.Signature
import PCF.Syntax
import PCF.Equality
-- | Miscellaneous
-- Lenses
import Lens.Signature
import Lens.Syntax
import Lens.Equality
-- Inception algebras
import Inception.Signature
import Inception.Syntax
import Inception.Equality
-- Substitution algebras
import Sub.Signature
import Sub.Syntax
import Sub.Equality
-- Partial differentiation (with some example proofs)
import PDiff.Signature
import PDiff.Syntax
import PDiff.Equality
|
algebraic-stack_agda0000_doc_8947 | {-# OPTIONS --without-K --safe #-}
module Experiment.Zero where
open import Level using (_⊔_)
-- Empty type
data ⊥ : Set where
-- Unit type
record ⊤ : Set where
constructor tt
-- Boolean
data Bool : Set where
true false : Bool
-- Natural number
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
-- Propositional Equality
data _≡_ {a} {A : Set a} (x : A) : A → Set a where
refl : x ≡ x
-- Sum type
data _⊎_ {a} {b} (A : Set a) (B : Set b) : Set (a ⊔ b) where
inj₁ : A → A ⊎ B
inj₂ : B → A ⊎ B
-- Dependent Product type
record Σ {a} {b} (A : Set a) (B : A → Set b) : Set (a ⊔ b) where
constructor _,_
field
fst : A
snd : B fst
-- Induction
⊤-ind : ∀ {p} {P : ⊤ → Set p} → P tt → ∀ x → P x
⊤-ind P⊤ tt = P⊤
⊥-ind : ∀ {p} {P : ⊥ → Set p} → ∀ x → P x
⊥-ind ()
Bool-ind : ∀ {p} {P : Bool → Set p} → P true → P false → ∀ x → P x
Bool-ind t e true = t
Bool-ind t e false = e
ℕ-ind : ∀ {p} {P : ℕ → Set p} → P zero → (∀ m → P m → P (suc m)) → ∀ n → P n
ℕ-ind P0 Ps zero = P0
ℕ-ind P0 Ps (suc n) = Ps n (ℕ-ind P0 Ps n)
≡-ind : ∀ {a p} {A : Set a}
(P : (x y : A) → x ≡ y → Set p) →
(∀ x → P x x refl) →
∀ x y (eq : x ≡ y) → P x y eq
≡-ind P Pr x .x refl = Pr x
⊎-ind : ∀ {a b p} {A : Set a} {B : Set b} {P : A ⊎ B → Set p} →
(∀ x → P (inj₁ x)) → (∀ y → P (inj₂ y)) → ∀ s → P s
⊎-ind i1 i2 (inj₁ x) = i1 x
⊎-ind i1 i2 (inj₂ y) = i2 y
Σ-ind : ∀ {a b p} {A : Set a} {B : A → Set b} {P : Σ A B → Set p} →
(∀ x y → P (x , y)) → ∀ p → P p
Σ-ind f (x , y) = f x y
|
algebraic-stack_agda0000_doc_8948 | {-# OPTIONS --without-K --safe #-}
module Dodo.Binary.Intersection where
-- Stdlib imports
open import Level using (Level; _⊔_)
open import Data.Product as P
open import Data.Product using (_×_; _,_; swap; proj₁; proj₂)
open import Relation.Binary using (REL)
-- Local imports
open import Dodo.Binary.Equality
-- # Definitions
infixl 30 _∩₂_
_∩₂_ : {a b ℓ₁ ℓ₂ : Level} {A : Set a} {B : Set b}
→ REL A B ℓ₁
→ REL A B ℓ₂
→ REL A B (ℓ₁ ⊔ ℓ₂)
_∩₂_ P Q x y = P x y × Q x y
-- # Properties
module _ {a b ℓ : Level} {A : Set a} {B : Set b} {R : REL A B ℓ} where
∩₂-idem : (R ∩₂ R) ⇔₂ R
∩₂-idem = ⇔: ⊆-proof ⊇-proof
where
⊆-proof : (R ∩₂ R) ⊆₂' R
⊆-proof _ _ = proj₁
⊇-proof : R ⊆₂' (R ∩₂ R)
⊇-proof _ _ Rxy = (Rxy , Rxy)
module _ {a b ℓ₁ ℓ₂ : Level} {A : Set a} {B : Set b}
{P : REL A B ℓ₁} {Q : REL A B ℓ₂} where
∩₂-comm : (P ∩₂ Q) ⇔₂ (Q ∩₂ P)
∩₂-comm = ⇔: (λ _ _ → swap) (λ _ _ → swap)
module _ {a b ℓ₁ ℓ₂ ℓ₃ : Level} {A : Set a} {B : Set b}
{P : REL A B ℓ₁} {Q : REL A B ℓ₂} {R : REL A B ℓ₃} where
∩₂-assoc : P ∩₂ (Q ∩₂ R) ⇔₂ (P ∩₂ Q) ∩₂ R
∩₂-assoc = ⇔: ⊆-proof ⊇-proof
where
⊆-proof : P ∩₂ (Q ∩₂ R) ⊆₂' (P ∩₂ Q) ∩₂ R
⊆-proof _ _ (Pxy , (Qxy , Rxy)) = ((Pxy , Qxy) , Rxy)
⊇-proof : (P ∩₂ Q) ∩₂ R ⊆₂' P ∩₂ (Q ∩₂ R)
⊇-proof _ _ ((Pxy , Qxy) , Rxy) = (Pxy , (Qxy , Rxy))
-- # Operations
-- ## Operations: ⊆₂
module _ {a b ℓ₁ ℓ₂ ℓ₃ : Level} {A : Set a} {B : Set b}
{P : REL A B ℓ₁} {Q : REL A B ℓ₂} {R : REL A B ℓ₃} where
∩₂-combine-⊆₂ : P ⊆₂ Q → P ⊆₂ R → P ⊆₂ (Q ∩₂ R)
∩₂-combine-⊆₂ (⊆: P⊆Q) (⊆: P⊆R) = ⊆: (λ x y Pxy → (P⊆Q x y Pxy , P⊆R x y Pxy))
module _ {a b ℓ₁ ℓ₂ : Level} {A : Set a} {B : Set b}
{P : REL A B ℓ₁} {Q : REL A B ℓ₂} where
∩₂-introˡ-⊆₂ : (P ∩₂ Q) ⊆₂ Q
∩₂-introˡ-⊆₂ = ⊆: λ _ _ → proj₂
∩₂-introʳ-⊆₂ : (P ∩₂ Q) ⊆₂ P
∩₂-introʳ-⊆₂ = ⊆: λ _ _ → proj₁
module _ {a b ℓ₁ ℓ₂ ℓ₃ : Level} {A : Set a} {B : Set b}
{P : REL A B ℓ₁} {Q : REL A B ℓ₂} {R : REL A B ℓ₃} where
∩₂-elimˡ-⊆₂ : P ⊆₂ (Q ∩₂ R) → P ⊆₂ R
∩₂-elimˡ-⊆₂ (⊆: P⊆[Q∩R]) = ⊆: (λ x y Pxy → proj₂ (P⊆[Q∩R] x y Pxy))
∩₂-elimʳ-⊆₂ : P ⊆₂ (Q ∩₂ R) → P ⊆₂ Q
∩₂-elimʳ-⊆₂ (⊆: P⊆[Q∩R]) = ⊆: (λ x y Pxy → proj₁ (P⊆[Q∩R] x y Pxy))
module _ {a b ℓ₁ ℓ₂ ℓ₃ : Level} {A : Set a} {B : Set b}
{P : REL A B ℓ₁} {Q : REL A B ℓ₂} {R : REL A B ℓ₃} where
∩₂-substˡ-⊆₂ : P ⊆₂ Q → (P ∩₂ R) ⊆₂ (Q ∩₂ R)
∩₂-substˡ-⊆₂ (⊆: P⊆Q) = ⊆: (λ x y → P.map₁ (P⊆Q x y))
∩₂-substʳ-⊆₂ : P ⊆₂ Q → (R ∩₂ P) ⊆₂ (R ∩₂ Q)
∩₂-substʳ-⊆₂ (⊆: P⊆Q) = ⊆: (λ x y → P.map₂ (P⊆Q x y))
-- ## Operations: ⇔₂
module _ {a b ℓ₁ ℓ₂ ℓ₃ : Level} {A : Set a} {B : Set b}
{P : REL A B ℓ₁} {Q : REL A B ℓ₂} {R : REL A B ℓ₃} where
∩₂-substˡ : P ⇔₂ Q → (P ∩₂ R) ⇔₂ (Q ∩₂ R)
∩₂-substˡ = ⇔₂-compose ∩₂-substˡ-⊆₂ ∩₂-substˡ-⊆₂
∩₂-substʳ : P ⇔₂ Q → (R ∩₂ P) ⇔₂ (R ∩₂ Q)
∩₂-substʳ = ⇔₂-compose ∩₂-substʳ-⊆₂ ∩₂-substʳ-⊆₂
|
algebraic-stack_agda0000_doc_8949 | -- Andreas, 2015-12-10, issue reported by Andrea Vezzosi
open import Common.Equality
open import Common.Bool
id : Bool → Bool
id true = true
id false = false
is-id : ∀ x → x ≡ id x
is-id true = refl
is-id false = refl
postulate
P : Bool → Set
b : Bool
p : P (id b)
proof : P b
proof rewrite is-id b = p
|
algebraic-stack_agda0000_doc_8950 | module Selective where
open import Prelude.Equality
open import Agda.Builtin.TrustMe
-----------------------------------------------------------------
-- id : ∀ {a} {A : Set a} → A → A
-- id x = x
id : ∀ {A : Set} → A → A
id x = x
{-# INLINE id #-}
infixl -10 id
syntax id {A = A} x = x ofType A
const : ∀ {a b} {A : Set a} {B : Set b} → A → B → A
const x _ = x
{-# INLINE const #-}
flip : ∀ {a b c} {A : Set a} {B : Set b} {C : A → B → Set c} →
(∀ x y → C x y) → ∀ y x → C x y
flip f x y = f y x
{-# INLINE flip #-}
infixr 9 _∘_
_∘_ : ∀ {a b c} {A : Set a} {B : A → Set b} {C : ∀ x → B x → Set c}
(f : ∀ {x} (y : B x) → C x y) (g : ∀ x → B x) →
∀ x → C x (g x)
(f ∘ g) x = f (g x)
{-# INLINE _∘_ #-}
infixr -20 _$_
_$_ : ∀ {a b} {A : Set a} {B : A → Set b} → (∀ x → B x) → ∀ x → B x
f $ x = f x
------------------------------------------------------------------
data Either (A : Set) (B : Set) : Set where
left : A → Either A B
right : B → Either A B
either : ∀ {A : Set} {B : Set} {C : Set} →
(A → C) → (B → C) → Either A B → C
either f g (left x) = f x
either f g (right x) = g x
data Pair (a b : Set) : Set where
_×_ : a → b → Pair a b
------------------------------------------------------------------
record Functor (F : Set → Set) : Set₁ where
infixl 5 _<$>_
field
fmap : ∀ {A B} → (A → B) → F A → F B
-- Functor laws
fmap-id : ∀ {A} {x : F A} → fmap id x ≡ id x
fmap-compose : ∀ {A B C} {f : A → B} {g : B → C} {x : F A} →
fmap (g ∘ f) x ≡ (fmap g ∘ fmap f) x
_<$>_ = fmap
open Functor {{...}} public
instance
FunctorFunction : {X : Set} → Functor (λ Y → (X → Y))
fmap {{FunctorFunction}} f g = λ x → (f ∘ g) x
fmap-id {{FunctorFunction}} = refl
fmap-compose {{FunctorFunction}} = refl
record Applicative (F : Set → Set) : Set₁ where
infixl 5 _<*>_ _<*_ _*>_
field
overlap {{functor}} : Functor F
pure : ∀ {A} → A → F A
_<*>_ : ∀ {A B} → F (A → B) → F A → F B
-- Applicative laws
ap-identity : ∀ {A B} {f : F (A → B)} → (pure id <*> f) ≡ f
ap-homomorphism : ∀ {A B} {x : A} {f : A → B} →
pure f <*> pure x ≡ pure (f x)
ap-interchange : ∀ {A B} {x : A} {f : F (A → B)} →
f <*> pure x ≡ pure (_$ x) <*> f
-- ap-composition : ∀ {A B C} {x : F A} {f : F (A → B)} {g : F (B → C)} →
-- (pure (_∘_) <*> g <*> f <*> x) ≡ (g <*> (f <*> x))
fmap-pure-ap : ∀ {A B} {x : F A} {f : A → B} →
f <$> x ≡ pure f <*> x
_<*_ : ∀ {A B} → F A → F B → F A
a <* b = ⦇ const a b ⦈
_*>_ : ∀ {A B} → F A → F B → F B
a *> b = ⦇ (const id) a b ⦈
open Applicative {{...}} public
instance
ApplicativeFunction : {X : Set} → Applicative (λ Y → (X → Y))
pure {{ApplicativeFunction}} f = const f
_<*>_ {{ApplicativeFunction}} f g = λ x → f x (g x)
-- Applicative laws
ap-identity {{ApplicativeFunction}} = refl
ap-homomorphism {{ApplicativeFunction}} = refl
ap-interchange {{ApplicativeFunction}} = refl
fmap-pure-ap {{ApplicativeFunction}} {_} {_} {x} {f} = primTrustMe
-- f <$> x -- f <$> x
-- ≡⟨ {!!} ⟩
-- pure f <*> x
-- ∎
record Bifunctor (P : Set → Set → Set) : Set₁ where
field
bimap : ∀ {A B C D} → (A → B) → (C → D) → P A C → P B D
first : ∀ {A B C} → (A -> B) -> P A C -> P B C
second : ∀ {A B C} → (B -> C) -> P A B -> P A C
open Bifunctor {{...}} public
instance
BifunctorEither : Bifunctor Either
bimap {{BifunctorEither}} f _ (left a) = left (f a)
bimap {{BifunctorEither}} _ g (right b) = right (g b)
first {{BifunctorEither}} f = bimap f id
second {{BifunctorEither}} = bimap id
record Selective (F : Set → Set) : Set₁ where
field
overlap {{applicative}} : Applicative F
handle : ∀ {A B} → F (Either A B) → F (A → B) → F B
-- Laws:
-- (F1) Apply a pure function to the result:
f1 : ∀ {A B C} {f : B → C} {x : F (Either A B)} {y : F (A → B)} →
(f <$> (handle x y)) ≡ handle (second f <$> x) ((f ∘_) <$> y)
-- (F2) Apply a pure function to the left (error) branch:
f2 : ∀ {A B C} {f : A -> C} {x : F (Either A B)} {y : F (C → B)} →
handle (first f <$> x) y ≡ handle x ((_∘ f) <$> y)
-- (F3) Apply a pure function to the handler:
f3 : ∀ {A B C} {f : C → A → B} {x : F (Either A B)} {y : F C} →
(handle x (f <$> y)) ≡ handle (first (flip f) <$> x) (flip (_$_) <$> y)
-- (P1) Apply a pure handler:
p1 : ∀ {A B} {x : F (Either A B)} {y : A → B} →
handle x (pure y) ≡ (either y id <$> x)
-- (P2) Handle a pure error:
p2 : ∀ {A B} {x : A} {y : F (A → B)} →
handle (pure (left x)) y ≡ ((_$ x) <$> y)
-- -- (A1) Associativity
-- a1 : ∀ {A B C} {x : F (Either A B)}
-- {y : F (Either C (A → B))}
-- {z : F (C → A → B)} →
-- handle x (handle y z) ≡
-- handle (handle ((λ x → right x) <$> x) (λ a → bimap (λ x → (x × a)) (_$ a) y))
-- A1: handle x (handle y z) = handle (handle (f <$> x) (g <$> y)) (h <$> z)
-- where f x = Right <$> x
-- g y = \a -> bimap (,a) ($a) y
-- h z = uncurry z
-- a1 :: Selective f => f (Either a b) -> f (Either c (a -> b)) -> f (c -> a -> b) -> f b
-- a1 x y z = handle x (handle y z) === handle (handle (f <$> x) (g <$> y)) (h <$> z)
-- where
-- f x = Right <$> x
-- g y = \a -> bimap (,a) ($a) y
-- h z = uncurry z
open Selective {{...}} public
-- | 'Selective' is more powerful than 'Applicative': we can recover the
-- application operator '<*>'. In particular, the following 'Applicative' laws
-- hold when expressed using 'apS':
--
-- * Identity : pure id <*> v = v
-- * Homomorphism : pure f <*> pure x = pure (f x)
-- * Interchange : u <*> pure y = pure ($y) <*> u
-- * Composition : (.) <$> u <*> v <*> w = u <*> (v <*> w)
apS : ∀ {A B : Set} {F : Set → Set} {{_ : Selective F}} →
F (A → B) → F A → F B
apS f x = handle (left <$> f) (flip (_$_) <$> x)
---------------------------------------------------------------------
|
algebraic-stack_agda0000_doc_8951 | module SizedIO.ConsoleObject where
open import Size
open import SizedIO.Console
open import SizedIO.Object
open import SizedIO.IOObject
-- A console object is an IO object for the IO interface of console
ConsoleObject : (i : Size) → (iface : Interface) → Set
ConsoleObject i iface = IOObject consoleI iface i
|
algebraic-stack_agda0000_doc_8952 | module Acc where
data Rel(A : Set) : Set1 where
rel : (A -> A -> Set) -> Rel A
_is_than_ : {A : Set} -> A -> Rel A -> A -> Set
x is rel f than y = f x y
data Acc {A : Set} (less : Rel A) (x : A) : Set where
acc : ((y : A) -> x is less than y -> Acc less y) -> Acc less x
data WO {A : Set} (less : Rel A) : Set where
wo : ((x : A) -> Acc less x) -> WO less
data False : Set where
data True : Set where
tt : True
data Nat : Set where
Z : Nat
S : Nat -> Nat
data ∏ {A : Set} (f : A -> Set) : Set where
∏I : ((z : A) -> f z) -> ∏ f
data Ord : Set where
z : Ord
lim : (Nat -> Ord) -> Ord
zp : Ord -> Ord
zp z = z
zp (lim f) = lim (\x -> zp (f x))
_<_ : Ord -> Ord -> Set
z < _ = True
lim _ < z = False
lim f < lim g = ∏ \(n : Nat) -> f n < g n
ltNat : Nat -> Nat -> Set
ltNat Z Z = False
ltNat Z (S n) = True
ltNat (S m) (S n) = ltNat m n
ltNat (S m) Z = False
ltNatRel : Rel Nat
ltNatRel = rel ltNat
postulate woltNat : WO ltNatRel
|
algebraic-stack_agda0000_doc_8953 | {-# OPTIONS --cumulativity #-}
open import Agda.Builtin.Equality
mutual
X : Set
X = _
Y : Set₁
Y = Set
test : _≡_ {A = Set₁} X Y
test = refl
|
algebraic-stack_agda0000_doc_8954 | ------------------------------------------------------------------------
-- Potentially cyclic precedence graphs
------------------------------------------------------------------------
module Mixfix.Cyclic.PrecedenceGraph where
open import Data.Fin using (Fin)
open import Data.Nat using (ℕ)
open import Data.Vec as Vec using (allFin)
open import Data.List using (List)
open import Data.Product using (∃)
open import Mixfix.Fixity
open import Mixfix.Operator
open import Mixfix.Expr hiding (module PrecedenceGraph)
-- Precedence graphs are represented by the number of precedence
-- levels, plus functions mapping node identifiers (precedences) to
-- node contents and successor precedences.
record PrecedenceGraph : Set where
field
-- The number of precedence levels.
levels : ℕ
-- Precedence levels.
Precedence : Set
Precedence = Fin levels
field
-- The precedence level's operators.
ops : Precedence → (fix : Fixity) → List (∃ (Operator fix))
-- The immediate successors of the precedence level.
↑ : Precedence → List Precedence
-- All precedence levels.
anyPrecedence : List Precedence
anyPrecedence = Vec.toList (allFin levels)
-- Potentially cyclic precedence graphs.
cyclic : PrecedenceGraphInterface
cyclic = record
{ PrecedenceGraph = PrecedenceGraph
; Precedence = PrecedenceGraph.Precedence
; ops = PrecedenceGraph.ops
; ↑ = PrecedenceGraph.↑
; anyPrecedence = PrecedenceGraph.anyPrecedence
}
|
algebraic-stack_agda0000_doc_8955 | ------------------------------------------------------------------------
-- This module establishes that the recognisers are as expressive as
-- possible when the alphabet is Bool (this could be generalised to
-- arbitrary finite alphabets), whereas this is not the case when the
-- alphabet is ℕ
------------------------------------------------------------------------
module TotalRecognisers.LeftRecursion.ExpressiveStrength where
open import Algebra
open import Codata.Musical.Notation
open import Data.Bool as Bool hiding (_∧_)
open import Data.Empty
open import Function.Base
open import Function.Equality using (_⟨$⟩_)
open import Function.Equivalence
using (_⇔_; equivalence; module Equivalence)
open import Data.List
import Data.List.Properties as ListProp
open import Data.List.Reverse
open import Data.Nat as Nat
open import Data.Nat.InfinitelyOften as Inf
import Data.Nat.Properties as NatProp
open import Data.Product
open import Data.Sum
open import Relation.Binary
open import Relation.Binary.PropositionalEquality hiding ([_])
open import Relation.Nullary
open import Relation.Nullary.Decidable
open import Relation.Nullary.Negation
private
module ListMonoid {A : Set} = Monoid (ListProp.++-monoid A)
module NatOrder = DecTotalOrder NatProp.≤-decTotalOrder
import TotalRecognisers.LeftRecursion
open TotalRecognisers.LeftRecursion Bool using (_∧_; left-zero)
private
open module LR {Tok : Set} = TotalRecognisers.LeftRecursion Tok
hiding (P; ∞⟨_⟩P; _∧_; left-zero; _∷_)
P : Set → Bool → Set
P Tok = LR.P {Tok}
∞⟨_⟩P : Bool → Set → Bool → Set
∞⟨ b ⟩P Tok n = LR.∞⟨_⟩P {Tok} b n
open import TotalRecognisers.LeftRecursion.Lib Bool hiding (_∷_)
------------------------------------------------------------------------
-- A boring lemma
private
lemma : (f : List Bool → Bool) →
(false ∧ f [ true ] ∨ false ∧ f [ false ]) ∨ f [] ≡ f []
lemma f = cong₂ (λ b₁ b₂ → (b₁ ∨ b₂) ∨ f [])
(left-zero (f [ true ]))
(left-zero (f [ false ]))
------------------------------------------------------------------------
-- Expressive strength
-- For every grammar there is an equivalent decidable predicate.
grammar⇒pred : ∀ {Tok n} (p : P Tok n) →
∃ λ (f : List Tok → Bool) → ∀ {s} → s ∈ p ⇔ T (f s)
grammar⇒pred p =
((λ s → ⌊ s ∈? p ⌋) , λ {_} → equivalence fromWitness toWitness)
-- When the alphabet is Bool the other direction holds: for every
-- decidable predicate there is a corresponding grammar.
--
-- Note that the grammars constructed by the proof are all "infinite
-- LL(1)".
pred⇒grammar : (f : List Bool → Bool) →
∃ λ (p : P Bool (f [])) → ∀ {s} → s ∈ p ⇔ T (f s)
pred⇒grammar f =
(p f , λ {s} → equivalence (p-sound f) (p-complete f s))
where
p : (f : List Bool → Bool) → P Bool (f [])
p f = cast (lemma f)
( ♯? (sat id ) · ♯ p (f ∘ _∷_ true )
∣ ♯? (sat not) · ♯ p (f ∘ _∷_ false)
∣ accept-if-true (f [])
)
p-sound : ∀ f {s} → s ∈ p f → T (f s)
p-sound f (cast (∣-right s∈)) with AcceptIfTrue.sound (f []) s∈
... | (refl , ok) = ok
p-sound f (cast (∣-left (∣-left (t∈ · s∈)))) with drop-♭♯ (f [ true ]) t∈
... | sat {t = true} _ = p-sound (f ∘ _∷_ true ) s∈
... | sat {t = false} ()
p-sound f (cast (∣-left (∣-right (t∈ · s∈)))) with drop-♭♯ (f [ false ]) t∈
... | sat {t = false} _ = p-sound (f ∘ _∷_ false) s∈
... | sat {t = true} ()
p-complete : ∀ f s → T (f s) → s ∈ p f
p-complete f [] ok =
cast (∣-right {n₁ = false ∧ f [ true ] ∨ false ∧ f [ false ]} $
AcceptIfTrue.complete ok)
p-complete f (true ∷ bs) ok =
cast (∣-left $ ∣-left $
add-♭♯ (f [ true ]) (sat _) ·
p-complete (f ∘ _∷_ true ) bs ok)
p-complete f (false ∷ bs) ok =
cast (∣-left $ ∣-right {n₁ = false ∧ f [ true ]} $
add-♭♯ (f [ false ]) (sat _) ·
p-complete (f ∘ _∷_ false) bs ok)
-- An alternative proof which uses a left recursive definition of the
-- grammar to avoid the use of a cast.
pred⇒grammar′ : (f : List Bool → Bool) →
∃ λ (p : P Bool (f [])) → ∀ {s} → s ∈ p ⇔ T (f s)
pred⇒grammar′ f =
(p f , λ {s} → equivalence (p-sound f) (p-complete f s))
where
extend : {A B : Set} → (List A → B) → A → (List A → B)
extend f x = λ xs → f (xs ∷ʳ x)
p : (f : List Bool → Bool) → P Bool (f [])
p f = ♯ p (extend f true ) · ♯? (sat id )
∣ ♯ p (extend f false) · ♯? (sat not)
∣ accept-if-true (f [])
p-sound : ∀ f {s} → s ∈ p f → T (f s)
p-sound f (∣-right s∈) with AcceptIfTrue.sound (f []) s∈
... | (refl , ok) = ok
p-sound f (∣-left (∣-left (s∈ · t∈))) with drop-♭♯ (f [ true ]) t∈
... | sat {t = true} _ = p-sound (extend f true ) s∈
... | sat {t = false} ()
p-sound f (∣-left (∣-right (s∈ · t∈))) with drop-♭♯ (f [ false ]) t∈
... | sat {t = false} _ = p-sound (extend f false) s∈
... | sat {t = true} ()
p-complete′ : ∀ f {s} → Reverse s → T (f s) → s ∈ p f
p-complete′ f [] ok =
∣-right {n₁ = false} $ AcceptIfTrue.complete ok
p-complete′ f (bs ∶ rs ∶ʳ true ) ok =
∣-left {n₁ = false} $ ∣-left {n₁ = false} $
p-complete′ (extend f true ) rs ok ·
add-♭♯ (f [ true ]) (sat _)
p-complete′ f (bs ∶ rs ∶ʳ false) ok =
∣-left {n₁ = false} $ ∣-right {n₁ = false} $
p-complete′ (extend f false) rs ok ·
add-♭♯ (f [ false ]) (sat _)
p-complete : ∀ f s → T (f s) → s ∈ p f
p-complete f s = p-complete′ f (reverseView s)
-- If infinite alphabets are allowed the result is different: there
-- are decidable predicates which cannot be realised as grammars. The
-- proof below shows that a recogniser for natural number strings
-- cannot accept exactly the strings of the form "nn".
module NotExpressible where
-- A "pair" is a string containing two equal elements.
pair : ℕ → List ℕ
pair n = n ∷ n ∷ []
-- OnlyPairs p is inhabited iff p only accepts pairs and empty
-- strings. (Empty strings are allowed due to the presence of the
-- nonempty combinator.)
OnlyPairs : ∀ {n} → P ℕ n → Set
OnlyPairs p = ∀ {n s} → n ∷ s ∈ p → s ≡ [ n ]
-- ManyPairs p is inhabited iff p accepts infinitely many pairs.
ManyPairs : ∀ {n} → P ℕ n → Set
ManyPairs p = Inf (λ n → pair n ∈ p)
-- AcceptsNonEmptyString p is inhabited iff p accepts a non-empty
-- string.
AcceptsNonEmptyString : ∀ {Tok n} → P Tok n → Set
AcceptsNonEmptyString p = ∃₂ λ t s → t ∷ s ∈ p
-- If a recogniser does not accept any non-empty string, then it
-- either accepts the empty string or no string at all.
nullable-or-fail : ∀ {Tok n} {p : P Tok n} →
¬ AcceptsNonEmptyString p →
[] ∈ p ⊎ (∀ s → ¬ s ∈ p)
nullable-or-fail {p = p} ¬a with [] ∈? p
... | yes []∈p = inj₁ []∈p
... | no []∉p = inj₂ helper
where
helper : ∀ s → ¬ s ∈ p
helper [] = []∉p
helper (t ∷ s) = ¬a ∘ _,_ t ∘ _,_ s
-- If p₁ · p₂ accepts infinitely many pairs, and nothing but pairs
-- (or the empty string), then at most one of p₁ and p₂ accepts a
-- non-empty string. This follows because p₁ and p₂ are independent
-- of each other. For instance, if p₁ accepted n and p₂ accepted i
-- and j, then p₁ · p₂ would accept both ni and nj, and if p₁
-- accepted mm and p₂ accepted n then p₁ · p₂ would accept mmn.
at-most-one : ∀ {n₁ n₂} {p₁ : ∞⟨ n₂ ⟩P ℕ n₁} {p₂ : ∞⟨ n₁ ⟩P ℕ n₂} →
OnlyPairs (p₁ · p₂) →
ManyPairs (p₁ · p₂) →
AcceptsNonEmptyString (♭? p₁) →
AcceptsNonEmptyString (♭? p₂) → ⊥
at-most-one op mp (n₁ , s₁ , n₁s₁∈p₁) (n₂ , s₂ , n₂s₂∈p₂)
with op (n₁s₁∈p₁ · n₂s₂∈p₂)
at-most-one _ _ (_ , _ ∷ [] , _) (_ , _ , _) | ()
at-most-one _ _ (_ , _ ∷ _ ∷ _ , _) (_ , _ , _) | ()
at-most-one {p₁ = p₁} {p₂} op mp
(n , [] , n∈p₁) (.n , .[] , n∈p₂) | refl =
twoDifferentWitnesses mp helper
where
¬pair : ∀ {i s} → s ∈ p₁ · p₂ → n ≢ i → s ≢ pair i
¬pair (_·_ {s₁ = []} _ ii∈p₂) n≢i refl with op (n∈p₁ · ii∈p₂)
... | ()
¬pair (_·_ {s₁ = i ∷ []} i∈p₁ _) n≢i refl with op (i∈p₁ · n∈p₂)
¬pair (_·_ {s₁ = .n ∷ []} n∈p₁ _) n≢n refl | refl = n≢n refl
¬pair (_·_ {s₁ = i ∷ .i ∷ []} ii∈p₁ _) n≢i refl with op (ii∈p₁ · n∈p₂)
... | ()
¬pair (_·_ {s₁ = _ ∷ _ ∷ _ ∷ _} _ _) _ ()
helper : ¬ ∃₂ λ i j → i ≢ j × pair i ∈ p₁ · p₂ × pair j ∈ p₁ · p₂
helper (i , j , i≢j , ii∈ , jj∈) with Nat._≟_ n i
helper (.n , j , n≢j , nn∈ , jj∈) | yes refl = ¬pair jj∈ n≢j refl
helper (i , j , i≢j , ii∈ , jj∈) | no n≢i = ¬pair ii∈ n≢i refl
-- OnlyPairs and ManyPairs are mutually exclusive.
¬pairs : ∀ {n} (p : P ℕ n) → OnlyPairs p → ManyPairs p → ⊥
¬pairs fail op mp = witness mp (helper ∘ proj₂)
where
helper : ∀ {t} → ¬ pair t ∈ fail
helper ()
¬pairs empty op mp = witness mp (helper ∘ proj₂)
where
helper : ∀ {t} → ¬ pair t ∈ empty
helper ()
¬pairs (sat f) op mp = witness mp (helper ∘ proj₂)
where
helper : ∀ {t} → ¬ pair t ∈ sat f
helper ()
¬pairs (nonempty p) op mp =
¬pairs p (op ∘ nonempty) (Inf.map helper mp)
where
helper : ∀ {n} → pair n ∈ nonempty p → pair n ∈ p
helper (nonempty pr) = pr
¬pairs (cast eq p) op mp = ¬pairs p (op ∘ cast) (Inf.map helper mp)
where
helper : ∀ {n} → pair n ∈ cast eq p → pair n ∈ p
helper (cast pr) = pr
-- The most interesting cases are _∣_ and _·_. For the choice
-- combinator we make use of the fact that if p₁ ∣ p₂ accepts
-- infinitely many pairs, then at least one of p₁ and p₂ do. (We are
-- deriving a contradiction, so the use of classical reasoning is
-- unproblematic.)
¬pairs (p₁ ∣ p₂) op mp = commutes-with-∪ (Inf.map split mp) helper
where
helper : ¬ (ManyPairs p₁ ⊎ ManyPairs p₂)
helper (inj₁ mp₁) = ¬pairs p₁ (op ∘ ∣-left) mp₁
helper (inj₂ mp₂) = ¬pairs p₂ (op ∘ ∣-right {p₁ = p₁}) mp₂
split : ∀ {s} → s ∈ p₁ ∣ p₂ → s ∈ p₁ ⊎ s ∈ p₂
split (∣-left s∈p₁) = inj₁ s∈p₁
split (∣-right s∈p₂) = inj₂ s∈p₂
-- For the sequencing combinator we make use of the fact that the
-- argument recognisers cannot both accept non-empty strings.
¬pairs (p₁ · p₂) op mp =
excluded-middle λ a₁? →
excluded-middle λ a₂? →
helper a₁? a₂?
where
continue : {n n′ : Bool} (p : ∞⟨ n′ ⟩P ℕ n) → n′ ≡ true →
OnlyPairs (♭? p) → ManyPairs (♭? p) → ⊥
continue p eq with forced? p
continue p refl | true = ¬pairs p
continue p () | false
helper : Dec (AcceptsNonEmptyString (♭? p₁)) →
Dec (AcceptsNonEmptyString (♭? p₂)) → ⊥
helper (yes a₁) (yes a₂) = at-most-one op mp a₁ a₂
helper (no ¬a₁) _ with nullable-or-fail ¬a₁
... | inj₁ []∈p₁ =
continue p₂ (⇒ []∈p₁) (op ∘ _·_ []∈p₁) (Inf.map right mp)
where
right : ∀ {s} → s ∈ p₁ · p₂ → s ∈ ♭? p₂
right (_·_ {s₁ = []} _ ∈p₂) = ∈p₂
right (_·_ {s₁ = _ ∷ _} ∈p₁ _) = ⊥-elim (¬a₁ (-, -, ∈p₁))
... | inj₂ is-fail = witness mp (∉ ∘ proj₂)
where
∉ : ∀ {s} → ¬ s ∈ p₁ · p₂
∉ (∈p₁ · _) = is-fail _ ∈p₁
helper _ (no ¬a₂) with nullable-or-fail ¬a₂
... | inj₁ []∈p₂ =
continue p₁ (⇒ []∈p₂)
(op ∘ (λ ∈p₁ → cast∈ (proj₂ ListMonoid.identity _) refl
(∈p₁ · []∈p₂)))
(Inf.map left mp)
where
left : ∀ {s} → s ∈ p₁ · p₂ → s ∈ ♭? p₁
left (_·_ {s₂ = _ ∷ _} _ ∈p₂) = ⊥-elim (¬a₂ (-, -, ∈p₂))
left (_·_ {s₁ = s₁} {s₂ = []} ∈p₁ _) =
cast∈ (sym $ proj₂ ListMonoid.identity s₁) refl ∈p₁
... | inj₂ is-fail = witness mp (∉ ∘ proj₂)
where
∉ : ∀ {s} → ¬ s ∈ p₁ · p₂
∉ (_ · ∈p₂) = is-fail _ ∈p₂
-- Note that it is easy to decide whether a string is a pair or not.
pair? : List ℕ → Bool
pair? (m ∷ n ∷ []) = ⌊ Nat._≟_ m n ⌋
pair? _ = false
-- This means that there are decidable predicates over token strings
-- which cannot be realised using the recogniser combinators.
not-realisable :
¬ ∃₂ (λ n (p : P ℕ n) → ∀ {s} → s ∈ p ⇔ T (pair? s))
not-realisable (_ , p , hyp) = ¬pairs p op mp
where
op : OnlyPairs p
op {n} {[]} s∈p = ⊥-elim (Equivalence.to hyp ⟨$⟩ s∈p)
op {n} { m ∷ []} s∈p with toWitness (Equivalence.to hyp ⟨$⟩ s∈p)
op {n} {.n ∷ []} s∈p | refl = refl
op {n} {_ ∷ _ ∷ _} s∈p = ⊥-elim (Equivalence.to hyp ⟨$⟩ s∈p)
mp : ManyPairs p
mp (i , ¬pair) =
¬pair i NatOrder.refl $ Equivalence.from hyp ⟨$⟩ fromWitness refl
not-expressible :
∃₂ λ (Tok : Set) (f : List Tok → Bool) →
¬ ∃₂ (λ n (p : P Tok n) → ∀ {s} → s ∈ p ⇔ T (f s))
not-expressible = (ℕ , pair? , not-realisable)
where open NotExpressible
|
algebraic-stack_agda0000_doc_8956 | module Lemmachine.Spike where
open import Data.Fin
open import Data.Digit
-- 3.9 Quality Values
DIGIT = Decimal
data qvalue : DIGIT → DIGIT → DIGIT → Set where
zero : (d₁ d₂ d₃ : DIGIT) → qvalue d₁ d₂ d₃
one : qvalue zero zero zero
|
algebraic-stack_agda0000_doc_8957 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Categories.Commutativity where
open import Cubical.Foundations.Prelude
open import Cubical.Categories.Category
private
variable
ℓ ℓ' : Level
module _ {C : Precategory ℓ ℓ'} where
open Precategory C
compSq : ∀ {x y z w u v} {f : C [ x , y ]} {g h} {k : C [ z , w ]} {l} {m} {n : C [ u , v ]}
-- square 1
→ f ⋆ g ≡ h ⋆ k
-- square 2 (sharing g)
→ k ⋆ l ≡ m ⋆ n
→ f ⋆ (g ⋆ l) ≡ (h ⋆ m) ⋆ n
compSq {f = f} {g} {h} {k} {l} {m} {n} p q
= f ⋆ (g ⋆ l)
≡⟨ sym (⋆Assoc _ _ _) ⟩
(f ⋆ g) ⋆ l
≡⟨ cong (_⋆ l) p ⟩
(h ⋆ k) ⋆ l
≡⟨ ⋆Assoc _ _ _ ⟩
h ⋆ (k ⋆ l)
≡⟨ cong (h ⋆_) q ⟩
h ⋆ (m ⋆ n)
≡⟨ sym (⋆Assoc _ _ _) ⟩
(h ⋆ m) ⋆ n
∎
|
algebraic-stack_agda0000_doc_8958 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Lexicographic induction
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Induction.Lexicographic where
open import Data.Product
open import Induction
open import Level
-- The structure of lexicographic induction.
Σ-Rec : ∀ {a b ℓ₁ ℓ₂ ℓ₃} {A : Set a} {B : A → Set b} →
RecStruct A (ℓ₁ ⊔ b) ℓ₂ → (∀ x → RecStruct (B x) ℓ₁ ℓ₃) →
RecStruct (Σ A B) _ _
Σ-Rec RecA RecB P (x , y) =
-- Either x is constant and y is "smaller", ...
RecB x (λ y' → P (x , y')) y
×
-- ...or x is "smaller" and y is arbitrary.
RecA (λ x' → ∀ y' → P (x' , y')) x
_⊗_ : ∀ {a b ℓ₁ ℓ₂ ℓ₃} {A : Set a} {B : Set b} →
RecStruct A (ℓ₁ ⊔ b) ℓ₂ → RecStruct B ℓ₁ ℓ₃ →
RecStruct (A × B) _ _
RecA ⊗ RecB = Σ-Rec RecA (λ _ → RecB)
-- Constructs a recursor builder for lexicographic induction.
Σ-rec-builder :
∀ {a b ℓ₁ ℓ₂ ℓ₃} {A : Set a} {B : A → Set b}
{RecA : RecStruct A (ℓ₁ ⊔ b) ℓ₂}
{RecB : ∀ x → RecStruct (B x) ℓ₁ ℓ₃} →
RecursorBuilder RecA → (∀ x → RecursorBuilder (RecB x)) →
RecursorBuilder (Σ-Rec RecA RecB)
Σ-rec-builder {RecA = RecA} {RecB = RecB} recA recB P f (x , y) =
(p₁ x y p₂x , p₂x)
where
p₁ : ∀ x y →
RecA (λ x' → ∀ y' → P (x' , y')) x →
RecB x (λ y' → P (x , y')) y
p₁ x y x-rec = recB x
(λ y' → P (x , y'))
(λ y y-rec → f (x , y) (y-rec , x-rec))
y
p₂ : ∀ x → RecA (λ x' → ∀ y' → P (x' , y')) x
p₂ = recA (λ x → ∀ y → P (x , y))
(λ x x-rec y → f (x , y) (p₁ x y x-rec , x-rec))
p₂x = p₂ x
[_⊗_] : ∀ {a b ℓ₁ ℓ₂ ℓ₃} {A : Set a} {B : Set b}
{RecA : RecStruct A (ℓ₁ ⊔ b) ℓ₂} {RecB : RecStruct B ℓ₁ ℓ₃} →
RecursorBuilder RecA → RecursorBuilder RecB →
RecursorBuilder (RecA ⊗ RecB)
[ recA ⊗ recB ] = Σ-rec-builder recA (λ _ → recB)
------------------------------------------------------------------------
-- Example
private
open import Data.Nat
open import Induction.Nat as N
-- The Ackermann function à la Rózsa Péter.
ackermann : ℕ → ℕ → ℕ
ackermann m n =
build [ N.recBuilder ⊗ N.recBuilder ]
(λ _ → ℕ)
(λ { (zero , n) _ → 1 + n
; (suc m , zero) (_ , ackm•) → ackm• 1
; (suc m , suc n) (ack[1+m]n , ackm•) → ackm• ack[1+m]n
})
(m , n)
|
algebraic-stack_agda0000_doc_8959 | {-
This file contains:
- Fibers of induced map between set truncations is the set truncation of fibers
modulo a certain equivalence relation defined by π₁ of the base.
-}
{-# OPTIONS --safe #-}
module Cubical.HITs.SetTruncation.Fibers where
open import Cubical.HITs.SetTruncation.Base
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Path
open import Cubical.Foundations.GroupoidLaws
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Function
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Data.Sigma
open import Cubical.HITs.PropositionalTruncation as Prop
open import Cubical.HITs.SetTruncation as Set
open import Cubical.HITs.SetQuotients as SetQuot
open import Cubical.Relation.Binary
private
variable
ℓ ℓ' : Level
module _
{X : Type ℓ }
{Y : Type ℓ'}
(f : X → Y) where
private
∥f∥₂ : ∥ X ∥₂ → ∥ Y ∥₂
∥f∥₂ = Set.map f
module _ (y : Y) where
open Iso
isSetFiber∥∥₂ : isSet (fiber ∥f∥₂ ∣ y ∣₂)
isSetFiber∥∥₂ = isOfHLevelΣ 2 squash₂ (λ _ → isProp→isSet (squash₂ _ _))
fiberRel : ∥ fiber f y ∥₂ → ∥ fiber f y ∥₂ → Type ℓ
fiberRel a b = Set.map fst a ≡ Set.map fst b
private
proj : ∥ fiber f y ∥₂ / fiberRel → ∥ X ∥₂
proj = SetQuot.rec squash₂ (Set.map fst) (λ _ _ p → p)
∥fiber∥₂/R→fiber∥∥₂ : ∥ fiber f y ∥₂ / fiberRel → fiber ∥f∥₂ ∣ y ∣₂
∥fiber∥₂/R→fiber∥∥₂ = SetQuot.rec isSetFiber∥∥₂ ∥fiber∥₂→fiber∥∥₂ feq
where
fiber→fiber∥∥₂ : fiber f y → fiber ∥f∥₂ ∣ y ∣₂
fiber→fiber∥∥₂ (x , p) = ∣ x ∣₂ , cong ∣_∣₂ p
∥fiber∥₂→fiber∥∥₂ : ∥ fiber f y ∥₂ → fiber ∥f∥₂ ∣ y ∣₂
∥fiber∥₂→fiber∥∥₂ = Set.rec isSetFiber∥∥₂ fiber→fiber∥∥₂
feq : (a b : ∥ fiber f y ∥₂) (r : fiberRel a b) → ∥fiber∥₂→fiber∥∥₂ a ≡ ∥fiber∥₂→fiber∥∥₂ b
feq =
Set.elim2 (λ _ _ → isProp→isSet (isPropΠ (λ _ → isSetFiber∥∥₂ _ _))) λ _ _ p →
ΣPathP (p , isSet→isSet' squash₂ _ _ _ _)
mereFiber→∥fiber∥₂/R : (x : X) → ∥ f x ≡ y ∥ → ∥ fiber f y ∥₂ / fiberRel
mereFiber→∥fiber∥₂/R x = Prop.rec→Set squash/ (λ p → [ ∣ _ , p ∣₂ ]) (λ _ _ → eq/ _ _ refl)
fiber∥∥₂→∥fiber∥₂/R : fiber ∥f∥₂ ∣ y ∣₂ → ∥ fiber f y ∥₂ / fiberRel
fiber∥∥₂→∥fiber∥₂/R =
uncurry
(Set.elim (λ _ → isSetΠ λ _ → squash/) λ x p →
mereFiber→∥fiber∥₂/R x (PathIdTrunc₀Iso .fun p))
∥fiber∥₂/R→fiber∥∥₂→fst : (q : ∥ fiber f y ∥₂ / fiberRel) → ∥fiber∥₂/R→fiber∥∥₂ q .fst ≡ proj q
∥fiber∥₂/R→fiber∥∥₂→fst =
SetQuot.elimProp (λ _ → squash₂ _ _)
(Set.elim (λ _ → isProp→isSet (squash₂ _ _)) (λ _ → refl))
fiber∥∥₂→∥fiber∥₂/R→proj : (x : fiber ∥f∥₂ ∣ y ∣₂) → proj (fiber∥∥₂→∥fiber∥₂/R x) ≡ x .fst
fiber∥∥₂→∥fiber∥₂/R→proj =
uncurry
(Set.elim (λ _ → isSetΠ λ _ → isProp→isSet (squash₂ _ _)) λ x p →
Prop.elim {P = λ t → proj (mereFiber→∥fiber∥₂/R x t) ≡ ∣ x ∣₂}
(λ _ → squash₂ _ _)
(λ _ → refl)
(PathIdTrunc₀Iso .fun p))
∥fiber∥₂/R→fiber∥∥₂→∥fiber∥₂/R :
(x : ∥ fiber f y ∥₂ / fiberRel) → fiber∥∥₂→∥fiber∥₂/R (∥fiber∥₂/R→fiber∥∥₂ x) ≡ x
∥fiber∥₂/R→fiber∥∥₂→∥fiber∥₂/R =
SetQuot.elimProp (λ _ → squash/ _ _)
(Set.elim (λ _ → isProp→isSet (squash/ _ _))
(λ _ → eq/ _ _ refl))
fiber∥∥₂→∥fiber∥₂/R→fiber∥∥₂ :
(x : fiber ∥f∥₂ ∣ y ∣₂) → ∥fiber∥₂/R→fiber∥∥₂ (fiber∥∥₂→∥fiber∥₂/R x) ≡ x
fiber∥∥₂→∥fiber∥₂/R→fiber∥∥₂ x =
Σ≡Prop
(λ _ → squash₂ _ _)
(∥fiber∥₂/R→fiber∥∥₂→fst (fiber∥∥₂→∥fiber∥₂/R x) ∙ fiber∥∥₂→∥fiber∥₂/R→proj x)
Iso-∥fiber∥₂/R-fiber∥∥₂ : Iso (∥ fiber f y ∥₂ / fiberRel) (fiber ∥f∥₂ ∣ y ∣₂)
Iso-∥fiber∥₂/R-fiber∥∥₂ .fun = ∥fiber∥₂/R→fiber∥∥₂
Iso-∥fiber∥₂/R-fiber∥∥₂ .inv = fiber∥∥₂→∥fiber∥₂/R
Iso-∥fiber∥₂/R-fiber∥∥₂ .leftInv = ∥fiber∥₂/R→fiber∥∥₂→∥fiber∥₂/R
Iso-∥fiber∥₂/R-fiber∥∥₂ .rightInv = fiber∥∥₂→∥fiber∥₂/R→fiber∥∥₂
-- main results
∥fiber∥₂/R≃fiber∥∥₂ : ∥ fiber f y ∥₂ / fiberRel ≃ fiber ∥f∥₂ ∣ y ∣₂
∥fiber∥₂/R≃fiber∥∥₂ = isoToEquiv Iso-∥fiber∥₂/R-fiber∥∥₂
-- the relation is an equivalence relation
open BinaryRelation
open isEquivRel
isEquivRelFiberRel : isEquivRel fiberRel
isEquivRelFiberRel .reflexive _ = refl
isEquivRelFiberRel .symmetric _ _ = sym
isEquivRelFiberRel .transitive _ _ _ = _∙_
-- alternative characterization of the relation in terms of equality in Y and fiber f y
∣transport∣ : ∥ y ≡ y ∥₂ → ∥ fiber f y ∥₂ → ∥ fiber f y ∥₂
∣transport∣ = Set.rec2 squash₂ (λ s (x , q) → ∣ x , q ∙ s ∣₂)
fiberRel2 : (x x' : ∥ fiber f y ∥₂) → Type (ℓ-max ℓ ℓ')
fiberRel2 x x' = ∥ Σ[ s ∈ ∥ y ≡ y ∥₂ ] ∣transport∣ s x ≡ x' ∥
fiberRel2→1 : ∀ x x' → fiberRel2 x x' → fiberRel x x'
fiberRel2→1 =
Set.elim2 (λ _ _ → isSetΠ λ _ → isOfHLevelPath 2 squash₂ _ _) λ _ _ →
Prop.rec (squash₂ _ _)
(uncurry
(Set.elim (λ _ → isSetΠ λ _ → isOfHLevelPath 2 squash₂ _ _) λ _ →
cong (Set.map fst)))
fiberRel1→2 : ∀ x x' → fiberRel x x' → fiberRel2 x x'
fiberRel1→2 =
Set.elim2 (λ _ _ → isSetΠ λ _ → isProp→isSet squash) λ a b p →
Prop.rec squash
(λ q →
let
filler = doubleCompPath-filler (sym (a .snd)) (cong f q) (b .snd)
in
∣ ∣ filler i1 ∣₂ , cong ∣_∣₂ (ΣPathP (q , adjustLemma (flipSquare filler))) ∣)
(PathIdTrunc₀Iso .Iso.fun p)
where
adjustLemma : {x y z w : Y} {p : x ≡ y} {q : x ≡ z} {r : z ≡ w} {s : y ≡ w}
→ PathP (λ i → p i ≡ r i) q s
→ PathP (λ i → p i ≡ w) (q ∙ r) s
adjustLemma {p = p} {q} {r} {s} α i j =
hcomp
(λ k → λ
{ (i = i0) → compPath-filler q r k j
; (i = i1) → s j
; (j = i0) → p i
; (j = i1) → r (i ∨ k)})
(α i j)
fiberRel1≃2 : ∀ x x' → fiberRel x x' ≃ fiberRel2 x x'
fiberRel1≃2 _ _ =
propBiimpl→Equiv (squash₂ _ _) squash (fiberRel1→2 _ _) (fiberRel2→1 _ _)
|
algebraic-stack_agda0000_doc_17408 | {-# OPTIONS --without-K --safe #-}
module Definition.Conversion.Consequences.Completeness where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Conversion
open import Definition.Conversion.EqRelInstance
open import Definition.LogicalRelation
open import Definition.LogicalRelation.Substitution
open import Definition.LogicalRelation.Substitution.Escape
open import Definition.LogicalRelation.Fundamental
open import Tools.Product
-- Algorithmic equality is derivable from judgemental equality of types.
completeEq : ∀ {A B Γ} → Γ ⊢ A ≡ B → Γ ⊢ A [conv↑] B
completeEq A≡B =
let [Γ] , [A] , [B] , [A≡B] = fundamentalEq A≡B
in escapeEqᵛ [Γ] [A] [A≡B]
-- Algorithmic equality is derivable from judgemental equality of terms.
completeEqTerm : ∀ {t u A Γ} → Γ ⊢ t ≡ u ∷ A → Γ ⊢ t [conv↑] u ∷ A
completeEqTerm t≡u =
let [Γ] , modelsTermEq [A] [t] [u] [t≡u] = fundamentalTermEq t≡u
in escapeEqTermᵛ [Γ] [A] [t≡u]
|
algebraic-stack_agda0000_doc_17409 | ------------------------------------------------------------------------------
-- All the Peano arithmetic modules
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module PA.Everything where
open import PA.Axiomatic.Mendelson.Base
open import PA.Axiomatic.Mendelson.Base.Consistency.Axioms
open import PA.Axiomatic.Mendelson.PropertiesATP
open import PA.Axiomatic.Mendelson.PropertiesI
open import PA.Axiomatic.Mendelson.Relation.Binary.EqReasoning
open import PA.Axiomatic.Mendelson.Relation.Binary.PropositionalEqualityI
open import PA.Axiomatic.Mendelson.Relation.Binary.PropositionalEqualityATP
open import PA.Axiomatic.Standard.Base
open import PA.Axiomatic.Standard.Base.Consistency.Axioms
open import PA.Axiomatic.Standard.PropertiesATP
open import PA.Axiomatic.Standard.PropertiesI
open import PA.Inductive.Base
open import PA.Inductive.Base.Core
open import PA.Inductive.Existential
open import PA.Inductive.PropertiesATP
open import PA.Inductive.PropertiesI
open import PA.Inductive.PropertiesByInduction
open import PA.Inductive.PropertiesByInductionATP
open import PA.Inductive.PropertiesByInductionI
open import PA.Inductive.Relation.Binary.EqReasoning
open import PA.Inductive.Relation.Binary.PropositionalEquality
open import PA.Inductive2Mendelson
open import PA.Inductive2Standard
|
algebraic-stack_agda0000_doc_17410 | module Computability.Data.Fin.Opposite where
open import Computability.Prelude
open import Data.Nat using (_≤_; _<_; s≤s; z≤n)
open import Data.Nat.Properties using (≤-step)
open import Data.Fin using (Fin; zero; suc; inject₁; fromℕ; fromℕ<; toℕ; opposite)
opposite-fromℕ : ∀ k → opposite (fromℕ k) ≡ zero
opposite-fromℕ zero = refl
opposite-fromℕ (suc k) rewrite opposite-fromℕ k = refl
opposite-inject₁-suc : ∀{k}(i : Fin k) → opposite (inject₁ i) ≡ suc (opposite i)
opposite-inject₁-suc zero = refl
opposite-inject₁-suc (suc i) rewrite opposite-inject₁-suc i = refl
opposite-opposite : ∀{k}(i : Fin k) → opposite (opposite i) ≡ i
opposite-opposite {suc k} zero rewrite opposite-fromℕ k = refl
opposite-opposite (suc i)
rewrite opposite-inject₁-suc (opposite i)
| opposite-opposite i = refl
opposite-fromℕ< : ∀ a b (lt : a < b) → opposite (fromℕ< (≤-step lt)) ≡ suc (opposite (fromℕ< lt))
opposite-fromℕ< zero .(suc _) (s≤s le) = refl
opposite-fromℕ< (suc a) .(suc _) (s≤s le) rewrite opposite-fromℕ< _ _ le = refl
|
algebraic-stack_agda0000_doc_17411 | module Type.Properties.Decidable.Proofs where
open import Data
open import Data.Proofs
open import Data.Boolean using (if_then_else_)
open import Data.Boolean.Stmt
open import Data.Either as Either using (_‖_)
open import Data.Tuple as Tuple using (_⨯_ ; _,_)
open import Functional
import Lvl
open import Data.Boolean using (Bool ; 𝑇 ; 𝐹)
import Data.Boolean.Operators
open Data.Boolean.Operators.Programming
open import Lang.Inspect
open import Logic
open import Logic.Classical
open import Logic.Predicate
open import Logic.Propositional
open import Numeral.Natural
open import Relator.Equals.Proofs.Equiv
open import Type.Properties.Decidable
open import Type.Properties.Empty
open import Type.Properties.Inhabited
open import Type.Properties.Singleton.Proofs
open import Type
private variable ℓ ℓₚ : Lvl.Level
private variable A B C P Q R T : Type{ℓ}
private variable b b₁ b₂ d : Bool
private variable f : A → B
module _ (P : Stmt{ℓ}) where
decider-classical : ⦃ dec : Decider₀(P)(d) ⦄ → Classical(P)
Classical.excluded-middle (decider-classical ⦃ dec = dec ⦄) = elim(\_ → (P ∨ (¬ P))) [∨]-introₗ [∨]-introᵣ dec
classical-decidable : ⦃ classical : Classical(P) ⦄ → Decidable(0)(P)
∃.witness classical-decidable = Either.isLeft(excluded-middle(P))
∃.proof classical-decidable with excluded-middle(P) | inspect Either.isLeft(excluded-middle(P))
... | Either.Left p | _ = true p
... | Either.Right np | _ = false np
module _ {ℓ₂} {x y : R} {Pred : (P ∨ (¬ P)) → R → Type{ℓ₂}} where
decider-if-intro : ∀{f} ⦃ dec : Decider₀(P)(f) ⦄ → ((p : P) → Pred(Either.Left p)(x)) → ((np : (¬ P)) → Pred(Either.Right np)(y)) → Pred(excluded-middle(P) ⦃ decider-classical ⦄)(if f then x else y)
decider-if-intro {f = 𝑇} ⦃ true p ⦄ fp _ = fp p
decider-if-intro {f = 𝐹} ⦃ false np ⦄ _ fnp = fnp np
decider-to-classical : ⦃ dec : Decider₀(P)(d) ⦄ → Classical(P)
decider-to-classical{P = P} = decider-classical(P)
classical-to-decidable : ⦃ classical : Classical(P) ⦄ → Decidable(0)(P)
classical-to-decidable{P = P} = classical-decidable(P)
classical-to-decider : ⦃ classical : Classical(P) ⦄ → Decider(0)(P)([∃]-witness classical-to-decidable)
classical-to-decider{P = P} = [∃]-proof classical-to-decidable
decider-true : ⦃ dec : Decider₀(P)(b) ⦄ → (P ↔ IsTrue(b))
decider-true ⦃ dec = true p ⦄ = [↔]-intro (const p) (const <>)
decider-true ⦃ dec = false np ⦄ = [↔]-intro empty (empty ∘ np)
decider-false : ⦃ dec : Decider₀(P)(b) ⦄ → ((P → Empty{ℓ}) ↔ IsFalse(b))
decider-false ⦃ dec = true p ⦄ = [↔]-intro empty (empty ∘ apply p)
decider-false ⦃ dec = false np ⦄ = [↔]-intro (const(empty ∘ np)) (const <>)
isempty-decider : ⦃ empty : IsEmpty(P) ⦄ → Decider₀(P)(𝐹)
isempty-decider ⦃ intro p ⦄ = false (empty ∘ p)
inhabited-decider : ⦃ inhab : (◊ P) ⦄ → Decider₀(P)(𝑇)
inhabited-decider ⦃ intro ⦃ p ⦄ ⦄ = true p
empty-decider : Decider₀(Empty{ℓ})(𝐹)
empty-decider = isempty-decider
unit-decider : Decider₀(Unit{ℓ})(𝑇)
unit-decider = inhabited-decider ⦃ unit-is-pos ⦄
instance
tuple-decider : ⦃ dec-P : Decider₀(P)(b₁) ⦄ → ⦃ dec-Q : Decider₀(Q)(b₂) ⦄ → Decider₀(P ⨯ Q)(b₁ && b₂)
tuple-decider ⦃ true p ⦄ ⦃ true q ⦄ = true(p , q)
tuple-decider ⦃ true p ⦄ ⦃ false nq ⦄ = false(nq ∘ Tuple.right)
tuple-decider ⦃ false np ⦄ ⦃ true q ⦄ = false(np ∘ Tuple.left)
tuple-decider ⦃ false np ⦄ ⦃ false nq ⦄ = false(np ∘ Tuple.left)
instance
either-decider : ⦃ dec-P : Decider₀(P)(b₁) ⦄ → ⦃ dec-Q : Decider₀(Q)(b₂) ⦄ → Decider₀(P ‖ Q)(b₁ || b₂)
either-decider ⦃ true p ⦄ ⦃ true q ⦄ = true (Either.Left p)
either-decider ⦃ true p ⦄ ⦃ false nq ⦄ = true (Either.Left p)
either-decider ⦃ false np ⦄ ⦃ true q ⦄ = true (Either.Right q)
either-decider ⦃ false np ⦄ ⦃ false nq ⦄ = false (Either.elim np nq)
instance
function-decider : ⦃ dec-P : Decider₀(P)(b₁) ⦄ → ⦃ dec-Q : Decider₀(Q)(b₂) ⦄ → Decider₀(P → Q)((! b₁) || b₂)
function-decider ⦃ true p ⦄ ⦃ true q ⦄ = true (const q)
function-decider ⦃ true p ⦄ ⦃ false nq ⦄ = false (apply p ∘ (nq ∘_))
function-decider ⦃ false np ⦄ ⦃ true q ⦄ = true (const q)
function-decider ⦃ false np ⦄ ⦃ false nq ⦄ = true (empty ∘ np)
instance
not-decider : ⦃ dec : Decider₀(P)(b) ⦄ → Decider₀(¬ P)(! b)
not-decider = function-decider {b₂ = 𝐹} ⦃ dec-Q = empty-decider ⦄
instance
IsTrue-decider : Decider₀(IsTrue(b))(b)
IsTrue-decider {𝑇} = true <>
IsTrue-decider {𝐹} = false id
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.