Search is not available for this dataset
text
string | meta
dict |
|---|---|
module Numeral.Sign.Oper0 where
open import Numeral.Sign
-- Negation
−_ : (+|0|−) → (+|0|−)
− (➕) = (➖)
− (𝟎) = (𝟎)
− (➖) = (➕)
-- Bounded addition
_+_ : (+|0|−) → (+|0|−) → (+|0|−)
(➕) + (➕) = (➕)
(➕) + (➖) = (𝟎)
(➕) + (𝟎) = (➕)
(➖) + (➕) = (𝟎)
(➖) + (➖) = (➖)
(➖) + (𝟎) = (➖)
(𝟎) + (➕) = (➕)
(𝟎) + (➖) = (➖)
(𝟎) + (𝟎) = (𝟎)
-- Multiplication
_⨯_ : (+|0|−) → (+|0|−) → (+|0|−)
(➕) ⨯ (➕) = (➕)
(➕) ⨯ (➖) = (➖)
(➕) ⨯ (𝟎) = (𝟎)
(➖) ⨯ (➕) = (➖)
(➖) ⨯ (➖) = (➕)
(➖) ⨯ (𝟎) = (𝟎)
(𝟎) ⨯ (➕) = (𝟎)
(𝟎) ⨯ (➖) = (𝟎)
(𝟎) ⨯ (𝟎) = (𝟎)
_⋚_ : (+|0|−) → (+|0|−) → (+|0|−)
➕ ⋚ 𝟎 = ➕
➕ ⋚ ➖ = ➕
𝟎 ⋚ ➖ = ➕
➕ ⋚ ➕ = 𝟎
𝟎 ⋚ 𝟎 = 𝟎
➖ ⋚ ➖ = 𝟎
𝟎 ⋚ ➕ = ➖
➖ ⋚ ➕ = ➖
➖ ⋚ 𝟎 = ➖
| {
"alphanum_fraction": 0.2058371736,
"avg_line_length": 14.4666666667,
"ext": "agda",
"hexsha": "9da8accdcdafe2bd3a878bcf308c71f8b9ba0ca7",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Lolirofle/stuff-in-agda",
"max_forks_repo_path": "Numeral/Sign/Oper0.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "Numeral/Sign/Oper0.agda",
"max_line_length": 33,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Lolirofle/stuff-in-agda",
"max_stars_repo_path": "Numeral/Sign/Oper0.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-05T06:53:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:58:13.000Z",
"num_tokens": 555,
"size": 651
} |
module n2o.Network.Core where
open import proto.Base
open import proto.IO
open import n2o.Network.Internal
{-# FOREIGN GHC import Network.N2O.Core #-}
postulate
protoRun : ∀ {F : Set → Set} {A : Set} → F A → List (Proto F A) → N2O F A (Result (F A))
{-# COMPILE GHC protoRun = Network.N2O.Core.protoRun #-}
| {
"alphanum_fraction": 0.6719242902,
"avg_line_length": 22.6428571429,
"ext": "agda",
"hexsha": "1661de0ee39990e397db6cc4c52da5f2e3927aad",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "d7903dfffcd66ae174eed9347afe008f892b2491",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "o4/n2o",
"max_forks_repo_path": "n2o/Network/Core.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "d7903dfffcd66ae174eed9347afe008f892b2491",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "o4/n2o",
"max_issues_repo_path": "n2o/Network/Core.agda",
"max_line_length": 92,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "d7903dfffcd66ae174eed9347afe008f892b2491",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "o4/n2o",
"max_stars_repo_path": "n2o/Network/Core.agda",
"max_stars_repo_stars_event_max_datetime": "2019-01-02T06:37:47.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-11-30T11:37:10.000Z",
"num_tokens": 93,
"size": 317
} |
{-# OPTIONS --cubical --safe --guardedness #-}
module Data.PolyP.Composition where
open import Function hiding (_⟨_⟩_)
open import Data.Sum
open import Data.Sigma
open import Level
open import Data.Unit
open import Data.Nat
open import Data.Vec
open import Data.Empty
open import WellFounded
open import Literals.Number
open import Data.Fin.Indexed.Literals
open import Data.Fin.Indexed.Properties
open import Data.Fin.Indexed
open import Data.Nat.Literals
open import Data.Maybe
open import Data.PolyP.Universe
infixr 9 _⊚_
_⇑_ : Fin (suc n) → Functor n → Functor (suc n)
i ⇑ (! j) = ! (insert i j)
i ⇑ (x ⊕ y) = i ⇑ x ⊕ i ⇑ y
i ⇑ (x ⊗ y) = i ⇑ x ⊗ i ⇑ y
i ⇑ μ⟨ x ⟩ = μ⟨ fs i ⇑ x ⟩
i ⇑ ⓪ = ⓪
i ⇑ ① = ①
⇓ : Functor n → Functor (suc n)
⇓ (! x) = ! (weaken x)
⇓ (x ⊕ y) = ⇓ x ⊕ ⇓ y
⇓ (x ⊗ y) = ⇓ x ⊗ ⇓ y
⇓ μ⟨ x ⟩ = μ⟨ f0 ⇑ x ⟩
⇓ ⓪ = ⓪
⇓ ① = ①
substAt : Fin (suc n) → Functor (suc n) → Functor n → Functor n
substAt i (! j) xs = maybe xs ! (j \\ i)
substAt i (ys ⊕ zs) xs = substAt i ys xs ⊕ substAt i zs xs
substAt i (ys ⊗ zs) xs = substAt i ys xs ⊗ substAt i zs xs
substAt i μ⟨ ys ⟩ xs = μ⟨ substAt (fs i) ys (f0 ⇑ xs) ⟩
substAt i ⓪ xs = ⓪
substAt i ① xs = ①
_⊚_ : Functor (suc n) → Functor n → Functor n
_⊚_ = substAt f0
| {
"alphanum_fraction": 0.6123101519,
"avg_line_length": 24.5294117647,
"ext": "agda",
"hexsha": "d2ac1ed17c67dd716fd0fb48a66a2bc4494fdcaf",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "oisdk/agda-playground",
"max_forks_repo_path": "Data/PolyP/Composition.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "oisdk/agda-playground",
"max_issues_repo_path": "Data/PolyP/Composition.agda",
"max_line_length": 63,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "oisdk/agda-playground",
"max_stars_repo_path": "Data/PolyP/Composition.agda",
"max_stars_repo_stars_event_max_datetime": "2021-11-16T08:11:34.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-09-11T17:45:41.000Z",
"num_tokens": 547,
"size": 1251
} |
{-# OPTIONS --cubical --safe #-}
module Data.Binary.Multiplication.Properties where
open import Prelude
open import Data.Binary.Definition
open import Data.Binary.Addition
open import Data.Binary.Addition.Properties using (+-cong)
open import Data.Binary.Multiplication
open import Data.Binary.Conversion
import Data.Nat as ℕ
import Data.Nat.Properties as ℕ
open import Path.Reasoning
open import Data.Binary.Isomorphism
double-cong : ∀ xs → ⟦ double xs ⇓⟧ ≡ ⟦ xs ⇓⟧ ℕ.* 2
double-cong 0ᵇ i = zero
double-cong (1ᵇ xs) i = 2 ℕ.+ double-cong xs i ℕ.* 2
double-cong (2ᵇ xs) i = ⟦ 2ᵇ 1ᵇ xs ⇓⟧
double-plus : ∀ x → x ℕ.+ x ≡ x ℕ.* 2
double-plus x = cong (x ℕ.+_) (sym (ℕ.+-idʳ x)) ; ℕ.*-comm 2 x
lemma₁ : ∀ x y → x ℕ.* y ℕ.* 2 ≡ y ℕ.* 2 ℕ.* x
lemma₁ x y =
x ℕ.* y ℕ.* 2 ≡⟨ ℕ.*-assoc x y 2 ⟩
x ℕ.* (y ℕ.* 2) ≡⟨ ℕ.*-comm x (y ℕ.* 2) ⟩
y ℕ.* 2 ℕ.* x ∎
lemma₂ : ∀ x y → (x ℕ.+ x ℕ.* y) ℕ.* 2 ≡ x ℕ.+ (x ℕ.+ y ℕ.* 2 ℕ.* x)
lemma₂ x y =
(x ℕ.+ x ℕ.* y) ℕ.* 2 ≡⟨ ℕ.+-*-distrib x (x ℕ.* y) 2 ⟩
x ℕ.* 2 ℕ.+ x ℕ.* y ℕ.* 2 ≡⟨ cong₂ ℕ._+_ (sym (double-plus x)) (lemma₁ x y) ⟩
x ℕ.+ x ℕ.+ y ℕ.* 2 ℕ.* x ≡⟨ ℕ.+-assoc x x (y ℕ.* 2 ℕ.* x) ⟩
x ℕ.+ (x ℕ.+ y ℕ.* 2 ℕ.* x) ∎
*-cong : ∀ xs ys → ⟦ xs * ys ⇓⟧ ≡ ⟦ xs ⇓⟧ ℕ.* ⟦ ys ⇓⟧
*-cong 0ᵇ ys = refl
*-cong (1ᵇ xs) ys =
⟦ ys + double (ys * xs) ⇓⟧ ≡⟨ +-cong ys (double (ys * xs)) ⟩
⟦ ys ⇓⟧ ℕ.+ ⟦ double (ys * xs) ⇓⟧ ≡⟨ cong (⟦ ys ⇓⟧ ℕ.+_) (double-cong (ys * xs)) ⟩
⟦ ys ⇓⟧ ℕ.+ ⟦ ys * xs ⇓⟧ ℕ.* 2 ≡⟨ cong (⟦ ys ⇓⟧ ℕ.+_) (cong (ℕ._* 2) (*-cong ys xs)) ⟩
⟦ ys ⇓⟧ ℕ.+ ⟦ ys ⇓⟧ ℕ.* ⟦ xs ⇓⟧ ℕ.* 2 ≡⟨ cong (⟦ ys ⇓⟧ ℕ.+_) (lemma₁ ⟦ ys ⇓⟧ ⟦ xs ⇓⟧) ⟩
⟦ ys ⇓⟧ ℕ.+ ⟦ xs ⇓⟧ ℕ.* 2 ℕ.* ⟦ ys ⇓⟧ ∎
*-cong (2ᵇ xs) ys =
⟦ double (ys + ys * xs) ⇓⟧ ≡⟨ double-cong (ys + ys * xs) ⟩
⟦ ys + ys * xs ⇓⟧ ℕ.* 2 ≡⟨ cong (ℕ._* 2) (+-cong ys (ys * xs)) ⟩
(⟦ ys ⇓⟧ ℕ.+ ⟦ ys * xs ⇓⟧) ℕ.* 2 ≡⟨ cong (ℕ._* 2) (cong (⟦ ys ⇓⟧ ℕ.+_) (*-cong ys xs)) ⟩
(⟦ ys ⇓⟧ ℕ.+ ⟦ ys ⇓⟧ ℕ.* ⟦ xs ⇓⟧) ℕ.* 2 ≡⟨ lemma₂ ⟦ ys ⇓⟧ ⟦ xs ⇓⟧ ⟩
⟦ ys ⇓⟧ ℕ.+ (⟦ ys ⇓⟧ ℕ.+ ⟦ xs ⇓⟧ ℕ.* 2 ℕ.* ⟦ ys ⇓⟧) ∎
| {
"alphanum_fraction": 0.4842735896,
"avg_line_length": 39.2745098039,
"ext": "agda",
"hexsha": "cbe5702d8fac49ab9b3a8b3ef3fb97b2ca52495e",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-11T12:30:21.000Z",
"max_forks_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "oisdk/agda-playground",
"max_forks_repo_path": "Data/Binary/Multiplication/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "oisdk/agda-playground",
"max_issues_repo_path": "Data/Binary/Multiplication/Properties.agda",
"max_line_length": 90,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "97a3aab1282b2337c5f43e2cfa3fa969a94c11b7",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "oisdk/agda-playground",
"max_stars_repo_path": "Data/Binary/Multiplication/Properties.agda",
"max_stars_repo_stars_event_max_datetime": "2021-11-16T08:11:34.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-09-11T17:45:41.000Z",
"num_tokens": 1073,
"size": 2003
} |
import Lvl
open import Structure.Operator.Vector
open import Structure.Setoid
open import Type
module Structure.Operator.Vector.Subspace
{ℓᵥ ℓₛ ℓᵥₑ ℓₛₑ}
{V : Type{ℓᵥ}} ⦃ equiv-V : Equiv{ℓᵥₑ}(V) ⦄
{S : Type{ℓₛ}} ⦃ equiv-S : Equiv{ℓₛₑ}(S) ⦄
{_+ᵥ_ : V → V → V}
{_⋅ₛᵥ_ : S → V → V}
{_+ₛ_ _⋅ₛ_ : S → S → S}
⦃ vectorSpace : VectorSpace(_+ᵥ_)(_⋅ₛᵥ_)(_+ₛ_)(_⋅ₛ_) ⦄
where
open VectorSpace(vectorSpace)
open import Logic
open import Logic.Predicate
open import Logic.Predicate.Equiv
open import Sets.ExtensionalPredicateSet as PredSet using (PredSet ; _∈_ ; [∋]-binaryRelator)
open import Structure.Container.SetLike using (SetElement)
private open module SetLikeFunctionProperties{ℓ} = Structure.Container.SetLike.FunctionProperties{C = PredSet{ℓ}(V)}(_∈_)
open import Structure.Operator.Vector
open import Structure.Operator.Vector.LinearCombination ⦃ vectorSpace = vectorSpace ⦄
open import Syntax.Transitivity
private variable ℓ : Lvl.Level
-- A subspace is a subset of V such that it is a vector space under the same operators.
record Subspace (Vₛ : PredSet{ℓ}(V)) : Stmt{ℓᵥ Lvl.⊔ ℓₛ Lvl.⊔ ℓ} where
constructor intro
field
⦃ add-closure ⦄ : Vₛ closed-under₂ (_+ᵥ_)
⦃ mul-closure ⦄ : ∀{s} → (Vₛ closed-under₁ (s ⋅ₛᵥ_))
_+_ : SetElement(_∈_)(Vₛ) → SetElement(_∈_)(Vₛ) → SetElement(_∈_)(Vₛ)
_+_ = [∃]-map₂(_+ᵥ_) (Vₛ closureUnder₂ (_+ᵥ_))
_⋅_ : S → SetElement(_∈_)(Vₛ) → SetElement(_∈_)(Vₛ)
_⋅_ s = [∃]-map(s ⋅ₛᵥ_) (Vₛ closureUnder₁ (s ⋅ₛᵥ_))
-- TODO: A proof of this would be easier if a similar "substructure" relation was defined on groups and fields, but I am not sure if using PredSet is the correct choice (maybe this is unprovable when using this?). Another alternative is to use a general set structure by Structure.Container.SetLike
postulate is-vectorSpace : VectorSpace{V = SetElement(_∈_)(Vₛ)}{S = S}(_+_)(_⋅_)(_+ₛ_)(_⋅ₛ_)
-- is-vectorSpace = {!!}
SubspaceObject : ∀{ℓ} → Stmt
SubspaceObject{ℓ} = ∃(Subspace{ℓ})
| {
"alphanum_fraction": 0.6991374937,
"avg_line_length": 40.2244897959,
"ext": "agda",
"hexsha": "6e2027db85cf4c8b4d513b6257bc10471387f874",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Lolirofle/stuff-in-agda",
"max_forks_repo_path": "Structure/Operator/Vector/Subspace.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "Structure/Operator/Vector/Subspace.agda",
"max_line_length": 300,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Lolirofle/stuff-in-agda",
"max_stars_repo_path": "Structure/Operator/Vector/Subspace.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-05T06:53:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:58:13.000Z",
"num_tokens": 775,
"size": 1971
} |
module plfa-code.Relations where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong; sym; trans)
open import Data.Nat using (ℕ; zero; suc; _+_; _*_)
open import Data.Nat.Properties using (+-comm)
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_)
open import plfa-code.Reasoning-legacy
open import Function
data _≤_ : ℕ → ℕ → Set where
z≤n : ∀ {n : ℕ}
---------
→ zero ≤ n
s≤s : ∀ {m n : ℕ}
→ m ≤ n
--------------
→ suc m ≤ suc n
infix 4 _≤_
_ : 2 ≤ 4
_ = s≤s (s≤s z≤n)
inv-s≤s : ∀ {m n : ℕ}
→ suc m ≤ suc n
-------------
→ m ≤ n
inv-s≤s (s≤s m≤n) = m≤n
inv-z≤n : ∀ {m : ℕ}
→ m ≤ zero
---------
→ m ≡ zero
inv-z≤n z≤n = refl
≤-refl : ∀ {n : ℕ}
------
→ n ≤ n
≤-refl {zero} = z≤n
≤-refl {suc n} = s≤s ≤-refl
≤-trans : ∀ {m n p : ℕ}
→ m ≤ n
→ n ≤ p
------
→ m ≤ p
≤-trans z≤n _ = z≤n
≤-trans (s≤s m≤n) (s≤s n≤p) = s≤s (≤-trans m≤n n≤p)
≤-trans′ : ∀ (m n p : ℕ)
→ m ≤ n
→ n ≤ p
------
→ m ≤ p
≤-trans′ zero _ _ z≤n _ = z≤n
≤-trans′ (suc m) (suc n) (suc p) (s≤s m≤n) (s≤s n≤p) = s≤s (≤-trans′ m n p m≤n n≤p)
≤-antisym : ∀ {m n : ℕ}
→ m ≤ n
→ n ≤ m
-------
→ m ≡ n
≤-antisym z≤n z≤n = refl
≤-antisym (s≤s m≤n) (s≤s n≤m) = cong suc (≤-antisym m≤n n≤m)
-- when m is zero there is no instance for `n ≤ m`, the same as when n is zero
data Total (m n : ℕ) : Set where
forward :
m ≤ n
----------
→ Total m n
flipped :
n ≤ m
----------
→ Total m n
≤-total : ∀ (m n : ℕ) → Total m n
≤-total zero n = forward z≤n
≤-total (suc m) zero = flipped z≤n
≤-total (suc m) (suc n) with ≤-total m n
... | forward m≤n = forward (s≤s m≤n)
... | flipped n≤m = flipped (s≤s n≤m)
≤-total′ : ∀ (m n : ℕ) → Total m n
≤-total′ zero n = forward z≤n
≤-total′ (suc m) zero = flipped z≤n
≤-total′ (suc m) (suc n) = helper (≤-total′ m n)
where
helper : Total m n → Total (suc m) (suc n)
helper (forward m≤n) = forward (s≤s m≤n)
helper (flipped n≤m) = flipped (s≤s n≤m)
+-monoʳ-≤ : ∀ (n p q : ℕ)
→ p ≤ q
--------------
→ n + p ≤ n + q
+-monoʳ-≤ zero p q p≤q = p≤q
+-monoʳ-≤ (suc n) p q p≤q = s≤s (+-monoʳ-≤ n p q p≤q)
+-monoˡ-≤ : ∀ (m n p : ℕ)
→ m ≤ n
--------------
→ m + p ≤ n + p
+-monoˡ-≤ m n p m≤n rewrite +-comm m p | +-comm n p = +-monoʳ-≤ p m n m≤n
+-mono-≤ : ∀ (m n p q : ℕ)
→ m ≤ n
→ p ≤ q
--------------
→ m + p ≤ n + q
+-mono-≤ m n p q m≤n p≤q = ≤-trans (+-monoˡ-≤ m n p m≤n) (+-monoʳ-≤ n p q p≤q)
---------- practice ----------
*-mono-≤ : ∀ (m n p q : ℕ) → m ≤ n → p ≤ q → m * p ≤ n * q
*-mono-≤ zero n p q m≤n p≤q = z≤n
*-mono-≤ (suc m) (suc n) p q m≤n p≤q = +-mono-≤ p q (m * p) (n * q) p≤q (*-mono-≤ m n p q (inv-s≤s m≤n) p≤q)
------------------------------
infix 4 _<_
data _<_ : ℕ → ℕ → Set where
z<s : ∀ {n : ℕ}
-------------
→ zero < suc n
s<s : ∀ {m n : ℕ}
→ m < n
--------------
→ suc m < suc n
---------- practice ----------
inv-s<s : ∀ {m n : ℕ} → suc m < suc n → m < n
inv-s<s (s<s mLTn) = mLTn
<-trans : ∀ (m n p : ℕ) → m < n → n < p → m < p
<-trans zero (suc n) (suc p) zLTsn snLTsp = z<s
<-trans (suc m) (suc n) (suc p) smLTsn snLTsp = s<s (<-trans m n p (inv-s<s smLTsn) (inv-s<s snLTsp))
data Trichotomy (m n : ℕ) : Set where
less : m < n → Trichotomy m n
equal : m ≡ n → Trichotomy m n
greater : n < m → Trichotomy m n
<-trichotomy : ∀ (m n : ℕ) → Trichotomy m n
<-trichotomy zero zero = equal refl
<-trichotomy zero (suc n) = less z<s
<-trichotomy (suc m) zero = greater z<s
<-trichotomy (suc m) (suc n) with <-trichotomy m n
... | less mLTn = less (s<s mLTn)
... | equal refl = equal refl
... | greater nLTm = greater (s<s nLTm)
+-monoʳ-< : ∀ (n p q : ℕ) → p < q → n + p < n + q
+-monoʳ-< zero p q pLTq = pLTq
+-monoʳ-< (suc n) p q pLTq = s<s (+-monoʳ-< n p q pLTq)
+-monoˡ-< : ∀ (m n p : ℕ) → m < n → m + p < n + p
+-monoˡ-< m n p mLTn rewrite +-comm m p | +-comm n p = +-monoʳ-< p m n mLTn
+-mono-< : ∀ (m n p q : ℕ) → m < n → p < q → m + p < n + q
+-mono-< m n p q mLTn pLTq = <-trans (m + p) (n + p) (n + q) (+-monoˡ-< m n p mLTn) (+-monoʳ-< n p q pLTq)
≤-iff-< : ∀ (m n : ℕ) → suc m ≤ n → m < n
≤-iff-< zero (suc n) _ = z<s
≤-iff-< (suc m) (suc n) ssm≤sn = s<s (≤-iff-< m n sm≤n)
where
sm≤n = inv-s≤s ssm≤sn
<-iff-≤ : ∀ (m n : ℕ) → m < n → suc m ≤ n
<-iff-≤ zero (suc n) mLTn = s≤s z≤n
<-iff-≤ (suc m) (suc n) smLTn = s≤s (<-iff-≤ m n (inv-s<s smLTn))
<→≤ : ∀ (n p : ℕ) → n < p → n ≤ p
<→≤ zero p nLTp = z≤n
<→≤ (suc n) (suc p) nLTp = s≤s (<→≤ n p (inv-s<s nLTp))
<-trans-revisited : ∀ (m n p : ℕ) → m < n → n < p → m < p
<-trans-revisited m n p mLTn nLTp = ≤-iff-< m p (inv-s≤s ssm≤sp)
where ssm≤sp = s≤s (≤-trans (<-iff-≤ m n mLTn) (<→≤ n p nLTp))
------------------------------
data even : ℕ → Set
data odd : ℕ → Set
data even where
zero :
---------
even zero
suc : ∀ {n : ℕ}
→ odd n
-------------
→ even (suc n)
data odd where
suc : ∀ {n : ℕ}
→ even n
------------
→ odd (suc n)
e+e≡e : ∀ {m n : ℕ}
→ even m
→ even n
-------------
→ even (m + n)
o+e≡o : ∀ {m n : ℕ}
→ odd m
→ even n
------------
→ odd (m + n)
e+e≡e zero en = en
e+e≡e (suc om) en = suc (o+e≡o om en)
o+e≡o (suc em) en = suc (e+e≡e em en)
---------- practice ----------
o+o≡e : ∀ {m n : ℕ} → odd m → odd n → even (m + n)
o+o≡e (suc zero) on = suc on
o+o≡e (suc (suc ox)) on = suc (suc (o+o≡e ox on))
open import plfa-code.Induction using (Bin; nil; x0_; x1_; inc; from; to;
+1≡suc; suc-from-inc; from-to-const)
data Can : Bin → Set
data One : Bin → Set
data One where
one : One (x1 nil)
x0_ : ∀ {b : Bin} → One b → One(x0 b)
x1_ : ∀ {b : Bin} → One b → One(x1 b)
data Can where
zero : Can (x0 nil)
can-one : ∀ {b : Bin} → One b → Can b
one-inc : ∀ {x : Bin} → One x → One (inc x)
one-inc one = x0 one
one-inc (x0 x) = x1 x
one-inc (x1 x) = x0 (one-inc x)
can-inc : ∀ {x : Bin} → Can x → Can (inc x)
can-inc zero = can-one one
can-inc (can-one x) = can-one (one-inc x)
one-to-n : ∀ (n : ℕ) → One (to (suc n))
one-to-n zero = one
one-to-n (suc n) = one-inc (one-to-n n)
can-to-n : ∀ (n : ℕ) → Can (to n)
can-to-n zero = zero
can-to-n (suc n) = can-one (one-to-n n)
open Data.Nat.Properties using (+-identityʳ; +-suc)
l0 : ∀ (n) → to (suc n) ≡ inc (to n)
l0 zero = refl
l0 (suc n) = refl
2n-eq-x0 : ∀ (n) → 1 ≤ n → to (n + n) ≡ x0 (to n)
2n-eq-x0 zero ()
2n-eq-x0 (suc zero) (s≤s z≤n) = refl
2n-eq-x0 (suc (suc n)) (s≤s z≤n) =
begin to (suc (suc n) + suc (suc n))
≡⟨ cong (λ x → to x) (+-suc (suc (suc n)) (suc n)) ⟩ to (suc (suc (suc n + suc n)))
≡⟨⟩ inc (inc (to (suc n + suc n)))
≡⟨ cong (λ x → (inc (inc x))) (2n-eq-x0 (suc n) (s≤s z≤n)) ⟩ inc (inc (x0 (to (suc n))))
≡⟨⟩ x0 (inc (to (suc n)))
≡⟨⟩ x0 (to (suc (suc n)))
∎
one-b-iff-1≤b : ∀ (b) → One b → 1 ≤ from b
one-b-iff-1≤b (x0 b) (x0 ob)
rewrite +-identityʳ (from b)
= +-mono-≤ 1 n 0 n (one-b-iff-1≤b b ob) z≤n
where n = from b
one-b-iff-1≤b (x1 .nil) one = s≤s z≤n
one-b-iff-1≤b (x1 b) (x1 ob) = s≤s z≤n
one-tf-eq : ∀ {b} → One b → to (from b) ≡ b
one-tf-eq {_} one = refl
one-tf-eq {x0 b} (x0 x) =
begin
to (from (x0 b))
≡⟨⟩
to (from b + (from b + zero))
≡⟨ cong (λ n → to (from b + n)) (+-identityʳ (from b)) ⟩
to (from b + from b)
≡⟨ 2n-eq-x0 (from b) (one-b-iff-1≤b b x) ⟩
x0 (to (from b))
≡⟨ cong x0_ (one-tf-eq x) ⟩
x0 b
∎
one-tf-eq {x1 b} (x1 x) =
begin
to (from (x1 b))
≡⟨⟩
inc (to (from b + (from b + zero)))
≡⟨ cong (λ n → inc (to (from b + n))) (+-identityʳ (from b)) ⟩
inc (to (from b + from b))
≡⟨ cong inc (2n-eq-x0 (from b) (one-b-iff-1≤b b x)) ⟩
inc (x0 (to (from b)))
≡⟨⟩
x1 (to (from b))
≡⟨ cong x1_ (one-tf-eq x) ⟩
x1 b
∎
can-tf-eq : ∀ {x} → Can x → to (from x) ≡ x
can-tf-eq {_} zero = refl
can-tf-eq {b} (can-one x) = one-tf-eq x
------------------------------
| {
"alphanum_fraction": 0.4452021432,
"avg_line_length": 25.3456790123,
"ext": "agda",
"hexsha": "b315cafb37a022c48736248a726f91900222cd4c",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "ec5b359a8c22bf5268cae3c36a97e6737c75d5f3",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "chirsz-ever/plfa-code",
"max_forks_repo_path": "src/plfa-code/Relations.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "ec5b359a8c22bf5268cae3c36a97e6737c75d5f3",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "chirsz-ever/plfa-code",
"max_issues_repo_path": "src/plfa-code/Relations.agda",
"max_line_length": 108,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "ec5b359a8c22bf5268cae3c36a97e6737c75d5f3",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "chirsz-ever/plfa-code",
"max_stars_repo_path": "src/plfa-code/Relations.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 3875,
"size": 8212
} |
------------------------------------------------------------------------
-- Pointwise equalities can be lifted
------------------------------------------------------------------------
module Stream.Pointwise where
open import Codata.Musical.Notation hiding (∞)
open import Stream
open import Stream.Equality
import Stream.Programs as Prog
open Prog hiding (lift; ⟦_⟧)
open import Data.Nat
open import Data.Fin using (Fin; zero; suc)
open import Data.Vec as Vec using (Vec; _∷_)
open import Relation.Binary
open import Relation.Binary.PropositionalEquality
private
module IsEq {A : Set} =
IsEquivalence (Setoid.isEquivalence (Stream.setoid A))
------------------------------------------------------------------------
-- Definitions
infix 8 _∞
infixr 7 _·_
infix 6 _⟨_⟩_
-- Expressions corresponding to pointwise definitions of streams.
-- Indexed on the number of variables.
-- It is possible to generalise this type, allowing variables to
-- correspond to streams containing elements of arbitrary type, and
-- letting the function arguments of _·_ and _⟨_⟩_ be more general.
-- However, this would complicate the development, so I hesitate to do
-- so without evidence that it would be genuinely useful.
data Pointwise A n : Set where
var : (x : Fin n) → Pointwise A n
_∞ : (x : A) → Pointwise A n
_·_ : (f : A → A) (xs : Pointwise A n) → Pointwise A n
_⟨_⟩_ : (xs : Pointwise A n)
(_∙_ : A → A → A)
(ys : Pointwise A n) →
Pointwise A n
-- Stream semantics.
⟦_⟧ : ∀ {A n} → Pointwise A n → (Vec (Prog A) n → Prog A)
⟦ var x ⟧ ρ = Vec.lookup ρ x
⟦ x ∞ ⟧ ρ = x ∞
⟦ f · xs ⟧ ρ = f · ⟦ xs ⟧ ρ
⟦ xs ⟨ _∙_ ⟩ ys ⟧ ρ = ⟦ xs ⟧ ρ ⟨ _∙_ ⟩ ⟦ ys ⟧ ρ
-- Pointwise semantics.
⟪_⟫ : ∀ {A n} → Pointwise A n → (Vec A n → A)
⟪ var x ⟫ ρ = Vec.lookup ρ x
⟪ x ∞ ⟫ ρ = x
⟪ f · xs ⟫ ρ = f (⟪ xs ⟫ ρ)
⟪ xs ⟨ _∙_ ⟩ ys ⟫ ρ = ⟪ xs ⟫ ρ ∙ ⟪ ys ⟫ ρ
------------------------------------------------------------------------
-- Some lemmas used below
private
-- lookup is natural.
lookup-nat : ∀ {a b n} {A : Set a} {B : Set b}
(f : A → B) (x : Fin n) ρ →
f (Vec.lookup ρ x) ≡ Vec.lookup (Vec.map f ρ) x
lookup-nat f zero (x ∷ ρ) = refl
lookup-nat f (suc i) (x ∷ ρ) = lookup-nat f i ρ
------------------------------------------------------------------------
-- The two semantics above are related via the function lift
private
-- Lifts a pointwise function to a function on stream programs.
lift : ∀ {A B n} →
(Vec A n → B) → Vec (Prog A) n → Prog B
lift f xs = f (Vec.map headP xs) ≺ ♯ lift f (Vec.map tailP xs)
-- lift is a congruence in its first argument.
lift-cong : ∀ {A B n} {f g : Vec A n → B} →
(∀ ρ → f ρ ≡ g ρ) →
∀ ρ → lift f ρ ≊ lift g ρ
lift-cong hyp ρ = hyp (Vec.map headP ρ) ≺
♯ lift-cong hyp (Vec.map tailP ρ)
-- unfold xs ρ is the one-step unfolding of ⟦ xs ⟧ ρ. Note the
-- similarity to lift.
unfold : ∀ {A n} (xs : Pointwise A n) ρ → Prog A
unfold xs ρ = ⟪ xs ⟫ (Vec.map headP ρ) ≺♯
⟦ xs ⟧ (Vec.map tailP ρ)
unfold-lemma : ∀ {A n} (xs : Pointwise A n) ρ →
⟦ xs ⟧ ρ ≊ unfold xs ρ
unfold-lemma (var x) ρ =
Vec.lookup ρ x
≊⟨ ≊-η (Vec.lookup ρ x) ⟩
headP (Vec.lookup ρ x) ≺♯ tailP (Vec.lookup ρ x)
≊⟨ lookup-nat headP x ρ ≺
♯ ≈⇒≅ (IsEq.reflexive
(cong Prog.⟦_⟧ (lookup-nat tailP x ρ))) ⟩
Vec.lookup (Vec.map headP ρ) x ≺♯
Vec.lookup (Vec.map tailP ρ) x
≡⟨ refl ⟩
unfold (var x) ρ
∎
unfold-lemma (x ∞) ρ = x ∞ ∎
unfold-lemma (f · xs) ρ =
f · ⟦ xs ⟧ ρ
≊⟨ ·-cong f (⟦ xs ⟧ ρ) (unfold xs ρ) (unfold-lemma xs ρ) ⟩
f · unfold xs ρ
∎
unfold-lemma (xs ⟨ ∙ ⟩ ys) ρ =
⟦ xs ⟧ ρ ⟨ ∙ ⟩ ⟦ ys ⟧ ρ
≊⟨ ⟨ ∙ ⟩-cong (⟦ xs ⟧ ρ) (unfold xs ρ) (unfold-lemma xs ρ)
(⟦ ys ⟧ ρ) (unfold ys ρ) (unfold-lemma ys ρ) ⟩
unfold xs ρ ⟨ ∙ ⟩ unfold ys ρ
∎
-- The two semantics are related.
main-lemma : ∀ {A n} (xs : Pointwise A n) →
∀ ρ → ⟦ xs ⟧ ρ ≊ lift ⟪ xs ⟫ ρ
main-lemma xs ρ =
⟦ xs ⟧ ρ
≊⟨ unfold-lemma xs ρ ⟩
unfold xs ρ
≡⟨ refl ⟩
⟪ xs ⟫ (Vec.map headP ρ) ≺♯ ⟦ xs ⟧ (Vec.map tailP ρ)
≊⟨ refl ≺ ♯ main-lemma xs (Vec.map tailP ρ) ⟩
lift ⟪ xs ⟫ ρ
∎
------------------------------------------------------------------------
-- To prove that two streams which are defined pointwise are equal, it
-- is enough to reason about a single (arbitrary) point
-- This function is a bit awkward to use, since the user has to come
-- up with a suitable environment manually. The alternative function
-- pointwise below may be slightly easier to use.
pointwise' : ∀ {A n} (xs ys : Pointwise A n) →
(∀ ρ → ⟪ xs ⟫ ρ ≡ ⟪ ys ⟫ ρ) →
(∀ ρ → ⟦ xs ⟧ ρ ≊ ⟦ ys ⟧ ρ)
pointwise' xs ys hyp ρ =
⟦ xs ⟧ ρ
≊⟨ main-lemma xs ρ ⟩
lift ⟪ xs ⟫ ρ
≊⟨ lift-cong hyp ρ ⟩
lift ⟪ ys ⟫ ρ
≊⟨ ≅-sym (main-lemma ys ρ) ⟩
⟦ ys ⟧ ρ
∎
open import Data.Vec.N-ary
-- Applies the function to all possible variables.
app : ∀ {A} n →
N-ary n (Pointwise A n) (Pointwise A n) → Pointwise A n
app n f = f $ⁿ Vec.map var (Vec.allFin n)
-- The type signature of this function may be a bit daunting, but once
-- n, f and g are instantiated with well-behaved concrete values the
-- remaining type evaluates nicely.
pointwise
: ∀ {A} n (f g : N-ary n (Pointwise A n) (Pointwise A n)) →
Eq n _≡_ (curryⁿ ⟪ app n f ⟫) (curryⁿ ⟪ app n g ⟫) →
Eq n _≊_ (curryⁿ ⟦ app n f ⟧) (curryⁿ ⟦ app n g ⟧)
pointwise n f g hyp =
curryⁿ-cong _≊_ ⟦ app n f ⟧ ⟦ app n g ⟧
(pointwise' (app n f) (app n g)
(curryⁿ-cong⁻¹ _≡_ ⟪ app n f ⟫ ⟪ app n g ⟫ hyp))
------------------------------------------------------------------------
-- Some examples
private
example₁ : suc · 0 ∞ ≊ 1 ∞
example₁ = pointwise 0 (suc · 0 ∞) (1 ∞) refl
example₂ : ∀ s → suc · s ≊ 1 ∞ ⟨ _+_ ⟩ s
example₂ = pointwise 1 (λ s → suc · s)
(λ s → 1 ∞ ⟨ _+_ ⟩ s)
(λ _ → refl)
example₃ : ∀ s t u →
(s ⟨ _+_ ⟩ t) ⟨ _+_ ⟩ u ≊ s ⟨ _+_ ⟩ (t ⟨ _+_ ⟩ u)
example₃ = pointwise 3 (λ s t u → (s ⟨ _+_ ⟩ t) ⟨ _+_ ⟩ u)
(λ s t u → s ⟨ _+_ ⟩ (t ⟨ _+_ ⟩ u))
+-assoc
where
open import Data.Nat.Properties
| {
"alphanum_fraction": 0.4973561431,
"avg_line_length": 31.5196078431,
"ext": "agda",
"hexsha": "a967b51db6b7f8f8af079c1b2de4aa3612734dcf",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "1b90445566df0d3b4ba6e31bd0bac417b4c0eb0e",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/codata",
"max_forks_repo_path": "Stream/Pointwise.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "1b90445566df0d3b4ba6e31bd0bac417b4c0eb0e",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/codata",
"max_issues_repo_path": "Stream/Pointwise.agda",
"max_line_length": 72,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "1b90445566df0d3b4ba6e31bd0bac417b4c0eb0e",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/codata",
"max_stars_repo_path": "Stream/Pointwise.agda",
"max_stars_repo_stars_event_max_datetime": "2021-02-13T14:48:45.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-02-13T14:48:45.000Z",
"num_tokens": 2348,
"size": 6430
} |
-- from http://wiki.portal.chalmers.se/agda/pmwiki.php?n=ReferenceManual.LocalDefinition
module Local where
data Nat : Set where
zero : Nat
succ : Nat -> Nat
infixl 5 _+_
_+_ : Nat -> Nat -> Nat
zero + n = n
(succ m) + n = succ (m + n)
infixl 6 _*_
_*_ : Nat -> Nat -> Nat
zero * _ = zero
(succ m) * n = n + m * n
f : Nat
f = let h : Nat -> Nat
h m = succ (succ m)
in h zero + h (succ zero)
t1 : Nat
t1 = f
h : Nat -> Nat
h n = let add2 : Nat
add2 = succ (succ n)
twice : Nat -> Nat
twice m = m * m
in twice add2
g : Nat -> Nat
g n = fib n + fact n
where fib : Nat -> Nat
fib zero = succ zero
fib (succ zero) = succ zero
fib (succ (succ n)) = fib (succ n) + fib n
fact : Nat -> Nat
fact zero = succ zero
fact (succ n) = succ n * fact n
k : Nat -> Nat
k n = let aux : Nat -> Nat
aux m = pred (g m) + h m
in aux (pred n)
where pred : Nat -> Nat
pred zero = zero
pred (succ m) = m
| {
"alphanum_fraction": 0.4741613781,
"avg_line_length": 20.4259259259,
"ext": "agda",
"hexsha": "20158d36df05ce3015237e0c6931bd5fd723f7f1",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "dc333ed142584cf52cc885644eed34b356967d8b",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "andrejtokarcik/agda-semantics",
"max_forks_repo_path": "tests/covered/Local.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "dc333ed142584cf52cc885644eed34b356967d8b",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "andrejtokarcik/agda-semantics",
"max_issues_repo_path": "tests/covered/Local.agda",
"max_line_length": 88,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "dc333ed142584cf52cc885644eed34b356967d8b",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "andrejtokarcik/agda-semantics",
"max_stars_repo_path": "tests/covered/Local.agda",
"max_stars_repo_stars_event_max_datetime": "2018-12-06T17:24:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-08-10T15:33:56.000Z",
"num_tokens": 366,
"size": 1103
} |
{-
This second-order equational theory was created from the following second-order syntax description:
syntax TLC | Λ
type
N : 0-ary
_↣_ : 2-ary | r30
𝟙 : 0-ary
_⊗_ : 2-ary | l40
𝟘 : 0-ary
_⊕_ : 2-ary | l30
term
app : α ↣ β α -> β | _$_ l20
lam : α.β -> α ↣ β | ƛ_ r10
unit : 𝟙
pair : α β -> α ⊗ β | ⟨_,_⟩
fst : α ⊗ β -> α
snd : α ⊗ β -> β
abort : 𝟘 -> α
inl : α -> α ⊕ β
inr : β -> α ⊕ β
case : α ⊕ β α.γ β.γ -> γ
ze : N
su : N -> N
nrec : N α (α,N).α -> α
theory
(ƛβ) b : α.β a : α |> app (lam(x.b[x]), a) = b[a]
(ƛη) f : α ↣ β |> lam (x. app(f, x)) = f
(𝟙η) u : 𝟙 |> u = unit
(fβ) a : α b : β |> fst (pair(a, b)) = a
(sβ) a : α b : β |> snd (pair(a, b)) = b
(pη) p : α ⊗ β |> pair (fst(p), snd(p)) = p
(𝟘η) e : 𝟘 c : α |> abort(e) = c
(lβ) a : α f : α.γ g : β.γ |> case (inl(a), x.f[x], y.g[y]) = f[a]
(rβ) b : β f : α.γ g : β.γ |> case (inr(b), x.f[x], y.g[y]) = g[b]
(cη) s : α ⊕ β c : (α ⊕ β).γ |> case (s, x.c[inl(x)], y.c[inr(y)]) = c[s]
(zeβ) z : α s : (α,N).α |> nrec (ze, z, r m. s[r,m]) = z
(suβ) z : α s : (α,N).α n : N |> nrec (su (n), z, r m. s[r,m]) = s[nrec (n, z, r m. s[r,m]), n]
(ift) t f : α |> if (true, t, f) = t
(iff) t f : α |> if (false, t, f) = f
-}
module TLC.Equality where
open import SOAS.Common
open import SOAS.Context
open import SOAS.Variable
open import SOAS.Families.Core
open import SOAS.Families.Build
open import SOAS.ContextMaps.Inductive
open import TLC.Signature
open import TLC.Syntax
open import SOAS.Metatheory.SecondOrder.Metasubstitution Λ:Syn
open import SOAS.Metatheory.SecondOrder.Equality Λ:Syn
private
variable
α β γ τ : ΛT
Γ Δ Π : Ctx
infix 1 _▹_⊢_≋ₐ_
-- Axioms of equality
data _▹_⊢_≋ₐ_ : ∀ 𝔐 Γ {α} → (𝔐 ▷ Λ) α Γ → (𝔐 ▷ Λ) α Γ → Set where
ƛβ : ⁅ α ⊩ β ⁆ ⁅ α ⁆̣ ▹ ∅ ⊢ (ƛ 𝔞⟨ x₀ ⟩) $ 𝔟 ≋ₐ 𝔞⟨ 𝔟 ⟩
ƛη : ⁅ α ↣ β ⁆̣ ▹ ∅ ⊢ ƛ (𝔞 $ x₀) ≋ₐ 𝔞
𝟙η : ⁅ 𝟙 ⁆̣ ▹ ∅ ⊢ 𝔞 ≋ₐ unit
fβ : ⁅ α ⁆ ⁅ β ⁆̣ ▹ ∅ ⊢ fst (⟨ 𝔞 , 𝔟 ⟩) ≋ₐ 𝔞
sβ : ⁅ α ⁆ ⁅ β ⁆̣ ▹ ∅ ⊢ snd (⟨ 𝔞 , 𝔟 ⟩) ≋ₐ 𝔟
pη : ⁅ α ⊗ β ⁆̣ ▹ ∅ ⊢ ⟨ (fst 𝔞) , (snd 𝔞) ⟩ ≋ₐ 𝔞
𝟘η : ⁅ 𝟘 ⁆ ⁅ α ⁆̣ ▹ ∅ ⊢ abort 𝔞 ≋ₐ 𝔟
lβ : ⁅ α ⁆ ⁅ α ⊩ γ ⁆ ⁅ β ⊩ γ ⁆̣ ▹ ∅ ⊢ case (inl 𝔞) (𝔟⟨ x₀ ⟩) (𝔠⟨ x₀ ⟩) ≋ₐ 𝔟⟨ 𝔞 ⟩
rβ : ⁅ β ⁆ ⁅ α ⊩ γ ⁆ ⁅ β ⊩ γ ⁆̣ ▹ ∅ ⊢ case (inr 𝔞) (𝔟⟨ x₀ ⟩) (𝔠⟨ x₀ ⟩) ≋ₐ 𝔠⟨ 𝔞 ⟩
cη : ⁅ α ⊕ β ⁆ ⁅ (α ⊕ β) ⊩ γ ⁆̣ ▹ ∅ ⊢ case 𝔞 (𝔟⟨ inl x₀ ⟩) (𝔟⟨ inr x₀ ⟩) ≋ₐ 𝔟⟨ 𝔞 ⟩
zeβ : ⁅ α ⁆ ⁅ α · N ⊩ α ⁆̣ ▹ ∅ ⊢ nrec ze 𝔞 (𝔟⟨ x₀ ◂ x₁ ⟩) ≋ₐ 𝔞
suβ : ⁅ α ⁆ ⁅ α · N ⊩ α ⁆ ⁅ N ⁆̣ ▹ ∅ ⊢ nrec (su 𝔠) 𝔞 (𝔟⟨ x₀ ◂ x₁ ⟩) ≋ₐ 𝔟⟨ (nrec 𝔠 𝔞 (𝔟⟨ x₀ ◂ x₁ ⟩)) ◂ 𝔠 ⟩
open EqLogic _▹_⊢_≋ₐ_
open ≋-Reasoning
-- Derived equations
ift : ⁅ α ⁆ ⁅ α ⁆̣ ▹ ∅ ⊢ if true 𝔞 𝔟 ≋ 𝔞
ift = ax lβ with《 unit ◃ 𝔞 ◃ 𝔟 》
iff : ⁅ α ⁆ ⁅ α ⁆̣ ▹ ∅ ⊢ if false 𝔞 𝔟 ≋ 𝔟
iff = ax rβ with《 unit ◃ 𝔞 ◃ 𝔟 》
-- Double beta reduction
ƛβ² : ⁅ β · α ⊩ γ ⁆ ⁅ α ⁆ ⁅ β ⁆̣ ▹ ∅ ⊢ (ƛ (ƛ 𝔞⟨ x₀ ◂ x₁ ⟩)) $ 𝔟 $ 𝔠 ≋ 𝔞⟨ 𝔠 ◂ 𝔟 ⟩
ƛβ² = begin
(ƛ (ƛ 𝔞⟨ x₀ ◂ x₁ ⟩)) $ 𝔟 $ 𝔠
≋⟨ cong[ ax ƛβ with《 (ƛ 𝔞⟨ x₀ ◂ x₁ ⟩) ◃ 𝔟 》 ]inside ◌ᵈ $ 𝔠 ⟩
(ƛ 𝔞⟨ x₀ ◂ 𝔟 ⟩) $ 𝔠
≋⟨ ax ƛβ with《 (𝔞⟨ x₀ ◂ 𝔟 ⟩) ◃ 𝔠 》 ⟩
𝔞⟨ 𝔠 ◂ 𝔟 ⟩
∎
-- Uncurrying and arithmetic
1+2 : ⁅⁆ ▹ ∅ ⊢ uncurry $ plus $ ⟨ su ze , su (su ze) ⟩ ≋ su (su (su ze))
1+2 = begin
uncurry $ plus $ ⟨ su ze , su (su ze) ⟩
≋⟨ thm ƛβ² with《 x₁ $ fst x₀ $ snd x₀ ◃ plus ◃ ⟨ su ze , su (su ze) ⟩ 》 ⟩
plus $ fst ⟨ su ze , su (su ze) ⟩ $ snd ⟨ su ze , su (su ze) ⟩
≋⟨ cong₂[ ax fβ with《 su ze ◃ su (su ze) 》 ][
ax sβ with《 su ze ◃ su (su ze) 》 ]inside plus $ ◌ᵃ $ ◌ᵇ ⟩
plus $ su ze $ su (su ze)
≋⟨ thm ƛβ² with《 nrec x₁ x₀ (su x₀) ◃ su ze ◃ su (su ze) 》 ⟩
nrec (su ze) (su (su ze)) (su x₀)
≋⟨ ax suβ with《 su (su ze) ◃ su x₀ ◃ ze 》 ⟩
su (nrec ze (su (su ze)) (su x₀))
≋⟨ cong[ ax zeβ with《 su (su ze) ◃ su x₀ 》 ]inside su ◌ᵃ ⟩
su (su (su ze))
∎
| {
"alphanum_fraction": 0.4050814957,
"avg_line_length": 35.3559322034,
"ext": "agda",
"hexsha": "586af86547cc5fa4a0337c1dedd4518949e8a40a",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2022-01-24T12:49:17.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-09T20:39:59.000Z",
"max_forks_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "JoeyEremondi/agda-soas",
"max_forks_repo_path": "out/TLC/Equality.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_issues_repo_issues_event_max_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-11-21T12:19:32.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "JoeyEremondi/agda-soas",
"max_issues_repo_path": "out/TLC/Equality.agda",
"max_line_length": 113,
"max_stars_count": 39,
"max_stars_repo_head_hexsha": "ff1a985a6be9b780d3ba2beff68e902394f0a9d8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "JoeyEremondi/agda-soas",
"max_stars_repo_path": "out/TLC/Equality.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-19T17:33:12.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-11-09T20:39:55.000Z",
"num_tokens": 2407,
"size": 4172
} |
{-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Implementation.Data.Unit where
open import Light.Library.Data.Unit using (Library ; Dependencies)
instance dependencies : Dependencies
dependencies = record {}
instance library : Library dependencies
library = record { Implementation }
where
module Implementation where
record Unit : Set where constructor unit
| {
"alphanum_fraction": 0.7476851852,
"avg_line_length": 28.8,
"ext": "agda",
"hexsha": "4ab48c08e942aa3458ce290ec6bb304034d8502b",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "44b1c724f2de95d3a9effe87ca36ef9eca8b4756",
"max_forks_repo_licenses": [
"0BSD"
],
"max_forks_repo_name": "Zambonifofex/lightlib",
"max_forks_repo_path": "Light/Implementation/Data/Unit.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "44b1c724f2de95d3a9effe87ca36ef9eca8b4756",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"0BSD"
],
"max_issues_repo_name": "Zambonifofex/lightlib",
"max_issues_repo_path": "Light/Implementation/Data/Unit.agda",
"max_line_length": 79,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "44b1c724f2de95d3a9effe87ca36ef9eca8b4756",
"max_stars_repo_licenses": [
"0BSD"
],
"max_stars_repo_name": "zamfofex/lightlib",
"max_stars_repo_path": "Light/Implementation/Data/Unit.agda",
"max_stars_repo_stars_event_max_datetime": "2019-12-20T21:33:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-12-20T21:33:05.000Z",
"num_tokens": 76,
"size": 432
} |
-- 2018-09-05, reported by Andreas Abel
-- The new type-directed rewriting was using the wrong type for
-- constructors of parametrized datatypes.
{-# OPTIONS --rewriting #-}
module _ where
module _ (Form : Set) where
open import Agda.Builtin.Equality
{-# BUILTIN REWRITE _≡_ #-}
data Cxt : Set where
_∙_ : (Γ : Cxt) (A : Form) → Cxt
data _≤_ : (Γ Δ : Cxt) → Set where
id≤ : ∀{Γ} → Γ ≤ Γ
lift : ∀{A Γ Δ} (τ : Γ ≤ Δ) → (Γ ∙ A) ≤ (Δ ∙ A)
postulate
lift-id≤ : ∀{Γ A} → lift id≤ ≡ id≤ {Γ ∙ A}
{-# REWRITE lift-id≤ #-}
| {
"alphanum_fraction": 0.5711678832,
"avg_line_length": 21.92,
"ext": "agda",
"hexsha": "3fe8acfbd1721177f140904b9696445cba75702d",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "2fa8ede09451d43647f918dbfb24ff7b27c52edc",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "phadej/agda",
"max_forks_repo_path": "test/Succeed/Issue3211.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "2fa8ede09451d43647f918dbfb24ff7b27c52edc",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "phadej/agda",
"max_issues_repo_path": "test/Succeed/Issue3211.agda",
"max_line_length": 63,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "2fa8ede09451d43647f918dbfb24ff7b27c52edc",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "phadej/agda",
"max_stars_repo_path": "test/Succeed/Issue3211.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 214,
"size": 548
} |
module Syntax.Transitivity where
import Lvl
open import Logic
import Structure.Relator.Names as Names
open import Structure.Relator.Properties
open import Type
private variable ℓ₁ ℓ₂ ℓ₃ : Lvl.Level
private variable T : Type{ℓ₁}
-- The transitivity operator
infixl 1000 _🝖_
_🝖_ : ∀{_▫_ : T → T → Stmt{ℓ₂}} → ⦃ _ : Transitivity(_▫_) ⦄ → Names.Transitivity(_▫_)
_🝖_ {_▫_ = _▫_} = transitivity(_▫_)
_🝖-subₗ_ : ∀{_▫₁_ : T → T → Stmt{ℓ₂}}{_▫₂_ : T → T → Stmt{ℓ₃}} → ⦃ _ : Subtransitivityₗ(_▫₁_)(_▫₂_) ⦄ → Names.Subtransitivityₗ(_▫₁_)(_▫₂_)
_🝖-subₗ_ {_▫₁_ = _▫₁_} {_▫₂_ = _▫₂_} = subtransitivityₗ(_▫₁_)(_▫₂_)
_🝖-subᵣ_ : ∀{_▫₁_ : T → T → Stmt{ℓ₂}}{_▫₂_ : T → T → Stmt{ℓ₃}} → ⦃ _ : Subtransitivityᵣ(_▫₁_)(_▫₂_) ⦄ → Names.Subtransitivityᵣ(_▫₁_)(_▫₂_)
_🝖-subᵣ_ {_▫₁_ = _▫₁_} {_▫₂_ = _▫₂_} = subtransitivityᵣ(_▫₁_)(_▫₂_)
-- Syntax for "equational reasoning" for reflexive-transitive relation
infixr 1 _🝖[_]-[_]_
_🝖[_]-[_]_ : (x : T) → ∀{y z : T} → (_▫_ : T → T → Stmt{ℓ₂}) → ⦃ _ : Transitivity(_▫_) ⦄ → (x ▫ y) → (y ▫ z) → (x ▫ z)
_🝖[_]-[_]_ (_)(_▫_) = transitivity(_▫_)
infixr 1 _🝖[_]-[_]-sym_
_🝖[_]-[_]-sym_ : (x : T) → ∀{y z : T} → (_▫_ : T → T → Stmt{ℓ₂}) → ⦃ _ : Transitivity(_▫_) ⦄ → ⦃ _ : Symmetry(_▫_) ⦄ → (y ▫ x) → (y ▫ z) → (x ▫ z)
_🝖[_]-[_]-sym_ (_)(_▫_) yx yz = transitivity(_▫_) (symmetry(_▫_) yx) (yz)
infixr 1 _🝖[_]-[_]-sub_
_🝖[_]-[_]-sub_ : (x : T) → ∀{y z : T}{_▫₁_ : T → T → Stmt{ℓ₂}} (_▫₂_ : T → T → Stmt{ℓ₃}) → ⦃ _ : Subtransitivityₗ(_▫₁_)(_▫₂_) ⦄ → (x ▫₂ y) → (y ▫₁ z) → (x ▫₁ z)
_🝖[_]-[_]-sub_ (_) {_▫₁_ = _▫₁_} (_▫₂_) = subtransitivityₗ(_▫₁_)(_▫₂_)
infixr 1 _🝖[_]-[_]-super_
_🝖[_]-[_]-super_ : (x : T) → ∀{y z : T} (_▫₁_ : T → T → Stmt{ℓ₂}) {_▫₂_ : T → T → Stmt{ℓ₃}} → ⦃ _ : Subtransitivityᵣ(_▫₁_)(_▫₂_) ⦄ → (x ▫₁ y) → (y ▫₂ z) → (x ▫₁ z)
_🝖[_]-[_]-super_ (_) (_▫₁_) {_▫₂_ = _▫₂_} = subtransitivityᵣ(_▫₁_)(_▫₂_)
infixr 1 _🝖[_]-[]_
_🝖[_]-[]_ : (x : T) → ∀{y : T} → (_▫_ : T → T → Stmt{ℓ₂}) → (x ▫ y) → (x ▫ y)
_🝖[_]-[]_ (_)(_▫_) xy = xy
infixr 2 _🝖-semiend_🝖[_]-end-from-[_]
_🝖-semiend_🝖[_]-end-from-[_] : (x y : T) → (_▫_ : T → T → Stmt{ℓ₂}) → ⦃ _ : Transitivity(_▫_) ⦄ → (x ▫ y) → (x ▫ y)
_🝖-semiend_🝖[_]-end-from-[_] _ _ (_▫_) xy = xy
infixr 2 _🝖[_]-end
_🝖[_]-end : (x : T) → (_▫_ : T → T → Stmt{ℓ₂}) → ⦃ _ : Reflexivity(_▫_) ⦄ → (x ▫ x)
_🝖[_]-end (_)(_▫_) = reflexivity(_▫_)
-- Syntax for "equational reasoning" for reflexive-transitive relations.
-- Example:
-- import Lvl
-- open import Logic
-- open import Structure.Relator.Properties
-- open import Type
-- postulate ℓ₁ ℓ₂ : Lvl.Level
-- postulate T : Type{ℓ₁}
-- postulate _▫_ : T → T → Stmt{ℓ₂}
-- instance postulate trans : Transitivity(_▫_)
-- instance postulate sym : Symmetry (_▫_)
-- instance postulate refl : Reflexivity (_▫_)
-- postulate a b c e : T
-- d = c
-- postulate ab : (a ▫ b)
-- postulate cb : (c ▫ b)
-- postulate de : (d ▫ e)
--
-- ac : (a ▫ e)
-- ac =
-- a 🝖-[ ab ]
-- b 🝖-[ cb ]-sym
-- c 🝖-[]
-- d 🝖-[ de ]
-- e 🝖-end
infixr 1 _🝖-[_]_
_🝖-[_]_ : (x : T) → ∀{y z : T}{_▫_ : T → T → Stmt{ℓ₂}} → ⦃ _ : Transitivity(_▫_) ⦄ → (x ▫ y) → (y ▫ z) → (x ▫ z)
_🝖-[_]_ (_) {_▫_ = _▫_} = transitivity(_▫_)
infixr 1 _🝖-[_]-sym_
_🝖-[_]-sym_ : (x : T) → ∀{y z : T}{_▫_ : T → T → Stmt{ℓ₂}} → ⦃ _ : Transitivity(_▫_) ⦄ → ⦃ _ : Symmetry(_▫_) ⦄ → (y ▫ x) → (y ▫ z) → (x ▫ z)
_🝖-[_]-sym_ (_) {_▫_ = _▫_} yx yz = transitivity(_▫_) (symmetry(_▫_) yx) (yz)
infixr 1 _🝖-[_]-sub_
_🝖-[_]-sub_ : (x : T) → ∀{y z : T}{_▫₁_ : T → T → Stmt{ℓ₂}}{_▫₂_ : T → T → Stmt{ℓ₃}} → ⦃ _ : Subtransitivityₗ(_▫₁_)(_▫₂_) ⦄ → (x ▫₂ y) → (y ▫₁ z) → (x ▫₁ z)
_🝖-[_]-sub_ (_) {_▫₁_ = _▫₁_} {_▫₂_ = _▫₂_} = subtransitivityₗ(_▫₁_)(_▫₂_)
infixr 1 _🝖-[_]-super_
_🝖-[_]-super_ : (x : T) → ∀{y z : T}{_▫₁_ : T → T → Stmt{ℓ₂}}{_▫₂_ : T → T → Stmt{ℓ₃}} → ⦃ _ : Subtransitivityᵣ(_▫₁_)(_▫₂_) ⦄ → (x ▫₁ y) → (y ▫₂ z) → (x ▫₁ z)
_🝖-[_]-super_ (_) {_▫₁_ = _▫₁_} {_▫₂_ = _▫₂_} = subtransitivityᵣ(_▫₁_)(_▫₂_)
infixr 1 _🝖-[]_
_🝖-[]_ : (x : T) → ∀{y : T}{_▫_ : T → T → Stmt{ℓ₂}} → (x ▫ y) → (x ▫ y)
_🝖-[]_ (_) xy = xy
infixr 2 _🝖-semiend_🝖-end-from-[_]
_🝖-semiend_🝖-end-from-[_] : (x y : T) → ∀{_▫_ : T → T → Stmt{ℓ₂}} → ⦃ _ : Transitivity(_▫_) ⦄ → (x ▫ y) → (x ▫ y)
_🝖-semiend_🝖-end-from-[_] _ _ {_▫_ = _▫_} xy = xy
infixr 2 _🝖-end
_🝖-end : (x : T) → ∀{_▫_ : T → T → Stmt{ℓ₂}} → ⦃ _ : Reflexivity(_▫_) ⦄ → (x ▫ x)
_🝖-end x {_▫_} = reflexivity(_▫_)
-- syntax _🝖-[]_ a {b} ab = a 🝖-[ ab ]-end b
| {
"alphanum_fraction": 0.5052036199,
"avg_line_length": 39.4642857143,
"ext": "agda",
"hexsha": "cbbefe66809fca43551aaf7033dc5657c03d9537",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Lolirofle/stuff-in-agda",
"max_forks_repo_path": "Syntax/Transitivity.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "Syntax/Transitivity.agda",
"max_line_length": 163,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Lolirofle/stuff-in-agda",
"max_stars_repo_path": "Syntax/Transitivity.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-05T06:53:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:58:13.000Z",
"num_tokens": 2465,
"size": 4420
} |
module UniDB.Subst.Inst where
open import UniDB.Spec
open import UniDB.Subst.Core
open import UniDB.Subst.Pair
open import UniDB.Subst.Shifts
open import UniDB.Morph.Pair
open import UniDB.Morph.Shift
open import UniDB.Morph.Shifts
open import UniDB.Morph.Unit
-- These are two unused instances. Just to show that ApHComp is slightly
-- stronger than ApPair, but given ApRel then ApPair and ApHComp become
-- equivalent. Unfortunately neither ApPair nor ApHComp imply ApRel but
-- both can be made stronger to do so.
module _
(T : STX) {{vrT : Vr T}} {{wkT : Wk T}} {{apTT : Ap T T}}
(X : STX) {{apTX : Ap T X}} {{apHCompTX : ApHComp T X}}
where
iApPair : ApPair T X
ap-pair {{iApPair}} {Ξ} {Ζ} ξ ζ x = ap-⊡ {T} {X} {Ξ} {Ζ} {Pair Ξ Ζ} ξ ζ x
module _
(T : STX) {{vrT : Vr T}} {{wkT : Wk T}}
(X : STX) {{wkX : Wk X}} {{apTX : Ap T X}}
{{apRelTX : ApRel T X}}
(Ξ : MOR) {{lkTΞ : Lk T Ξ}} {{upΞ : Up Ξ}} {{wkmΞ : Wkm Ξ}}
{{lkUpTΞ : LkUp T Ξ}} {{lkWkmTΞ : LkWkm T Ξ}}
(Ζ : MOR) {{lkTΖ : Lk T Ζ}} {{upΖ : Up Ζ}} {{wkmΖ : Wkm Ζ}}
{{lkUpTΖ : LkUp T Ζ}} {{lkWkmTΖ : LkWkm T Ζ}}
where
ap-wkm-rel : {γ : Dom} (δ : Dom) (x : X γ) →
ap {T} (wkm {Ξ} δ) x ≡ ap {T} (wkm {Ζ} δ) x
ap-wkm-rel {γ} δ = ap-rel≃ {T} lemma
where
lemma : [ T ] wkm {Ξ} {γ} δ ≃ wkm {Ζ} δ
lk≃ lemma i = begin
lk {T} (wkm {Ξ} δ) i ≡⟨ lk-wkm {T} {Ξ} δ i ⟩
vr (wk δ i) ≡⟨ sym (lk-wkm {T} {Ζ} δ i) ⟩
lk {T} (wkm {Ζ} δ) i ∎
module _
(T : STX) {{vrT : Vr T}} {{wkT : Wk T}} {{apTT : Ap T T}}
(X : STX) {{apTX : Ap T X}} {{apPairTX : ApPair T X}} {{apRelTX : ApRel T X}}
where
iApHComp : ApHComp T X
ap-⊡ {{iApHComp}} {Ξ} {Ζ} {Θ} ξ ζ x = begin
ap {T} {X} {Θ} (ξ ⊡ ζ) x ≡⟨ ap-rel≅ {T} (≃-to-≅` lem) x ⟩
ap {T} {X} {Pair Ξ Ζ} (ξ ⊡ ζ) x ≡⟨ ap-pair {T} ξ ζ x ⟩
ap {T} {X} {Ζ} ζ (ap {T} {X} {Ξ} ξ x) ∎
where
lem : (δ : Dom) → [ T ] ((_⊡_ {Θ = Θ} ξ ζ) ↑ δ) ≃ (ξ ⊗ ζ) ↑ δ
lk≃ (lem δ) i = begin
lk {T} {Θ} ((ξ ⊡ ζ) ↑ δ) i ≡⟨ cong (λ ρ → lk {T} {Θ} ρ i) (⊡-↑ {Ξ} {Ζ} {Θ} ξ ζ δ) ⟩
lk {T} {Θ} (ξ ↑ δ ⊡ ζ ↑ δ) i ≡⟨ lk-⊡-ap {T} {Ξ} {Ζ} {Θ} (ξ ↑ δ) (ζ ↑ δ) i ⟩
lk {T} {Pair Ξ Ζ} (ξ ↑ δ ⊗ ζ ↑ δ) i ≡⟨ cong (λ ρ → lk {T} {Pair Ξ Ζ} ρ i) (sym (⊡-↑ {Ξ} {Ζ} {Pair Ξ Ζ} ξ ζ δ)) ⟩
lk {T} {Pair Ξ Ζ} ((ξ ⊗ ζ) ↑ δ) i ∎
module _
(T : STX) {{vrT : Vr T}} {{wkT : Wk T}} {{apTT : Ap T T}}
(X : STX) {{apTX : Ap T X}} {{apPairTX : ApPair T X}} {{apRelTX : ApRel T X}}
where
iApComp : ApComp T X
ap-⊙ {{iApComp}} {Ξ} ξ ζ x = begin
ap {T} (ξ ⊙ ζ) x ≡⟨ ap-rel≅ {T} (≃-to-≅` lem) x ⟩
ap {T} (ξ ⊗ ζ) x ≡⟨ ap-pair {T} ξ ζ x ⟩
ap {T} ζ (ap {T} ξ x) ∎
where
lem : (δ : Dom) → [ T ] (ξ ⊙ ζ) ↑ δ ≃ (ξ ⊗ ζ) ↑ δ
lk≃ (lem δ) i = begin
lk ((ξ ⊙ ζ) ↑ δ) i ≡⟨ cong (λ ρ → lk ρ i) (⊙-↑ ξ ζ δ) ⟩
lk (ξ ↑ δ ⊙ ζ ↑ δ) i ≡⟨ lk-⊙-ap (ξ ↑ δ) (ζ ↑ δ) i ⟩
ap {T} (ζ ↑ δ) (lk (ξ ↑ δ) i) ≡⟨ refl ⟩
lk (ξ ↑ δ ⊗ ζ ↑ δ) i ≡⟨ refl ⟩ -- cong (λ ρ → lk ρ i) (sym (⊡-↑ {Ξ} {Ξ} {Pair Ξ Ξ} ξ ζ δ)) ⟩
lk ((ξ ⊗ ζ) ↑ δ) i ∎
module _
(T : STX) {{vrT : Vr T}} {{wkT : Wk T}} {{apTT : Ap T T}}
{{apVrT : ApVr T}} {{apWkmWkTT : ApWkmWk T T}}
(X : STX) {{wkX : Wk X}} {{apTX : Ap T X}}
{{apWkmWkTX : ApWkmWk T X}}
{{apPairTX : ApPair T X}} {{apRelTX : ApRel T X}}
(Ρ : MOR) {{lkTΡ : Lk T Ρ}} {{upΡ : Up Ρ}} {{lkUpTΡ : LkUp T Ρ}}
{{wkmΡ : Wkm Ρ}} {{lkWkmΡ : LkWkm T Ρ}}
(Ξ : MOR) {{lkTΞ : Lk T Ξ}} {{upΞ : Up Ξ}} {{lkUpTΞ : LkUp T Ξ}}
{{lkUpPairΞΡ : LkUp T (Pair Ξ Ρ)}}
{{lkUpPairΞΡ : LkUp T (Pair Ρ Ξ)}}
where
ap-wk₁-gen : {γ₁ γ₂ : Dom} (ξ : Ξ γ₁ γ₂) (x : X γ₁) →
ap {T} {X} {Ξ} (ξ ↑₁) (wk₁ x) ≡ wk₁ (ap {T} {X} {Ξ} ξ x)
ap-wk₁-gen ξ x = begin
ap {T} (ξ ↑₁) (wk₁ x) ≡⟨ cong (ap {T} (ξ ↑₁)) (sym (ap-wkm-wk₁ {T} {X} {Ρ} x)) ⟩
ap {T} (ξ ↑₁) (ap {T} (wkm {Ρ} 1) x) ≡⟨ sym (ap-pair {T} (wkm {Ρ} 1) (ξ ↑₁) x) ⟩
ap {T} (wkm {Ρ} 1 ⊗ ξ ↑₁) x ≡⟨ ap-rel≃ {T} lem x ⟩
ap {T} (ξ ⊗ wkm {Ρ} 1) x ≡⟨ ap-pair {T} ξ (wkm {Ρ} 1) x ⟩
ap {T} (wkm {Ρ} 1) (ap {T} ξ x) ≡⟨ ap-wkm-wk₁ {T} (ap {T} ξ x) ⟩
wk₁ (ap {T} ξ x)
∎
where
lem : [ T ] (wkm {Ρ} 1 ⊗ ξ ↑₁) ≃ (ξ ⊗ wkm {Ρ} 1)
lk≃ lem i = begin
ap {T} (ξ ↑₁) (lk {T} (wkm {Ρ} 1) i) ≡⟨ cong (ap {T} (_↑₁ ξ)) (lk-wkm {T} {Ρ} 1 i) ⟩
ap {T} (ξ ↑₁) (vr (suc i)) ≡⟨ ap-vr {T} (ξ ↑₁) (suc i) ⟩
lk {T} (ξ ↑₁) (suc i) ≡⟨ lk-↑₁-suc {T} ξ i ⟩
wk₁ (lk {T} ξ i) ≡⟨ sym (ap-wkm-wk₁ {T} (lk {T} ξ i)) ⟩
ap {T} (wkm {Ρ} 1) (lk {T} ξ i) ∎
module _
(T : STX) {{vrT : Vr T}} {{wkT : Wk T}} {{apTT : Ap T T}}
{{wkVrT : WkVr T}}
{{apVrT : ApVr T}} {{apWkmWkTT : ApWkmWk T T}}
{{apPairTT : ApPair T T}} {{apRelTT : ApRel T T}}
(X : STX) {{wkX : Wk X}} {{apTX : Ap T X}}
{{apWkmWkTX : ApWkmWk T X}}
{{apPairTX : ApPair T X}} {{apRelTX : ApRel T X}}
where
private
Ren : MOR
Ren = Shift
iApWk : ApWk T X
ap-wk₁ {{iApWk}} {Ξ} = ap-wk₁-gen T X Ren Ξ
where
instance
iLkUpRenRen : LkUp T (Pair Ren Ren)
iLkUpRenRen = iLkUpPairRenaming T Ren Ren
iLkUpRenΞ : LkUp T (Pair Ren Ξ)
iLkUpRenΞ = iLkUpPairRenaming T Ren Ξ
iLkUpΞRen : LkUp T (Pair Ξ Ren)
iLkUpΞRen = iLkUpPairSubstitution T Ξ Ren
(ap-wk₁-gen T T Ren Ren)
{-
module _
(T : STX) {{vrT : Vr T}} {{wkT : Wk T}} {{apTT : Ap T T}}
{{wkVrT : WkVr T}} {{apVrT : ApVr T}}
(X : STX) {{wkX : Wk X}} {{apTX : Ap T X}}
{{apWkmWkTX : ApWkmWk T X}} {{apIdmTX : ApIdm T X}} {{apCompTX : ApComp T X}}
where
private
module _
(Ξ : MOR) {{lkTΞ : Lk T Ξ}} {{upΞ : Up Ξ}}
{{idmΞ : Idm Ξ}} {{wkmΞ : Wkm Ξ}} {{compΞ : Comp Ξ}}
{{lkUpTΞ : LkUp T Ξ}} {{lkWkmTΞ : LkWkm T Ξ}} {{lkIdmTΞ : LkIdm T Ξ}}
{{upIdmΞ : UpIdm Ξ}} {{upCompΞ : UpComp Ξ}} {{lkCompTΞ : LkCompAp T Ξ}}
{{wkmHomΞ : WkmHom Ξ}}
where
iWkHom` : WkHom X
wk-zero {{iWkHom`}} x = begin
wk 0 x ≡⟨ sym (ap-wkm-wk T X Ξ 0 x) ⟩
ap T X Ξ (wkm Ξ 0) x ≡⟨ cong (λ ξ → ap T X Ξ ξ x) (wkm-zero Ξ) ⟩
ap T X Ξ (idm Ξ _) x ≡⟨ ap-idm T X Ξ x ⟩
x ∎
wk-suc {{iWkHom`}} δ x = begin
wk (suc δ) x ≡⟨ sym (ap-wkm-wk T X Ξ (suc δ) x) ⟩
ap T X Ξ (wkm Ξ (suc δ)) x ≡⟨ cong (λ ξ → ap T X Ξ ξ x) (wkm-suc Ξ δ) ⟩
ap T X Ξ (wkm Ξ δ ⊙ wkm Ξ 1) x ≡⟨ ap-⊙ T X Ξ (wkm Ξ δ) (wkm Ξ 1) x ⟩
ap T X Ξ (wkm Ξ 1) (ap T X Ξ (wkm Ξ δ) x) ≡⟨ ap-wkm-wk₁ T X Ξ (ap T X Ξ (wkm Ξ δ) x) ⟩
wk₁ (ap T X Ξ (wkm Ξ δ) x) ≡⟨ cong wk₁ (ap-wkm-wk T X Ξ δ x) ⟩
wk₁ (wk δ x) ∎
iWkHom : WkHom X
iWkHom = iWkHom` Shifts
-}
| {
"alphanum_fraction": 0.4428840307,
"avg_line_length": 39.9248554913,
"ext": "agda",
"hexsha": "4a9353e58127bb44955e3257fbbe42e610424470",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "7ae52205db44ad4f463882ba7e5082120fb76349",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "skeuchel/unidb-agda",
"max_forks_repo_path": "UniDB/Subst/Inst.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7ae52205db44ad4f463882ba7e5082120fb76349",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "skeuchel/unidb-agda",
"max_issues_repo_path": "UniDB/Subst/Inst.agda",
"max_line_length": 120,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "7ae52205db44ad4f463882ba7e5082120fb76349",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "skeuchel/unidb-agda",
"max_stars_repo_path": "UniDB/Subst/Inst.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 3630,
"size": 6907
} |
{-# OPTIONS --copatterns #-}
module Issue950a where
postulate
A : Set
record R : Set where
field
x : A
record S : Set where
field
y : A
open R
f : A
x f = ?
-- Bad error:
-- Arguments left we cannot split on. TODO: better error message
-- when checking that the clause x f = ? has type A
-- Better error:
-- Cannot eliminate type A with projection pattern x
-- when checking that the clause x f = ? has type A
| {
"alphanum_fraction": 0.6543778802,
"avg_line_length": 14.4666666667,
"ext": "agda",
"hexsha": "9c0e057bb7da555071c236cbc56fed6606ec4e37",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Fail/Issue950a.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Fail/Issue950a.agda",
"max_line_length": 64,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Fail/Issue950a.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 120,
"size": 434
} |
module FFI.System.Exit where
open import Agda.Builtin.Int using (Int)
open import Agda.Builtin.IO using (IO)
open import Agda.Builtin.Unit using (⊤)
data ExitCode : Set where
ExitSuccess : ExitCode
ExitFailure : Int → ExitCode
{-# FOREIGN GHC data AgdaExitCode = AgdaExitSuccess | AgdaExitFailure Integer #-}
{-# COMPILE GHC ExitCode = data AgdaExitCode (AgdaExitSuccess | AgdaExitFailure) #-}
{-# FOREIGN GHC import qualified System.Exit #-}
{-# FOREIGN GHC
toExitCode :: AgdaExitCode -> System.Exit.ExitCode
toExitCode AgdaExitSuccess = System.Exit.ExitSuccess
toExitCode (AgdaExitFailure n) = System.Exit.ExitFailure (fromIntegral n)
fromExitCode :: System.Exit.ExitCode -> AgdaExitCode
fromExitCode System.Exit.ExitSuccess = AgdaExitSuccess
fromExitCode (System.Exit.ExitFailure n) = AgdaExitFailure (fromIntegral n)
#-}
postulate
exitWith : ExitCode → IO ⊤
{-# COMPILE GHC exitWith = System.Exit.exitWith . toExitCode #-}
| {
"alphanum_fraction": 0.7651434644,
"avg_line_length": 31.3666666667,
"ext": "agda",
"hexsha": "fcf01395eca5bfb2d677d07b7d7c8a5404f87ce2",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "362428f8b4b6f5c9d43f4daf55bcf7873f536c3f",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "XanderYZZ/luau",
"max_forks_repo_path": "prototyping/FFI/System/Exit.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "362428f8b4b6f5c9d43f4daf55bcf7873f536c3f",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "XanderYZZ/luau",
"max_issues_repo_path": "prototyping/FFI/System/Exit.agda",
"max_line_length": 84,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "72d8d443431875607fd457a13fe36ea62804d327",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "TheGreatSageEqualToHeaven/luau",
"max_stars_repo_path": "prototyping/FFI/System/Exit.agda",
"max_stars_repo_stars_event_max_datetime": "2021-12-05T21:53:03.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-12-05T21:53:03.000Z",
"num_tokens": 248,
"size": 941
} |
module Issue566 where
open import Common.Level using (Level; _⊔_)
data D (a : Level) (A : Set a) : Set a where
d : D a A → D a A
P-level : (a : Level) (A : Set a) → D a A → Level
P-level a A (d x) = P-level a A x
P : (a : Level) (A : Set a) (x : D a A) → Set (P-level a A x)
P a A (d x) = P a A x
postulate
a : Level
E : (b : Level) → Set b → Set a → Set (a ⊔ b)
Q : (A : Set a) → D a A → Set a
e : (A : Set a) (x : D a A) → E (P-level a A x) (P a A x) (Q A x)
A : Set a
x : D a A
foo : E (P-level a A x) (P a A x) (Q A x)
foo = e _ _
-- Bug.agda:23,7-12
-- P-level a A x ⊔ a != P-level a A x ⊔ a of type Level
-- when checking that the expression e _ _ has type
-- E (P-level a A x) (P a A x) (Q A x)
| {
"alphanum_fraction": 0.5216178522,
"avg_line_length": 23.9,
"ext": "agda",
"hexsha": "afb575e5ce7f1489d69133ea6ea677342ca3c986",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue566.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue566.agda",
"max_line_length": 66,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue566.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 307,
"size": 717
} |
-- MIT License
-- Copyright (c) 2021 Luca Ciccone and Luca Padovani
-- Permission is hereby granted, free of charge, to any person
-- obtaining a copy of this software and associated documentation
-- files (the "Software"), to deal in the Software without
-- restriction, including without limitation the rights to use,
-- copy, modify, merge, publish, distribute, sublicense, and/or sell
-- copies of the Software, and to permit persons to whom the
-- Software is furnished to do so, subject to the following
-- conditions:
-- The above copyright notice and this permission notice shall be
-- included in all copies or substantial portions of the Software.
-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-- OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-- HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-- WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-- FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-- OTHER DEALINGS IN THE SOFTWARE.
{-# OPTIONS --guardedness --sized-types #-}
open import Data.Empty
open import Data.Unit
open import Data.Product
open import Data.Maybe
open import Data.Sum
open import Data.List using (_++_; []; _∷_; _∷ʳ_; length)
open import Data.List.Properties using (∷-injective)
open import Relation.Nullary
open import Relation.Nullary.Negation using (contraposition)
open import Relation.Unary using (_∈_; _⊆_)
open import Relation.Binary.PropositionalEquality using (_≡_; _≢_; refl; sym; subst; cong)
open import Function.Base using (case_of_)
open import Common
module Divergence {ℙ : Set} (message : Message ℙ)
where
open import SessionType message
open import Session message
open import Trace message
open import HasTrace message
open import TraceSet message
open import Transitions message
open import Semantics message
open import Subtyping message
DivergeForward : SessionType -> SessionType -> Trace -> Set
record _↑_ (T : SessionType) (S : SessionType) : Set where
coinductive
field
trace : Trace
with-trace : T HasTrace trace
without-trace : ¬ S HasTrace trace
divergence : DivergeForward T S trace
DivergeForward T S φ =
∀{ψ x}
(pre : ψ ⊑ φ)
(tψx : T HasTrace (ψ ∷ʳ O x))
(sψx : S HasTrace (ψ ∷ʳ O x)) -> after tψx ↑ after sψx
diverge-before-input : ∀{f g x} -> f x .force ↑ g x .force -> inp f ↑ inp g
_↑_.trace (diverge-before-input {_} {_} {x} div) = I x ∷ _↑_.trace div
_↑_.with-trace (diverge-before-input div) = inp-has-trace (_↑_.with-trace div)
_↑_.without-trace (diverge-before-input div) = inp-has-no-trace (_↑_.without-trace div)
_↑_.divergence (diverge-before-input div) none (_ , _ , step () _) _
_↑_.divergence (diverge-before-input div) (some le) (_ , tdef , step inp tr) (_ , sdef , step inp sr) =
_↑_.divergence div le (_ , tdef , tr) (_ , sdef , sr)
DivergeBackward : ∀{T S φ} -> T HasTrace φ -> S HasTrace φ -> Set
DivergeBackward {_} {_} {φ} tφ sφ =
∀{ψ} (pre : ψ ⊑ φ) -> after (⊑-has-trace pre tφ) ↑ after (⊑-has-trace pre sφ)
⊑-diverge-backward :
∀{T S φ ψ}
{tφ : T HasTrace φ}
{sφ : S HasTrace φ}
(pre : ψ ⊑ φ) ->
DivergeBackward tφ sφ ->
DivergeBackward (⊑-has-trace pre tφ) (⊑-has-trace pre sφ)
⊑-diverge-backward {_} {_} {_} {_} {tφ} {sφ} pre div pre' rewrite ⊑-tran-has-trace pre' pre tφ | ⊑-tran-has-trace pre' pre sφ =
div (⊑-tran pre' pre)
data DiscSet : SessionType -> SessionType -> Trace -> Set where
inc : ∀{T S φ}
(tφ : T HasTrace φ)
(sφ : S HasTrace φ)
(div←φ : DivergeBackward tφ sφ) -> DiscSet T S φ
exc : ∀{T S φ ψ x}
(eq : φ ≡ ψ ∷ʳ O x)
(tψ : T HasTrace ψ)
(sψ : S HasTrace ψ)
(tφ : T HasTrace φ)
(nsφ : ¬ S HasTrace φ)
(div←ψ : DivergeBackward tψ sψ) -> DiscSet T S φ
⊑-proper : ∀{φ ψ α} -> φ ⊑ (ψ ∷ʳ α) -> φ ⊑ ψ ⊎ φ ≡ ψ ∷ʳ α
⊑-proper {[]} {[]} none = inj₁ none
⊑-proper {_ ∷ []} {[]} (some none) = inj₂ refl
⊑-proper {[]} {_ ∷ _} none = inj₁ none
⊑-proper {_} {_ ∷ _} (some pre) with ⊑-proper pre
... | inj₁ pre' = inj₁ (some pre')
... | inj₂ refl = inj₂ refl
disc-set->closed : (T S : SessionType) -> PrefixClosed (DiscSet T S)
disc-set->closed T S pre (inc tφ sφ div←φ) =
inc (⊑-has-trace pre tφ) (⊑-has-trace pre sφ) (⊑-diverge-backward pre div←φ)
disc-set->closed T S pre (exc refl tψ sψ tφ nsφ div←ψ) with ⊑-proper pre
... | inj₁ pre' = inc (⊑-has-trace pre' tψ) (⊑-has-trace pre' sψ) (⊑-diverge-backward pre' div←ψ)
... | inj₂ refl = exc refl tψ sψ tφ nsφ div←ψ
input-lemma : ∀{φ x ψ χ y} -> φ ++ I x ∷ ψ ≡ χ ∷ʳ O y -> (φ ∷ʳ I x) ⊑ χ
input-lemma {[]} {_} {_} {I x ∷ χ} refl = some none
input-lemma {x ∷ φ} {_} {_} {[]} eq with ∷-injective eq
... | (_ , eq') = ⊥-elim (absurd-++-≡ eq')
input-lemma {x ∷ φ} {_} {_} {y ∷ χ} eq with ∷-injective eq
... | (refl , eq'') = some (input-lemma eq'')
disc-set-input : ∀{φ x ψ} {T S : SessionType} -> DiscSet T S (φ ++ I x ∷ ψ) ->
T HasTrace (φ ∷ʳ I x) × S HasTrace (φ ∷ʳ I x)
disc-set-input {φ} {x} {ψ} (inc tφ sφ div←φ) with ⊑-precong-++ {φ} {I x ∷ []} {I x ∷ ψ} (some none)
... | pre = ⊑-has-trace pre tφ , ⊑-has-trace pre sφ
disc-set-input (exc eq tχ sχ _ _ _) with input-lemma eq
... | pre = ⊑-has-trace pre tχ , ⊑-has-trace pre sχ
disc-set-output : ∀{φ x ψ} {T S : SessionType} -> DiscSet T S (φ ++ O x ∷ ψ) -> T HasTrace (φ ∷ʳ O x)
disc-set-output {φ} {x} {ψ} (inc tφx sφx _) =
let pre = ⊑-precong-++ {φ} {O x ∷ []} {O x ∷ ψ} (some none) in
⊑-has-trace pre tφx
disc-set-output {φ} {x} {ψ} (exc _ _ _ tφx _ _) =
let pre = ⊑-precong-++ {φ} {O x ∷ []} {O x ∷ ψ} (some none) in
⊑-has-trace pre tφx
disc-set->coherent : (T S : SessionType) -> Coherent (DiscSet T S)
disc-set->coherent T S ti to =
let (ti[] , _) = disc-set-input ti in
let to[] = disc-set-output to in
⊥-elim (coherent (sem-sound T) ti[] to[])
disc-set->semantics : (T S : SessionType) -> Semantics (DiscSet T S)
closed (disc-set->semantics T S) = disc-set->closed T S
coherent (disc-set->semantics T S) = disc-set->coherent T S
disc-set-subset : ∀{T S} -> DiscSet T S ⊆ ⟦ T ⟧
disc-set-subset (inc tφ _ _) = tφ
disc-set-subset (exc _ _ _ tφ _ _) = tφ
disc-set-disjoint :
∀{T S φ} ->
φ ∈ DiscSet T S ->
¬ S HasTrace φ ->
∃[ ψ ] ∃[ x ] (φ ≡ ψ ∷ʳ O x × S HasTrace ψ)
disc-set-disjoint (inc _ sφ _) nsφ = ⊥-elim (nsφ sφ)
disc-set-disjoint (exc eq _ sψ _ _ _) nsφ = _ , _ , eq , sψ
-- --| BEGIN MAXIMAL TRACES |--
diverge-forward-input :
∀{f g x φ} -> DivergeForward (inp f) (inp g) (I x ∷ φ)
-> DivergeForward (f x .force) (g x .force) φ
diverge-forward-input div pre (_ , tdef , tr) (_ , sdef , sr) = div (some pre) (_ , tdef , step inp tr) (_ , sdef , step inp sr)
diverge-forward-input' :
∀{f g x φ} -> DivergeForward (f x .force) (g x .force) φ
-> DivergeForward (inp f) (inp g) (I x ∷ φ)
diverge-forward-input' div none (_ , _ , step () _) (_ , _ , _)
diverge-forward-input' div (some le) (_ , tdef , step inp tr) (_ , sdef , step inp sr) = div le (_ , tdef , tr) (_ , sdef , sr)
diverge-forward-output :
∀{f g x φ} -> DivergeForward (out f) (out g) (O x ∷ φ)
-> DivergeForward (f x .force) (g x .force) φ
diverge-forward-output div pre (_ , tdef , tr) (_ , sdef , sr) =
div (some pre)
(_ , tdef , step (out (transitions+defined->defined tr tdef)) tr)
(_ , sdef , step (out (transitions+defined->defined sr sdef)) sr)
-- the next lemma says that if T ↑ S and φ is the trace that
-- discriminates between them, then we have divergence along any
-- common prefix of φ shared by both T and S
diverge-forward->backward :
∀{T S φ ψ}
(tφ : T HasTrace φ)
(nsφ : ¬ S HasTrace φ)
(div : DivergeForward T S φ)
(pre : ψ ⊑ φ)
(tψ : T HasTrace ψ)
(sψ : S HasTrace ψ) ->
DivergeBackward tψ sψ
_↑_.trace (diverge-forward->backward tφ nsφ div pre tψ sψ none) = _
_↑_.with-trace (diverge-forward->backward tφ nsφ div pre tψ sψ none) = tφ
_↑_.without-trace (diverge-forward->backward tφ nsφ div pre tψ sψ none) = nsφ
_↑_.divergence (diverge-forward->backward tφ nsφ div pre tψ sψ none) = div
diverge-forward->backward (_ , tdef , step inp tr) nsφ div (some pre) (_ , tdef' , step (inp {f}) tr') (_ , sdef , step (inp {g}) sr) (some pre') =
diverge-forward->backward (_ , tdef , tr) (contraposition inp-has-trace nsφ) (diverge-forward-input {f} {g} div) pre (_ , tdef' , tr') (_ , sdef , sr) pre'
diverge-forward->backward (_ , tdef , step (out _) tr) nsφ div (some pre) (_ , tdef' , step (out {f} _) tr') (_ , sdef , step (out {g} _) sr) (some pre') =
diverge-forward->backward (_ , tdef , tr) (contraposition out-has-trace nsφ) (diverge-forward-output {f} {g} div) pre (_ , tdef' , tr') (_ , sdef , sr) pre'
prefix-last-element : ∀{φ φ' ψ ψ' x y} -> φ ⊑ ψ -> φ ≡ φ' ++ O x ∷ [] -> ψ ≡ ψ' ∷ʳ O y -> ψ ≡ φ ⊎ φ ⊑ ψ'
prefix-last-element none e1 e2 = inj₂ none
prefix-last-element {φ' = []} {ψ' = []} (some pre) e1 e2 with ∷-injective e1 | ∷-injective e2
... | (_ , e1') | (_ , e2') rewrite e1' | e2' = inj₁ refl
prefix-last-element {φ' = []} {ψ' = x ∷ ψ'} (some _) e1 e2 with ∷-injective e1 | ∷-injective e2
... | (eq1 , e1') | (eq2 , e2') rewrite eq1 | eq2 | e1' | e2' = inj₂ (some none)
prefix-last-element {φ' = x ∷ φ'} {ψ' = []} (some pre) e1 e2 with ∷-injective e1 | ∷-injective e2
... | (eq1 , e1') | (eq2 , e2') rewrite e1' | e2' = ⊥-elim (absurd-++-⊑ pre)
prefix-last-element {φ' = x ∷ φ'} {ψ' = x₁ ∷ ψ'} (some pre) e1 e2 with ∷-injective e1 | ∷-injective e2
... | (eq1 , e1') | (eq2 , e2') rewrite eq1 | eq2 with prefix-last-element pre e1' e2'
... | inj₁ eq rewrite eq = inj₁ refl
... | inj₂ pre' = inj₂ (some pre')
disc-set-maximal-1 :
∀{T S φ} ->
φ ∈ DiscSet T S ->
¬ S HasTrace φ ->
φ ∈ Maximal (DiscSet T S)
disc-set-maximal-1 dsφ nsφ with disc-set-disjoint dsφ nsφ
... | _ , _ , refl , sψ =
maximal dsφ λ le ds' ->
let _ , _ , eq , sψ' = disc-set-disjoint ds' (contraposition (⊑-has-trace le) nsφ) in
case prefix-last-element le refl eq of λ
{ (inj₁ refl) → refl
; (inj₂ le') → ⊥-elim (contraposition (⊑-has-trace le') nsφ sψ') }
has-trace-after : ∀{T φ ψ} (tφ : T HasTrace φ) -> after tφ HasTrace ψ -> T HasTrace (φ ++ ψ)
has-trace-after (_ , _ , refl) tφψ = tφψ
has-trace-after (_ , tdef , step inp tr) tφψ = inp-has-trace (has-trace-after (_ , tdef , tr) tφψ)
has-trace-after (_ , tdef , step (out _) tr) tφψ = out-has-trace (has-trace-after (_ , tdef , tr) tφψ)
has-no-trace-after : ∀{T φ ψ} (tφ : T HasTrace φ) -> ¬ after tφ HasTrace ψ -> ¬ T HasTrace (φ ++ ψ)
has-no-trace-after (_ , _ , refl) tφ/nψ = tφ/nψ
has-no-trace-after (_ , tdef , step inp tr) tφ/nψ = inp-has-no-trace (has-no-trace-after (_ , tdef , tr) tφ/nψ)
has-no-trace-after (_ , tdef , step (out _) tr) tφ/nψ = out-has-no-trace (has-no-trace-after (_ , tdef , tr) tφ/nψ)
append-diverge-backward :
∀{T S φ ψ}
(tφ : T HasTrace φ)
(sφ : S HasTrace φ)
(tφ/ψ : after tφ HasTrace ψ)
(sφ/ψ : after sφ HasTrace ψ)
(div←φ : DivergeBackward tφ sφ)
(divφ←ψ : DivergeBackward tφ/ψ sφ/ψ) ->
DivergeBackward (has-trace-after tφ tφ/ψ) (has-trace-after sφ sφ/ψ)
append-diverge-backward (_ , tdef , refl) (_ , sdef , refl) tφ/ψ sφ/ψ div←φ divφ←ψ pre = divφ←ψ pre
append-diverge-backward (_ , tdef , step t tr) (_ , sdef , step s sr) tφ/ψ sφ/ψ div←φ divφ←ψ none = div←φ none
append-diverge-backward (_ , tdef , step inp tr) (_ , sdef , step inp sr) tφ/ψ sφ/ψ div←φ divφ←ψ (some pre) =
append-diverge-backward (_ , tdef , tr) (_ , sdef , sr) tφ/ψ sφ/ψ (λ pre -> div←φ (some pre)) divφ←ψ pre
append-diverge-backward (_ , tdef , step (out _) tr) (_ , sdef , step (out _) sr) tφ/ψ sφ/ψ div←φ divφ←ψ (some pre) =
append-diverge-backward (_ , tdef , tr) (_ , sdef , sr) tφ/ψ sφ/ψ (λ pre -> div←φ (some pre)) divφ←ψ pre
append-snoc : ∀{φ ψ : Trace}{α : Action} -> φ ++ (ψ ∷ʳ α) ≡ (φ ++ ψ) ∷ʳ α
append-snoc {[]} = refl
append-snoc {β ∷ φ} = cong (β ∷_) (append-snoc {φ})
completion :
∀{φ T S} ->
T <: S ->
φ ∈ DiscSet T S ->
(∃[ ψ ] (φ ⊏ ψ × ψ ∈ Maximal (DiscSet T S))) ⊎ (φ ∈ Maximal (DiscSet T S) × ¬ S HasTrace φ)
completion {φ} sub (inc tφ sφ div←φ) with div←φ (⊑-refl _)
... | div rewrite ⊑-has-trace-after tφ | ⊑-has-trace-after sφ =
let χ = _↑_.trace div in
let tφ/χ = _↑_.with-trace div in
let sφ/nχ = _↑_.without-trace div in
let divφ→χ = _↑_.divergence div in
let subφ = sub-after tφ sφ sub in
let ψ , x , ψ⊑χ , tφ/ψ , sφ/ψ , tφ/ψx , sφ/nψx = sub-excluded subφ tφ/χ sφ/nχ in
let tφψ = has-trace-after tφ tφ/ψ in
let sφψ = has-trace-after sφ sφ/ψ in
let tφψx = has-trace-after tφ tφ/ψx in
let sφnψx = has-no-trace-after sφ sφ/nψx in
let divφ←ψ = diverge-forward->backward tφ/χ sφ/nχ divφ→χ ψ⊑χ tφ/ψ sφ/ψ in
let div←ψ = append-diverge-backward tφ sφ tφ/ψ sφ/ψ div←φ divφ←ψ in
let ds = exc {_} {_} {φ ++ (ψ ∷ʳ O x)} {φ ++ ψ} {x} (append-snoc {φ} {ψ} {O x}) tφψ sφψ tφψx sφnψx div←ψ in
inj₁ (φ ++ (ψ ∷ʳ O x) , ⊏-++ , disc-set-maximal-1 ds sφnψx)
completion sub ds@(exc _ _ _ _ nsφ _) =
inj₂ (disc-set-maximal-1 ds nsφ , nsφ)
disc-set-maximal-2 :
∀{T S φ} ->
T <: S ->
φ ∈ Maximal (DiscSet T S) ->
¬ S HasTrace φ
disc-set-maximal-2 sub (maximal dφ F) sφ with completion sub dφ
... | inj₁ (ψ , φ⊏ψ , maximal dψ _) = ⊏->≢ φ⊏ψ (sym (F (⊏->⊑ φ⊏ψ) dψ))
... | inj₂ (_ , nsφ) = nsφ sφ
--| END MAXIMAL TRACES |--
-- Sia R il session type determinato da disc-set T S quando T ↑
-- S. L'obiettivo è dimostrare che R |- T e ¬ R |- S
--
-- R |- T
--
-- Ogni riduzione di (R # T) può essere completata a (R' # T') in
-- cui Win R' e Defined T'
--
-- Siccome le tracce di R sono incluse in quelle di T, basta
-- dimostrare che ogni traccia di R può essere completata, cioè che
-- ogni traccia di disc-set T S è prefisso di una traccia completa
-- di disc-set T S.
--
-- ∀ φ ∈ R => ∃ ψ : φ ++ ψ ∈ Maximal R
--
-- ¬ R |- S
--
-- Dimostrare che ogni traccia completa di R non è una traccia di S.
--
-- Maximal R ∩ ⟦ S ⟧ ≡ ∅
| {
"alphanum_fraction": 0.6159816039,
"avg_line_length": 43.3520249221,
"ext": "agda",
"hexsha": "43fb3dd079ddee5e344a43fe48590b814deaa3be",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "c4b78e70c3caf68d509f4360b9171d9f80ecb825",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "boystrange/FairSubtypingAgda",
"max_forks_repo_path": "src/Divergence.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c4b78e70c3caf68d509f4360b9171d9f80ecb825",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "boystrange/FairSubtypingAgda",
"max_issues_repo_path": "src/Divergence.agda",
"max_line_length": 158,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "c4b78e70c3caf68d509f4360b9171d9f80ecb825",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "boystrange/FairSubtypingAgda",
"max_stars_repo_path": "src/Divergence.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-24T14:38:47.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-07-29T14:32:30.000Z",
"num_tokens": 5499,
"size": 13916
} |
module Lvl.MultiFunctions.Proofs where
open import Data
open import Lvl hiding (𝐒)
open import Lvl.MultiFunctions
open import Data.Tuple.Raise
open import Data.Tuple.Raiseᵣ.Functions
open import Lvl.MultiFunctions
open import Numeral.Natural
open import Relator.Equals
open import Syntax.Number
max-repeat : ∀{n}{ℓ} → ((ℓ ⊔ (⨆(repeat n ℓ))) ≡ ℓ)
max-repeat {n = 0} = [≡]-intro
max-repeat {n = 1} = [≡]-intro
max-repeat {n = 𝐒(𝐒(n))} = max-repeat {n = 𝐒(n)}
{- TODO: Is this possible?
open import Relator.Equals.Proofs
test2 : ∀{a b} → (eq : a ≡ b) → ([≡]-substitutionᵣ eq {\n → Set(n)} (Set(a)) ≡ Set(b))
test2 : ∀{a b} → (a ≡ b) → (Set(a) ≡ Set(b))
postulate ℓ : Level
postulate n : ℕ
postulate s : Set(ℓ ⊔ (⨆{n} (repeat n ℓ)))
postulate p : Set(ℓ) → Set
want : Set
want rewrite max-repeat{n}{ℓ} = p s
-}
| {
"alphanum_fraction": 0.6387878788,
"avg_line_length": 25,
"ext": "agda",
"hexsha": "7c33fbee060fbda5ceb30515b63a8cdd81323b4e",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Lolirofle/stuff-in-agda",
"max_forks_repo_path": "Lvl/MultiFunctions/Proofs.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "Lvl/MultiFunctions/Proofs.agda",
"max_line_length": 86,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Lolirofle/stuff-in-agda",
"max_stars_repo_path": "Lvl/MultiFunctions/Proofs.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-05T06:53:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:58:13.000Z",
"num_tokens": 313,
"size": 825
} |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Setoids.Setoids
open import Functions.Definition
open import Sets.EquivalenceRelations
open import Rings.Definition
module Rings.Divisible.Lemmas {a b : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ _*_ : A → A → A} (R : Ring S _+_ _*_) where
open Setoid S
open Equivalence eq
open Ring R
open import Rings.Divisible.Definition R
open import Rings.Units.Definition R
divisionTransitive : (x y z : A) → x ∣ y → y ∣ z → x ∣ z
divisionTransitive x y z (a , pr) (b , pr2) = (a * b) , transitive (transitive *Associative (*WellDefined pr reflexive)) pr2
divisionReflexive : (x : A) → x ∣ x
divisionReflexive x = 1R , transitive *Commutative identIsIdent
everythingDividesZero : (r : A) → r ∣ 0R
everythingDividesZero r = 0R , timesZero
nonzeroInherits : {x y : A} (nz : (x ∼ 0R) → False) → y ∣ x → (y ∼ 0R) → False
nonzeroInherits {x} {y} nz (c , pr) y=0 = nz (transitive (symmetric pr) (transitive (*WellDefined y=0 reflexive) (transitive *Commutative timesZero)))
nonunitInherits : {x y : A} (nonunit : Unit x → False) → x ∣ y → Unit y → False
nonunitInherits nu (s , pr) (a , b) = nu ((s * a) , transitive (transitive *Associative (*WellDefined pr reflexive)) b)
| {
"alphanum_fraction": 0.6825775656,
"avg_line_length": 40.5483870968,
"ext": "agda",
"hexsha": "70623075906105b8808b7011e1efe30267009678",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-29T13:23:07.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-29T13:23:07.000Z",
"max_forks_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Smaug123/agdaproofs",
"max_forks_repo_path": "Rings/Divisible/Lemmas.agda",
"max_issues_count": 14,
"max_issues_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_issues_repo_issues_event_max_datetime": "2020-04-11T11:03:39.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-06T21:11:59.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Smaug123/agdaproofs",
"max_issues_repo_path": "Rings/Divisible/Lemmas.agda",
"max_line_length": 150,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Smaug123/agdaproofs",
"max_stars_repo_path": "Rings/Divisible/Lemmas.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-28T06:04:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-08-08T12:44:19.000Z",
"num_tokens": 432,
"size": 1257
} |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
-- Definition of the Arrow Category of a Category C
module Categories.Category.Construction.Arrow {o ℓ e} (C : Category o ℓ e) where
open import Level
open import Data.Product using (_,_; _×_; map; zip)
open import Function using (_$_)
open import Relation.Binary using (Rel)
import Categories.Morphism as M
open M C
open import Categories.Morphism.Reasoning C
open Category C hiding (dom; cod)
open HomReasoning
private
variable
A B D E : Obj
record Morphism : Set (o ⊔ ℓ) where
field
{dom} : Obj
{cod} : Obj
arr : dom ⇒ cod
record Morphism⇒ (f g : Morphism) : Set (ℓ ⊔ e) where
constructor mor⇒
private
module f = Morphism f
module g = Morphism g
field
{dom⇒} : f.dom ⇒ g.dom
{cod⇒} : f.cod ⇒ g.cod
square : CommutativeSquare f.arr dom⇒ cod⇒ g.arr
Arrow : Category _ _ _
Arrow = record
{ Obj = Morphism
; _⇒_ = Morphism⇒
; _≈_ = λ f g → dom⇒ f ≈ dom⇒ g × cod⇒ f ≈ cod⇒ g
; id = mor⇒ $ identityˡ ○ ⟺ identityʳ
; _∘_ = λ m₁ m₂ → mor⇒ $ glue (square m₁) (square m₂)
; assoc = assoc , assoc
; sym-assoc = sym-assoc , sym-assoc
; identityˡ = identityˡ , identityˡ
; identityʳ = identityʳ , identityʳ
; identity² = identity² , identity²
; equiv = record
{ refl = refl , refl
; sym = map sym sym
; trans = zip trans trans
}
; ∘-resp-≈ = zip ∘-resp-≈ ∘-resp-≈
}
where open Morphism⇒
private
module MM = M Arrow
module _ where
open _≅_
lift-iso : ∀ {f h} →
(iso₁ : A ≅ D) → (iso₂ : B ≅ E) →
CommutativeSquare f (from iso₁) (from iso₂) h →
record { arr = f } MM.≅ record { arr = h }
lift-iso {f = f} {h = h} iso₁ iso₂ sq = record
{ from = record { square = sq }
; to = record { square = begin
to iso₂ ∘ h ≈⟨ introʳ (isoʳ iso₁) ⟩
(to iso₂ ∘ h) ∘ from iso₁ ∘ to iso₁ ≈⟨ assoc ⟩
to iso₂ ∘ h ∘ from iso₁ ∘ to iso₁ ≈˘⟨ refl ⟩∘⟨ pushˡ sq ⟩
to iso₂ ∘ (from iso₂ ∘ f) ∘ to iso₁ ≈˘⟨ assoc ⟩
(to iso₂ ∘ (from iso₂ ∘ f)) ∘ to iso₁ ≈⟨ cancelˡ (isoˡ iso₂) ⟩∘⟨ refl ⟩
f ∘ to iso₁ ∎ }
; iso = record
{ isoˡ = isoˡ iso₁ , isoˡ iso₂
; isoʳ = isoʳ iso₁ , isoʳ iso₂
}
}
| {
"alphanum_fraction": 0.5548442168,
"avg_line_length": 27.5647058824,
"ext": "agda",
"hexsha": "d7dfc7a0f38a7b766948a510c0a5b755a1c1fccd",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "6ebc1349ee79669c5c496dcadd551d5bbefd1972",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Taneb/agda-categories",
"max_forks_repo_path": "Categories/Category/Construction/Arrow.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "6ebc1349ee79669c5c496dcadd551d5bbefd1972",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Taneb/agda-categories",
"max_issues_repo_path": "Categories/Category/Construction/Arrow.agda",
"max_line_length": 80,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "6ebc1349ee79669c5c496dcadd551d5bbefd1972",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Taneb/agda-categories",
"max_stars_repo_path": "Categories/Category/Construction/Arrow.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 882,
"size": 2343
} |
data Fun (A B : Set) : Set where
fun : (A → B) → Fun A B
syntax fun (λ x → y) = fn x , y
foo : ∀ {A} → Fun A A → A
foo (fn x , y) = y
| {
"alphanum_fraction": 0.4604316547,
"avg_line_length": 15.4444444444,
"ext": "agda",
"hexsha": "016a838a043ab21092c7a5688ebef01025d49772",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "b5b3b1657556f720a7310cb7744edb1fac71eaf4",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "Seanpm2001-Agda-lang/agda",
"max_forks_repo_path": "test/Fail/Issue5763.agda",
"max_issues_count": 6,
"max_issues_repo_head_hexsha": "b5b3b1657556f720a7310cb7744edb1fac71eaf4",
"max_issues_repo_issues_event_max_datetime": "2021-11-24T08:31:10.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-10-18T08:12:24.000Z",
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "Seanpm2001-Agda-lang/agda",
"max_issues_repo_path": "test/Fail/Issue5763.agda",
"max_line_length": 32,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "6b13364d36eeb60d8ec15eaf8effe23c73401900",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "sseefried/agda",
"max_stars_repo_path": "test/Fail/Issue5763.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-05T00:25:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2022-03-05T00:25:14.000Z",
"num_tokens": 63,
"size": 139
} |
------------------------------------------------------------------------
-- Coinductive lists
------------------------------------------------------------------------
module Data.Colist where
open import Coinduction
open import Data.Bool using (Bool; true; false)
open import Data.Maybe using (Maybe; nothing; just)
open import Data.Nat using (ℕ; zero; suc)
open import Data.Conat
open import Data.List using (List; []; _∷_)
open import Data.List.NonEmpty using (List⁺; _∷_)
renaming ([_] to [_]⁺)
open import Data.BoundedVec.Inefficient as BVec
using (BoundedVec; []; _∷_)
open import Data.Product using (_,_)
open import Data.Function
open import Relation.Binary
------------------------------------------------------------------------
-- The type
infixr 5 _∷_
data Colist (A : Set) : Set where
[] : Colist A
_∷_ : (x : A) (xs : ∞ (Colist A)) → Colist A
data Any {A} (P : A → Set) : Colist A → Set where
here : ∀ {x xs} (px : P x) → Any P (x ∷ xs)
there : ∀ {x xs} (pxs : Any P (♭ xs)) → Any P (x ∷ xs)
data All {A} (P : A → Set) : Colist A → Set where
[] : All P []
_∷_ : ∀ {x xs} (px : P x) (pxs : ∞ (All P (♭ xs))) → All P (x ∷ xs)
------------------------------------------------------------------------
-- Some operations
null : ∀ {A} → Colist A → Bool
null [] = true
null (_ ∷ _) = false
length : ∀ {A} → Colist A → Coℕ
length [] = zero
length (x ∷ xs) = suc (♯ length (♭ xs))
map : ∀ {A B} → (A → B) → Colist A → Colist B
map f [] = []
map f (x ∷ xs) = f x ∷ ♯ map f (♭ xs)
fromList : ∀ {A} → List A → Colist A
fromList [] = []
fromList (x ∷ xs) = x ∷ ♯ fromList xs
take : ∀ {A} (n : ℕ) → Colist A → BoundedVec A n
take zero xs = []
take (suc n) [] = []
take (suc n) (x ∷ xs) = x ∷ take n (♭ xs)
replicate : ∀ {A} → Coℕ → A → Colist A
replicate zero x = []
replicate (suc n) x = x ∷ ♯ replicate (♭ n) x
lookup : ∀ {A} → ℕ → Colist A → Maybe A
lookup n [] = nothing
lookup zero (x ∷ xs) = just x
lookup (suc n) (x ∷ xs) = lookup n (♭ xs)
infixr 5 _++_
_++_ : ∀ {A} → Colist A → Colist A → Colist A
[] ++ ys = ys
(x ∷ xs) ++ ys = x ∷ ♯ (♭ xs ++ ys)
concat : ∀ {A} → Colist (List⁺ A) → Colist A
concat [] = []
concat ([ x ]⁺ ∷ xss) = x ∷ ♯ concat (♭ xss)
concat ((x ∷ xs) ∷ xss) = x ∷ ♯ concat (xs ∷ xss)
[_] : ∀ {A} → A → Colist A
[ x ] = x ∷ ♯ []
------------------------------------------------------------------------
-- Equality and other relations
-- xs ≈ ys means that xs and ys are equal.
infix 4 _≈_
data _≈_ {A} : (xs ys : Colist A) → Set where
[] : [] ≈ []
_∷_ : ∀ x {xs ys} (xs≈ : ∞ (♭ xs ≈ ♭ ys)) → x ∷ xs ≈ x ∷ ys
-- x ∈ xs means that x is a member of xs.
infix 4 _∈_
data _∈_ {A : Set} : A → Colist A → Set where
here : ∀ {x xs} → x ∈ x ∷ xs
there : ∀ {x y xs} (x∈xs : x ∈ ♭ xs) → x ∈ y ∷ xs
-- xs ⊑ ys means that xs is a prefix of ys.
infix 4 _⊑_
data _⊑_ {A : Set} : Colist A → Colist A → Set where
[] : ∀ {ys} → [] ⊑ ys
_∷_ : ∀ x {xs ys} (p : ∞ (♭ xs ⊑ ♭ ys)) → x ∷ xs ⊑ x ∷ ys
------------------------------------------------------------------------
-- Some proofs
setoid : Set → Setoid
setoid A = record
{ carrier = Colist A
; _≈_ = _≈_
; isEquivalence = record
{ refl = refl
; sym = sym
; trans = trans
}
}
where
refl : Reflexive _≈_
refl {[]} = []
refl {x ∷ xs} = x ∷ ♯ refl
sym : Symmetric _≈_
sym [] = []
sym (x ∷ xs≈) = x ∷ ♯ sym (♭ xs≈)
trans : Transitive _≈_
trans [] [] = []
trans (x ∷ xs≈) (.x ∷ ys≈) = x ∷ ♯ trans (♭ xs≈) (♭ ys≈)
poset : Set → Poset
poset A = record
{ carrier = Colist A
; _≈_ = _≈_
; _≤_ = _⊑_
; isPartialOrder = record
{ isPreorder = record
{ isEquivalence = Setoid.isEquivalence (setoid A)
; reflexive = reflexive
; trans = trans
; ∼-resp-≈ = ((λ {_} → ⊑-resp-≈ˡ) , λ {_} → ⊑-resp-≈ʳ)
}
; antisym = antisym
}
}
where
reflexive : _≈_ ⇒ _⊑_
reflexive [] = []
reflexive (x ∷ xs≈) = x ∷ ♯ reflexive (♭ xs≈)
trans : Transitive _⊑_
trans [] _ = []
trans (x ∷ xs≈) (.x ∷ ys≈) = x ∷ ♯ trans (♭ xs≈) (♭ ys≈)
⊑-resp-≈ˡ : {xs : Colist A} → (λ ys → xs ⊑ ys) Respects _≈_
⊑-resp-≈ˡ _ [] = []
⊑-resp-≈ˡ (x ∷ xs≈) (.x ∷ p) = x ∷ ♯ ⊑-resp-≈ˡ (♭ xs≈) (♭ p)
⊑-resp-≈ʳ : {ys : Colist A} → (λ xs → xs ⊑ ys) Respects _≈_
⊑-resp-≈ʳ [] _ = []
⊑-resp-≈ʳ (x ∷ xs≈) (.x ∷ p) = x ∷ ♯ ⊑-resp-≈ʳ (♭ xs≈) (♭ p)
antisym : Antisymmetric _≈_ _⊑_
antisym [] [] = []
antisym (x ∷ p₁) (.x ∷ p₂) = x ∷ ♯ antisym (♭ p₁) (♭ p₂)
map-cong : ∀ {A B} (f : A → B) → _≈_ =[ map f ]⇒ _≈_
map-cong f [] = []
map-cong f (x ∷ xs≈) = f x ∷ ♯ map-cong f (♭ xs≈)
take-⊑ : ∀ {A} n (xs : Colist A) →
let toColist = fromList ∘ BVec.toList in
toColist (take n xs) ⊑ xs
take-⊑ zero xs = []
take-⊑ (suc n) [] = []
take-⊑ (suc n) (x ∷ xs) = x ∷ ♯ take-⊑ n (♭ xs)
| {
"alphanum_fraction": 0.4214368037,
"avg_line_length": 28.2934782609,
"ext": "agda",
"hexsha": "94519bcc9d6641c57639e2c66c8ee81831c97e81",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:54:10.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-07-21T16:37:58.000Z",
"max_forks_repo_head_hexsha": "8ef786b40e4a9ab274c6103dc697dcb658cf3db3",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "isabella232/Lemmachine",
"max_forks_repo_path": "vendor/stdlib/src/Data/Colist.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "8ef786b40e4a9ab274c6103dc697dcb658cf3db3",
"max_issues_repo_issues_event_max_datetime": "2022-03-12T12:17:51.000Z",
"max_issues_repo_issues_event_min_datetime": "2022-03-12T12:17:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "larrytheliquid/Lemmachine",
"max_issues_repo_path": "vendor/stdlib/src/Data/Colist.agda",
"max_line_length": 72,
"max_stars_count": 56,
"max_stars_repo_head_hexsha": "8ef786b40e4a9ab274c6103dc697dcb658cf3db3",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "isabella232/Lemmachine",
"max_stars_repo_path": "vendor/stdlib/src/Data/Colist.agda",
"max_stars_repo_stars_event_max_datetime": "2021-12-21T17:02:19.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-20T02:11:42.000Z",
"num_tokens": 2031,
"size": 5206
} |
open import Categories
open import Monads
module Monads.CatofAdj.TermAdj {a b}{C : Cat {a}{b}}(M : Monad C) where
open import Library
open import Functors
open import Monads.CatofAdj M
open import Categories.Terminal
open import Monads.CatofAdj.TermAdjObj M
open import Monads.CatofAdj.TermAdjHom M
open import Monads.CatofAdj.TermAdjUniq M
EMIsTerm : Term CatofAdj EMObj
EMIsTerm = record {
t = λ {A} → EMHom A;
law = λ {A} {V} →
HomAdjEq _ _ (FunctorEq _ _ (omaplem A V)
(iext λ _ → iext λ _ → ext $ hmaplem A V))}
| {
"alphanum_fraction": 0.6814159292,
"avg_line_length": 28.25,
"ext": "agda",
"hexsha": "7949c6a9d1eec0e026e3dd6dcd48c52837b158bc",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-11-04T21:33:13.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-11-04T21:33:13.000Z",
"max_forks_repo_head_hexsha": "74707d3538bf494f4bd30263d2f5515a84733865",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "jmchapman/Relative-Monads",
"max_forks_repo_path": "Monads/CatofAdj/TermAdj.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "74707d3538bf494f4bd30263d2f5515a84733865",
"max_issues_repo_issues_event_max_datetime": "2019-05-29T09:50:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-13T13:12:33.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "jmchapman/Relative-Monads",
"max_issues_repo_path": "Monads/CatofAdj/TermAdj.agda",
"max_line_length": 76,
"max_stars_count": 21,
"max_stars_repo_head_hexsha": "74707d3538bf494f4bd30263d2f5515a84733865",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "jmchapman/Relative-Monads",
"max_stars_repo_path": "Monads/CatofAdj/TermAdj.agda",
"max_stars_repo_stars_event_max_datetime": "2021-02-13T18:02:18.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-07-30T01:25:12.000Z",
"num_tokens": 185,
"size": 565
} |
{-
Finitely presented algebras.
An R-algebra A is finitely presented, if there merely is an exact sequence
of R-modules:
(a₁,⋯,aₘ) → R[X₁,⋯,Xₙ] → A → 0
-}
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommAlgebra.FPAlgebra where
open import Cubical.Foundations.Prelude
open import Cubical.Data.FinData
open import Cubical.Data.Nat
open import Cubical.Data.Vec
open import Cubical.Data.Sigma
open import Cubical.HITs.PropositionalTruncation
open import Cubical.Algebra.CommRing
open import Cubical.Algebra.CommAlgebra
open import Cubical.Algebra.CommAlgebra.FreeCommAlgebra
open import Cubical.Algebra.CommAlgebra.QuotientAlgebra
open import Cubical.Algebra.CommAlgebra.Ideal
open import Cubical.Algebra.CommAlgebra.FGIdeal
private
variable
ℓ : Level
module _ {R : CommRing ℓ} where
freeAlgebra : (n : ℕ) → CommAlgebra R ℓ
freeAlgebra n = R [ Fin n ]
makeFPAlgebra : {m : ℕ} (n : ℕ) (l : FinVec (fst (freeAlgebra n)) m)
→ CommAlgebra R ℓ
makeFPAlgebra n l = freeAlgebra n / generatedIdeal (freeAlgebra n) l
isFPAlgebra : (A : CommAlgebra R ℓ) → Type _
isFPAlgebra A = ∃[ ((n , m) , l) ∈ Σ[ (n , m) ∈ ℕ × ℕ ] FinVec (fst (freeAlgebra n)) m ]
makeFPAlgebra n l ≡ A
isFPAlgebraIsProp : {A : CommAlgebra R ℓ} → isProp (isFPAlgebra A)
isFPAlgebraIsProp = isPropPropTrunc
| {
"alphanum_fraction": 0.7103499628,
"avg_line_length": 30.5227272727,
"ext": "agda",
"hexsha": "8e1d74d9fd9ed0fba444265576757279638c2fd7",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "howsiyu/cubical",
"max_forks_repo_path": "Cubical/Algebra/CommAlgebra/FPAlgebra.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "howsiyu/cubical",
"max_issues_repo_path": "Cubical/Algebra/CommAlgebra/FPAlgebra.agda",
"max_line_length": 90,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "howsiyu/cubical",
"max_stars_repo_path": "Cubical/Algebra/CommAlgebra/FPAlgebra.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 449,
"size": 1343
} |
{-# OPTIONS --without-K #-}
open import Level renaming (zero to lzero ; suc to lsuc)
open import Syntax
open import Data.List using (length ; [] ; _∷_ ) renaming ( _++_ to _++L_ )
open import Data.Vec using ([] ; _∷_ ) renaming ( _++_ to _++V_ )
open import Data.Vec.Relation.Unary.All using (All ; [] ; _∷_)
open import Data.Nat
open import Data.Product
open import Function using () renaming (case_of_ to case*_of_)
open import Size
open import Relation.Binary.PropositionalEquality
-- Sets indexed by invertible environments (that is, Θ and Ξ). This
-- actually is our semantic domain.
Dom : ∀ ℓ -> Set (lsuc ℓ)
Dom ℓ = (Θ : TyEnv) -> (Ξ : MultEnv (length Θ)) -> Set ℓ
-- A pairing operator, inspired by the Day convolution in category theory.
data _⊛_ {ℓ : Level}
(F : Dom ℓ)
(G : Dom ℓ)
(Θ : TyEnv) (Ξ : MultEnv (length Θ)) : Set ℓ where
tup : ∀ Ξ₁ Ξ₂ -> (spΞ : Ξ₁ +ₘ Ξ₂ ≡ Ξ) ->
(fst : F Θ Ξ₁) -> (snd : G Θ Ξ₂) -> (F ⊛ G) Θ Ξ
-- mult is used for representing entries in value environments that are aware of multiplicities.
data mult {ℓ : Level} (F : Dom ℓ) : (m : Multiplicity₀) -> Dom ℓ where
-- An entry corresponds to multiplicity zero, i.e., nothing.
mult-zero :
∀ {Θ Ξ} ->
(eq : Ξ ≡ ∅) ->
mult F zero Θ Ξ
-- An entry corresponds to multiplicity one, a value must be used linearly.
mult-one :
∀ {Θ Ξ} ->
(v : F Θ Ξ) -> mult F one Θ Ξ
-- An entry corresponds to multiplicity omega; such values must be indexed by the empty invertible environment.
mult-omega :
∀ {Θ Ξ} ->
(v : F Θ ∅) -> (eq : Ξ ≡ ∅) -> mult F omega Θ Ξ
-- Values (Value), residuals (Residual) and value environments
-- (ValEnv) are mutually defined.
--
-- The sized types are used for termination checking with the presence
-- of --without-K, which weakens termination analysis for
-- with-abstractions that the original definitions used to have.
data Value (Θ : TyEnv) : MultEnv (length Θ) -> Ty zero -> {i : Size} -> Set
data Residual (Θ : TyEnv) : MultEnv (length Θ) -> Ty zero -> {i : Size} -> Set
ValEnv :
(Γ : TyEnv) -> (Δ : MultEnv (length Γ)) -> {i : Size} ->
(Θ : TyEnv) -> MultEnv (length Θ) -> Set
-- ValEnv Γ Δ : Dom 0 represents value environments conforms to Γ Δ.
-- Intuitively, (Θ , Ξ) of ValEnv Γ Δ Θ Ξ represents typed resources contained in
-- value environments.
ValEnv [] Δ {i} = λ Θ Ξ -> Ξ ≡ ∅
ValEnv (A ∷ Γ) (m ∷ Δ) {i} =
mult (V A) m ⊛ ValEnv Γ Δ {i}
where
V : Ty zero -> Dom 0ℓ
V A Θ Ξ = Value Θ Ξ A {i}
-- Values
data Value Θ where
clo :
∀ {Ξ Ξ' Γ' Δ' A B Ξₜ i} ->
(m : Multiplicity) ->
(spΞ : Ξ' +ₘ Ξₜ ≡ Ξ) ->
(θ : ValEnv Γ' Δ' {i} Θ Ξ' ) ->
(t : Term (A ∷ Γ') (M→M₀ m ∷ Δ') Θ Ξₜ B) ->
Value Θ Ξ (A # m ~> B) {↑ i}
unit :
∀ {Ξ i} ->
(eq : ∅ ≡ Ξ) ->
Value Θ Ξ tunit {↑ i}
pair :
∀ {Ξ Ξ₁ Ξ₂ A B i} ->
(spΞ : Ξ₁ +ₘ Ξ₂ ≡ Ξ) ->
Value Θ Ξ₁ A {i} ->
Value Θ Ξ₂ B {i} ->
Value Θ Ξ (A ⊗ B) {↑ i}
many :
∀ {Ξ Ξ₀ A i} ->
(m : Multiplicity) ->
(spΞ : m ×ₘ Ξ₀ ≡ Ξ) ->
Value Θ Ξ₀ A {i} ->
Value Θ Ξ (Many m A) {↑ i}
inl :
∀ {Ξ} {A B i} ->
Value Θ Ξ A {i} ->
Value Θ Ξ (A ⊕ B) {↑ i}
inr :
∀ {Ξ} {A B i} ->
Value Θ Ξ B {i} ->
Value Θ Ξ (A ⊕ B) {↑ i}
roll :
∀ {Ξ F i} ->
Value Θ Ξ (substTy F (μ F)) {i} ->
Value Θ Ξ (μ F) {↑ i}
inj :
∀ {Ξ A B i}
-> (eq : ∅ ≡ Ξ)
-> (r : Residual (A ∷ []) (one ∷ ∅) (B ●) {i})
-> Value Θ Ξ (A ↔ B) {↑ i}
red :
∀ {Ξ A i} ->
Residual Θ Ξ (A ●) {i} ->
Value Θ Ξ (A ●) {↑ i}
-- Residuals
data Residual Θ where
unit● :
∀ {i} ->
Residual Θ ∅ (tunit ●) {↑ i}
letunit● :
∀ {Ξ₀ Ξ A i} ->
Residual Θ Ξ₀ (tunit ●) {i} ->
Residual Θ Ξ (A ●) {i} ->
Residual Θ (Ξ₀ +ₘ Ξ) (A ●) {↑ i}
pair● :
∀ {Ξ₁ Ξ₂ A B i} ->
Residual Θ Ξ₁ (A ●) {i} ->
Residual Θ Ξ₂ (B ●) {i} ->
Residual Θ (Ξ₁ +ₘ Ξ₂) ((A ⊗ B) ●) {↑ i}
letpair● :
∀ {Ξ₀ Ξ A B C i} ->
Residual Θ Ξ₀ ((A ⊗ B) ●) {i} ->
Residual (A ∷ B ∷ Θ) (one ∷ one ∷ Ξ) (C ●) {i} ->
Residual Θ (Ξ₀ +ₘ Ξ) (C ●) {↑ i}
inl● :
∀ {Ξ} {A B} {i} ->
Residual Θ Ξ (A ●) {i} ->
Residual Θ Ξ ((A ⊕ B) ●) {↑ i}
inr● :
∀ {Ξ} {A B} {i} ->
Residual Θ Ξ (B ●) {i} ->
Residual Θ Ξ ((A ⊕ B) ●) {↑ i}
case● :
∀ {Ξ₀ Ξ Ξₑ Ξₜ Γ₁ Γ₂ Δ₁ Δ₂ A B C i} ->
Residual Θ Ξ₀ ((A ⊕ B) ●) {i} ->
(spΞ : Ξₑ +ₘ Ξₜ ≡ Ξ) ->
(θ₁ : ValEnv Γ₁ Δ₁ {i} Θ Ξₑ) ->
(t₁ : Term Γ₁ Δ₁ (A ∷ Θ) (one ∷ Ξₜ) (C ●)) ->
(θ₂ : ValEnv Γ₂ Δ₂ {i} Θ Ξₑ) ->
(t₂ : Term Γ₂ Δ₂ (B ∷ Θ) (one ∷ Ξₜ) (C ●)) ->
(v : Value [] ∅ (C # omega ~> tbool) {i}) ->
Residual Θ (Ξ₀ +ₘ Ξ) (C ●) {↑ i}
var● : ∀ {Ξ A i} ->
(x : Θ ∋ A) -> (ok : varOk● Θ x Ξ) ->
Residual Θ Ξ (A ●) {↑ i}
pin : ∀ {Ξ₁ Ξ₂ A B i} ->
Residual Θ Ξ₁ (A ●) {i} ->
(v : Value Θ Ξ₂ (A # omega ~> B ●) {i}) ->
Residual Θ (Ξ₁ +ₘ Ξ₂) ((A ⊗ B) ●) {↑ i}
open ≡-Reasoning
-- A property on value environments that says discardable value environments cannot contain any resources.
discardable-has-no-resources : ∀ {Γ Δ Θ Ξ} -> ValEnv Γ Δ Θ Ξ -> All discardable Δ -> Ξ ≡ ∅
discardable-has-no-resources {[]} {Δ} θ ad = θ
discardable-has-no-resources {A ∷ Γ} {.omega ∷ Δ} (tup .∅ Ξ₂ spΞ (mult-omega v refl) snd) (omega ∷ ad) =
begin
_
≡⟨ sym spΞ ⟩
∅ +ₘ Ξ₂
≡⟨ ∅-lid Ξ₂ ⟩
Ξ₂
≡⟨ discardable-has-no-resources {Γ} {Δ} snd ad ⟩
∅
∎
discardable-has-no-resources {A ∷ Γ} {.zero ∷ Δ} (tup .∅ Ξ₂ spΞ (mult-zero refl) snd) (zero ∷ ad) =
begin
_
≡⟨ sym spΞ ⟩
∅ +ₘ Ξ₂
≡⟨ ∅-lid Ξ₂ ⟩
Ξ₂
≡⟨ discardable-has-no-resources {Γ} {Δ} snd ad ⟩
∅
∎
-- Looking up variables in an environment. Unlike the usual variable looking-up functions, this version
-- takes varOk Γ x Δ instead of x to ensure that the variable can be looked up. Notice
-- for example that we cannot look up variables with multiplicity zero. Also, the fact that the
-- return type is Value Θ Ξ A means that the value environment cannot contain other resources.
lookupVar : ∀ {Γ Δ Θ Ξ A} {x : Γ ∋ A} -> ValEnv Γ Δ Θ Ξ -> varOk Γ x Δ -> Value Θ Ξ A
lookupVar (tup .(∅) Ξ₂ spΞ (mult-omega v refl) snd) (there omega ok) with (trans (sym (∅-lid _)) spΞ)
... | refl = lookupVar snd ok
lookupVar (tup .∅ Ξ₂ spΞ (mult-zero refl) snd) (there zero ok) with (trans (sym (∅-lid _)) spΞ)
... | refl = lookupVar snd ok
lookupVar {Γ = A ∷ Γ} {Δ = m ∷ Δ} (tup Ξ₁ Ξ₂ spΞ fst snd) (here u ad) with discardable-has-no-resources {Γ} {Δ} snd ad
... | refl with trans (sym (∅-rid _)) spΞ
lookupVar {A ∷ Γ} {.omega ∷ Δ} (tup .∅ .∅ spΞ (mult-omega v refl) snd) (here omega ad) | refl | refl = v
lookupVar {A ∷ Γ} {.one ∷ Δ} (tup Ξ₁ .∅ spΞ (mult-one v) snd) (here one ad) | refl | refl = v
-- separateEnv separates value environments according to separation of
-- (unidirectional) type environments.
separateEnv : ∀ {Γ Θ Ξ} -> ∀ Δ₁ Δ₂ ->
ValEnv Γ (Δ₁ +ₘ Δ₂) Θ Ξ ->
(ValEnv Γ Δ₁ ⊛ ValEnv Γ Δ₂) Θ Ξ
separateEnv {[]} Δ₁ Δ₂ refl = tup ∅ ∅ (∅-lid ∅) refl refl
separateEnv {A ∷ Γ} (m₁ ∷ Δ₁) (m₂ ∷ Δ₂) (tup Ξ₁ Ξ₂ spΞ fst snd) with separateEnv {Γ} Δ₁ Δ₂ snd
separateEnv {A ∷ Γ} {Θ = Θ} {Ξ = Ξ} (zero ∷ Δ₁) (m₂ ∷ Δ₂) (tup Ξ₁ Ξ₂ spΞ fst snd) | tup Ξ₁' Ξ₂' spΞ₂ θ₁ θ₂ =
tup Ξ₁' (Ξ₁ +ₘ Ξ₂') lemma (tup ∅ Ξ₁' (∅-lid _) (mult-zero refl) θ₁)
(tup Ξ₁ Ξ₂' refl fst θ₂)
where
open import Algebra.Solver.CommutativeMonoid (+ₘ-commutativeMonoid (length Θ))
renaming (_⊕_ to _⊞_)
lemma : Ξ₁' +ₘ (Ξ₁ +ₘ Ξ₂') ≡ Ξ
lemma =
begin
Ξ₁' +ₘ (Ξ₁ +ₘ Ξ₂')
≡⟨ solve 3 (λ x y z -> x ⊞ (y ⊞ z) ⊜ y ⊞ (x ⊞ z)) refl Ξ₁' Ξ₁ Ξ₂' ⟩
Ξ₁ +ₘ (Ξ₁' +ₘ Ξ₂')
≡⟨ cong (_ +ₘ_) spΞ₂ ⟩
Ξ₁ +ₘ Ξ₂
≡⟨ spΞ ⟩
Ξ
∎
separateEnv {A ∷ Γ} {Ξ = Ξ} (one ∷ Δ₁) (zero ∷ Δ₂) (tup Ξ₁ Ξ₂ spΞ fst snd) | tup Ξ₁' Ξ₂' spΞ₂ θ₁ θ₂ =
tup (Ξ₁ +ₘ Ξ₁') Ξ₂' lemma (tup Ξ₁ Ξ₁' refl fst θ₁)
(tup ∅ Ξ₂' (∅-lid _) (mult-zero refl) θ₂)
where
lemma : Ξ₁ +ₘ Ξ₁' +ₘ Ξ₂' ≡ Ξ
lemma =
begin
Ξ₁ +ₘ Ξ₁' +ₘ Ξ₂'
≡⟨ +ₘ-assoc Ξ₁ Ξ₁' _ ⟩
Ξ₁ +ₘ (Ξ₁' +ₘ Ξ₂')
≡⟨ cong (_ +ₘ_) spΞ₂ ⟩
Ξ₁ +ₘ Ξ₂
≡⟨ spΞ ⟩
Ξ
∎
separateEnv {A ∷ Γ} (one ∷ Δ₁) (one ∷ Δ₂) (tup .(∅) .(Ξ₁' +ₘ Ξ₂') refl (mult-omega v refl) snd) | tup Ξ₁' Ξ₂' refl θ₁ θ₂ =
tup Ξ₁' Ξ₂' (sym (∅-lid _)) (tup ∅ Ξ₁' (∅-lid _) (mult-one v) θ₁)
(tup ∅ Ξ₂' (∅-lid _) (mult-one v) θ₂)
separateEnv {A ∷ Γ} (one ∷ Δ₁) (omega ∷ Δ₂) (tup .(∅) .(Ξ₁' +ₘ Ξ₂') refl (mult-omega v refl) snd) | tup Ξ₁' Ξ₂' refl θ₁ θ₂ =
tup Ξ₁' Ξ₂' (sym (∅-lid _)) (tup ∅ Ξ₁' (∅-lid _) (mult-one v) θ₁)
(tup ∅ Ξ₂' (∅-lid _) (mult-omega v refl) θ₂)
separateEnv {A ∷ Γ} (omega ∷ Δ₁) (zero ∷ Δ₂) (tup .(∅) .(Ξ₁' +ₘ Ξ₂') refl (mult-omega v refl) snd) | tup Ξ₁' Ξ₂' refl θ₁ θ₂ =
tup Ξ₁' Ξ₂' (sym (∅-lid _)) (tup ∅ Ξ₁' (∅-lid _) (mult-omega v refl) θ₁)
(tup ∅ Ξ₂' (∅-lid _) (mult-zero refl) θ₂)
separateEnv {A ∷ Γ} (omega ∷ Δ₁) (one ∷ Δ₂) (tup .(∅) .(Ξ₁' +ₘ Ξ₂') refl (mult-omega v refl) snd) | tup Ξ₁' Ξ₂' refl θ₁ θ₂ =
tup Ξ₁' Ξ₂' (sym (∅-lid _)) (tup ∅ Ξ₁' (∅-lid _) (mult-omega v refl) θ₁)
(tup ∅ Ξ₂' (∅-lid _) (mult-one v) θ₂)
separateEnv {A ∷ Γ} (omega ∷ Δ₁) (omega ∷ Δ₂) (tup .(∅) .(Ξ₁' +ₘ Ξ₂') refl (mult-omega v refl) snd) | tup Ξ₁' Ξ₂' refl θ₁ θ₂ =
tup Ξ₁' Ξ₂' (sym (∅-lid _)) (tup ∅ Ξ₁' (∅-lid _) (mult-omega v refl) θ₁)
(tup ∅ Ξ₂' (∅-lid _) (mult-omega v refl) θ₂)
-- un×ₘ-valEnv is a counter of separateEnv for ×ₘ.
un×ₘ-valEnv : ∀ Γ {m Δ Θ Ξ} -> ValEnv Γ (m ×ₘ Δ) Θ Ξ -> ∃[ Ξ' ] (ValEnv Γ Δ Θ Ξ' × m ×ₘ Ξ' ≡ Ξ)
un×ₘ-valEnv [] {m} θ = ∅ , refl , trans (×ₘ∅ m) (sym θ)
un×ₘ-valEnv (_ ∷ Γ) {Δ = mₓ ∷ Δ} (tup Ξ₁ Ξ₂ refl fst snd) with un×ₘ-valEnv Γ snd
un×ₘ-valEnv (_ ∷ Γ) {one} {mₓ ∷ Δ} (tup Ξ₁ .(Data.Vec.map (λ y → y) Ξ') refl fst snd) | Ξ' , θ' , refl = Ξ₁ +ₘ Ξ' , tup Ξ₁ Ξ' refl fst θ' , lemma
where
open import Data.Vec.Properties using (map-id)
lemma : Data.Vec.map (λ x -> x) (Ξ₁ +ₘ Ξ') ≡ Ξ₁ +ₘ Data.Vec.map (λ x -> x) Ξ'
lemma = begin
Data.Vec.map (λ x -> x) (Ξ₁ +ₘ Ξ')
≡⟨ map-id _ ⟩
Ξ₁ +ₘ Ξ'
≡⟨ cong (_ +ₘ_) (sym (map-id _)) ⟩
Ξ₁ +ₘ Data.Vec.map (λ x -> x) Ξ'
∎
un×ₘ-valEnv (_ ∷ Γ) {omega} {zero ∷ Δ} (tup .(∅) .(Data.Vec.map (mul₀ omega) Ξ') refl (mult-zero refl) snd) | Ξ' , θ' , refl = Ξ' , tup ∅ Ξ' (∅-lid _) (mult-zero refl) θ' , sym (∅-lid _)
un×ₘ-valEnv (_ ∷ Γ) {omega} {one ∷ Δ} (tup .(∅) .(Data.Vec.map (mul₀ omega) Ξ') refl (mult-omega v refl) snd) | Ξ' , θ' , refl = Ξ' , tup ∅ Ξ' (∅-lid _) (mult-one v) θ' , sym (∅-lid _)
un×ₘ-valEnv (_ ∷ Γ) {omega} {omega ∷ Δ} (tup .(∅) .(Data.Vec.map (mul₀ omega) Ξ') refl (mult-omega v refl) snd) | Ξ' , θ' , refl = Ξ' , tup ∅ Ξ' (∅-lid _) (mult-omega v refl) θ' , sym (∅-lid _)
-- weakenΘ-value and weakenΘ-residual are counterparts of
-- weakenΘ-term for values and residuals.
weakenΘ-value :
∀ {Θ Ξ Θ' Ξ' A i} ->
compatΘ Θ Ξ Θ' Ξ' ->
Value Θ Ξ A {i} -> Value Θ' Ξ' A
weakenΘ-residual :
∀ {Θ Ξ Θ' Ξ' A i} ->
compatΘ Θ Ξ Θ' Ξ' ->
Residual Θ Ξ A {i} -> Residual Θ' Ξ' A
weakenΘ-valEnv :
∀ Γ {Δ Θ Ξ Θ' Ξ' i} ->
compatΘ Θ Ξ Θ' Ξ' ->
ValEnv Γ Δ {i} Θ Ξ -> ValEnv Γ Δ Θ' Ξ'
weakenΘ-mult :
∀ {Θ Ξ Θ' Ξ' m A i} ->
compatΘ Θ Ξ Θ' Ξ' ->
mult (λ Θ Ξ -> Value Θ Ξ A {i}) m Θ Ξ ->
mult (λ Θ Ξ -> Value Θ Ξ A) m Θ' Ξ'
weakenΘ-value ext (clo {Γ' = Γ'} m refl θ t) =
case* compatΘ-split ext of λ {
(_ , _ , ext₁ , ext₂ , refl) ->
clo m refl (weakenΘ-valEnv Γ' ext₁ θ)
(weakenΘ-term ext₂ t)
}
weakenΘ-value ext (unit refl) =
case* compatΘ-∅ ext of λ where
refl -> unit refl
weakenΘ-value ext (pair refl v₁ v₂) =
case* compatΘ-split ext of λ where
(_ , _ , ext₁ , ext₂ , refl) ->
pair refl (weakenΘ-value ext₁ v₁) (weakenΘ-value ext₂ v₂)
weakenΘ-value ext (many m refl v) =
case* compatΘ-×ₘ ext of λ where
(_ , ext' , refl) -> many m refl (weakenΘ-value ext' v)
weakenΘ-value ext (inl v) = inl (weakenΘ-value ext v)
weakenΘ-value ext (inr v) = inr (weakenΘ-value ext v)
weakenΘ-value ext (roll v) = roll (weakenΘ-value ext v)
weakenΘ-value ext (red x) = red (weakenΘ-residual ext x)
weakenΘ-value ext (inj refl r) =
case* compatΘ-∅ ext of λ {
refl -> inj refl (weakenΘ-residual ext-id r)
}
weakenΘ-mult ext (mult-zero refl) =
case* compatΘ-∅ ext of λ {
refl -> mult-zero refl
}
weakenΘ-mult ext (mult-one v) = mult-one (weakenΘ-value ext v)
weakenΘ-mult ext (mult-omega v refl) =
case* compatΘ-∅ ext of λ {
refl -> mult-omega (weakenΘ-value ext v) refl
}
weakenΘ-valEnv [] ext refl =
case* compatΘ-∅ ext of λ {
refl -> refl
}
weakenΘ-valEnv (_ ∷ Γ) {_ ∷ Δ} ext (tup Ξ₁ Ξ₂ refl mv θ) =
case* compatΘ-split ext of λ {
(Ξ₁' , Ξ₂' , ext₁ , ext₂ , refl) ->
tup Ξ₁' Ξ₂' refl (weakenΘ-mult ext₁ mv) (weakenΘ-valEnv Γ ext₂ θ)
}
weakenΘ-residual ext unit● =
case* compatΘ-∅ ext of λ {
refl -> unit●
}
weakenΘ-residual ext (letunit● r₁ r₂) =
case* compatΘ-split ext of λ {
(_ , _ , ext₁ , ext₂ , refl) ->
letunit● (weakenΘ-residual ext₁ r₁)
(weakenΘ-residual ext₂ r₂)
}
weakenΘ-residual ext (pair● r₁ r₂) =
case* compatΘ-split ext of λ {
(_ , _ , ext₁ , ext₂ , refl) ->
pair● (weakenΘ-residual ext₁ r₁)
(weakenΘ-residual ext₂ r₂)
}
weakenΘ-residual ext (letpair● r₁ r₂) =
case* compatΘ-split ext of λ {
(_ , _ , ext₁ , ext₂ , refl) ->
letpair● (weakenΘ-residual ext₁ r₁)
(weakenΘ-residual (compat-skip (compat-skip ext₂)) r₂)
}
weakenΘ-residual ext (inl● r) = inl● (weakenΘ-residual ext r)
weakenΘ-residual ext (inr● r) = inr● (weakenΘ-residual ext r)
weakenΘ-residual ext (case● {Γ₁ = Γ₁} {Γ₂} r refl θ₁ t₁ θ₂ t₂ v) with compatΘ-split ext
... | _ , _ , ext₁ , ext₂ , refl
with compatΘ-split ext₂
... | _ , _ , extₑ , extₜ , refl =
case● (weakenΘ-residual ext₁ r)
refl
(weakenΘ-valEnv Γ₁ extₑ θ₁)
(weakenΘ-term (compat-skip extₜ) t₁)
(weakenΘ-valEnv Γ₂ extₑ θ₂)
(weakenΘ-term (compat-skip extₜ) t₂)
(weakenΘ-value adjust∅Θ v)
weakenΘ-residual ext (var● x ok) =
case* compatΘ-preserves-varOk● ext ok of λ {
(x' , ok') -> var● x' ok'
}
weakenΘ-residual ext (pin r v) =
case* compatΘ-split ext of λ {
(_ , _ , ext₁ , ext₂ , refl) ->
pin (weakenΘ-residual ext₁ r)
(weakenΘ-value ext₂ v)
}
-- Converting a value (of multiplicty m) into an entry to be inserted to a value environment.
value-to-multM :
∀ {Θ m Ξ A} ->
all-no-omega (m ×ₘ Ξ) -> Value Θ Ξ A -> mult (λ Θ' Ξ' -> Value Θ' Ξ' A) (M→M₀ m) Θ (m ×ₘ Ξ)
value-to-multM {Θ} {one} ano v = mult-one (subst (λ x -> Value Θ x _) (sym (one×ₘ _)) v )
value-to-multM {Θ} {omega} {Ξ} ano v with all-no-omega-omega×ₘ Ξ ano
... | refl = mult-omega v (×ₘ∅ _)
-- Some specialized versions of subst.
substV : ∀ {Θ Ξ Ξ' A} -> Ξ ≡ Ξ' -> Value Θ Ξ A -> Value Θ Ξ' A
substV refl v = v
substR : ∀ {Θ Ξ Ξ' A} -> Ξ ≡ Ξ' -> Residual Θ Ξ A -> Residual Θ Ξ' A
substR refl E = E
| {
"alphanum_fraction": 0.5206394042,
"avg_line_length": 34.2351648352,
"ext": "agda",
"hexsha": "48a9fbb40570a2bd17e529a22f425e56b4358751",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "e2fb3a669e733a9020a51b24244d89abd8fcf725",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "kztk-m/sparcl-agda",
"max_forks_repo_path": "Value.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e2fb3a669e733a9020a51b24244d89abd8fcf725",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "kztk-m/sparcl-agda",
"max_issues_repo_path": "Value.agda",
"max_line_length": 193,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "e2fb3a669e733a9020a51b24244d89abd8fcf725",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "kztk-m/sparcl-agda",
"max_stars_repo_path": "Value.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 6959,
"size": 15577
} |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.Polynomials.Multivariate.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat renaming(_+_ to _+n_; _·_ to _·n_)
open import Cubical.Data.Vec
open import Cubical.Algebra.Ring
open import Cubical.Algebra.CommRing
open import Cubical.Algebra.Polynomials.Multivariate.Base
private variable
ℓ ℓ' : Level
module Nth-Poly-structure (A' : CommRing ℓ) (n : ℕ) where
private
A = fst A'
Ar = CommRing→Ring A'
open CommRingStr (snd A')
open RingTheory Ar
-----------------------------------------------------------------------------
Poly-com-adv : (P Q R S : Poly A' n) → ((P Poly+ Q) Poly+ (R Poly+ S) ≡ (P Poly+ R) Poly+ (Q Poly+ S))
Poly-com-adv P Q R S = ((P Poly+ Q) Poly+ (R Poly+ S) ≡⟨ Poly+-assoc (P Poly+ Q) R S ⟩
(((P Poly+ Q) Poly+ R) Poly+ S) ≡⟨ cong (λ X → X Poly+ S) (sym (Poly+-assoc P Q R)) ⟩
((P Poly+ (Q Poly+ R)) Poly+ S) ≡⟨ cong (λ X → (P Poly+ X) Poly+ S) (Poly+-comm Q R) ⟩
((P Poly+ (R Poly+ Q)) Poly+ S) ≡⟨ cong (λ X → X Poly+ S) (Poly+-assoc P R Q) ⟩
(((P Poly+ R) Poly+ Q) Poly+ S) ≡⟨ sym (Poly+-assoc (P Poly+ R) Q S) ⟩
((P Poly+ R) Poly+ (Q Poly+ S)) ∎)
Poly+-Lid : (P : Poly A' n) → 0P Poly+ P ≡ P
Poly+-Lid P = (Poly+-comm 0P P) ∙ (Poly+-Rid P)
Poly-inv : Poly A' n → Poly A' n
Poly-inv = Poly-Rec-Set.f A' n (Poly A' n) trunc
0P
(λ v a → base v (- a))
(λ PS RS → PS Poly+ RS)
Poly+-assoc
Poly+-Rid
Poly+-comm
(λ v → base v (- 0r) ≡⟨ cong (base v) 0Selfinverse ⟩ base v 0r ≡⟨ base-0P v ⟩ 0P ∎)
λ v a b → (base-Poly+ v (- a) (- b)) ∙ (cong (base v) (-Dist a b))
Poly-invinv : (P : Poly A' n) → Poly-inv (Poly-inv P) ≡ P
Poly-invinv = Poly-Ind-Prop.f A' n (λ P → Poly-inv (Poly-inv P) ≡ P) (λ _ → trunc _ _)
refl
(λ v a → cong (base v) (-Idempotent a))
λ {P Q} ind-P ind-Q → cong₂ _Poly+_ ind-P ind-Q
Poly+-rinv : (P : Poly A' n ) → P Poly+ (Poly-inv P) ≡ 0P
Poly+-rinv = Poly-Ind-Prop.f A' n (λ P → (P Poly+ Poly-inv P) ≡ 0P) (λ _ → trunc _ _)
(Poly+-Rid 0P)
(λ v a → (base-Poly+ v a (- a)) ∙ cong (base v) (+Rinv a) ∙ base-0P v)
λ {P Q} ind-P ind-Q → ((P Poly+ Q) Poly+ ((Poly-inv P) Poly+ (Poly-inv Q)))
≡⟨ Poly-com-adv P Q (Poly-inv P) (Poly-inv Q) ⟩
((P Poly+ Poly-inv P) Poly+ (Q Poly+ Poly-inv Q))
≡⟨ cong₂ _Poly+_ ind-P ind-Q ⟩
(0P Poly+ 0P)
≡⟨ Poly+-Rid 0P ⟩
0P ∎
Poly+-linv : (P : Poly A' n) → (Poly-inv P) Poly+ P ≡ 0P
Poly+-linv = Poly-Ind-Prop.f A' n _ (λ _ → trunc _ _)
(Poly+-Rid 0P)
(λ v a → (base-Poly+ v (- a) a) ∙ cong (base v) (snd (+Inv a)) ∙ base-0P v)
λ {U V} ind-U ind-V → Poly-com-adv (Poly-inv U) (Poly-inv V) U V ∙ cong₂ _Poly+_ ind-U ind-V ∙ Poly+-Rid 0P
-----------------------------------------------------------------------------
_Poly*_ : Poly A' n → Poly A' n → Poly A' n
_Poly*_ = -- Induction Left Argument
Poly-Rec-Set.f A' n (Poly A' n → Poly A' n)
(λ f g p q i j Q → trunc (f Q) (g Q) (λ X → p X Q) (λ X → q X Q) i j )
(λ Q → 0P)
(λ v a → -- Induction Right Argument
Poly-Rec-Set.f A' n (Poly A' n) trunc
0P
(λ v' a' → base (v +n-vec v') (a · a'))
_Poly+_
Poly+-assoc
Poly+-Rid
Poly+-comm
(λ v' → (cong (base (v +n-vec v')) (0RightAnnihilates a)) ∙ (base-0P (v +n-vec v')))
λ v' b c → (base-Poly+ (v +n-vec v') (a · b) (a · c)) ∙ (cong (base (v +n-vec v')) (sym (·Rdist+ a b c))))
-- End Right induction
(λ PS QS Q → (PS Q) Poly+ (QS Q) )
(λ PS QS RS i Q → Poly+-assoc (PS Q) (QS Q) (RS Q) i)
(λ PS i Q → Poly+-Rid (PS Q) i)
(λ PS QS i Q → Poly+-comm (PS Q) (QS Q) i)
(λ v → funExt (
-- Induction Right Argument
Poly-Ind-Prop.f A' n _ (λ _ → trunc _ _)
refl
(λ v' a' → (cong (base (v +n-vec v')) (0LeftAnnihilates a')) ∙ (base-0P (v +n-vec v')))
λ {P Q} ind-P ind-Q → (cong₂ _Poly+_ ind-P ind-Q) ∙ (Poly+-Rid 0P) ))
-- End Right Induction
λ v a b → funExt (
-- Induction Right Argument
Poly-Ind-Prop.f A' n _ (λ _ → trunc _ _)
(Poly+-Rid 0P)
(λ v' c → (base-Poly+ (v +n-vec v') (a · c) (b · c)) ∙ (cong (base (v +n-vec v')) (sym (·Ldist+ a b c))))
λ {P Q} ind-P ind-Q → (Poly-com-adv _ _ _ _) ∙ (cong₂ _Poly+_ ind-P ind-Q))
-- End Right Induction
-- End Left Induction
Poly*-assoc : (P Q R : Poly A' n) → P Poly* (Q Poly* R) ≡ (P Poly* Q) Poly* R
Poly*-assoc = Poly-Ind-Prop.f A' n _
(λ P p q i Q R j → trunc (P Poly* (Q Poly* R)) ((P Poly* Q) Poly* R) (p Q R) (q Q R) i j)
(λ _ _ → refl)
(λ v a → Poly-Ind-Prop.f A' n _
(λ Q p q i R j → trunc (base v a Poly* (Q Poly* R)) ((base v a Poly* Q) Poly* R) (p R) (q R) i j)
(λ _ → refl)
(λ v' a' → Poly-Ind-Prop.f A' n _ (λ _ → trunc _ _)
refl
(λ v'' a'' → cong₂ base (+n-vec-assoc v v' v'') (·Assoc a a' a''))
(λ {U V} ind-U ind-V → cong₂ _Poly+_ ind-U ind-V))
(λ {U V} ind-U ind-V R → cong₂ _Poly+_ (ind-U R) (ind-V R)))
λ {U V} ind-U ind-V Q R → cong₂ _Poly+_ (ind-U Q R) (ind-V Q R)
0PLeftAnnihilatesPoly : (P : Poly A' n) → 0P Poly* P ≡ 0P
0PLeftAnnihilatesPoly P = refl
0PRightAnnihilatesPoly : (P : Poly A' n) → P Poly* 0P ≡ 0P
0PRightAnnihilatesPoly = Poly-Ind-Prop.f A' n (λ P → (P Poly* 0P) ≡ 0P) (λ _ → trunc _ _)
refl
(λ _ _ → refl)
λ {P Q} ind-P ind-Q → (cong₂ _Poly+_ ind-P ind-Q) ∙ (Poly+-Rid 0P)
1P : Poly A' n
1P = base (replicate zero) 1r
Poly*-Rid : (P : Poly A' n) → P Poly* 1P ≡ P
Poly*-Rid = Poly-Ind-Prop.f A' n (λ P → (P Poly* 1P) ≡ P) (λ _ → trunc _ _)
refl
(λ v a → cong₂ base (+n-vec-rid v) (·Rid a))
(λ {P Q} ind-P ind-Q → cong₂ _Poly+_ ind-P ind-Q)
Poly*-Lid : (P : Poly A' n) → 1P Poly* P ≡ P
Poly*-Lid = Poly-Ind-Prop.f A' n (λ P → (1P Poly* P) ≡ P) (λ _ → trunc _ _)
refl
(λ v a → cong₂ base (+n-vec-lid v) (·Lid a))
λ {P Q} ind-P ind-Q → cong₂ _Poly+_ ind-P ind-Q
Poly*-Rdist : (P Q R : Poly A' n) → P Poly* (Q Poly+ R) ≡ (P Poly* Q) Poly+ (P Poly* R)
Poly*-Rdist = Poly-Ind-Prop.f A' n _
(λ P p q i Q R j → trunc (P Poly* (Q Poly+ R)) ((P Poly* Q) Poly+ (P Poly* R)) (p Q R) (q Q R) i j)
(λ _ _ → sym (Poly+-Rid 0P))
(λ v a → λ Q R → refl)
λ {U V} ind-U ind-V Q R → (cong₂ _Poly+_ (ind-U Q R) (ind-V Q R)) ∙ Poly-com-adv (U Poly* Q) (U Poly* R) (V Poly* Q) (V Poly* R)
Poly*-Ldist : (P Q R : Poly A' n) → (P Poly+ Q) Poly* R ≡ (P Poly* R) Poly+ (Q Poly* R)
Poly*-Ldist P Q R = refl
Poly*-comm : (P Q : Poly A' n) → P Poly* Q ≡ Q Poly* P
Poly*-comm = Poly-Ind-Prop.f A' n _
(λ P p q i Q j → trunc (P Poly* Q) (Q Poly* P) (p Q) (q Q) i j)
(λ Q → sym (0PRightAnnihilatesPoly Q))
(λ v a → Poly-Ind-Prop.f A' n _ (λ _ → trunc _ _)
refl
(λ v' a' → cong₂ base (+n-vec-comm v v') (·Comm a a'))
(λ {U V} ind-U ind-V → cong₂ _Poly+_ ind-U ind-V))
λ {U V} ind-U ind-V Q → ((cong₂ _Poly+_ (ind-U Q) (ind-V Q)) ∙ sym (Poly*-Rdist Q U V))
| {
"alphanum_fraction": 0.4201866978,
"avg_line_length": 46.8306010929,
"ext": "agda",
"hexsha": "8c9564d6045a61ce966670df1ff8fb6372bde71b",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "howsiyu/cubical",
"max_forks_repo_path": "Cubical/Algebra/Polynomials/Multivariate/Properties.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "howsiyu/cubical",
"max_issues_repo_path": "Cubical/Algebra/Polynomials/Multivariate/Properties.agda",
"max_line_length": 144,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "howsiyu/cubical",
"max_stars_repo_path": "Cubical/Algebra/Polynomials/Multivariate/Properties.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2966,
"size": 8570
} |
{-# OPTIONS --cubical --no-import-sorts #-}
open import Cubical.Foundations.Everything renaming (_⁻¹ to _⁻¹ᵖ; assoc to ∙-assoc)
open import Function.Base using (_∋_; _$_)
open import Cubical.Data.Sum.Base renaming (_⊎_ to infixr 4 _⊎_)
open import Cubical.HITs.PropositionalTruncation.Base -- ∣_∣
open import Cubical.HITs.PropositionalTruncation.Properties using (propTruncIsProp) renaming (elim to ∣∣-elim)
open import Cubical.Foundations.Logic renaming
( inl to inlᵖ
; inr to inrᵖ
; _⇒_ to infixr 0 _⇒_ -- shifting by -6
; _⇔_ to infixr -2 _⇔_ --
; ∃[]-syntax to infix -4 ∃[]-syntax --
; ∃[∶]-syntax to infix -4 ∃[∶]-syntax --
; ∀[∶]-syntax to infix -4 ∀[∶]-syntax --
; ∀[]-syntax to infix -4 ∀[]-syntax --
)
open import Utils
open import MorePropAlgebra.Bundles
open import MoreLogic.Definitions hiding (≡ˢ-syntax)
open import MoreLogic.Reasoning
open import MoreLogic.Properties
module MorePropAlgebra.Properties.Lattice {ℓ} {ℓ'} (assumptions : Lattice {ℓ} {ℓ'}) where
open Lattice assumptions renaming (Carrier to A)
module OnType where
abstract
≤-reflectsʳ-≡ : ∀ x y → [ (∀[ z ] z ≤ x ⇔ z ≤ y) ⇔ x ≡ₚ y ]
≤-reflectsʳ-≡ x y .fst z≤x⇔z≤y = ≤-antisym x y (z≤x⇔z≤y x .fst (≤-refl x)) (z≤x⇔z≤y y .snd (≤-refl y))
≤-reflectsʳ-≡ x y .snd x≡y z .fst = substₚ (λ p → z ≤ p) x≡y
≤-reflectsʳ-≡ x y .snd x≡y z .snd = substₚ (λ p → z ≤ p) (symₚ x≡y)
≤-reflectsˡ-≡ : ∀ x y → [ (∀[ z ] x ≤ z ⇔ y ≤ z) ⇔ x ≡ₚ y ]
≤-reflectsˡ-≡ x y .fst x≤z⇔y≤z = ≤-antisym x y (x≤z⇔y≤z y .snd (≤-refl y)) (x≤z⇔y≤z x .fst (≤-refl x))
≤-reflectsˡ-≡ x y .snd x≡y z .fst = substₚ (λ p → p ≤ z) x≡y
≤-reflectsˡ-≡ x y .snd x≡y z .snd = substₚ (λ p → p ≤ z) (symₚ x≡y)
min-≤ : ∀ x y → [ (min x y ≤ x) ⊓ (min x y ≤ y) ]
min-≤ x y = is-min x y (min x y) .fst (≤-refl (min x y))
max-≤ : ∀ x y → [ (x ≤ max x y) ⊓ (y ≤ max x y) ]
max-≤ x y = is-max x y (max x y) .fst (≤-refl (max x y))
min-identity-≤ : ∀ x y → [ x ≤ y ] → [ min x y ≡ₚ x ]
min-identity-≤ x y x≤y = symₚ $ ≤-antisym x (min x y) (is-min x y x .snd (≤-refl x , x≤y)) (min-≤ x y .fst)
max-identity-≤ : ∀ x y → [ x ≤ y ] → [ max x y ≡ₚ y ]
max-identity-≤ x y x≤y = symₚ $ ≤-antisym y (max x y) (max-≤ x y .snd) (is-max x y y .snd (x≤y , ≤-refl y))
-- min-≤-⊔ : ∀ x y z → [ min x y ≤ z ] → [ (x ≤ z) ⊔ (y ≤ z) ]
-- min-≤-⊔ x y z mxy≤z = {! contraposition (x ≤ y) ⊓ (y ≤ z) (x ≤ z) $ uncurryₚ (x ≤ y) (y ≤ z) (x ≤ z)$ ≤-trans x y z !}
min-identity : ∀ x → [ min x x ≡ₚ x ]
min-identity x =
let p = is-min x x x .snd (≤-refl x , ≤-refl x)
q = min-≤ x x .fst
in ≤-antisym (min x x) x q p
min-comm : ∀ x y → [ min x y ≡ₚ min y x ]
min-comm x y = ≤-reflectsʳ-≡ (min x y) (min y x) .fst γ where
γ : ∀ z → [ (z ≤ min x y) ⇔ (z ≤ min y x) ]
γ z .fst p = is-min y x z .snd (swap (is-min x y z .fst p))
γ z .snd p = is-min x y z .snd (swap (is-min y x z .fst p))
min-assoc : ∀ x y z → [ min (min x y) z ≡ₚ min x (min y z) ]
min-assoc x y z = ≤-reflectsʳ-≡ (min (min x y) z) (min x (min y z)) .fst γ where
γ : ∀ w → [ (w ≤ min (min x y) z) ⇔ (w ≤ min x (min y z)) ]
γ w .fst p = let (w≤mxy , w≤z) = is-min (min x y) z w .fst p
(w≤x , w≤y) = is-min x y w .fst w≤mxy
w≤myz = is-min y z w .snd (w≤y , w≤z)
in is-min x (min y z) w .snd (w≤x , w≤myz)
γ w .snd p = let (w≤x , w≤myz) = is-min x (min y z) w .fst p
(w≤y , w≤z ) = is-min y z w .fst w≤myz
w≤mxy = is-min x y w .snd (w≤x , w≤y)
in is-min (min x y) z w .snd (w≤mxy , w≤z)
max-identity : ∀ x → [ max x x ≡ₚ x ]
max-identity x =
let p = is-max x x x .snd (≤-refl x , ≤-refl x)
q = max-≤ x x .fst
in symₚ $ ≤-antisym x (max x x) q p
max-comm : ∀ x y → [ max x y ≡ₚ max y x ]
max-comm x y = ≤-reflectsˡ-≡ (max x y) (max y x) .fst γ where
γ : ∀ z → [ (max x y ≤ z) ⇔ (max y x ≤ z) ]
γ z .fst p = is-max y x z .snd (swap (is-max x y z .fst p))
γ z .snd p = is-max x y z .snd (swap (is-max y x z .fst p))
max-assoc : ∀ x y z → [ max (max x y) z ≡ₚ max x (max y z) ]
max-assoc x y z = ≤-reflectsˡ-≡ (max (max x y) z) (max x (max y z)) .fst γ where
γ : ∀ w → [ (max (max x y) z ≤ w) ⇔ (max x (max y z)) ≤ w ]
γ w .fst p = let (mxy≤w , z≤w) = is-max (max x y) z w .fst p
(x≤w , y≤w) = is-max x y w .fst mxy≤w
myz≤w = is-max y z w .snd (y≤w , z≤w)
in is-max x (max y z) w .snd (x≤w , myz≤w)
γ w .snd p = let (x≤w , myz≤w) = is-max x (max y z) w .fst p
(y≤w , z≤w ) = is-max y z w .fst myz≤w
mxy≤w = is-max x y w .snd (x≤w , y≤w)
in is-max (max x y) z w .snd (mxy≤w , z≤w)
min-max-absorptive : ∀ x y → [ min x (max x y) ≡ₚ x ]
min-max-absorptive x y = ≤-reflectsʳ-≡ (min x (max x y)) x .fst γ where
γ : ∀ z → [ (z ≤ min x (max x y)) ⇔ (z ≤ x) ]
γ z .fst p = is-min x (max x y) z .fst p .fst
γ z .snd p = is-min x (max x y) z .snd (p , ≤-trans _ _ _ p (max-≤ x y .fst))
max-min-absorptive : ∀ x y → [ max x (min x y) ≡ₚ x ]
max-min-absorptive x y = ≤-reflectsˡ-≡ (max x (min x y)) x .fst γ where
γ : ∀ z → [ (max x (min x y) ≤ z) ⇔ (x ≤ z) ]
γ z .fst p = is-max x (min x y) z .fst p .fst
γ z .snd p = is-max x (min x y) z .snd (p , ≤-trans _ _ _ (min-≤ x y .fst) p)
-- min-split : ∀ x y → [ x ≤ min x y ⊔ y ≤ min x y ]
-- min-split x y = {! is-min x y x !}
-- min-elim : ∀ x y → P x → P y → P (min x y)
-- w < x + z → w <
-- w ≤ a + b → w ≤ a ⊔ w ≤ b
-- also interesting: interaction of max and abs
-- https://math.stackexchange.com/questions/3149575/max-and-min-inequality
module +-inv⇒
(_+_ : A → A → A)
(0f : A)
(+-creates-≤ : ∀ a b x → [ (a ≤ b) ⇔ ((a + x) ≤ (b + x)) ])
(+-assoc : ∀ a b c → [ ((a + b) + c) ≡ₚ (a + (b + c)) ])
(+-identityʳ : ∀ x → [ (x + 0f) ≡ₚ x ])
(+-comm : ∀ a b → [ (a + b) ≡ₚ (b + a) ])
(+-inv'' : ∀ x → [ ∃[ y ] (x + y) ≡ₚ 0f ])
where
≤-min-+ : ∀ a b c w → [ w ≤ (a + c) ] → [ w ≤ (b + c) ] → [ w ≤ (min a b + c) ]
≤-min-+ a b c w w≤a+c w≤b+c = ∣∣-elim (λ _ → isProp[] (w ≤ (min a b + c))) (λ{ (-c , p) → γ -c p }) (+-inv'' c) where
γ : ∀ -c → [ (c + -c) ≡ₚ 0f ] → [ w ≤ (min a b + c) ]
γ -c p = (
(w ≤ (a + c) ) ⊓ (w ≤ (b + c) ) ⇒ᵖ⟨ (λ{ (q , r) → +-creates-≤ w (a + c) -c .fst q , +-creates-≤ w (b + c) -c .fst r}) ⟩
(w + -c ≤ (a + c) + -c) ⊓ (w + -c ≤ (b + c) + -c) ⇒ᵖ⟨ (λ{ (q , r) → substₚ (λ p → w + -c ≤ p) (+-assoc a c -c) q , substₚ (λ p → w + -c ≤ p) (+-assoc b c -c) r}) ⟩
(w + -c ≤ a + (c + -c)) ⊓ (w + -c ≤ b + (c + -c)) ⇒ᵖ⟨ (λ{ (q , r) → substₚ (λ p → w + -c ≤ a + p) p q , substₚ (λ p → w + -c ≤ b + p) p r}) ⟩
(w + -c ≤ a + 0f ) ⊓ (w + -c ≤ b + 0f ) ⇒ᵖ⟨ (λ{ (q , r) → substₚ (λ p → w + -c ≤ p) (+-identityʳ a) q , substₚ (λ p → w + -c ≤ p) (+-identityʳ b) r}) ⟩
(w + -c ≤ a ) ⊓ (w + -c ≤ b ) ⇒ᵖ⟨ is-min a b (w + -c) .snd ⟩
(w + -c ≤ min a b ) ⇒ᵖ⟨ +-creates-≤ (w + -c) (min a b) c .fst ⟩
((w + -c) + c ≤ min a b + c) ⇒ᵖ⟨ substₚ (λ p → p ≤ min a b + c) (+-assoc w -c c) ⟩
(w + (-c + c) ≤ min a b + c) ⇒ᵖ⟨ substₚ (λ p → w + p ≤ min a b + c) (substₚ (λ p → p ≡ₚ 0f) (+-comm c -c) p) ⟩
(w + 0f ≤ min a b + c) ⇒ᵖ⟨ substₚ (λ p → p ≤ min a b + c) (+-identityʳ w) ⟩
(w ≤ min a b + c) ◼ᵖ) .snd (w≤a+c , w≤b+c)
≤-max-+ : ∀ a b c w → [ (a + c) ≤ w ] → [ (b + c) ≤ w ] → [ (max a b + c) ≤ w ]
≤-max-+ a b c w a+c≤w b+c≤ = ∣∣-elim (λ _ → isProp[] ((max a b + c) ≤ w)) (λ{ (-c , p) → γ -c p }) (+-inv'' c) where
γ : ∀ -c → [ (c + -c) ≡ₚ 0f ] → [ (max a b + c) ≤ w ]
γ -c p = (
((a + c) ≤ w ) ⊓ ((b + c) ≤ w ) ⇒ᵖ⟨ (λ{ (q , r) → +-creates-≤ (a + c) w -c .fst q , +-creates-≤ (b + c) w -c .fst r }) ⟩
((a + c) + -c ≤ w + -c) ⊓ ((b + c) + -c ≤ w + -c) ⇒ᵖ⟨ (λ{ (q , r) → substₚ (λ p → p ≤ w + -c) (+-assoc a c -c) q , substₚ (λ p → p ≤ w + -c) (+-assoc b c -c) r }) ⟩
(a + (c + -c) ≤ w + -c) ⊓ (b + (c + -c) ≤ w + -c) ⇒ᵖ⟨ (λ{ (q , r) → substₚ (λ p → a + p ≤ w + -c) p q , substₚ (λ p → b + p ≤ w + -c) p r }) ⟩
(a + 0f ≤ w + -c) ⊓ (b + 0f ≤ w + -c) ⇒ᵖ⟨ (λ{ (q , r) → substₚ (λ p → p ≤ w + -c) (+-identityʳ a) q , substₚ (λ p → p ≤ w + -c) (+-identityʳ b) r }) ⟩
(a ≤ w + -c) ⊓ (b ≤ w + -c) ⇒ᵖ⟨ is-max a b (w + -c) .snd ⟩
(max a b ≤ w + -c) ⇒ᵖ⟨ +-creates-≤ (max a b) (w + -c) c .fst ⟩
(max a b + c ≤ (w + -c) + c) ⇒ᵖ⟨ substₚ (λ p → max a b + c ≤ p) (+-assoc w -c c) ⟩
(max a b + c ≤ w + (-c + c)) ⇒ᵖ⟨ substₚ (λ p → max a b + c ≤ w + p) (substₚ (λ p → p ≡ₚ 0f) (+-comm c -c) p) ⟩
(max a b + c ≤ w + 0f) ⇒ᵖ⟨ substₚ (λ p → max a b + c ≤ p) (+-identityʳ w) ⟩
(max a b + c ≤ w) ◼ᵖ) .snd (a+c≤w , b+c≤)
module ·-inv⇒
{ℓ}
(_·_ : A → A → A)
(_#_ : hPropRel A A ℓ)
(0f 1f : A)
(·-creates-≤ : ∀ a b x → [ 0f ≤ x ] → [ (a ≤ b) ⇔ ((a · x) ≤ (b · x)) ])
(·-assoc : ∀ a b c → [ ((a · b) · c) ≡ₚ (a · (b · c)) ])
(·-identityʳ : ∀ x → [ (x · 0f) ≡ₚ x ])
(·-comm : ∀ a b → [ (a · b) ≡ₚ (b · a) ])
(·-inv'' : ∀ x → [ ∃[ y ] (x · y) ≡ₚ 1f ])
where
-- ≤-min-· : ∀ a b c w → [ w ≤ (a · c) ] → [ w ≤ (b · c) ] → [ w ≤ (min a b · c) ]
-- ≤-min-· a b c w w≤a·c w≤b· = {! is-min a b !}
--
-- ≤-max-· : ∀ a b c w → [ (a · c) ≤ w ] → [ (b · c) ≤ w ] → [ (max a b · c) ≤ w ]
-- ≤-max-· a b c w a·c≤w b·c≤ = {! !}
module ≤-dicho⇒+
(_+_ : A → A → A)
(≤-dicho : ∀ x y → [ (x ≤ y) ⊔ (y ≤ x) ])
where
≤-min-+ : ∀ a b c w → [ w ≤ (a + c) ] → [ w ≤ (b + c) ] → [ w ≤ (min a b + c) ]
≤-min-+ a b c w w≤a+c w≤b+c = case ≤-dicho a b as (a ≤ b) ⊔ (b ≤ a) ⇒ (w ≤ (min a b + c)) of λ
{ (inl a≤b) → substₚ (λ p → w ≤ p + c) (symₚ (min-identity-≤ a b a≤b)) w≤a+c
; (inr b≤a) → substₚ (λ p → w ≤ p + c) (substₚ (λ p → b ≡ₚ p) (min-comm b a) (symₚ (min-identity-≤ b a b≤a))) w≤b+c
}
≤-max-+ : ∀ a b c w → [ (a + c) ≤ w ] → [ (b + c) ≤ w ] → [ (max a b + c) ≤ w ]
≤-max-+ a b c w a+c≤w b+c≤w = case ≤-dicho a b as (a ≤ b) ⊔ (b ≤ a) ⇒ ((max a b + c) ≤ w) of λ
{ (inl a≤b) → substₚ (λ p → p + c ≤ w) (symₚ (max-identity-≤ a b a≤b)) b+c≤w
; (inr b≤a) → substₚ (λ p → p + c ≤ w) (substₚ (λ p → a ≡ₚ p) (max-comm b a) (symₚ (max-identity-≤ b a b≤a))) a+c≤w
}
module ≤-dicho⇒·
(_·_ : A → A → A)
(≤-dicho : ∀ x y → [ (x ≤ y) ⊔ (y ≤ x) ])
where
≤-min-· : ∀ a b c w → [ w ≤ (a · c) ] → [ w ≤ (b · c) ] → [ w ≤ (min a b · c) ]
≤-min-· a b c w w≤a·c w≤b·c = case ≤-dicho a b as (a ≤ b) ⊔ (b ≤ a) ⇒ (w ≤ (min a b · c)) of λ
{ (inl a≤b) → substₚ (λ p → w ≤ p · c) (symₚ (min-identity-≤ a b a≤b)) w≤a·c
; (inr b≤a) → substₚ (λ p → w ≤ p · c) (substₚ (λ p → b ≡ₚ p) (min-comm b a) (symₚ (min-identity-≤ b a b≤a))) w≤b·c
}
≤-max-· : ∀ a b c w → [ (a · c) ≤ w ] → [ (b · c) ≤ w ] → [ (max a b · c) ≤ w ]
≤-max-· a b c w a·c≤w b·c≤w = case ≤-dicho a b as (a ≤ b) ⊔ (b ≤ a) ⇒ ((max a b · c) ≤ w) of λ
{ (inl a≤b) → substₚ (λ p → p · c ≤ w) (symₚ (max-identity-≤ a b a≤b)) b·c≤w
; (inr b≤a) → substₚ (λ p → p · c ≤ w) (substₚ (λ p → a ≡ₚ p) (max-comm b a) (symₚ (max-identity-≤ b a b≤a))) a·c≤w
}
+-min-distribʳ' : (_+_ : A → A → A) (+-creates-≤ : ∀ a b x → [ (a ≤ b) ⇔ ((a + x) ≤ (b + x)) ])
→ ∀ x y z w → [ (w ≤ (min x y + z)) ⇒ (w ≤ min (x + z) (y + z)) ]
+-min-distribʳ' _+_ +-creates-≤ x y z w p = (
( min x y ≤ x ) ⊓ ( min x y ≤ y ) ⇒ᵖ⟨ (λ{ (q , r) → +-creates-≤ (min x y) x z .fst q , +-creates-≤ (min x y) y z .fst r}) ⟩
((min x y + z ) ≤ (x + z)) ⊓ ((min x y + z) ≤ (y + z)) ⇒ᵖ⟨ (λ{ (q , r) → ≤-trans _ _ _ p q , ≤-trans _ _ _ p r}) ⟩
( w ≤ (x + z)) ⊓ ( w ≤ (y + z)) ⇒ᵖ⟨ is-min (x + z) (y + z) w .snd ⟩
( w ≤ min (x + z) (y + z)) ◼ᵖ) .snd (min-≤ x y)
·-min-distribʳ' : (0f : A) (_·_ : A → A → A) (·-creates-≤ : ∀ a b x → [ 0f ≤ x ] → [ (a ≤ b) ⇔ ((a · x) ≤ (b · x)) ])
→ ∀ x y z w → [ 0f ≤ z ] → [ (w ≤ (min x y · z)) ⇒ (w ≤ min (x · z) (y · z)) ]
·-min-distribʳ' 0f _·_ ·-creates-≤ x y z w 0≤z p = (
( min x y ≤ x ) ⊓ ( min x y ≤ y ) ⇒ᵖ⟨ (λ{ (q , r) → ·-creates-≤ (min x y) x z 0≤z .fst q , ·-creates-≤ (min x y) y z 0≤z .fst r}) ⟩
((min x y · z) ≤ (x · z)) ⊓ ((min x y · z) ≤ (y · z)) ⇒ᵖ⟨ (λ{ (q , r) → ≤-trans _ _ _ p q , ≤-trans _ _ _ p r}) ⟩
( w ≤ (x · z)) ⊓ ( w ≤ (y · z)) ⇒ᵖ⟨ is-min (x · z) (y · z) w .snd ⟩
( w ≤ min (x · z) (y · z)) ◼ᵖ) .snd (min-≤ x y)
+-max-distribʳ' : (_+_ : A → A → A) (+-creates-≤ : ∀ a b x → [ (a ≤ b) ⇔ ((a + x) ≤ (b + x)) ])
→ ∀ x y z w → [ ((max x y + z) ≤ w) ⇒ (max (x + z) (y + z) ≤ w) ]
+-max-distribʳ' _+_ +-creates-≤ x y z w p = (
( x ≤ max x y ) ⊓ ( y ≤ max x y ) ⇒ᵖ⟨ (λ{ (q , r) → +-creates-≤ x (max x y) z .fst q , +-creates-≤ y (max x y) z .fst r}) ⟩
((x + z) ≤ (max x y + z )) ⊓ ((y + z) ≤ (max x y + z)) ⇒ᵖ⟨ (λ{ (q , r) → ≤-trans _ _ _ q p , ≤-trans _ _ _ r p}) ⟩
((x + z) ≤ w ) ⊓ ((y + z) ≤ w ) ⇒ᵖ⟨ is-max (x + z) (y + z) w .snd ⟩
( max (x + z) (y + z) ≤ w) ◼ᵖ) .snd (max-≤ x y)
·-max-distribʳ' : (0f : A) (_·_ : A → A → A) (·-creates-≤ : ∀ a b x → [ 0f ≤ x ] → [ (a ≤ b) ⇔ ((a · x) ≤ (b · x)) ])
→ ∀ x y z w → [ 0f ≤ z ] → [ ((max x y · z) ≤ w) ⇒ (max (x · z) (y · z) ≤ w) ]
·-max-distribʳ' 0f _·_ ·-creates-≤ x y z w 0≤z p = (
( x ≤ max x y ) ⊓ (y ≤ max x y ) ⇒ᵖ⟨ (λ{ (q , r) → ·-creates-≤ x (max x y) z 0≤z .fst q , ·-creates-≤ y (max x y) z 0≤z .fst r}) ⟩
((x · z) ≤ (max x y · z)) ⊓ ((y · z) ≤ (max x y · z)) ⇒ᵖ⟨ (λ{ (q , r) → ≤-trans _ _ _ q p , ≤-trans _ _ _ r p}) ⟩
((x · z) ≤ w ) ⊓ ((y · z) ≤ w ) ⇒ᵖ⟨ is-max (x · z) (y · z) w .snd ⟩
( max (x · z) (y · z) ≤ w) ◼ᵖ) .snd (max-≤ x y)
+-min-distribʳ : (_+_ : A → A → A)
→ (+-creates-≤ : ∀ a b x → [ (a ≤ b) ⇔ ((a + x) ≤ (b + x)) ])
→ (≤-min-+ : ∀ a b c w → [ w ≤ (a + c) ] → [ w ≤ (b + c) ] → [ w ≤ (min a b + c) ])
→ ∀ x y z → [ (min x y + z) ≡ₚ min (x + z) (y + z) ]
+-min-distribʳ _+_ +-creates-≤ ≤-min-+ x y z = ≤-reflectsʳ-≡ (min x y + z) (min (x + z) (y + z)) .fst γ where
γ : ∀ w → [ (w ≤ (min x y + z)) ⇔ (w ≤ min (x + z) (y + z)) ]
γ w .fst p = +-min-distribʳ' _+_ +-creates-≤ x y z w p
γ w .snd p = let (w≤x+z , w≤y+z) = is-min (x + z) (y + z) w .fst p
in ≤-min-+ x y z w w≤x+z w≤y+z
·-min-distribʳ : (0f : A) (_·_ : A → A → A)
→ (·-creates-≤ : ∀ a b x → [ 0f ≤ x ] → [ (a ≤ b) ⇔ ((a · x) ≤ (b · x)) ])
→ (≤-min-· : ∀ a b c w → [ w ≤ (a · c) ] → [ w ≤ (b · c) ] → [ w ≤ (min a b · c) ])
→ ∀ x y z → [ 0f ≤ z ] → [ (min x y · z) ≡ₚ min (x · z) (y · z) ]
·-min-distribʳ 0f _·_ ·-creates-≤ ≤-min-· x y z 0≤z = ≤-reflectsʳ-≡ (min x y · z) (min (x · z) (y · z)) .fst γ where
γ : ∀ w → [ (w ≤ (min x y · z)) ⇔ (w ≤ min (x · z) (y · z)) ]
γ w .fst p = ·-min-distribʳ' 0f _·_ ·-creates-≤ x y z w 0≤z p
γ w .snd p = let (w≤x·z , w≤y·z) = is-min (x · z) (y · z) w .fst p
in ≤-min-· x y z w w≤x·z w≤y·z
+-max-distribʳ : (_+_ : A → A → A)
→ (+-creates-≤ : ∀ a b x → [ (a ≤ b) ⇔ ((a + x) ≤ (b + x)) ])
→ (≤-max-+ : ∀ a b c w → [ (a + c) ≤ w ] → [ (b + c) ≤ w ] → [ (max a b + c) ≤ w ])
→ ∀ x y z → [ (max x y + z) ≡ₚ max (x + z) (y + z) ]
+-max-distribʳ _+_ +-creates-≤ ≤-max-+ x y z = ≤-reflectsˡ-≡ (max x y + z) (max (x + z) (y + z)) .fst γ where
γ : ∀ w → [ ((max x y + z) ≤ w) ⇔ (max (x + z) (y + z) ≤ w) ]
γ w .fst p = +-max-distribʳ' _+_ +-creates-≤ x y z w p
γ w .snd p = let (w≤x+z , w≤y+z) = is-max (x + z) (y + z) w .fst p
in ≤-max-+ x y z w w≤x+z w≤y+z
·-max-distribʳ : (0f : A) (_·_ : A → A → A)
→ (·-creates-≤ : ∀ a b x → [ 0f ≤ x ] → [ (a ≤ b) ⇔ ((a · x) ≤ (b · x)) ])
→ (≤-max-· : ∀ a b c w → [ (a · c) ≤ w ] → [ (b · c) ≤ w ] → [ (max a b · c) ≤ w ])
→ ∀ x y z → [ 0f ≤ z ] → [ (max x y · z) ≡ₚ max (x · z) (y · z) ]
·-max-distribʳ 0f _·_ ·-creates-≤ ≤-max-· x y z 0≤z = ≤-reflectsˡ-≡ (max x y · z) (max (x · z) (y · z)) .fst γ where
γ : ∀ w → [ ((max x y · z) ≤ w) ⇔ (max (x · z) (y · z) ≤ w) ]
γ w .fst p = ·-max-distribʳ' 0f _·_ ·-creates-≤ x y z w 0≤z p
γ w .snd p = let (w≤x·z , w≤y·z) = is-max (x · z) (y · z) w .fst p
in ≤-max-· x y z w w≤x·z w≤y·z
-- -flips-min : ∀ x y → min (- x) (- y) ≡ - max x y
-- -flips-min x y = ?
--
-- -·-flips-min : ∀ x y z → [ z < 0 ] → min x y · z ≡ max (x · z) (y · z)
-- -·-flips-min x y z = ?
module OnSet (is-set : isSet A)
(let _≡ˢ_ = λ(x y : A) → MoreLogic.Definitions.≡ˢ-syntax x y {is-set}
infixl 4 _≡ˢ_
) where
open OnType public using (min-≤; max-≤)
module ≤-dicho⇒+ = OnType.≤-dicho⇒+
module ≤-dicho⇒· = OnType.≤-dicho⇒·
≤-reflectsʳ-≡ : ∀ x y → [ (∀[ z ] z ≤ x ⇔ z ≤ y) ⇔ x ≡ˢ y ]
≤-reflectsʳ-≡ x y .fst p = ∣∣-elim (λ c → is-set x y) (λ x → x) (OnType.≤-reflectsʳ-≡ x y .fst p)
≤-reflectsʳ-≡ x y .snd p = OnType.≤-reflectsʳ-≡ x y .snd ∣ p ∣
≤-reflectsˡ-≡ : ∀ x y → [ (∀[ z ] x ≤ z ⇔ y ≤ z) ⇔ x ≡ˢ y ]
≤-reflectsˡ-≡ x y .fst p = ∣∣-elim (λ c → is-set x y) (λ x → x) (OnType.≤-reflectsˡ-≡ x y .fst p)
≤-reflectsˡ-≡ x y .snd p = OnType.≤-reflectsˡ-≡ x y .snd ∣ p ∣
min-identity : ∀ x → [ min x x ≡ˢ x ]
min-identity x = ∣∣-elim (λ c → is-set (min x x) x) (λ x → x) (OnType.min-identity x)
min-identity-≤ : ∀ x y → [ x ≤ y ] → [ min x y ≡ˢ x ]
min-identity-≤ x y p = ∣∣-elim (λ c → is-set (min x y) x) (λ x → x) (OnType.min-identity-≤ x y p)
max-identity-≤ : ∀ x y → [ x ≤ y ] → [ max x y ≡ˢ y ]
max-identity-≤ x y p = ∣∣-elim (λ c → is-set (max x y) y) (λ x → x) (OnType.max-identity-≤ x y p)
min-comm : ∀ x y → [ min x y ≡ˢ min y x ]
min-comm x y = ∣∣-elim (λ c → is-set (min x y) (min y x)) (λ x → x) (OnType.min-comm x y)
min-assoc : ∀ x y z → [ min (min x y) z ≡ˢ min x (min y z) ]
min-assoc x y z = ∣∣-elim (λ c → is-set (min (min x y) z) (min x (min y z))) (λ x → x) (OnType.min-assoc x y z)
max-identity : ∀ x → [ max x x ≡ˢ x ]
max-identity x = ∣∣-elim (λ c → is-set (max x x) x) (λ x → x) (OnType.max-identity x)
max-comm : ∀ x y → [ max x y ≡ˢ max y x ]
max-comm x y = ∣∣-elim (λ c → is-set (max x y) (max y x)) (λ x → x) (OnType.max-comm x y)
max-assoc : ∀ x y z → [ max (max x y) z ≡ˢ max x (max y z) ]
max-assoc x y z = ∣∣-elim (λ c → is-set (max (max x y) z) (max x (max y z))) (λ x → x) (OnType.max-assoc x y z)
min-max-absorptive : ∀ x y → [ min x (max x y) ≡ˢ x ]
min-max-absorptive x y = ∣∣-elim (λ c → is-set (min x (max x y)) x) (λ x → x) (OnType.min-max-absorptive x y)
max-min-absorptive : ∀ x y → [ max x (min x y) ≡ˢ x ]
max-min-absorptive x y = ∣∣-elim (λ c → is-set (max x (min x y)) x) (λ x → x) (OnType.max-min-absorptive x y)
+-min-distribʳ : (_+_ : A → A → A)
→ (+-creates-≤ : ∀ a b x → [ (a ≤ b) ⇔ ((a + x) ≤ (b + x)) ])
→ (≤-min-+ : ∀ a b c w → [ w ≤ (a + c) ] → [ w ≤ (b + c) ] → [ w ≤ (min a b + c) ])
→ ∀ x y z → [ (min x y + z) ≡ˢ min (x + z) (y + z) ]
+-min-distribʳ _+_ +-creates-≤ ≤-min-+ x y z = ∣∣-elim (λ c → is-set (min x y + z) (min (x + z) (y + z))) (λ x → x) (OnType.+-min-distribʳ _+_ +-creates-≤ ≤-min-+ x y z)
·-min-distribʳ : (0f : A) (_·_ : A → A → A)
→ (·-creates-≤ : ∀ a b x → [ 0f ≤ x ] → [ (a ≤ b) ⇔ ((a · x) ≤ (b · x)) ])
→ (≤-min-· : ∀ a b c w → [ w ≤ (a · c) ] → [ w ≤ (b · c) ] → [ w ≤ (min a b · c) ])
→ ∀ x y z → [ 0f ≤ z ] → [ (min x y · z) ≡ˢ min (x · z) (y · z) ]
·-min-distribʳ 0f _·_ ·-creates-≤ ≤-min-· x y z 0≤z = ∣∣-elim (λ c → is-set (min x y · z) (min (x · z) (y · z))) (λ x → x) (OnType.·-min-distribʳ 0f _·_ ·-creates-≤ ≤-min-· x y z 0≤z)
+-max-distribʳ : (_+_ : A → A → A)
→ (+-creates-≤ : ∀ a b x → [ (a ≤ b) ⇔ ((a + x) ≤ (b + x)) ])
→ (≤-max-+ : ∀ a b c w → [ (a + c) ≤ w ] → [ (b + c) ≤ w ] → [ (max a b + c) ≤ w ])
→ ∀ x y z → [ (max x y + z) ≡ˢ max (x + z) (y + z) ]
+-max-distribʳ _+_ +-creates-≤ ≤-max-+ x y z = ∣∣-elim (λ c → is-set (max x y + z) (max (x + z) (y + z))) (λ x → x) (OnType.+-max-distribʳ _+_ +-creates-≤ ≤-max-+ x y z)
·-max-distribʳ : (0f : A) (_·_ : A → A → A)
→ (·-creates-≤ : ∀ a b x → [ 0f ≤ x ] → [ (a ≤ b) ⇔ ((a · x) ≤ (b · x)) ])
→ (≤-max-· : ∀ a b c w → [ (a · c) ≤ w ] → [ (b · c) ≤ w ] → [ (max a b · c) ≤ w ])
→ ∀ x y z → [ 0f ≤ z ] → [ (max x y · z) ≡ˢ max (x · z) (y · z) ]
·-max-distribʳ 0f _·_ ·-creates-≤ ≤-max-· x y z 0≤z = ∣∣-elim (λ c → is-set (max x y · z) (max (x · z) (y · z))) (λ x → x) (OnType.·-max-distribʳ 0f _·_ ·-creates-≤ ≤-max-· x y z 0≤z)
| {
"alphanum_fraction": 0.3854431257,
"avg_line_length": 59.1612021858,
"ext": "agda",
"hexsha": "fa4c1d1d274da2f789f1448866036ccef04eee66",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "10206b5c3eaef99ece5d18bf703c9e8b2371bde4",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "mchristianl/synthetic-reals",
"max_forks_repo_path": "agda/MorePropAlgebra/Properties/Lattice.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "10206b5c3eaef99ece5d18bf703c9e8b2371bde4",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "mchristianl/synthetic-reals",
"max_issues_repo_path": "agda/MorePropAlgebra/Properties/Lattice.agda",
"max_line_length": 185,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "10206b5c3eaef99ece5d18bf703c9e8b2371bde4",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "mchristianl/synthetic-reals",
"max_stars_repo_path": "agda/MorePropAlgebra/Properties/Lattice.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-19T12:15:21.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-07-31T18:15:26.000Z",
"num_tokens": 10582,
"size": 21653
} |
-- Liang-Ting, 2022-01-14, issue #5734
{-# OPTIONS --cubical-compatible #-}
open import Agda.Builtin.Unit
open import Agda.Builtin.List
open import Agda.Builtin.Sigma
open import Agda.Builtin.Reflection
renaming (returnTC to return; bindTC to _>>=_)
open import Agda.Primitive
private variable
A B : Set _
reverseApp : List A → List A → List A
reverseApp [] ys = ys
reverseApp (x ∷ xs) ys = reverseApp xs (x ∷ ys)
reverse : List A → List A
reverse xs = reverseApp xs []
extend*Context : Telescope → TC A → TC A
extend*Context [] m = m
extend*Context ((s , a) ∷ tel) m = extendContext s a (extend*Context tel m)
pattern vArg x = arg (arg-info visible (modality relevant quantity-ω)) x
pattern visible-relevant-erased = arg-info visible (modality relevant quantity-0)
pattern var₀ x = var x []
Γ : Telescope
Γ = ("ℓ" , arg visible-relevant-erased (quoteTerm Level))
∷ ("A" , vArg (agda-sort (set (var₀ 0))))
∷ []
macro
m : Term → TC ⊤
m hole = do
_ ← extend*Context Γ do
_ ← checkType (var₀ 0) (agda-sort (set (var₀ 1)))
return tt
inContext (reverse Γ) do
return tt
_ : ⊤
_ = m
| {
"alphanum_fraction": 0.6527415144,
"avg_line_length": 24.9782608696,
"ext": "agda",
"hexsha": "9bf877918b90cc6e997d1a291c143a0a54abbecf",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "KDr2/agda",
"max_forks_repo_path": "test/Succeed/Issue5734.agda",
"max_issues_count": 6,
"max_issues_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_issues_repo_issues_event_max_datetime": "2021-11-24T08:31:10.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-10-18T08:12:24.000Z",
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "KDr2/agda",
"max_issues_repo_path": "test/Succeed/Issue5734.agda",
"max_line_length": 81,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "KDr2/agda",
"max_stars_repo_path": "test/Succeed/Issue5734.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 364,
"size": 1149
} |
module _ where
open import Common.IO
renaming (then to _>>_
)
open import Agda.Builtin.Unit
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality using (_≡_; refl)
open import Agda.Builtin.Float
renaming ( primFloatEquality to _≡ᵇ_
; primFloatInequality to _≤ᵇ_
; primFloatLess to _<ᵇ_
; primFloatPlus to infixl 6 _+_
; primFloatMinus to infixl 6 _-_
; primFloatTimes to infixl 7 _*_
; primFloatDiv to infixl 7 _÷_
; primFloatPow to infix 8 _**_
; primFloatNegate to infix 9 -_
; primFloatSqrt to sqrt
; primFloatExp to e^_
; primFloatLog to log
; primFloatSin to sin
; primFloatCos to cos
; primFloatTan to tan
; primFloatASin to asin
; primFloatACos to acos
; primFloatATan to atan
; primFloatATan2 to atan2
; primFloatSinh to sinh
; primFloatCosh to cosh
; primFloatTanh to tanh
; primFloatASinh to asinh
; primFloatACosh to acosh
; primFloatATanh to atanh
; primFloatRound to round
; primFloatFloor to floor
; primFloatCeiling to ceiling
; primShowFloat to showF
; primFloatToWord64 to toWord
; primFloatToRatio to toRatio
; primRatioToFloat to fromRatio
; primFloatDecode to decode
; primFloatEncode to encode
; primFloatIsInfinite to isInfinite
; primFloatIsNaN to isNaN
; primFloatIsNegativeZero to isNegativeZero
; primFloatIsSafeInteger to isSafeInteger
)
open import Agda.Builtin.Int
using (Int; pos; negsuc)
renaming ( primShowInteger to showI
)
open import Agda.Builtin.Nat
using (Nat)
renaming ( _==_ to _==N_
)
open import Agda.Builtin.Maybe
open import Agda.Builtin.Sigma
open import Agda.Builtin.String
using (String)
renaming ( primStringEquality to _==S_
; primShowNat to showN
; primStringAppend to _++_
)
open import Agda.Builtin.Word
using (Word64)
renaming ( primWord64ToNat to toℕ
)
-- Prelude
data ⊥ : Set where
_≢_ : {A : Set} (P Q : A) → Set
P ≢ Q = P ≡ Q → ⊥
NaN : Float
NaN = 0.0 ÷ 0.0
-NaN : Float
-NaN = - NaN
Infinity : Float
Infinity = 1.0 ÷ 0.0
-Infinity : Float
-Infinity = - Infinity
MaxFloat : Float
MaxFloat = 1.7976931348623157e308
MinFloat : Float
MinFloat = 2.2250738585072014e-308
MaxSafeIntF : Float
MaxSafeIntF = 9007199254740991.0
MaxSafeIntZ : Int
MaxSafeIntZ = pos 9007199254740991
-- * Tests
showB : Bool → String
showB false = "false"
showB true = "true"
maybeShow : {A : Set} (show : A → String) → Maybe A → String
maybeShow show (just x) = "(just (" ++ (show x ++ "))")
maybeShow show nothing = "nothing"
pairShow : {A B : Set} (showA : A → String) (showB : B → String) → Σ A (λ _ → B) → String
pairShow showA showB (x , y) = "(" ++ (showA x ++ (" , " ++ (showB y ++ ")")))
showR = pairShow showI showI
newline : IO ⊤
newline = putStr "\n"
T : Bool → Set
T false = ⊥
T true = ⊤
_==F_ : Float → Float → Bool
x ==F y = toℕ (toWord x) ==N toℕ (toWord x)
_==B_ : Bool → Bool → Bool
false ==B false = true
false ==B true = false
true ==B false = false
true ==B true = true
_==I_ : Int → Int → Bool
pos n ==I pos m = n ==N m
pos n ==I negsuc m = false
negsuc n ==I pos m = false
negsuc n ==I negsuc m = n ==N m
maybeEq : {A : Set} (eq : A → A → Bool) → Maybe A → Maybe A → Bool
maybeEq eq (just x) (just y) = eq x y
maybeEq eq (just x) nothing = false
maybeEq eq nothing (just y) = false
maybeEq eq nothing nothing = true
pairEq : {A B : Set} (eqA : A → A → Bool) (eqB : B → B → Bool) → Σ A (λ _ → B) → Σ A (λ _ → B) → Bool
pairEq eqA eqB (x , y) (z , w) = eqA x z && eqB y w
where
_&&_ : Bool → Bool → Bool
true && true = true
x && y = false
_==R_ = pairEq _==I_ _==I_
check : {A : Set} (show : A → String) (eq : A → A → Bool) (str : String) (exp act : A) {p : T (eq act exp)} → IO ⊤
check show eq str exp act = do
putStr str; putStr " = "; putStr (show exp); putStr " = "; putStr (show act); newline
checkB = check showB _==B_
checkS = check (λ x → x) _==S_
checkN = check showN _==N_
checkI = check showI _==I_
checkMI = check (maybeShow showI) (maybeEq _==I_)
checkR = check showR _==R_
checkF = check showF _==F_
checkMR = check (maybeShow showR) (maybeEq _==R_)
checkMF = check (maybeShow showF) (maybeEq _==F_)
-- ** Relations
main : IO ⊤
main = do
-- ** Relations
checkB " NaN ≡ᵇ NaN " false ( NaN ≡ᵇ NaN )
checkB "-NaN ≡ᵇ NaN " false (-NaN ≡ᵇ NaN )
checkB " NaN ≡ᵇ -NaN " false ( NaN ≡ᵇ -NaN )
checkB "-NaN ≡ᵇ -NaN " false (-NaN ≡ᵇ -NaN )
checkB " Infinity ≡ᵇ Infinity" true ( Infinity ≡ᵇ Infinity)
checkB "-Infinity ≡ᵇ Infinity" false (-Infinity ≡ᵇ Infinity)
checkB " Infinity ≡ᵇ -Infinity" false ( Infinity ≡ᵇ -Infinity)
checkB "-Infinity ≡ᵇ -Infinity" true (-Infinity ≡ᵇ -Infinity)
checkB " MaxFloat ≡ᵇ MaxFloat" true ( MaxFloat ≡ᵇ MaxFloat)
checkB " MinFloat ≡ᵇ MinFloat" true ( MinFloat ≡ᵇ MinFloat)
checkB " 1.0 ≡ᵇ 1.5 " false ( 1.0 ≡ᵇ 1.5 )
checkB " 1.0 ≡ᵇ 1.0 " true ( 1.0 ≡ᵇ 1.0 )
checkB " 1.5 ≡ᵇ 1.5 " true ( 1.5 ≡ᵇ 1.5 )
checkB " NaN ≤ᵇ NaN " false ( NaN ≤ᵇ NaN )
checkB "-NaN ≤ᵇ NaN " false (-NaN ≤ᵇ NaN )
checkB " NaN ≤ᵇ -NaN " false ( NaN ≤ᵇ -NaN )
checkB "-NaN ≤ᵇ -NaN " false (-NaN ≤ᵇ -NaN )
checkB " NaN ≤ᵇ 5.0 " false ( NaN ≤ᵇ 5.0 )
checkB "-NaN ≤ᵇ 5.0 " false (-NaN ≤ᵇ 5.0 )
checkB " 5.0 ≤ᵇ -NaN " false ( 5.0 ≤ᵇ -NaN )
checkB "-5.0 ≤ᵇ -NaN " false (-5.0 ≤ᵇ -NaN )
checkB " NaN ≤ᵇ Infinity" false ( NaN ≤ᵇ Infinity)
checkB "-NaN ≤ᵇ Infinity" false (-NaN ≤ᵇ Infinity)
checkB " Infinity ≤ᵇ -NaN " false ( Infinity ≤ᵇ -NaN )
checkB "-Infinity ≤ᵇ -NaN " false (-Infinity ≤ᵇ -NaN )
checkB " Infinity ≤ᵇ Infinity" true ( Infinity ≤ᵇ Infinity)
checkB "-Infinity ≤ᵇ Infinity" true (-Infinity ≤ᵇ Infinity)
checkB " Infinity ≤ᵇ -Infinity" false ( Infinity ≤ᵇ -Infinity)
checkB "-Infinity ≤ᵇ -Infinity" true (-Infinity ≤ᵇ -Infinity)
checkB " MaxFloat ≤ᵇ MaxFloat" true ( MaxFloat ≤ᵇ MaxFloat)
checkB " MinFloat ≤ᵇ MinFloat" true ( MinFloat ≤ᵇ MinFloat)
checkB " 1.0 ≤ᵇ 1.5 " true ( 1.0 ≤ᵇ 1.5 )
checkB " 1.0 ≤ᵇ 1.0 " true ( 1.0 ≤ᵇ 1.0 )
checkB " 1.5 ≤ᵇ 1.5 " true ( 1.5 ≤ᵇ 1.5 )
checkB " NaN <ᵇ NaN " false ( NaN <ᵇ NaN )
checkB "-NaN <ᵇ NaN " false (-NaN <ᵇ NaN )
checkB " NaN <ᵇ -NaN " false ( NaN <ᵇ -NaN )
checkB "-NaN <ᵇ -NaN " false (-NaN <ᵇ -NaN )
checkB " NaN <ᵇ 5.0 " false ( NaN <ᵇ 5.0 )
checkB "-NaN <ᵇ 5.0 " false (-NaN <ᵇ 5.0 )
checkB " 5.0 <ᵇ -NaN " false ( 5.0 <ᵇ -NaN )
checkB "-5.0 <ᵇ -NaN " false (-5.0 <ᵇ -NaN )
checkB " NaN <ᵇ Infinity" false ( NaN <ᵇ Infinity)
checkB "-NaN <ᵇ Infinity" false (-NaN <ᵇ Infinity)
checkB " Infinity <ᵇ -NaN " false ( Infinity <ᵇ -NaN )
checkB "-Infinity <ᵇ -NaN " false (-Infinity <ᵇ -NaN )
checkB " Infinity <ᵇ Infinity" false ( Infinity <ᵇ Infinity)
checkB "-Infinity <ᵇ Infinity" true (-Infinity <ᵇ Infinity)
checkB " Infinity <ᵇ -Infinity" false ( Infinity <ᵇ -Infinity)
checkB "-Infinity <ᵇ -Infinity" false (-Infinity <ᵇ -Infinity)
checkB " MaxFloat <ᵇ MaxFloat" false ( MaxFloat <ᵇ MaxFloat)
checkB " MinFloat <ᵇ MinFloat" false ( MinFloat <ᵇ MinFloat)
checkB " 1.0 <ᵇ 1.5 " true ( 1.0 <ᵇ 1.5 )
checkB " 1.0 <ᵇ 1.0 " false ( 1.0 <ᵇ 1.0 )
checkB " 1.5 <ᵇ 1.5 " false ( 1.5 <ᵇ 1.5 )
checkB "isNaN NaN " true (isNaN NaN )
checkB "isNaN -NaN " true (isNaN -NaN )
checkB "isNaN Infinity " false (isNaN Infinity )
checkB "isNaN -Infinity " false (isNaN -Infinity )
checkB "isNaN 0.0 " false (isNaN 0.0 )
checkB "isNaN -0.0 " false (isNaN -0.0 )
checkB "isNaN 1.0 " false (isNaN 1.0 )
checkB "isNaN 1.5 " false (isNaN 1.5 )
checkB "isInfinite NaN " false (isInfinite NaN )
checkB "isInfinite -NaN " false (isInfinite -NaN )
checkB "isInfinite Infinity " true (isInfinite Infinity )
checkB "isInfinite -Infinity " true (isInfinite -Infinity )
checkB "isInfinite 0.0 " false (isInfinite 0.0 )
checkB "isInfinite -0.0 " false (isInfinite -0.0 )
checkB "isInfinite 1.0 " false (isInfinite 1.0 )
checkB "isInfinite 1.5 " false (isInfinite 1.5 )
-- Depends on optimisation settings:
--
-- - with -O0 the test succeeds
-- - with -O the test fails
--
-- checkB "isInfinite ((MaxFloat * MaxFloat) ÷ MaxFloat)"
-- true
-- (isInfinite ((MaxFloat * MaxFloat) ÷ MaxFloat))
checkB "isNegativeZero NaN " false (isNegativeZero NaN )
checkB "isNegativeZero -NaN " false (isNegativeZero -NaN )
checkB "isNegativeZero Infinity " false (isNegativeZero Infinity )
checkB "isNegativeZero -Infinity " false (isNegativeZero -Infinity )
checkB "isNegativeZero 0.0 " false (isNegativeZero 0.0 )
checkB "isNegativeZero -0.0 " true (isNegativeZero -0.0 )
checkB "isNegativeZero 1.0 " false (isNegativeZero 1.0 )
checkB "isNegativeZero 1.5 " false (isNegativeZero 1.5 )
checkB "isSafeInteger 1.0 " true (isSafeInteger 1.0 )
checkB "isSafeInteger 1.5 " false (isSafeInteger 1.5 )
checkB "isSafeInteger MaxFloat " false (isSafeInteger MaxFloat )
checkB "isSafeInteger MinFloat " false (isSafeInteger MinFloat )
checkB "isSafeInteger MaxSafeIntF " true (isSafeInteger MaxSafeIntF )
-- ** Conversions
checkS "show NaN " "NaN" (showF NaN )
checkS "show -NaN " "NaN" (showF -NaN )
checkS "show 0.0 " "0.0" (showF 0.0 )
checkS "show -0.0 " "-0.0" (showF -0.0 )
checkS "show Infinity" "Infinity" (showF Infinity)
checkS "show -Infinity" "-Infinity" (showF -Infinity)
checkS "show 1.0 " "1.0" (showF 1.0 )
checkS "show 1.5 " "1.5" (showF 1.5 )
-- Breaks the JavaScript backend, on account of it being... too big:
--
-- checkN "toℕ (toWord 1.0) " 4607182418800017408 (toℕ (toWord 1.0) )
-- checkN "toℕ (toWord 1.5) " 4609434218613702656 (toℕ (toWord 1.5) )
-- checkN "toℕ (toWord 0.0) " 0 (toℕ (toWord 0.0) )
-- checkN "toℕ (toWord -0.0) " 9223372036854775808 (toℕ (toWord -0.0) )
-- checkN "toℕ (toWord NaN) " 18444492273895866368 (toℕ (toWord NaN) )
-- checkN "toℕ (toWord -NaN) " 18444492273895866368 (toℕ (toWord -NaN) )
-- checkN "toℕ (toWord Infinity) " 9218868437227405312 (toℕ (toWord Infinity) )
-- checkN "toℕ (toWord -Infinity)" 18442240474082181120 (toℕ (toWord -Infinity))
checkMI "round 1.0 " (just (pos 1)) (round 1.0 )
checkMI "round 1.5 " (just (pos 2)) (round 1.5 )
checkMI "round NaN " (nothing ) (round NaN )
checkMI "round -NaN " (nothing ) (round -NaN )
checkMI "round Infinity " (nothing ) (round Infinity )
checkMI "round -Infinity" (nothing ) (round -Infinity)
checkMI "round MinFloat " (just (pos 0)) (round MinFloat )
--
-- Breaks the JavaScript backend, on account of it being... too big:
--
-- checkMI "round MaxFloat " (just (pos 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368)) (round MaxFloat )
checkMI "floor 1.0 " (just (pos 1)) (floor 1.0 )
checkMI "floor 1.5 " (just (pos 1)) (floor 1.5 )
checkMI "floor NaN " (nothing ) (floor NaN )
checkMI "floor -NaN " (nothing ) (floor -NaN )
checkMI "floor Infinity " (nothing ) (floor Infinity )
checkMI "floor -Infinity" (nothing ) (floor -Infinity)
checkMI "floor MinFloat " (just (pos 0)) (floor MinFloat )
--
-- Breaks the JavaScript backend, on account of it being... too big:
--
-- checkMI "floor MaxFloat " (just (pos 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368)) (floor MaxFloat )
checkMI "ceiling 1.0 " (just (pos 1)) (ceiling 1.0 )
checkMI "ceiling 1.5 " (just (pos 2)) (ceiling 1.5 )
checkMI "ceiling NaN " (nothing ) (ceiling NaN )
checkMI "ceiling -NaN " (nothing ) (ceiling -NaN )
checkMI "ceiling Infinity " (nothing ) (ceiling Infinity )
checkMI "ceiling -Infinity" (nothing ) (ceiling -Infinity)
checkMI "ceiling MinFloat " (just (pos 1)) (ceiling MinFloat )
--
-- Breaks the JavaScript backend, on account of it being... too big:
--
-- checkMI "ceiling MaxFloat " (just (pos 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368)) (ceiling MaxFloat )
checkMR "decode NaN " (nothing ) (decode NaN )
checkMR "decode Infinity" (nothing ) (decode Infinity)
checkMR "decode -Infinity" (nothing ) (decode -Infinity)
checkMR "decode 1.0 " (just (pos 1 , pos 0)) (decode 1.0 )
checkMR "decode 1.5 " (just (pos 3 , negsuc 0)) (decode 1.5 )
checkMR "decode MinFloat" (just (pos 1 , negsuc 1021)) (decode MinFloat)
--
-- Breaks the JavaScript backend, on account of it being... too big:
--
-- checkMR "decode MaxFloat" (just (MaxSafeIntZ , pos 971)) (decode MaxFloat)
checkMF "encode (pos 1) (pos 0)" (just 1.0 ) (encode (pos 1) (pos 0))
checkMF "encode (pos 3) (negsuc 0)" (just 1.5 ) (encode (pos 3) (negsuc 0))
--
-- Breaks the JavaScript backend, on account of it being... too big:
--
-- checkMF "encode MaxSafeIntZ (pos 0)" (just MaxSafeIntF) (encode MaxSafeIntZ (pos 0))
-- checkMF "encode MaxSafeIntZ (pos 971)" (just MaxFloat ) (encode MaxSafeIntZ (pos 971))
-- checkMF "encode MaxSafeIntZ (pos 972)" (nothing ) (encode MaxSafeIntZ (pos 972))
-- checkMF "encode (pos 1) (negsuc 1021)" (just MinFloat ) (encode (pos 1) (negsuc 1021))
-- checkMF "encode MaxSafeIntZ (negsuc 1075)" (nothing ) (encode MaxSafeIntZ (negsuc 1075))
checkR "toRatio NaN " (pos 0 , pos 0) (toRatio NaN )
checkR "toRatio Infinity" (pos 1 , pos 0) (toRatio Infinity)
checkR "toRatio -Infinity" (negsuc 0 , pos 0) (toRatio -Infinity)
checkR "toRatio 1.0 " (pos 1 , pos 1) (toRatio 1.0 )
checkR "toRatio 1.5 " (pos 3 , pos 2) (toRatio 1.5 )
checkF "fromRatio (pos 0) (pos 0)" ( NaN ) (fromRatio (pos 0) (pos 0))
checkF "fromRatio (pos 1) (pos 0)" ( Infinity) (fromRatio (pos 1) (pos 0))
checkF "fromRatio (negsuc 0) (pos 0)" (-Infinity) (fromRatio (negsuc 0) (pos 0))
checkF "fromRatio (pos 1) (pos 1)" ( 1.0 ) (fromRatio (pos 1) (pos 1))
checkF "fromRatio (pos 3) (pos 2)" ( 1.5 ) (fromRatio (pos 3) (pos 2))
checkF "e^ 1.0 " 2.718281828459045 (e^ 1.0 )
checkF "sin (asin 0.6) " 0.6 (sin (asin 0.6) )
checkF "cos (acos 0.6) " 0.6 (cos (acos 0.6) )
checkF "tan (atan 0.4) " 0.4 (tan (atan 0.4) )
checkF "tan (atan2 0.4 1.0)" 0.4 (tan (atan2 0.4 1.0))
| {
"alphanum_fraction": 0.5602661924,
"avg_line_length": 47.3668478261,
"ext": "agda",
"hexsha": "117ab25f63014c9dc44a615d1e32d6866ce01181",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Compiler/simple/Floats.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Compiler/simple/Floats.agda",
"max_line_length": 375,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Compiler/simple/Floats.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 6201,
"size": 17431
} |
open import Prelude
open import core
module ground-decidable where
ground-decidable : (τ : htyp) → (τ ground) + ((τ ground) → ⊥)
ground-decidable b = Inl GBase
ground-decidable ⦇-⦈ = Inr (λ ())
ground-decidable (b ==> b) = Inr (λ ())
ground-decidable (b ==> ⦇-⦈) = Inr (λ ())
ground-decidable (b ==> τ' ==> τ'') = Inr (λ ())
ground-decidable (⦇-⦈ ==> b) = Inr (λ ())
ground-decidable (⦇-⦈ ==> ⦇-⦈) = Inl GHole
ground-decidable (⦇-⦈ ==> τ' ==> τ'') = Inr (λ ())
ground-decidable ((τ ==> τ₁) ==> b) = Inr (λ ())
ground-decidable ((τ ==> τ₁) ==> ⦇-⦈) = Inr (λ ())
ground-decidable ((τ ==> τ₁) ==> τ' ==> τ'') = Inr (λ ())
ground-arr-lem : (τ : htyp) → ((τ ground) → ⊥) → (τ ≠ ⦇-⦈) → Σ[ τ1 ∈ htyp ] Σ[ τ2 ∈ htyp ] ((τ == (τ1 ==> τ2)) × ((τ1 ==> τ2) ≠ (⦇-⦈ ==> ⦇-⦈)))
ground-arr-lem b ng nh = abort (ng GBase)
ground-arr-lem ⦇-⦈ ng nh = abort (nh refl)
ground-arr-lem (τ1 ==> τ2) ng nh = τ1 , τ2 , refl , (λ x → ng (lem' x))
where
lem' : ∀{τ1 τ2} → τ1 ==> τ2 == ⦇-⦈ ==> ⦇-⦈ → (τ1 ==> τ2) ground
lem' refl = GHole
| {
"alphanum_fraction": 0.4796978281,
"avg_line_length": 42.36,
"ext": "agda",
"hexsha": "5c3d8a0bb6a3c0c3ae976bc71c913c83e53ae12e",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-09-13T18:20:02.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-09-13T18:20:02.000Z",
"max_forks_repo_head_hexsha": "229dfb06ea51ebe91cb3b1c973c2f2792e66797c",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "hazelgrove/hazelnut-dynamics-agda",
"max_forks_repo_path": "ground-decidable.agda",
"max_issues_count": 54,
"max_issues_repo_head_hexsha": "229dfb06ea51ebe91cb3b1c973c2f2792e66797c",
"max_issues_repo_issues_event_max_datetime": "2018-11-29T16:32:40.000Z",
"max_issues_repo_issues_event_min_datetime": "2017-06-29T20:53:34.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "hazelgrove/hazelnut-dynamics-agda",
"max_issues_repo_path": "ground-decidable.agda",
"max_line_length": 146,
"max_stars_count": 16,
"max_stars_repo_head_hexsha": "229dfb06ea51ebe91cb3b1c973c2f2792e66797c",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "hazelgrove/hazelnut-dynamics-agda",
"max_stars_repo_path": "ground-decidable.agda",
"max_stars_repo_stars_event_max_datetime": "2021-12-19T02:50:23.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-03-12T14:32:03.000Z",
"num_tokens": 491,
"size": 1059
} |
module ListsWithIrrelevantProofs where
data _≡_ {A : Set}(a : A) : A → Set where
refl : a ≡ a
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
{-# BUILTIN NATURAL ℕ #-}
postulate
_≤_ : ℕ → ℕ → Set
p1 : 0 ≤ 1
p2 : 0 ≤ 1
-- descending lists indexed by upper bound for largest element
data SList (bound : ℕ) : Set where
[] : SList bound
scons : (head : ℕ) →
.(head ≤ bound) → -- irrelevant proof, dotted non-dependent domain
(tail : SList head) →
SList bound
l1 : SList 1
l1 = scons 0 p1 []
l2 : SList 1
l2 = scons 0 p2 []
-- proofs in list are irrelevant
l1≡l2 : l1 ≡ l2
l1≡l2 = refl
| {
"alphanum_fraction": 0.5707620529,
"avg_line_length": 16.9210526316,
"ext": "agda",
"hexsha": "18a60b11fa16fcabeb708d228c01e7a98ed194a1",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "masondesu/agda",
"max_forks_repo_path": "test/succeed/ListsWithIrrelevantProofs.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "masondesu/agda",
"max_issues_repo_path": "test/succeed/ListsWithIrrelevantProofs.agda",
"max_line_length": 78,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "masondesu/agda",
"max_stars_repo_path": "test/succeed/ListsWithIrrelevantProofs.agda",
"max_stars_repo_stars_event_max_datetime": "2018-10-10T17:08:44.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-10-10T17:08:44.000Z",
"num_tokens": 240,
"size": 643
} |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Monoid.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.Transport
open import Cubical.Foundations.SIP
open import Cubical.Data.Sigma
open import Cubical.Structures.Axioms
open import Cubical.Structures.Auto
open import Cubical.Algebra.Semigroup hiding (⟨_⟩)
open Iso
private
variable
ℓ : Level
record IsMonoid {A : Type ℓ} (ε : A) (_·_ : A → A → A) : Type ℓ where
constructor ismonoid
field
isSemigroup : IsSemigroup _·_
identity : (x : A) → (x · ε ≡ x) × (ε · x ≡ x)
open IsSemigroup isSemigroup public
lid : (x : A) → ε · x ≡ x
lid x = identity x .snd
rid : (x : A) → x · ε ≡ x
rid x = identity x .fst
record Monoid : Type (ℓ-suc ℓ) where
constructor monoid
field
Carrier : Type ℓ
ε : Carrier
_·_ : Carrier → Carrier → Carrier
isMonoid : IsMonoid ε _·_
infixl 7 _·_
open IsMonoid isMonoid public
-- semigrp : Semigroup
-- semigrp = record { isSemigroup = isSemigroup }
-- open Semigroup semigrp public
-- Extractor for the carrier type
⟨_⟩ : Monoid → Type ℓ
⟨_⟩ = Monoid.Carrier
η-isMonoid : {A : Type ℓ} {ε : A} {_∙_ : A → A → A} (b : IsMonoid ε _∙_)
→ ismonoid (IsMonoid.isSemigroup b) (IsMonoid.identity b) ≡ b
IsMonoid.isSemigroup (η-isMonoid b i) = IsMonoid.isSemigroup b
IsMonoid.identity (η-isMonoid b i) = IsMonoid.identity b
-- Easier to use constructors
makeIsMonoid : {M : Type ℓ} {ε : M} {_·_ : M → M → M}
(is-setM : isSet M)
(assoc : (x y z : M) → x · (y · z) ≡ (x · y) · z)
(rid : (x : M) → x · ε ≡ x)
(lid : (x : M) → ε · x ≡ x)
→ IsMonoid ε _·_
IsMonoid.isSemigroup (makeIsMonoid is-setM assoc rid lid) = issemigroup is-setM assoc
IsMonoid.identity (makeIsMonoid is-setM assoc rid lid) = λ x → rid x , lid x
makeMonoid : {M : Type ℓ} (ε : M) (_·_ : M → M → M)
(is-setM : isSet M)
(assoc : (x y z : M) → x · (y · z) ≡ (x · y) · z)
(rid : (x : M) → x · ε ≡ x)
(lid : (x : M) → ε · x ≡ x)
→ Monoid
makeMonoid ε _·_ is-setM assoc rid lid =
monoid _ ε _·_ (makeIsMonoid is-setM assoc rid lid)
record MonoidEquiv (M N : Monoid {ℓ}) : Type ℓ where
constructor monoidiso
private
module M = Monoid M
module N = Monoid N
field
e : ⟨ M ⟩ ≃ ⟨ N ⟩
presε : equivFun e M.ε ≡ N.ε
isHom : (x y : ⟨ M ⟩) → equivFun e (x M.· y) ≡ equivFun e x N.· equivFun e y
module MonoidΣTheory {ℓ} where
RawMonoidStructure : Type ℓ → Type ℓ
RawMonoidStructure X = X × (X → X → X)
RawMonoidEquivStr = AutoEquivStr RawMonoidStructure
rawMonoidUnivalentStr : UnivalentStr _ RawMonoidEquivStr
rawMonoidUnivalentStr = autoUnivalentStr RawMonoidStructure
MonoidAxioms : (M : Type ℓ) → RawMonoidStructure M → Type ℓ
MonoidAxioms M (e , _·_) = IsSemigroup _·_
× ((x : M) → (x · e ≡ x) × (e · x ≡ x))
MonoidStructure : Type ℓ → Type ℓ
MonoidStructure = AxiomsStructure RawMonoidStructure MonoidAxioms
MonoidΣ : Type (ℓ-suc ℓ)
MonoidΣ = TypeWithStr ℓ MonoidStructure
isPropMonoidAxioms : (M : Type ℓ) (s : RawMonoidStructure M) → isProp (MonoidAxioms M s)
isPropMonoidAxioms M (e , _·_) =
isPropΣ (isPropIsSemigroup _·_)
λ α → isPropΠ λ _ → isProp× (IsSemigroup.is-set α _ _) (IsSemigroup.is-set α _ _)
MonoidEquivStr : StrEquiv MonoidStructure ℓ
MonoidEquivStr = AxiomsEquivStr RawMonoidEquivStr MonoidAxioms
MonoidAxiomsIsoIsMonoid : {M : Type ℓ} (s : RawMonoidStructure M)
→ Iso (MonoidAxioms M s) (IsMonoid (s .fst) (s .snd))
fun (MonoidAxiomsIsoIsMonoid s) (x , y) = ismonoid x y
inv (MonoidAxiomsIsoIsMonoid s) a = (IsMonoid.isSemigroup a) , IsMonoid.identity a
rightInv (MonoidAxiomsIsoIsMonoid s) b = η-isMonoid b
leftInv (MonoidAxiomsIsoIsMonoid s) _ = refl
MonoidAxioms≡IsMonoid : {M : Type ℓ} (s : RawMonoidStructure M)
→ MonoidAxioms M s ≡ IsMonoid (s .fst) (s .snd)
MonoidAxioms≡IsMonoid s = isoToPath (MonoidAxiomsIsoIsMonoid s)
open Monoid
Monoid→MonoidΣ : Monoid → MonoidΣ
Monoid→MonoidΣ M =
⟨ M ⟩ , ((ε M) , _·_ M) , MonoidAxiomsIsoIsMonoid ((ε M) , _·_ M) .inv (isMonoid M)
MonoidΣ→Monoid : MonoidΣ → Monoid
MonoidΣ→Monoid (M , (ε , _·_) , isMonoidΣ) =
monoid M ε _·_ (MonoidAxiomsIsoIsMonoid (ε , _·_) .fun isMonoidΣ)
MonoidIsoMonoidΣ : Iso Monoid MonoidΣ
MonoidIsoMonoidΣ =
iso Monoid→MonoidΣ MonoidΣ→Monoid (λ _ → refl) helper
where
helper : _
Carrier (helper a i) = ⟨ a ⟩
ε (helper a i) = ε a
_·_ (helper a i) = _·_ a
isMonoid (helper a i) = η-isMonoid (isMonoid a) i
monoidUnivalentStr : UnivalentStr MonoidStructure MonoidEquivStr
monoidUnivalentStr = axiomsUnivalentStr _ isPropMonoidAxioms rawMonoidUnivalentStr
MonoidΣPath : (M N : MonoidΣ) → (M ≃[ MonoidEquivStr ] N) ≃ (M ≡ N)
MonoidΣPath = SIP monoidUnivalentStr
MonoidEquivΣ : (M N : Monoid) → Type ℓ
MonoidEquivΣ M N = Monoid→MonoidΣ M ≃[ MonoidEquivStr ] Monoid→MonoidΣ N
MonoidIsoΣPath : {M N : Monoid} → Iso (MonoidEquiv M N) (MonoidEquivΣ M N)
fun MonoidIsoΣPath (monoidiso e h1 h2) = (e , h1 , h2)
inv MonoidIsoΣPath (e , h1 , h2) = monoidiso e h1 h2
rightInv MonoidIsoΣPath _ = refl
leftInv MonoidIsoΣPath _ = refl
MonoidPath : (M N : Monoid) → (MonoidEquiv M N) ≃ (M ≡ N)
MonoidPath M N =
MonoidEquiv M N ≃⟨ isoToEquiv MonoidIsoΣPath ⟩
MonoidEquivΣ M N ≃⟨ MonoidΣPath _ _ ⟩
Monoid→MonoidΣ M ≡ Monoid→MonoidΣ N ≃⟨ isoToEquiv (invIso (congIso MonoidIsoMonoidΣ)) ⟩
M ≡ N ■
RawMonoidΣ : Type (ℓ-suc ℓ)
RawMonoidΣ = TypeWithStr ℓ RawMonoidStructure
Monoid→RawMonoidΣ : Monoid → RawMonoidΣ
Monoid→RawMonoidΣ A = ⟨ A ⟩ , (ε A) , (_·_ A)
InducedMonoid : (M : Monoid) (N : RawMonoidΣ) (e : M .Monoid.Carrier ≃ N .fst)
→ RawMonoidEquivStr (Monoid→RawMonoidΣ M) N e → Monoid
InducedMonoid M N e r =
MonoidΣ→Monoid (transferAxioms rawMonoidUnivalentStr (Monoid→MonoidΣ M) N (e , r))
InducedMonoidPath : (M : Monoid {ℓ}) (N : RawMonoidΣ) (e : M .Monoid.Carrier ≃ N .fst)
(E : RawMonoidEquivStr (Monoid→RawMonoidΣ M) N e)
→ M ≡ InducedMonoid M N e E
InducedMonoidPath M N e E =
MonoidPath M (InducedMonoid M N e E) .fst (monoidiso e (E .fst) (E .snd))
-- We now extract the important results from the above module
isPropIsMonoid : {M : Type ℓ} (ε : M) (_·_ : M → M → M) → isProp (IsMonoid ε _·_)
isPropIsMonoid ε _·_ =
subst isProp (MonoidΣTheory.MonoidAxioms≡IsMonoid (ε , _·_))
(MonoidΣTheory.isPropMonoidAxioms _ (ε , _·_))
MonoidPath : (M N : Monoid {ℓ}) → (MonoidEquiv M N) ≃ (M ≡ N)
MonoidPath = MonoidΣTheory.MonoidPath
InducedMonoid : (M : Monoid {ℓ}) (N : MonoidΣTheory.RawMonoidΣ) (e : M .Monoid.Carrier ≃ N .fst)
→ MonoidΣTheory.RawMonoidEquivStr (MonoidΣTheory.Monoid→RawMonoidΣ M) N e
→ Monoid
InducedMonoid = MonoidΣTheory.InducedMonoid
InducedMonoidPath : (M : Monoid {ℓ}) (N : MonoidΣTheory.RawMonoidΣ) (e : M .Monoid.Carrier ≃ N .fst)
(E : MonoidΣTheory.RawMonoidEquivStr (MonoidΣTheory.Monoid→RawMonoidΣ M) N e)
→ M ≡ InducedMonoid M N e E
InducedMonoidPath = MonoidΣTheory.InducedMonoidPath
module MonoidTheory {ℓ} (M' : Monoid {ℓ}) where
open Monoid M' renaming ( Carrier to M )
-- Added for its use in groups
-- If there exists a inverse of an element it is unique
inv-lemma : (x y z : M) → y · x ≡ ε → x · z ≡ ε → y ≡ z
inv-lemma x y z left-inverse right-inverse =
y ≡⟨ sym (rid y) ⟩
y · ε ≡⟨ cong (λ - → y · -) (sym right-inverse) ⟩
y · (x · z) ≡⟨ assoc y x z ⟩
(y · x) · z ≡⟨ cong (λ - → - · z) left-inverse ⟩
ε · z ≡⟨ lid z ⟩
z ∎
| {
"alphanum_fraction": 0.6129913312,
"avg_line_length": 35.6822033898,
"ext": "agda",
"hexsha": "7bf7ea8e8b2a583bb3a63f74c7b2a496b51d8b79",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "f6771617374bfe65a7043d00731fed5a673aa729",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "knrafto/cubical",
"max_forks_repo_path": "Cubical/Algebra/Monoid/Base.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "f6771617374bfe65a7043d00731fed5a673aa729",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "knrafto/cubical",
"max_issues_repo_path": "Cubical/Algebra/Monoid/Base.agda",
"max_line_length": 101,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "f6771617374bfe65a7043d00731fed5a673aa729",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "knrafto/cubical",
"max_stars_repo_path": "Cubical/Algebra/Monoid/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 3142,
"size": 8421
} |
module _ where
data Nat : Set where
zero : Nat
suc : Nat → Nat
{-# BUILTIN NATURAL Nat #-}
_+_ : (m n : Nat) → Nat
zero + n = n
suc m + n = suc (m + n)
data Th : (m n : Nat) → Set where
os : ∀ {m n} → Th m n → Th (suc m) (suc n)
Fin : Nat → Set
Fin = Th (suc zero)
infixl 6 _++_
infix 4 _≈M_
postulate
U : Set
RCtx : Nat → Set
_++_ : ∀ {m n} → RCtx m → RCtx n → RCtx (n + m)
El : U → RCtx (suc zero)
_≈M_ : ∀ {n} (Δ0 Δ1 : RCtx n) → Set
infix 4 _⊢l-var_
data _⊢l-var_ : ∀ {n} (Δi : RCtx n) (i : Fin n) → Set where
os : ∀ {n} {e : Th zero n} {Δ Δπ π} (iq : Δπ ≈M (Δ ++ El π)) →
Δπ ⊢l-var os e
⊢l-var-sub : ∀ {n Δ} {i : Fin n} → Δ ⊢l-var i → Set
⊢l-var-sub (os iq) = Nat
| {
"alphanum_fraction": 0.4621513944,
"avg_line_length": 20.3513513514,
"ext": "agda",
"hexsha": "8af02ee8fbb2f88b1467223fabb2cc2cdcef8179",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Succeed/Issue3930.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Succeed/Issue3930.agda",
"max_line_length": 66,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Succeed/Issue3930.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 349,
"size": 753
} |
{-# OPTIONS --prop --rewriting #-}
module Examples.Sorting.Sequential.Comparable where
open import Calf.CostMonoid
open import Calf.CostMonoids
costMonoid = ℕ-CostMonoid
open import Data.Nat using (ℕ)
open CostMonoid costMonoid using (ℂ)
fromℕ : ℕ → ℂ
fromℕ n = n
open import Examples.Sorting.Comparable costMonoid fromℕ public
| {
"alphanum_fraction": 0.7754491018,
"avg_line_length": 19.6470588235,
"ext": "agda",
"hexsha": "061da231777db5bd1355e1662709cf8f9557e7b0",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2022-01-29T08:12:01.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-10-06T10:28:24.000Z",
"max_forks_repo_head_hexsha": "e51606f9ca18d8b4cf9a63c2d6caa2efc5516146",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "jonsterling/agda-calf",
"max_forks_repo_path": "src/Examples/Sorting/Sequential/Comparable.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "e51606f9ca18d8b4cf9a63c2d6caa2efc5516146",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Apache-2.0"
],
"max_issues_repo_name": "jonsterling/agda-calf",
"max_issues_repo_path": "src/Examples/Sorting/Sequential/Comparable.agda",
"max_line_length": 63,
"max_stars_count": 29,
"max_stars_repo_head_hexsha": "e51606f9ca18d8b4cf9a63c2d6caa2efc5516146",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "jonsterling/agda-calf",
"max_stars_repo_path": "src/Examples/Sorting/Sequential/Comparable.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-22T20:35:11.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-07-14T03:18:28.000Z",
"num_tokens": 98,
"size": 334
} |
module Type.Properties.Homotopy where
open import Functional
import Lvl
open import Numeral.Natural
open import Structure.Setoid
open import Type
open import Type.Dependent
open import Syntax.Function
private variable ℓ ℓ₁ ℓ₂ ℓₑ : Lvl.Level
private variable T A B : Type{ℓ}
private variable n : ℕ
module _ {ℓ} ⦃ equiv : ∀{T : Type{ℓ}} → Equiv{ℓ}(T) ⦄ where -- TODO: Maybe the requirements can be relaxed to a tower of equivalences?
module Names where
HomotopyLevel : ℕ → (A : Type{ℓ}) → Type
HomotopyLevel(𝟎) (A) = Σ(A)(x ↦ ∀{y} → (y ≡ x))
HomotopyLevel(𝐒(𝟎)) (A) = ∀{x y : A} → (x ≡ y)
HomotopyLevel(𝐒(𝐒(n)))(A) = ∀{x y : A} → HomotopyLevel(𝐒(n))(x ≡ y)
Truncation = HomotopyLevel ∘ 𝐒 ∘ 𝐒
record HomotopyLevel(n : ℕ) (A : Type{ℓ}) : Type{ℓ} where
constructor intro
field proof : Names.HomotopyLevel(n)(A)
Truncation = HomotopyLevel ∘ 𝐒 ∘ 𝐒
-- TODO: Where should this be stated?
-- ExcludedMiddle : (A : Type{ℓ}) ⦃ equiv-A : Equiv{ℓₑ}(A) ⦄ → Stmt
-- ExcludedMiddle(A) = MereProposition(A) → (IsUnit(A) ∨ IsEmpty(A))
| {
"alphanum_fraction": 0.6492048644,
"avg_line_length": 32.3939393939,
"ext": "agda",
"hexsha": "89d2a5a463182f3b5743f9be809345b4d28a3cf2",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Lolirofle/stuff-in-agda",
"max_forks_repo_path": "Type/Properties/Homotopy.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "Type/Properties/Homotopy.agda",
"max_line_length": 134,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Lolirofle/stuff-in-agda",
"max_stars_repo_path": "Type/Properties/Homotopy.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-05T06:53:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:58:13.000Z",
"num_tokens": 417,
"size": 1069
} |
open import Common.Prelude
_test_test_ : Nat → Nat → Nat → Nat
m test_test n = λ i → m + i + n
| {
"alphanum_fraction": 0.6458333333,
"avg_line_length": 19.2,
"ext": "agda",
"hexsha": "754c32f37acfb41bb1d8d335df398fb0f8974574",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Fail/Sections-12.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Fail/Sections-12.agda",
"max_line_length": 35,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Fail/Sections-12.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 32,
"size": 96
} |
-- A brief Agda tutorial.
-- Martín Escardó, 7 Sep 2012 (updated to be compatible with Agda 2.4.2 2 Oct 2014).
--
-- Agda is a computer-implemented dialect of Martin-Löf type theory.
-- It can both check and run proofs.
--
-- Propositions are types (also called sets, indicated by the keyword
-- Set), and their witnesses or proofs are programs.
--
-- If one ignores this view/encoding of propositions, Agda is simply a
-- strongly typed, pure, functional programming language with
-- dependent types and other kinds of fancy types.
--
-- All programs normalize in Agda.
---
-- Gödel's system T is included in Agda, but Platek-Scott-Plotkin's
-- PCF is not. But Agda is much more expressive than system T: it
-- defines many more functions ℕ → ℕ, for example, and encodes much
-- higher ordinals.
-- The Agda wiki http://wiki.portal.chalmers.se/agda/agda.php tells
-- you how to install Agda and get started with editing.
--
-- I recommend the tutorial paper
--- http://www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf,
-- among others available at
-- http://wiki.portal.chalmers.se/agda/agda.php?n=Main.Documentation
--
-- See also the standard library
-- http://www.cse.chalmers.se/~nad/listings/lib-0.6/README.html
-- which we will not use in this tutorial.
module EscardoTutorial where
-- An inductive definition:
data ℕ : Set where
zero : ℕ
succ : ℕ → ℕ
-- This notation uses unicode UTF-8. To enter unicode characters in emacs in Agda mode, see
-- http://wiki.portal.chalmers.se/agda/agda.php?n=Main.QuickGuideToEditingTypeCheckingAndCompilingAgdaCode
-- (usually LaTeX syntax works).
-- Could instead write the following, which is equivalent with a
-- different notation, using ascii characters only:
data N : Set where
zero : N
succ : N -> N
one : N
-- But we will use the first definition. (Later we may prove that ℕ
-- and N are isomorphic, as an exercise.)
-- Our first function, inductively defined:
_+_ : ℕ → ℕ → ℕ
x + zero = x
x + succ y = succ(x + y)
-- We can define a simple-recursion combinator:
rec : (X : Set) → X → (X → X) → (ℕ → X)
rec X x f zero = x
rec X x f (succ n) = f(rec X x f n)
-- Or the primitive-recursion combinator:
prim-rec : (X : Set) → X → (ℕ → X → X) → ℕ → X
prim-rec X x f zero = x
prim-rec X x f (succ n) = f n (prim-rec X x f n)
-- Addition can then be instead defined as:
_+₁_ : ℕ → ℕ → ℕ
x +₁ y = rec ℕ x succ y
-- We are using a subscript to indicate a different version. An
-- identifier is a sequence of unicode (UTF-8 encoding) characters not
-- containing white space or reserved characters @.(){};_.
--
-- Quoting from the agda wiki,
-- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=ReferenceManual.LexicalMatters:
--
-- Furthermore, the following set of reserved words cannot be used as name parts.
--
-- -> : = ? \ | → ∀ -- λ
-- abstract data forall hiding import in infix infixl infixr
-- let module mutual open postulate primitive private public record
-- renaming rewrite using where with
-- Prop Set[0–9]* [0–9]+
--
-- This means that strings like x:A and A→B are valid names. To write
-- the type signature and the function type, white space have to be
-- inserted: x : A, and A → B.
--
-- To illustrate some features, another equivalent definition is this:
rec₁ : (X : Set) → X → (X → X) → (ℕ → X)
rec₁ X x f = h
where
h : ℕ → X
h zero = x
h (succ n) = f(h n)
-- Indentation matters.
-- The parameter X of the definition of rec/rec₁ may be made implicit,
-- and this is sensible:
rec₂ : {X : Set} → X → (X → X) → (ℕ → X)
rec₂ {X} x f = h
where
h : ℕ → X
h zero = x
h (succ n) = f(h n)
-- Now we can define addition omitting the type ℕ:
_+₂_ : ℕ → ℕ → ℕ
x +₂ y = rec₂ x succ y
-- Agda then infers (by unification) that this is the only possibly
-- choice for the implicit argument.
-- In cases when the inference fails, or when you want to implicitly
-- supply the implicit parameter for emphasis, you can write:
_+₃_ : ℕ → ℕ → ℕ
x +₃ y = rec₂ {ℕ} x succ y
-- You can also write:
_+₄_ : ℕ → ℕ → ℕ
_+₄_ x y = rec₂ {ℕ} x succ y
-- or even, using η-contraction:
_+₅_ : ℕ → ℕ → ℕ
_+₅_ x = rec₂ {ℕ} x succ
-- or:
_+₆_ : ℕ → ℕ → ℕ
_+₆_ = λ x → rec₂ {ℕ} x succ
-- or, using only ascii characters:
_+₇_ : ℕ → ℕ → ℕ
_+₇_ = \x -> rec₂ {ℕ} x succ
-- I prefer the original definition.
-- You can also declare an associativity and precedence for (the
-- various versions of) _+_ if you wish (valid from now on):
infixl 5 _+_
-- Since we are discussing syntax, let also do:
-- {-# BUILTIN NATURAL ℕ #-}
{-# BUILTIN NATURAL N #-}
-- This allows you to write e.g. 0 to mean zero and 3 to mean
-- Succ(Succ(Succ zero)).
-- So far we have a few definitions. We want to prove something about
-- them.
-- Agda uses the Brouwer-Heyting-Kolmogorov-Curry-Howard
-- representation of propositions as types.
--
-- Types are called sets in Agda syntax, with the keyword "Set".
-- (And in the early accounts by Martin-Löf too.)
--
-- So a proposition is a set.
--
-- * A set may be empty: this represents "false".
--
-- * Or it may have an element: any inhabited set represents "true".
--
-- So a proposition may be true in many ways: an element of its
-- representing set is called a "witness" or a "realizer" or "a
-- proof".
--
--
-- A predicate on a type X is a function A : X → Set.
-- For each element x : X it gives a set A x representing a
-- proposition.
--
--
-- * The BHKCH intepretation of implication:
--
-- A realizer of the proposition "A implies B" is a function that
-- given any realizer of A produces a realizer of B.
--
-- Thus, the function type (A → B), built-in in Martin-Löf theory
-- and in Agda, codes implication.
--
--
-- * The BHKCH intepretation of universal quantification:
--
-- A realizer of "for all x in X, A x" is a function that
-- transforms any x in X into a realizer of A x.
--
-- The interpretation of universal quantification is given by
-- dependent products, again built-in in Martin-Löf theory and in
-- Agda.
--
-- In Martin-Löf type theory, it is written Π. In Agda, the
-- notation (x : X) → A x is used, where A : X → Set.
--
-- It is the type of functions that map any x : X to an element y : A x.
-- Notice that the type of the output depends on the input.
--
-- Agda allows you to write ∀(x : X) → A x to mean (x : X) → A x.
-- When types can be inferred by Agda, you can also write ∀ x → A x.
--
-- * The BHKCH intepretation of existential quantification:
--
-- A realizer of "there is x in X s.t. A x" is a pair (x , a)
-- where x is in X and a is a realizer of A x.
--
-- In Martin-Löf type theory, Σ is used to define the
-- interpretation of existential quantification.
--
-- In Agda we need to (inductively) define it ourselves:
data Σ {X : Set} (A : X → Set) : Set where
_,_ : (x₀ : X) → A x₀ → Σ \(x : X) → A x
-- Read Σ \(x : X) → A x as the sum of the sets A x for x : X. Agda
-- is "intensional", but it uses the η rule. So Σ \(x : X) → A x is
-- the same as Σ {X} A, because A is the same thing as \(x : X) → A x,
-- and because X can be inferred now, as it is given in the definition
-- \(x : X) → A x.
π₀ : {X : Set} {A : X → Set} → (Σ \(x : X) → A x) → X
π₀(x , a) = x
π₁ : {X : Set} {A : X → Set} → (z : Σ \(x : X) → A x) → A(π₀ z)
π₁(x , a) = a
-- Martin-Löf instead works with the following elimination rule, which
-- is a dependently type version of "uncurrying":
Σ-elim : {X : Set} → {Y : X → Set} →
{A : (Σ \(x : X) → Y x) → Set}
→ (∀(x : X) → ∀(y : Y x) → A(x , y))
→ ∀(t : (Σ \(x : X) → Y x)) → A t
Σ-elim f(x , y) = f x y
-- Notice that Σ-elim defines the projections:
π₀' : {X : Set} {A : X → Set} → (Σ \(x : X) → A x) → X
π₀' = Σ-elim (λ x a → x)
π₁' : {X : Set} {A : X → Set} → (z : Σ \(x : X) → A x) → A(π₀ z)
π₁' = Σ-elim (λ x a → a)
-- The converse holds if we assume "surjective-pairing", a form of the
-- η-rule for sums. Now this may be confusing: the way we defined Σ
-- using "data" doesn't give you that. But if you define Σ using a
-- record, then you do get that. See
-- http://www.cs.bham.ac.uk/~mhe/agda/SetsAndFunctions.html
-- Cartesian products are a special case of dependent sums, where Y
-- doesn't depend on x : X, which represent conjunctions in the BHKCH
-- interpretation of logic:
_×_ : Set → Set → Set
X × Y = Σ \(x : X) → Y
-- It is also useful to introduce ∃-notation:
∃ : {X : Set} → (A : X → Set) → Set
∃ = Σ
-- We have developed enough material to be able to formulate and prove
-- our first theorem: the Axiom of Choice:
AC : {X Y : Set} {A : X → Y → Set} →
(∀(x : X) → ∃ \(y : Y) → A x y) → ∃ \(f : X → Y) → ∀(x : X) → A x (f x)
AC g = (λ x → π₀(g x)) , (λ x → π₁(g x))
-- We have a dependently typed version as well (not to be confused
-- with dependent choice, which I will discuss later), with the same
-- proof:
AC' : {X : Set} {Y : X → Set} {A : (x : X) → Y x → Set} →
(∀(x : X) → ∃ \(y : Y x) → A x y) → ∃ \(f : ((x : X) → Y x)) → ∀(x : X) → A x (f x)
AC' g = ((λ x → π₀(g x)) , (λ x → π₁(g x)))
-- I find the following use of an implicit argument useful in order
-- to achieve a notation close to Martin-Löf's.
Π : {X : Set} → (Y : X → Set) → Set
Π {X} Y = (x : X) → Y x
-- For example the axiom of choice becomes less surprising when we
-- realize that it amounts to
AC-in-ML-notation : {X : Set} {Y : X → Set} {A : (x : X) → Y x → Set} →
(Π \(x : X) → Σ \(y : Y x) → A x y) → Σ \(f : ((x : X) → Y x)) → Π \(x : X) → A x (f x)
AC-in-ML-notation g = ((λ x → π₀(g x)) , (λ x → π₁(g x)))
-- (The axiom of choice usually fails in a topos, but the above always
-- holds. In fact, the function AC-in-ML-notation is a
-- (pointwise) isomorphism. Exercise: define its inverse in Agda.)
-- Let's return to the natural numbers.
-- We can also write an induction combinator:
induction : {A : ℕ → Set} →
A zero → (∀(k : ℕ) → A k → A(succ k)) → ∀(n : ℕ) → A n
induction base step 0 = base
induction base step (succ n) = step n (induction base step n)
-- Notice that the realizer of the principle of induction has the same
-- definition as primitive recursion. Only the types are different:
-- that of primitive recursion is less general, and that of induction
-- is the dependent-type generalization.
prim-rec' : {X : Set} → X → (ℕ → X → X) → ℕ → X
prim-rec' = induction
-- The empty type, representing the false proposition.
data ∅ : Set where
-- no constructors given
-- The "elimintation rule of false", or "ex-falso quod libet", or the
-- function from the empty set to any set:
from-∅ : {X : Set} → ∅ → X
from-∅ ()
-- This is our first encounter of "()" patterns. They assert that a
-- case is impossible (and Agda checks that), or that no constructor
-- is available to perform a match. All uses of () can be reduced to
-- from-∅, but sometimes it is clearer to use the "()" pattern.
-- The type with one element, giving one way of representing the true
-- proposition:
data ① : Set where
* : ①
-- This is something like the terminal object:
to-① : {X : Set} → X → ①
to-① x = *
-- * The BHKCH intepretation of disjunction is the binary co-product,
-- inductively defined. It is natural to use the symbol "+" to
-- denote the co-product, but in Agda there is no overloading other than
-- constructors defined in (different) "data" definitions. So let's
-- use "⨄" as in the standard library
data _⨄_ (X₀ X₁ : Set) : Set where
in₀ : X₀ → X₀ ⨄ X₁
in₁ : X₁ → X₀ ⨄ X₁
-- These constructors correspond to the introduction rules of disjunction.
-- Definition by cases corresponds to the elimination rule:
cases : {X₀ X₁ Y : Set} → (X₀ → Y) → (X₁ → Y) → (X₀ ⨄ X₁ → Y)
cases f₀ f₁ (in₀ x₀) = f₀ x₀
cases f₀ f₁ (in₁ x₁) = f₁ x₁
-- See Bove & Dybjer's paper "Dependent types at work" for
-- a dependently typed version of this:
-- http://www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf
-- Alternatively, work it out yourself as an exercise.
-- Binary co-products can be alternatively defined from sums and the
-- booleans in the presence of the "universe" Set.
--
-- First define the set of binary digits (the booleans with another
-- notation and perspective):
data ② : Set where
₀ : ②
₁ : ②
-- This amounts to if-then-else:
②-cases : {X : Set} → X → X → ② → X
②-cases x₀ x₁ ₀ = x₀
②-cases x₀ x₁ ₁ = x₁
-- Here is the dependently-typed version:
dep-②-cases : {X : ② → Set} → X ₀ → X ₁ → ((i : ②) → X i)
dep-②-cases x₀ x₁ ₀ = x₀
dep-②-cases x₀ x₁ ₁ = x₁
-- The following has the same definition but a different type:
②-Cases : Set → Set → ② → Set
②-Cases X₀ X₁ ₀ = X₀
②-Cases X₀ X₁ ₁ = X₁
-- Agda has universe polymorphism, but I won't mention it in this
-- tutorial. It requires to rewrite all code we have written and we
-- will write in this tutorial, everytime with a parameter for a
-- universe level. Explore the standard library to see how this works.
_⨄'_ : Set → Set → Set
X₀ ⨄' X₁ = Σ \(i : ②) → ②-Cases X₀ X₁ i
in₀' : {X₀ X₁ : Set} → X₀ → X₀ ⨄' X₁
in₀' x₀ = (₀ , x₀)
in₁' : {X₀ X₁ : Set} → X₁ → X₀ ⨄' X₁
in₁' x₁ = (₁ , x₁)
cases' : {X₀ X₁ Y : Set} → (X₀ → Y) → (X₁ → Y) → (X₀ ⨄' X₁ → Y)
cases' {X₀} {X₁} {Y} f₀ f₁ = h
where
Y' : X₀ ⨄' X₁ → Set
Y' z = Y
f : (i : ②) → (x : ②-Cases X₀ X₁ i) → Y'(i , x)
f = dep-②-cases f₀ f₁
g : (z : X₀ ⨄' X₁) → Y' z
g = Σ-elim {②} {②-Cases X₀ X₁} {Y'} f
h : X₀ ⨄' X₁ → Y
h = g
-- * The BHKCH intepretation of equality:
--
-- Howards idea: x = y is interpreted by a type that is empty if x
-- and y are equal, and has precisely one element if not.
--
-- In set theory (classical or constructive), this can be written
-- { z ∈ 1 | x = y }, where 1 is a singleton, say {0}.
--
-- But notice that this cannot be written down in Martin-Löf's
-- type theory, and already presuposes a notion of equality to be
-- available.
--
-- Martin-Löf's idea: inductively define this type. This is the
-- so-called identity type, which is complicated and hence we will
-- look at it later.
-- Using the universe Set, one can easily define equality on the
-- natural numbers by induction and show that the Martin-Löf induction
-- priciple J holds for this notion of equality on ℕ.
-- Notice that we use four stacked bars to denote the equality type on
-- the type ℕ. Later we will use three to denote the equality type, or
-- identity type, for any type (and in particular ℕ again).
infix 3 _≣_
_≣_ : ℕ → ℕ → Set
0 ≣ 0 = ①
(succ m) ≣ 0 = ∅
0 ≣ (succ n) = ∅
(succ m) ≣ (succ n) = m ≣ n
Reflℕ : ∀ n → n ≣ n
Reflℕ 0 = *
Reflℕ (succ n) = IH
-- Notice that we needed to inhabit the set ((succ m) ≣ (succ n))
-- in this case, but we instead inhabited the set (m ≣ n) using IH.
-- This works because, by definition, ((succ m) ≣ (succ n)) is (m ≣ n).
where
IH : n ≣ n
IH = Reflℕ n
-- We next show that _≣_ is the least reflexive relation on ℕ:
weak-Jℕ : (A : ℕ → ℕ → Set) → (∀ n → A n n) → ∀ m n → m ≣ n → A m n
weak-Jℕ A φ 0 0 * = φ 0
weak-Jℕ A φ 0 (succ n) ()
weak-Jℕ A φ (succ m) 0 ()
weak-Jℕ A φ (succ m) (succ n) e = weak-Jℕ A' φ' m n e
where
A' : ℕ → ℕ → Set
A' m n = A (succ m) (succ n)
φ' : ∀ n → A' n n
φ' n = φ(succ n)
-- If you don't like "()" patterns, you can use the function from-∅
-- (defined above using "()" patterns):
weak-Jℕ' : (A : ℕ → ℕ → Set) → (∀ n → A n n) → ∀ m n → m ≣ n → A m n
weak-Jℕ' A φ 0 0 * = φ 0
weak-Jℕ' A φ 0 (succ n) e = from-∅ e
weak-Jℕ' A φ (succ m) 0 e = from-∅ e
weak-Jℕ' A φ (succ m) (succ n) e =
weak-Jℕ' (λ m n → A(succ m)(succ n)) (λ n → φ(succ n)) m n e
-- There is a stronger, dependent(ly typed) version of weak-Jℕ:
Jℕ : (A : (m n : ℕ) → m ≣ n → Set)
→ (∀ n → A n n (Reflℕ n)) → ∀ m n → ∀(e : m ≣ n) → A m n e
Jℕ A φ 0 0 * = φ 0
Jℕ A φ 0 (succ n) ()
Jℕ A φ (succ m) 0 ()
Jℕ A φ (succ m) (succ n) e =
Jℕ (λ m n → A (succ m) (succ n)) (λ n → φ(succ n)) m n e
-- Of course we could have defined instead the weak version from the
-- strong one:
weak-Jℕ'' : (A : (m n : ℕ) → Set) → (∀ n → A n n) → ∀ m n → m ≣ n → A m n
weak-Jℕ'' A = Jℕ (λ m n e → A m n)
-- Jℕ can be regarded as an induction principle for equality on the
-- type ℕ. Several properties of ≣ can be proved using J without
-- reference to the inductive structure of the the type ℕ, and often
-- its weak version suffices.
symℕ : (x y : ℕ) → x ≣ y → y ≣ x
symℕ = weak-Jℕ A φ
where
A : (x y : ℕ) → Set
A x y = y ≣ x
φ : (x : ℕ) → x ≣ x
φ = Reflℕ
transℕ : (x y z : ℕ) → x ≣ y → y ≣ z → x ≣ z
transℕ x y z r s = transℕ' x y r z s
where
transℕ' : (x y : ℕ) → x ≣ y → (z : ℕ) → y ≣ z → x ≣ z
transℕ' = weak-Jℕ A φ
where
A : (x y : ℕ) → Set
A x y = ∀(z : ℕ) → y ≣ z → x ≣ z
φ : (x : ℕ) → A x x
φ x z s = s
substℕ : (P : ℕ → Set) → (x y : ℕ) → x ≣ y → P x → P y
substℕ P = weak-Jℕ A φ
where
A : (x y : ℕ) → Set
A x y = P x → P y
φ : (x : ℕ) → A x x
φ x p = p
-- Transitivity can be proved using substitution:
sym-transℕ : (x y z : ℕ) → x ≣ y → x ≣ z → y ≣ z
sym-transℕ x y z = rearrange z x y
where
rearrange : (z x y : ℕ) → x ≣ y → x ≣ z → y ≣ z
rearrange z = substℕ (λ x → x ≣ z)
transℕ' : (x y z : ℕ) → x ≣ y → y ≣ z → x ≣ z
transℕ' x y z r s = sym-transℕ y x z (symℕ x y r) s
congℕ→ℕ : (f : ℕ → ℕ) → (x x' : ℕ) → x ≣ x' → f x ≣ f x'
congℕ→ℕ f = weak-Jℕ (λ x x' → f x ≣ f x') (λ x → Reflℕ(f x))
-- As another example, we show that addition is commutative:
zero-is-left-neutral : ∀ n → 0 + n ≣ n
zero-is-left-neutral 0 = *
zero-is-left-neutral (succ n) = IH
-- We need to inhabit the type (0 + succ n ≣ succ n).
-- Expanding the definitions,
-- (0 + succ n ≣ succ n) =
-- (succ(0 + n) ≣ succ n) =
-- (0 + n ≣ n).
-- Here "=" is definitional equality, silently applied by Agda.
where
IH : 0 + n ≣ n
IH = zero-is-left-neutral n
-- Equivalently:
zero-is-left-neutral' : ∀ n → 0 + n ≣ n
zero-is-left-neutral' = induction base step
where
base : ①
base = *
step : ∀ n → 0 + n ≣ n → 0 + n ≣ n
step n e = e
-- This with the following shows that, of course, it is equivalent to
-- define addition by induction on the first argument. The proof is by
-- induction on the second argument, following the definition of _+_.
addition-on-first : ∀ m n → (succ m) + n ≣ succ(m + n)
addition-on-first m 0 = Reflℕ m
addition-on-first m (succ n) = IH
where
IH : succ m + n ≣ succ(m + n)
IH = addition-on-first m n
-- Because the situation is symmetric, we can choose any of the two
-- arguments to perform the induction in the following theorem:
addition-commutative : ∀ m n → m + n ≣ n + m
addition-commutative 0 n = zero-is-left-neutral n
addition-commutative (succ m) n = lemma
where
IH : m + n ≣ n + m
IH = addition-commutative m n
claim : succ(m + n) ≣ succ(n + m)
claim = congℕ→ℕ succ (m + n) (n + m) IH
lemma : succ m + n ≣ succ (n + m)
lemma = transℕ (succ m + n) (succ(m + n)) (succ (n + m))
(addition-on-first m n) claim
-- Exercise. Prove the Peano axioms that are not covered above.
-- The above theorem "Jℕ" motivates Martin-Löf's inductive definition
-- of the identity type for any type X:
data _≡_ {X : Set} : X → X → Set where
refl : {x : X} → x ≡ x
-- Martin-Löf's notation is the following:
Id : (X : Set) → X → X → Set
Id X x y = x ≡ y
Refl : (X : Set) → (x : X) → Id X x x
Refl X x = refl {X} {x}
-- The induction principle is as for equality on ℕ defined earlier:
J : {X : Set} → (A : (x x' : X) → x ≡ x' → Set)
→ (∀(x : X) → A x x refl) → ∀{x x' : X} → ∀(r : x ≡ x') → A x x' r
J A f {x} refl = f x
-- In Agda, one can prove the unique-of-identity proofs principle K by
-- pattern matching:
K : {X : Set} → ∀{x x' : X} → ∀(r s : x ≡ x') → r ≡ s
K refl refl = refl
-- This is not provable in intensional Martin-Löf type theory (Hofmann
-- & Streicher's groupoid interpretation paper).
--
-- However, it is known that the following is provable in MLTT:
pseudo-K : {X : Set} → ∀{x x' : X} → ∀(r : x ≡ x') → (x , refl) ≡ (x' , r)
pseudo-K {X} = J {X} A (λ x → refl)
where
A : ∀(x x' : X) → x ≡ x' → Set
A x x' r = _≡_ {Σ \(x' : X) → x ≡ x'} (x , refl) (x' , r)
-- It has been shown that types with decidable equality, such as ℕ and
-- the booleans, satisfy the K-rule. Moreover, for ℕ it can be easily
-- proved by induction (exercise, which we may eventually do).
-- Conor McBride proved that having the K-rule is equivalent to having
-- pattern matching over refl, which Agda does. But this can be
-- disabled in Agda using the pragma {-# OPTIONS --without-K #-}.
-- Without this pragma, many definitions by pattern matching,
-- including that of J, are accepted, but that of K, and other
-- definitions that require K, are not.
-- Exercise: formulate and prove sym, subst, trans, cong, generalizing
-- the above development for ℕ. Define a weak version of J from J, and
-- use this in your proofs.
-- The propositional "axiom of function extensionality" is
Extensionality : Set₁
Extensionality =
∀(X Y : Set) → ∀(f g : X → Y) → (∀(x : X) → f x ≡ g x) → f ≡ g
-- Here we have used the second universe. The first is Set = Set₀. We
-- have Set₀ : Set₁, Set₁ : Set₂, and so on. The "small" sets (or
-- types) live in Set₀. The large set Extensionality lives in Set₁
-- because it quantifies over elements of Set₀.
-- It is neither possible to show that the set Extensionality is
-- inhabited or that it is empty. That is, the extensionality axiom is
-- independent of MLTT. We can, if we wish, postulate it, or rather
-- postulate an inhabitant:
postulate ext : Extensionality
-- But then ext behaves like a constant, with no computation rules for
-- it. Reduction gets stuck when it encounters this case.
-- The principle of excluded middle is independent of MLTT.
EM : Set₁
EM = ∀(X : Set) → X ⨄ (X → ∅)
-- Notice that (X → ∅) represents negation because ∅ represents false.
-- Notice also that the independence of EM follows from that of
-- Extensionality if we don't have the above postulate.
-- It would be good, too good, to have an inhabitant of EM without
-- violating the computational character of MLTT. It would solve
-- Hilbert's decision problem for large fragments of mathematics,
-- including Peano arithmetic. It would amount to an algorithm for
-- deciding whether a proposition has a realizer, or its negation has
-- a realizer, and would also give the corresponding realizer. As is
-- well known, this is not possible, and this is why EM cannot be
-- inhabited in MLTT.
-- This is not to say that EM is false in MLTT.
-- In fact the set (EM → ∅) cannot be inhabited in MLTT either. This
-- is because MLTT is compatible with classical mathematics (like
-- Bishop mathematics). Set theory, say ZF with an inaccessible
-- cardinal modeling the universe, or with a stack of inaccessible
-- cardinals modelling a hierarchy of universes, can be used to give a
-- model of MLTT in which EM is inhabited (by simply using the
-- principle of excluded middle of ZF, whose consistency is not
-- disputed, even by constructive mathematicians).
-- The negation of EM is also consistent, because recursive models
-- of MLTT, in which an inhabitant of EM needs to be given by an
-- algorithm, exist, so that EM is empty and hence (EM → ∅) is
-- inhabited in such models. There are also (classical and
-- constructive) models in which all functions are continuous. In
-- those models, (EM → ∅) has an inhabitant too.
-- So it is very inaccurate to say that excluded middle "doesn't hold"
-- in Martin-Löf type theory. What we have is that EM is independent
-- of MLTT. Independence is a meta-theoretical property, which cannot
-- be written down in MLTT itself, of course. Formalized versions of
-- the assertions "all functions are computable" and "all functions
-- are continuous" are also independent. In constructive mathematics
-- in the style of Bishop or Martin-Löf, in which compatibility with
-- classical and computational mathematics is desired, it is very easy
-- to find independent statements, as there are plenty of theorems
-- that hold classically but have no computable realizers (EM is one).
-- To be continued.
Jℕeq : (A : (m n : ℕ) → m ≣ n → Set) → (φ : (∀ n → A n n (Reflℕ n))) → ∀ m
→ Jℕ A φ m m (Reflℕ m) ≡ φ m
Jℕeq A φ zero = refl
Jℕeq A φ (succ m) = Jℕeq (λ m n → A (succ m) (succ n)) (λ n → φ(succ n)) m
Jℕeq17 : (A : (m n : ℕ) → m ≣ n → Set) → (φ : (∀ n → A n n (Reflℕ n)))
→ Jℕ A φ 17 17 (Reflℕ 17) ≡ φ 17
Jℕeq17 A φ = refl
| {
"alphanum_fraction": 0.6218299858,
"avg_line_length": 32.1736292428,
"ext": "agda",
"hexsha": "e045909748249bf111d425a176c91b47f6031133",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "dc333ed142584cf52cc885644eed34b356967d8b",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "andrejtokarcik/agda-semantics",
"max_forks_repo_path": "tests/beyond/EscardoTutorial.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "dc333ed142584cf52cc885644eed34b356967d8b",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "andrejtokarcik/agda-semantics",
"max_issues_repo_path": "tests/beyond/EscardoTutorial.agda",
"max_line_length": 106,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "dc333ed142584cf52cc885644eed34b356967d8b",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "andrejtokarcik/agda-semantics",
"max_stars_repo_path": "tests/beyond/EscardoTutorial.agda",
"max_stars_repo_stars_event_max_datetime": "2018-12-06T17:24:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-08-10T15:33:56.000Z",
"num_tokens": 8334,
"size": 24645
} |
------------------------------------------------------------------------------
-- Testing the translation of definitions
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module Definition11 where
open import Common.FOL
-- We test the translation of a definition which Agda η-reduces.
P : D → Set
P d = ∃ λ e → d ≡ e
{-# ATP definition P #-}
postulate bar : ∀ {d} → P d → ∃ λ e → e ≡ d
{-# ATP prove bar #-}
| {
"alphanum_fraction": 0.4243902439,
"avg_line_length": 27.9545454545,
"ext": "agda",
"hexsha": "ccbf48885c9ad09f0886a49f3dea68cbc2e0f18f",
"lang": "Agda",
"max_forks_count": 4,
"max_forks_repo_forks_event_max_datetime": "2016-08-03T03:54:55.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-05-10T23:06:19.000Z",
"max_forks_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/apia",
"max_forks_repo_path": "test/Succeed/fol-theorems/Definition11.agda",
"max_issues_count": 121,
"max_issues_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_issues_repo_issues_event_max_datetime": "2018-04-22T06:01:44.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-25T13:22:12.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/apia",
"max_issues_repo_path": "test/Succeed/fol-theorems/Definition11.agda",
"max_line_length": 78,
"max_stars_count": 10,
"max_stars_repo_head_hexsha": "a66c5ddca2ab470539fd68c42c4fbd45f720d682",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/apia",
"max_stars_repo_path": "test/Succeed/fol-theorems/Definition11.agda",
"max_stars_repo_stars_event_max_datetime": "2019-12-03T13:44:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:54:16.000Z",
"num_tokens": 122,
"size": 615
} |
{-# OPTIONS --no-syntactic-equality #-}
open import Agda.Primitive
variable
ℓ : Level
A : Set ℓ
P : A → Set ℓ
| {
"alphanum_fraction": 0.6271186441,
"avg_line_length": 13.1111111111,
"ext": "agda",
"hexsha": "c710fa4c6b51730268ad49fe9eb0f0e5f60540a6",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "shlevy/agda",
"max_forks_repo_path": "test/Succeed/Issue4265b.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue4265b.agda",
"max_line_length": 39,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue4265b.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 42,
"size": 118
} |
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommRingSolver.EvalHom where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat using (ℕ)
open import Cubical.Data.Int.Base hiding (_+_ ; _·_ ; -_)
open import Cubical.Data.FinData
open import Cubical.Data.Vec
open import Cubical.Data.Bool
open import Cubical.Relation.Nullary.Base
open import Cubical.Algebra.CommRingSolver.Utility
open import Cubical.Algebra.CommRingSolver.RawAlgebra
open import Cubical.Algebra.CommRingSolver.IntAsRawRing
open import Cubical.Algebra.CommRingSolver.HornerForms
open import Cubical.Algebra.CommRingSolver.HornerEval
open import Cubical.Algebra.CommRing
open import Cubical.Algebra.Ring
private
variable
ℓ : Level
module HomomorphismProperties (R : CommRing ℓ) where
private
νR = CommRing→RawℤAlgebra R
open CommRingStr (snd R)
open RingTheory (CommRing→Ring R)
open IteratedHornerOperations νR
EvalHom+0 : {n : ℕ} (P : IteratedHornerForms νR n) (xs : Vec ⟨ νR ⟩ n)
→ eval (0ₕ +ₕ P) xs ≡ eval P xs
EvalHom+0 {n = ℕ.zero} (const x) [] = cong (scalar R) (+Ridℤ x)
EvalHom+0 {n = ℕ.suc _} P xs = refl
Eval0H : {n : ℕ} (xs : Vec ⟨ νR ⟩ n)
→ eval {A = νR} 0ₕ xs ≡ 0r
Eval0H [] = refl
Eval0H (x ∷ xs) = refl
Eval1ₕ : {n : ℕ} (xs : Vec ⟨ νR ⟩ n)
→ eval {A = νR} 1ₕ xs ≡ 1r
Eval1ₕ [] = refl
Eval1ₕ (x ∷ xs) =
eval 1ₕ (x ∷ xs) ≡⟨ refl ⟩
eval (0H ·X+ 1ₕ) (x ∷ xs) ≡⟨ combineCasesEval R 0H 1ₕ x xs ⟩
eval {A = νR} 0H (x ∷ xs) · x + eval 1ₕ xs ≡⟨ cong (λ u → u · x + eval 1ₕ xs)
(Eval0H (x ∷ xs)) ⟩
0r · x + eval 1ₕ xs ≡⟨ cong (λ u → 0r · x + u)
(Eval1ₕ xs) ⟩
0r · x + 1r ≡⟨ cong (λ u → u + 1r)
(0LeftAnnihilates _) ⟩
0r + 1r ≡⟨ +IdL _ ⟩
1r ∎
-EvalDist :
{n : ℕ} (P : IteratedHornerForms νR n) (xs : Vec ⟨ νR ⟩ n)
→ eval (-ₕ P) xs ≡ - eval P xs
-EvalDist (const x) [] = -DistScalar R x
-EvalDist 0H xs =
eval (-ₕ 0H) xs ≡⟨ Eval0H xs ⟩
0r ≡⟨ sym 0Selfinverse ⟩
- 0r ≡⟨ cong -_ (sym (Eval0H xs)) ⟩
- eval 0H xs ∎
-EvalDist (P ·X+ Q) (x ∷ xs) =
eval (-ₕ (P ·X+ Q)) (x ∷ xs)
≡⟨ refl ⟩
eval ((-ₕ P) ·X+ (-ₕ Q)) (x ∷ xs)
≡⟨ combineCasesEval R (-ₕ P) (-ₕ Q) x xs ⟩
(eval (-ₕ P) (x ∷ xs)) · x + eval (-ₕ Q) xs
≡⟨ cong (λ u → u · x + eval (-ₕ Q) xs) (-EvalDist P _) ⟩
(- eval P (x ∷ xs)) · x + eval (-ₕ Q) xs
≡⟨ cong (λ u → (- eval P (x ∷ xs)) · x + u) (-EvalDist Q _) ⟩
(- eval P (x ∷ xs)) · x + - eval Q xs
≡[ i ]⟨ -DistL· (eval P (x ∷ xs)) x i + - eval Q xs ⟩
- ((eval P (x ∷ xs)) · x) + (- eval Q xs)
≡⟨ -Dist _ _ ⟩
- ((eval P (x ∷ xs)) · x + eval Q xs)
≡[ i ]⟨ - combineCasesEval R P Q x xs (~ i) ⟩
- eval (P ·X+ Q) (x ∷ xs) ∎
combineCases+ : {n : ℕ} (P Q : IteratedHornerForms νR (ℕ.suc n))
(r s : IteratedHornerForms νR n)
(x : fst R) (xs : Vec (fst R) n)
→ eval ((P ·X+ r) +ₕ (Q ·X+ s)) (x ∷ xs)
≡ eval ((P +ₕ Q) ·X+ (r +ₕ s)) (x ∷ xs)
combineCases+ {n = n} P Q r s x xs with (isZero νR (P +ₕ Q) and isZero νR (r +ₕ s)) ≟ true
... | yes p = compute+ₕEvalBothZero R n P Q r s x xs p
... | no p = compute+ₕEvalNotBothZero R n P Q r s x xs (¬true→false _ p)
+Homeval :
{n : ℕ} (P Q : IteratedHornerForms νR n) (xs : Vec ⟨ νR ⟩ n)
→ eval (P +ₕ Q) xs ≡ (eval P xs) + (eval Q xs)
+Homeval (const x) (const y) [] = +HomScalar R x y
+Homeval 0H Q xs =
eval (0H +ₕ Q) xs ≡⟨ refl ⟩
eval Q xs ≡⟨ sym (+IdL _) ⟩
0r + eval Q xs ≡⟨ cong (λ u → u + eval Q xs) (sym (Eval0H xs)) ⟩
eval 0H xs + eval Q xs ∎
+Homeval (P ·X+ Q) 0H xs =
eval ((P ·X+ Q) +ₕ 0H) xs ≡⟨ refl ⟩
eval (P ·X+ Q) xs ≡⟨ sym (+IdR _) ⟩
eval (P ·X+ Q) xs + 0r
≡⟨ cong (λ u → eval (P ·X+ Q) xs + u) (sym (Eval0H xs)) ⟩
eval (P ·X+ Q) xs + eval 0H xs ∎
+Homeval (P ·X+ Q) (S ·X+ T) (x ∷ xs) =
eval ((P ·X+ Q) +ₕ (S ·X+ T)) (x ∷ xs)
≡⟨ combineCases+ P S Q T x xs ⟩
eval ((P +ₕ S) ·X+ (Q +ₕ T)) (x ∷ xs)
≡⟨ combineCasesEval R (P +ₕ S) (Q +ₕ T) x xs ⟩
(eval (P +ₕ S) (x ∷ xs)) · x + eval (Q +ₕ T) xs
≡⟨ cong (λ u → (eval (P +ₕ S) (x ∷ xs)) · x + u) (+Homeval Q T xs) ⟩
(eval (P +ₕ S) (x ∷ xs)) · x + (eval Q xs + eval T xs)
≡⟨ cong (λ u → u · x + (eval Q xs + eval T xs)) (+Homeval P S (x ∷ xs)) ⟩
(eval P (x ∷ xs) + eval S (x ∷ xs)) · x
+ (eval Q xs + eval T xs)
≡⟨ cong (λ u → u + (eval Q xs + eval T xs)) (·DistL+ _ _ _) ⟩
(eval P (x ∷ xs)) · x + (eval S (x ∷ xs)) · x
+ (eval Q xs + eval T xs)
≡⟨ +ShufflePairs _ _ _ _ ⟩
((eval P (x ∷ xs)) · x + eval Q xs)
+ ((eval S (x ∷ xs)) · x + eval T xs)
≡[ i ]⟨ combineCasesEval R P Q x xs (~ i) + combineCasesEval R S T x xs (~ i) ⟩
eval (P ·X+ Q) (x ∷ xs)
+ eval (S ·X+ T) (x ∷ xs) ∎
⋆Homeval : {n : ℕ}
(r : IteratedHornerForms νR n)
(P : IteratedHornerForms νR (ℕ.suc n)) (x : ⟨ νR ⟩) (xs : Vec ⟨ νR ⟩ n)
→ eval (r ⋆ P) (x ∷ xs) ≡ eval r xs · eval P (x ∷ xs)
⋆0LeftAnnihilates :
{n : ℕ} (P : IteratedHornerForms νR (ℕ.suc n)) (xs : Vec ⟨ νR ⟩ (ℕ.suc n))
→ eval (0ₕ ⋆ P) xs ≡ 0r
⋆0LeftAnnihilates 0H xs = Eval0H xs
⋆0LeftAnnihilates {n = ℕ.zero} (P ·X+ Q) (x ∷ xs) = refl
⋆0LeftAnnihilates {n = ℕ.suc _} (P ·X+ Q) (x ∷ xs) = refl
⋆isZeroLeftAnnihilates :
{n : ℕ} (r : IteratedHornerForms νR n)
(P : IteratedHornerForms νR (ℕ.suc n))
(xs : Vec ⟨ νR ⟩ (ℕ.suc n))
→ isZero νR r ≡ true
→ eval (r ⋆ P) xs ≡ 0r
⋆isZeroLeftAnnihilates r P xs isZero-r = evalIsZero R (r ⋆ P) xs (isZeroPresLeft⋆ r P isZero-r)
·0LeftAnnihilates :
{n : ℕ} (P : IteratedHornerForms νR n) (xs : Vec ⟨ νR ⟩ n)
→ eval (0ₕ ·ₕ P) xs ≡ 0r
·0LeftAnnihilates (const x) xs =
eval (const _) xs ≡⟨ Eval0H xs ⟩ 0r ∎
·0LeftAnnihilates 0H xs = Eval0H xs
·0LeftAnnihilates (P ·X+ P₁) xs = Eval0H xs
·isZeroLeftAnnihilates :
{n : ℕ} (P Q : IteratedHornerForms νR n)
(xs : Vec (fst R) n)
→ isZero νR P ≡ true
→ eval (P ·ₕ Q) xs ≡ 0r
·isZeroLeftAnnihilates P Q xs isZeroP = evalIsZero R (P ·ₕ Q) xs (isZeroPresLeft·ₕ P Q isZeroP)
·Homeval : {n : ℕ} (P Q : IteratedHornerForms νR n) (xs : Vec ⟨ νR ⟩ n)
→ eval (P ·ₕ Q) xs ≡ (eval P xs) · (eval Q xs)
combineCases⋆ : {n : ℕ} (x : fst R) (xs : Vec (fst R) n)
→ (r : IteratedHornerForms νR n)
→ (P : IteratedHornerForms νR (ℕ.suc n))
→ (Q : IteratedHornerForms νR n)
→ eval (r ⋆ (P ·X+ Q)) (x ∷ xs) ≡ eval ((r ⋆ P) ·X+ (r ·ₕ Q)) (x ∷ xs)
combineCases⋆ x xs r P Q with isZero νR r ≟ true
... | yes p =
eval (r ⋆ (P ·X+ Q)) (x ∷ xs) ≡⟨ ⋆isZeroLeftAnnihilates r (P ·X+ Q) (x ∷ xs) p ⟩
0r ≡⟨ someCalculation R ⟩
0r · x + 0r ≡⟨ step1 ⟩
eval (r ⋆ P) (x ∷ xs) · x + eval (r ·ₕ Q) xs ≡⟨ sym (combineCasesEval R (r ⋆ P) (r ·ₕ Q) x xs) ⟩
eval ((r ⋆ P) ·X+ (r ·ₕ Q)) (x ∷ xs) ∎
where
step1 : 0r · x + 0r ≡ eval (r ⋆ P) (x ∷ xs) · x + eval (r ·ₕ Q) xs
step1 i = ⋆isZeroLeftAnnihilates r P (x ∷ xs) p (~ i) · x + ·isZeroLeftAnnihilates r Q xs p (~ i)
... | no p with isZero νR r
... | true = byAbsurdity (p refl)
... | false = refl
⋆Homeval r 0H x xs =
eval (r ⋆ 0H) (x ∷ xs) ≡⟨ refl ⟩
0r ≡⟨ sym (0RightAnnihilates _) ⟩
eval r xs · 0r ≡⟨ refl ⟩
eval r xs · eval {A = νR} 0H (x ∷ xs) ∎
⋆Homeval r (P ·X+ Q) x xs =
eval (r ⋆ (P ·X+ Q)) (x ∷ xs) ≡⟨ combineCases⋆ x xs r P Q ⟩
eval ((r ⋆ P) ·X+ (r ·ₕ Q)) (x ∷ xs)
≡⟨ combineCasesEval R (r ⋆ P) (r ·ₕ Q) x xs ⟩
(eval (r ⋆ P) (x ∷ xs)) · x + eval (r ·ₕ Q) xs
≡⟨ cong (λ u → u · x + eval (r ·ₕ Q) xs) (⋆Homeval r P x xs) ⟩
(eval r xs · eval P (x ∷ xs)) · x + eval (r ·ₕ Q) xs
≡⟨ cong (λ u → (eval r xs · eval P (x ∷ xs)) · x + u) (·Homeval r Q xs) ⟩
(eval r xs · eval P (x ∷ xs)) · x + eval r xs · eval Q xs
≡⟨ cong (λ u → u + eval r xs · eval Q xs) (sym (·Assoc _ _ _)) ⟩
eval r xs · (eval P (x ∷ xs) · x) + eval r xs · eval Q xs
≡⟨ sym (·DistR+ _ _ _) ⟩
eval r xs · ((eval P (x ∷ xs) · x) + eval Q xs)
≡[ i ]⟨ eval r xs · combineCasesEval R P Q x xs (~ i) ⟩
eval r xs · eval (P ·X+ Q) (x ∷ xs) ∎
lemmaForCombineCases· :
{n : ℕ} (Q : IteratedHornerForms νR n) (P S : IteratedHornerForms νR (ℕ.suc n))
(xs : Vec (fst R) (ℕ.suc n))
→ isZero νR (P ·ₕ S) ≡ true
→ eval ((P ·X+ Q) ·ₕ S) xs ≡ eval (Q ⋆ S) xs
lemmaForCombineCases· Q P S xs isZeroProd with isZero νR (P ·ₕ S)
... | true = refl
... | false = byBoolAbsurdity isZeroProd
combineCases· :
{n : ℕ} (Q : IteratedHornerForms νR n) (P S : IteratedHornerForms νR (ℕ.suc n))
(xs : Vec (fst R) (ℕ.suc n))
→ eval ((P ·X+ Q) ·ₕ S) xs ≡ eval (((P ·ₕ S) ·X+ 0ₕ) +ₕ (Q ⋆ S)) xs
combineCases· Q P S (x ∷ xs) with isZero νR (P ·ₕ S) ≟ true
... | yes p =
eval ((P ·X+ Q) ·ₕ S) (x ∷ xs) ≡⟨ lemmaForCombineCases· Q P S (x ∷ xs) p ⟩
eval (Q ⋆ S) (x ∷ xs) ≡⟨ sym (+IdL _) ⟩
0r + eval (Q ⋆ S) (x ∷ xs) ≡⟨ step1 ⟩
eval ((P ·ₕ S) ·X+ 0ₕ) (x ∷ xs) + eval (Q ⋆ S) (x ∷ xs) ≡⟨ step2 ⟩
eval (((P ·ₕ S) ·X+ 0ₕ) +ₕ (Q ⋆ S)) (x ∷ xs) ∎
where
lemma =
eval ((P ·ₕ S) ·X+ 0ₕ) (x ∷ xs) ≡⟨ combineCasesEval R (P ·ₕ S) 0ₕ x xs ⟩
eval (P ·ₕ S) (x ∷ xs) · x + eval 0ₕ xs ≡[ i ]⟨ evalIsZero R (P ·ₕ S) (x ∷ xs) p i · x + Eval0H xs i ⟩
0r · x + 0r ≡⟨ sym (someCalculation R) ⟩
0r ∎
step1 : _ ≡ _
step1 i = lemma (~ i) + eval (Q ⋆ S) (x ∷ xs)
step2 = sym (+Homeval ((P ·ₕ S) ·X+ 0ₕ) (Q ⋆ S) (x ∷ xs))
... | no p with isZero νR (P ·ₕ S)
... | true = byAbsurdity (p refl)
... | false = refl
·Homeval (const x) (const y) [] = ·HomScalar R x y
·Homeval 0H Q xs =
eval (0H ·ₕ Q) xs ≡⟨ Eval0H xs ⟩
0r ≡⟨ sym (0LeftAnnihilates _) ⟩
0r · eval Q xs ≡⟨ cong (λ u → u · eval Q xs) (sym (Eval0H xs)) ⟩
eval 0H xs · eval Q xs ∎
·Homeval (P ·X+ Q) S (x ∷ xs) =
eval ((P ·X+ Q) ·ₕ S) (x ∷ xs)
≡⟨ combineCases· Q P S (x ∷ xs) ⟩
eval (((P ·ₕ S) ·X+ 0ₕ) +ₕ (Q ⋆ S)) (x ∷ xs)
≡⟨ +Homeval ((P ·ₕ S) ·X+ 0ₕ) (Q ⋆ S) (x ∷ xs) ⟩
eval ((P ·ₕ S) ·X+ 0ₕ) (x ∷ xs) + eval (Q ⋆ S) (x ∷ xs)
≡⟨ cong (λ u → u + eval (Q ⋆ S) (x ∷ xs)) (combineCasesEval R (P ·ₕ S) 0ₕ x xs) ⟩
(eval (P ·ₕ S) (x ∷ xs) · x + eval 0ₕ xs) + eval (Q ⋆ S) (x ∷ xs)
≡⟨ cong (λ u → u + eval (Q ⋆ S) (x ∷ xs))
((eval (P ·ₕ S) (x ∷ xs) · x + eval 0ₕ xs)
≡⟨ cong (λ u → eval (P ·ₕ S) (x ∷ xs) · x + u) (Eval0H xs) ⟩
(eval (P ·ₕ S) (x ∷ xs) · x + 0r)
≡⟨ +IdR _ ⟩
(eval (P ·ₕ S) (x ∷ xs) · x)
≡⟨ cong (λ u → u · x) (·Homeval P S (x ∷ xs)) ⟩
((eval P (x ∷ xs) · eval S (x ∷ xs)) · x)
≡⟨ sym (·Assoc _ _ _) ⟩
(eval P (x ∷ xs) · (eval S (x ∷ xs) · x))
≡⟨ cong (λ u → eval P (x ∷ xs) · u) (·Comm _ _) ⟩
(eval P (x ∷ xs) · (x · eval S (x ∷ xs)))
≡⟨ ·Assoc _ _ _ ⟩
(eval P (x ∷ xs) · x) · eval S (x ∷ xs)
∎) ⟩
(eval P (x ∷ xs) · x) · eval S (x ∷ xs) + eval (Q ⋆ S) (x ∷ xs)
≡⟨ cong (λ u → (eval P (x ∷ xs) · x) · eval S (x ∷ xs) + u)
(⋆Homeval Q S x xs) ⟩
(eval P (x ∷ xs) · x) · eval S (x ∷ xs) + eval Q xs · eval S (x ∷ xs)
≡⟨ sym (·DistL+ _ _ _) ⟩
((eval P (x ∷ xs) · x) + eval Q xs) · eval S (x ∷ xs)
≡⟨ cong (λ u → u · eval S (x ∷ xs)) (sym (combineCasesEval R P Q x xs)) ⟩
eval (P ·X+ Q) (x ∷ xs) · eval S (x ∷ xs) ∎
| {
"alphanum_fraction": 0.4502549988,
"avg_line_length": 44.7572463768,
"ext": "agda",
"hexsha": "207e82bc85da54b13f56bdba2db9ef5e28f847d2",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "thomas-lamiaux/cubical",
"max_forks_repo_path": "Cubical/Algebra/CommRingSolver/EvalHom.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "thomas-lamiaux/cubical",
"max_issues_repo_path": "Cubical/Algebra/CommRingSolver/EvalHom.agda",
"max_line_length": 115,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "thomas-lamiaux/cubical",
"max_stars_repo_path": "Cubical/Algebra/CommRingSolver/EvalHom.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 5479,
"size": 12353
} |
-- Applicative with law
{-# OPTIONS --without-K --safe #-}
module Experiment.Applicative where
open import Data.Product as Prod
open import Data.Unit
open import Function.Base
open import Relation.Binary.PropositionalEquality
record Functor (F : Set → Set) : Set₁ where
field
fmap : ∀ {A B} → (A → B) → F A → F B
field
fmap-id : ∀ {A} (x : F A) → fmap id x ≡ x
fmap-∘ : ∀ {A B C} (f : B → C) (g : A → B) (x : F A) →
fmap f (fmap g x) ≡ fmap (f ∘′ g) x
fmap-cong : ∀ {A B} {f g : A → B} {x : F A} →
(∀ v → f v ≡ g v) → fmap f x ≡ fmap g x
_<$>_ : ∀ {A B} → (A → B) → F A → F B
_<$>_ = fmap
×-assoc : ∀ {a b c} {A : Set a} {B : Set b} {C : Set c} → (A × B) × C → A × (B × C)
×-assoc ((x , y) , z) = x , (y , z)
×-assoc⁻¹ : ∀ {a b c} {A : Set a} {B : Set b} {C : Set c} → A × (B × C) → (A × B) × C
×-assoc⁻¹ (x , (y , z)) = (x , y) , z
app : ∀ {a} {b} {A : Set a} {B : Set b} → (A → B) × A → B
app = uncurry _$′_
record Applicative (F : Set → Set) : Set₁ where
infixl 5 _<*>_
field
functor : Functor F
unit : F ⊤
_<,>_ : ∀ {A B} → F A → F B → F (A × B)
open Functor functor public
field
natural : ∀ {A B C D} (f : A → C) (g : B → D) (fx : F A) (fy : F B) →
fmap f fx <,> fmap g fy ≡ fmap (Prod.map f g) (fx <,> fy)
assoc : ∀ {A B C} (fx : F A) (fy : F B) (fz : F C) →
fmap ×-assoc ((fx <,> fy) <,> fz) ≡ (fx <,> (fy <,> fz))
unitˡ : ∀ {B} (fy : F B) → fmap proj₂ (unit <,> fy) ≡ fy
unitʳ : ∀ {A} (fx : F A) → fmap proj₁ (fx <,> unit) ≡ fx
pure : ∀ {A} → A → F A
pure {A} x = fmap (λ _ → x) unit
_<*>_ : ∀ {A B} → F (A → B) → F A → F B
_<*>_ ff fx = fmap app (ff <,> fx)
liftA2 : ∀ {A B C} → (A → B → C) → F A → F B → F C
liftA2 f fx fy = fmap (uncurry f) (fx <,> fy)
natural₁ : ∀ {A B C} (f : A → C) (fx : F A) (fy : F B) →
fmap f fx <,> fy ≡ fmap (Prod.map₁ f) (fx <,> fy)
natural₁ f fx fy = begin
fmap f fx <,> fy ≡⟨ cong (fmap f fx <,>_) $ sym $ fmap-id fy ⟩
fmap f fx <,> fmap id fy ≡⟨ natural f id fx fy ⟩
fmap (Prod.map₁ f) (fx <,> fy) ∎
where open ≡-Reasoning
natural₂ : ∀ {A B D} (g : B → D) (fx : F A) (fy : F B) →
fx <,> fmap g fy ≡ fmap (Prod.map₂ g) (fx <,> fy)
natural₂ g fx fy = begin
fx <,> fmap g fy ≡⟨ cong (_<,> fmap g fy) $ sym $ fmap-id fx ⟩
fmap id fx <,> fmap g fy ≡⟨ natural id g fx fy ⟩
fmap (Prod.map₂ g) (fx <,> fy) ∎
where open ≡-Reasoning
assoc⁻¹ : ∀ {A B C} (fx : F A) (fy : F B) (fz : F C) →
fmap ×-assoc⁻¹ (fx <,> (fy <,> fz)) ≡ (fx <,> fy) <,> fz
assoc⁻¹ fx fy fz = begin
fmap ×-assoc⁻¹ (fx <,> (fy <,> fz))
≡⟨ sym $ cong (fmap ×-assoc⁻¹) (assoc fx fy fz) ⟩
fmap ×-assoc⁻¹ (fmap ×-assoc ((fx <,> fy) <,> fz))
≡⟨ fmap-∘ ×-assoc⁻¹ ×-assoc ((fx <,> fy) <,> fz) ⟩
fmap (×-assoc⁻¹ ∘′ ×-assoc) ((fx <,> fy) <,> fz)
≡⟨⟩
fmap id ((fx <,> fy) <,> fz)
≡⟨ fmap-id ((fx <,> fy) <,> fz) ⟩
(fx <,> fy) <,> fz
∎
where open ≡-Reasoning
unit-pure : unit ≡ pure tt
unit-pure = begin
unit ≡⟨ sym $ fmap-id unit ⟩
fmap id unit ≡⟨ refl ⟩
fmap (λ _ → tt) unit ∎
where open ≡-Reasoning
fmap-pure : ∀ {A B} (f : A → B) (x : A) → fmap f (pure x) ≡ pure (f x)
fmap-pure f x = begin
fmap f (fmap (λ _ → x) unit) ≡⟨ fmap-∘ f (λ _ → x) unit ⟩
fmap (λ _ → f x) unit ∎
where open ≡-Reasoning
unitˡʳ : ∀ {A} (fx : F A) → fmap proj₂ (unit <,> fx) ≡ fmap proj₁ (fx <,> unit)
unitˡʳ fx = trans (unitˡ fx) (sym $ unitʳ fx)
unitˡ′ : ∀ {B} (fy : F B) → unit <,> fy ≡ fmap (tt ,_) fy
unitˡ′ fy = begin
unit <,> fy
≡⟨ sym $ fmap-id (unit <,> fy) ⟩
fmap id (unit <,> fy)
≡⟨ fmap-cong (λ _ → refl) ⟩
fmap ((tt ,_) ∘′ proj₂) (unit <,> fy)
≡⟨ sym $ fmap-∘ (tt ,_) proj₂ (unit <,> fy) ⟩
fmap (tt ,_) (fmap proj₂ (unit <,> fy))
≡⟨ cong (fmap (tt ,_)) (unitˡ fy) ⟩
fmap (tt ,_) fy
∎
where open ≡-Reasoning
unitʳ′ : ∀ {A} (fx : F A) → fx <,> unit ≡ fmap (_, tt) fx
unitʳ′ fx = begin
fx <,> unit
≡⟨ sym $ fmap-id (fx <,> unit) ⟩
fmap id (fx <,> unit)
≡⟨⟩
fmap ((_, tt) ∘′ proj₁) (fx <,> unit)
≡⟨ sym $ fmap-∘ (_, tt) proj₁ (fx <,> unit) ⟩
fmap (_, tt) (fmap proj₁ (fx <,> unit))
≡⟨ cong (fmap (_, tt)) (unitʳ fx) ⟩
fmap (_, tt) fx
∎
where open ≡-Reasoning
<,>-pureˡ : ∀ {A B} (x : A) (fy : F B) → pure x <,> fy ≡ fmap (x ,_) fy
<,>-pureˡ x fy = begin
fmap (λ _ → x) unit <,> fy
≡⟨ natural₁ (λ _ → x) unit fy ⟩
fmap (Prod.map₁ (λ _ → x)) (unit <,> fy)
≡⟨ cong (fmap (Prod.map₁ (λ _ → x))) (unitˡ′ fy) ⟩
fmap (Prod.map₁ (λ _ → x)) (fmap (tt ,_) fy)
≡⟨ fmap-∘ (Prod.map₁ (λ _ → x)) (tt ,_) fy ⟩
fmap (Prod.map₁ (λ _ → x) ∘′ (tt ,_)) fy
≡⟨⟩
fmap (x ,_) fy
∎
where open ≡-Reasoning
<,>-pureʳ : ∀ {A B} (fx : F A) (y : B) → fx <,> pure y ≡ fmap (_, y) fx
<,>-pureʳ fx y = begin
fx <,> fmap (λ _ → y) unit
≡⟨ natural₂ (λ _ → y) fx unit ⟩
fmap (Prod.map₂ (λ _ → y)) (fx <,> unit)
≡⟨ cong (fmap (Prod.map₂ (λ _ → y))) (unitʳ′ fx) ⟩
fmap (Prod.map₂ (λ _ → y)) (fmap (_, tt) fx)
≡⟨ fmap-∘ (Prod.map₂ (λ _ → y)) (_, tt) fx ⟩
fmap (Prod.map₂ (λ _ → y) ∘′ (_, tt)) fx
≡⟨⟩
fmap (_, y) fx ∎
where open ≡-Reasoning
pure-<,> : ∀ {A B} (x : A) (y : B) → pure x <,> pure y ≡ pure (x , y)
pure-<,> x y = begin
pure x <,> pure y ≡⟨ <,>-pureˡ x (pure y) ⟩
fmap (x ,_) (pure y) ≡⟨ fmap-pure (x ,_) y ⟩
pure (x , y) ∎
where open ≡-Reasoning
<*>-fmap : ∀ {A B} (f : A → B) (fx : F A) → pure f <*> fx ≡ fmap f fx
<*>-fmap f fx = begin
fmap app (pure f <,> fx) ≡⟨ cong (fmap app) $ <,>-pureˡ f fx ⟩
fmap app (fmap (f ,_) fx) ≡⟨ fmap-∘ app (f ,_) fx ⟩
fmap (app ∘′ (f ,_)) fx ≡⟨⟩
fmap f fx ∎
where open ≡-Reasoning
<*>-identity : ∀ {A} (v : F A) → pure id <*> v ≡ v
<*>-identity v = begin
fmap (uncurry _$′_) (pure id <,> v) ≡⟨ cong (fmap (uncurry _$′_)) $ <,>-pureˡ id v ⟩
fmap (uncurry _$′_) (fmap (id ,_) v) ≡⟨ fmap-∘ (uncurry _$′_) (id ,_) v ⟩
fmap (uncurry _$′_ ∘′ (id ,_)) v ≡⟨ fmap-cong (λ _ → refl) ⟩
fmap id v ≡⟨ fmap-id v ⟩
v ∎
where open ≡-Reasoning
<*>-composition : ∀ {A B C} (u : F (A → C)) (v : F (B → A)) (w : F B) →
pure _∘′_ <*> u <*> v <*> w ≡ u <*> (v <*> w)
<*>-composition u v w = begin
pure _∘′_ <*> u <*> v <*> w
≡⟨ cong (λ t → t <*> v <*> w) $ <*>-fmap _∘′_ u ⟩
fmap _∘′_ u <*> v <*> w
≡⟨⟩
fmap app (fmap _∘′_ u <,> v) <*> w
≡⟨⟩
fmap app (fmap app (fmap _∘′_ u <,> v) <,> w)
≡⟨ cong (λ t → fmap app (fmap app t <,> w)) $ natural₁ _∘′_ u v ⟩
fmap app (fmap app (fmap (Prod.map₁ _∘′_) (u <,> v)) <,> w)
≡⟨ cong (fmap app) $ natural₁ app (fmap (Prod.map₁ _∘′_) (u <,> v)) w ⟩
fmap app (fmap (Prod.map₁ app) (fmap (Prod.map₁ _∘′_) (u <,> v) <,> w))
≡⟨ fmap-∘ app (Prod.map₁ app) _ ⟩
fmap (app ∘′ Prod.map₁ app) (fmap (Prod.map₁ _∘′_) (u <,> v) <,> w)
≡⟨ cong (fmap (app ∘′ Prod.map₁ app)) $ natural₁ (Prod.map₁ _∘′_) (u <,> v) w ⟩
fmap (app ∘′ Prod.map₁ app) (fmap (Prod.map₁ (Prod.map₁ _∘′_)) ((u <,> v) <,> w))
≡⟨ fmap-∘ (app ∘′ Prod.map₁ app) (Prod.map₁ (Prod.map₁ _∘′_)) _ ⟩
fmap (app ∘′ Prod.map₁ app ∘′ Prod.map₁ (Prod.map₁ _∘′_)) ((u <,> v) <,> w)
≡⟨ fmap-cong (λ _ → refl) ⟩
fmap (app ∘′ Prod.map₂ app ∘′ ×-assoc) ((u <,> v) <,> w)
≡⟨ sym $ fmap-∘ (app ∘′ Prod.map₂ app) ×-assoc ((u <,> v) <,> w) ⟩
fmap (app ∘′ Prod.map₂ app) (fmap ×-assoc ((u <,> v) <,> w))
≡⟨ cong (fmap (app ∘′ Prod.map₂ app)) (assoc u v w) ⟩
fmap (app ∘′ Prod.map₂ app) (u <,> (v <,> w))
≡⟨ sym $ fmap-∘ app (Prod.map₂ app) (u <,> (v <,> w)) ⟩
fmap app (fmap (Prod.map₂ app) (u <,> (v <,> w)))
≡⟨ sym $ cong (fmap app) $ natural₂ app u (v <,> w) ⟩
fmap app (u <,> fmap app (v <,> w))
≡⟨⟩
u <*> (v <*> w)
∎
where open ≡-Reasoning
<*>-homomorphism : ∀ {A B} (f : A → B) (x : A) → pure f <*> pure x ≡ pure (f x)
<*>-homomorphism f x = begin
pure f <*> pure x ≡⟨ <*>-fmap f (pure x) ⟩
fmap f (pure x) ≡⟨ fmap-pure f x ⟩
pure (f x) ∎
where open ≡-Reasoning
<*>-interchange : ∀ {A B} (u : F (A → B)) (y : A) →
u <*> pure y ≡ pure (_$ y) <*> u
<*>-interchange u y = begin
u <*> pure y ≡⟨⟩
fmap app (u <,> pure y) ≡⟨ cong (fmap app) (<,>-pureʳ u y) ⟩
fmap app (fmap (_, y) u) ≡⟨ fmap-∘ app (_, y) u ⟩
fmap (app ∘′ (_, y)) u ≡⟨⟩
fmap (_$ y) u ≡⟨ sym $ <*>-fmap (_$ y) u ⟩
pure (_$ y) <*> u ∎
where open ≡-Reasoning
liftA2-defn : ∀ {A B C} (f : A → B → C) (fx : F A) (fy : F B) →
liftA2 f fx fy ≡ pure f <*> fx <*> fy
liftA2-defn f fx fy = begin
fmap (uncurry f) (fx <,> fy) ≡⟨⟩
fmap (app ∘′ Prod.map₁ f) (fx <,> fy) ≡⟨ sym $ fmap-∘ app (Prod.map₁ f) (fx <,> fy) ⟩
fmap app (fmap (Prod.map₁ f) (fx <,> fy)) ≡⟨ cong (fmap app) $ sym $ natural₁ f fx fy ⟩
fmap app (fmap f fx <,> fy) ≡⟨⟩
fmap f fx <*> fy ≡⟨ sym $ cong (_<*> fy) $ <*>-fmap f fx ⟩
pure f <*> fx <*> fy ∎
where open ≡-Reasoning
liftA2-cong : ∀ {A B C} {f g : A → B → C} {fx : F A} {fy : F B} →
(∀ x y → f x y ≡ g x y) → liftA2 f fx fy ≡ liftA2 g fx fy
liftA2-cong {_} {_} {_} {f} {g} {fx} {gx} f≡g = fmap-cong λ v → f≡g (proj₁ v) (proj₂ v)
<*>-defn : ∀ {A B} (ff : F (A → B)) (fx : F A) → ff <*> fx ≡ liftA2 _$′_ ff fx
<*>-defn ff fx = refl
-- liftA2 f fx fy = pure f <*> fx <*> fy
{-
forall x y. p (q x y) = f x . g y
it follows from the above that
liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v
-}
record ApplicativeViaAp (F : Set → Set) : Set₁ where
infixl 5 _<*>_
field
functor : Functor F
pure : ∀ {A} → A → F A
_<*>_ : ∀ {A B} → F (A → B) → F A → F B
open Functor functor public
field
identity : ∀ {A} (fx : F A) → pure id <*> fx ≡ fx
composition : ∀ {A B C} (u : F (A → C)) (v : F (B → A)) (w : F B) →
pure _∘′_ <*> u <*> v <*> w ≡ u <*> (v <*> w)
homomorphism : ∀ {A B} (f : A → B) (x : A) → pure f <*> pure x ≡ pure (f x)
interchange : ∀ {A B} (u : F (A → B)) (y : A) →
u <*> pure y ≡ pure (_$ y) <*> u
<*>-fmap : ∀ {A B} (f : A → B) (fx : F A) → pure f <*> fx ≡ fmap f fx
_<,>_ : ∀ {A B} → F A → F B → F (A × B)
fx <,> fy = pure _,_ <*> fx <*> fy
liftA2 : ∀ {A B C} → (A → B → C) → F A → F B → F C
liftA2 f fx fy = fmap (uncurry f) (fx <,> fy)
unit : F ⊤
unit = pure tt
{-
<,>-natural : ∀ {A B C D} (f : A → C) (g : B → D) (fx : F A) (fy : F B) →
fmap f fx <,> fmap g fy ≡ fmap (Prod.map f g) (fx <,> fy)
<,>-natural f g fx fy = begin
pure _,_ <*> fmap f fx <*> fmap g fy
≡⟨ cong (_<*> fmap g fy) $ <*>-fmap _,_ (fmap f fx) ⟩
fmap _,_ (fmap f fx) <*> fmap g fy
≡⟨ cong (_<*> fmap g fy) $ fmap-∘ _,_ f fx ⟩
fmap (_,_ ∘′ f) fx <*> fmap g fy
≡⟨ {! !} ⟩
fmap (Prod.map f g) (fmap _,_ fx <*> fy)
≡⟨ sym $ cong (λ t → fmap (Prod.map f g) (t <*> fy)) $ <*>-fmap _,_ fx ⟩
fmap (Prod.map f g) (pure _,_ <*> fx <*> fy)
∎
where open ≡-Reasoning
liftA2-defn : ∀ {A B C} (f : A → B → C) (fx : F A) (fy : F B) →
liftA2 f fx fy ≡ pure f <*> fx <*> fy
liftA2-defn f fx fy = {! !}
-}
record Monad (F : Set → Set) : Set₁ where
infixl 5 _>>=_
field
functor : Functor F
return : ∀ {A} → A → F A
join : ∀ {A} → F (F A) → F A
open Functor functor public
field
assoc : ∀ {A} (fffx : F (F (F A))) → join (fmap join fffx) ≡ join (join fffx)
identityˡ : ∀ {A} (fx : F A) → join (fmap return fx) ≡ fx
identityʳ : ∀ {A} (fx : F A) → join (return fx) ≡ fx
join-natural : ∀ {A B} (f : A → B) (ffx : F (F A)) →
join (fmap (fmap f) ffx) ≡ fmap f (join ffx)
return-natural : ∀ {A B} (f : A → B) (x : A) → return (f x) ≡ fmap f (return x)
_>>=_ : ∀ {A B} → F A → (A → F B) → F B
_>>=_ m k = join (fmap k m)
_=<<_ : ∀ {A B} → (A → F B) → F A → F B
_=<<_ = flip _>>=_
liftM : ∀ {A B} → (A → B) → F A → F B
liftM f fx = fx >>= λ x → return (f x)
ap : ∀ {A B} → F (A → B) → F A → F B
ap ff fx = ff >>= λ f → fmap f fx
pair : ∀ {A B} → F A → F B → F (A × B)
pair fx fy = fx >>= λ x → fmap (λ y → x , y) fy
unitM : F ⊤
unitM = return tt
liftM-is-fmap : ∀ {A B} (f : A → B) (fx : F A) → liftM f fx ≡ fmap f fx
liftM-is-fmap f fx = begin
join (fmap (λ x → return (f x)) fx) ≡⟨ sym $ cong join $ fmap-∘ return f fx ⟩
join (fmap return (fmap f fx)) ≡⟨ identityˡ (fmap f fx) ⟩
fmap f fx ∎
where open ≡-Reasoning
>>=-cong : ∀ {A B} {f g : A → F B} {fx : F A} →
(∀ x → f x ≡ g x) → fx >>= f ≡ fx >>= g
>>=-cong f≡g = cong join (fmap-cong f≡g)
fmap-lemma : ∀ {A B C} (f : A → B) (fx : F A) (k : B → F C) →
fmap f fx >>= k ≡ fx >>= λ x → k (f x)
fmap-lemma f fx k = begin
fmap f fx >>= k ≡⟨⟩
join (fmap k (fmap f fx)) ≡⟨ cong join (fmap-∘ k f fx) ⟩
join (fmap (λ x → (k (f x))) fx) ∎
where open ≡-Reasoning
liftM-lemma : ∀ {A B C} (f : A → B) (fx : F A) (k : B → F C) →
liftM f fx >>= k ≡ fx >>= λ x → k (f x)
liftM-lemma f fx k = begin
liftM f fx >>= k ≡⟨ cong (_>>= k) $ liftM-is-fmap f fx ⟩
fmap f fx >>= k ≡⟨ fmap-lemma f fx k ⟩
fx >>= (λ x → k (f x)) ∎
where open ≡-Reasoning
{-
kleisli-assoc
-}
{-
kleisli-identityˡ : ∀ {A B : Set} (f : A → F B) (x : A) → join (fmap return (f x)) ≡ f x
kleisli-identityˡ f x = identityˡ (f x)
kleisli-identityʳ : ∀ {A B : Set} (f : A → F B) (x : A) → join (fmap f (return x)) ≡ f x
kleisli-identityʳ f x = >>=-identityˡ f x
-}
fmap-return : ∀ {A B} (f : A → B) (x : A) → fmap f (return x) ≡ return (f x)
fmap-return f x = sym $ return-natural f x
>>=-identityˡ : ∀ {A B} (a : A) (k : A → F B) → return a >>= k ≡ k a
>>=-identityˡ a k = begin
join (fmap k (return a)) ≡⟨ cong join $ fmap-return k a ⟩
join (return (k a)) ≡⟨ identityʳ (k a) ⟩
k a ∎
where open ≡-Reasoning
>>=-identityʳ : ∀ {A} (m : F A) → m >>= return ≡ m
>>=-identityʳ m = identityˡ m
>>=-assoc : ∀ {A B C} (m : F A) (k : A → F B) (h : B → F C) →
m >>= (λ x → k x >>= h) ≡ (m >>= k) >>= h
>>=-assoc m k h = begin
m >>= (λ x → k x >>= h)
≡⟨⟩
join (fmap (λ x → join (fmap h (k x))) m)
≡⟨ sym $ cong join $ fmap-∘ join (fmap h ∘′ k) m ⟩
join (fmap join (fmap (fmap h ∘′ k) m))
≡⟨ assoc (fmap (fmap h ∘′ k) m) ⟩
join (join (fmap (fmap h ∘′ k) m))
≡⟨ cong join (begin
join (fmap (fmap h ∘′ k) m) ≡⟨ sym $ cong join $ fmap-∘ (fmap h) k m ⟩
join (fmap (fmap h) (fmap k m)) ≡⟨ join-natural h (fmap k m) ⟩
fmap h (join (fmap k m)) ∎ ) ⟩
join (fmap h (join (fmap k m)))
≡⟨⟩
(m >>= k) >>= h
∎
where open ≡-Reasoning
fmap->>= : ∀ {A B C} (f : B → C) (m : F A) (k : A → F B) →
fmap f (m >>= k) ≡ m >>= (λ x → fmap f (k x))
fmap->>= f m k = begin
fmap f (m >>= k) ≡⟨⟩
fmap f (join (fmap k m)) ≡⟨ sym $ join-natural f (fmap k m) ⟩
join (fmap (fmap f) (fmap k m)) ≡⟨ cong join $ fmap-∘ (fmap f) k m ⟩
join (fmap (fmap f ∘′ k) m) ≡⟨⟩
m >>= (λ x → fmap f (k x)) ∎
where open ≡-Reasoning
fmap-move : ∀ {A B C D} (f : C → D) (g : A → B → C) (m1 : F A) (m2 : F B) →
fmap f (m1 >>= λ x → fmap (g x) m2) ≡ m1 >>= (λ x → fmap (f ∘′ g x) m2)
fmap-move f g m1 m2 = begin
fmap f (m1 >>= λ x → fmap (g x) m2) ≡⟨ fmap->>= f m1 (λ x → fmap (g x) m2) ⟩
m1 >>= (λ x → fmap f (fmap (g x) m2)) ≡⟨ >>=-cong (λ x → fmap-∘ f (g x) m2) ⟩
m1 >>= (λ x → fmap (f ∘′ g x) m2) ∎
where open ≡-Reasoning
{-
applicative : Applicative F
applicative = record
{ functor = functor
; unit = unitM
; _<,>_ = pair
; natural = λ f g fx fy → begin
pair (fmap f fx) (fmap g fy)
≡⟨⟩
fmap f fx >>= (λ x → fmap (λ y → x , y) (fmap g fy))
≡⟨ fmap-lemma f fx _ ⟩
fx >>= (λ x → fmap (λ y → f x , y) (fmap g fy) )
≡⟨ >>=-cong (λ x → fmap-∘ (f x ,_) g fy) ⟩
fx >>= (λ x → fmap (λ y → f x , g y) fy)
≡⟨⟩
fx >>= (λ x → fmap (λ y → Prod.map f g (x , y) ) fy )
≡⟨ sym $ fmap-move (Prod.map f g) _,_ fx fy ⟩
fmap (Prod.map f g) (fx >>= λ x → fmap (λ y → x , y) fy)
≡⟨⟩
fmap (Prod.map f g) (pair fx fy)
∎
; assoc = λ fx fy fz →
fmap ×-assoc (pair (pair fx fy) fz)
≡⟨⟩
fmap ×-assoc ((fx >>= λ x → fmap (x ,_) fy) >>= λ xy → fmap (xy ,_) fz)
≡⟨ {! sym $ >>=-assoc fx !} ⟩
fx >>= (λ x → fy >>= λ y → fmap (λ z → x , (y , z)) fz)
≡⟨ sym $ >>=-cong (λ x → fmap-move (x ,_) _,_ fy fz) ⟩
fx >>= (λ x → fmap (x ,_) (fy >>= λ y → fmap (y ,_) fz))
≡⟨⟩
pair fx (pair fy fz)
∎
; unitˡ = {! !}
; unitʳ = {! !}
}
where open ≡-Reasoning
-}
| {
"alphanum_fraction": 0.4306936416,
"avg_line_length": 37.1244635193,
"ext": "agda",
"hexsha": "bdfe8d84591c935afaf139e1d7b2607c242c3f4c",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "37200ea91d34a6603d395d8ac81294068303f577",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "rei1024/agda-misc",
"max_forks_repo_path": "Experiment/Applicative.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "37200ea91d34a6603d395d8ac81294068303f577",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "rei1024/agda-misc",
"max_issues_repo_path": "Experiment/Applicative.agda",
"max_line_length": 93,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "37200ea91d34a6603d395d8ac81294068303f577",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "rei1024/agda-misc",
"max_stars_repo_path": "Experiment/Applicative.agda",
"max_stars_repo_stars_event_max_datetime": "2020-04-21T00:03:43.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:49:42.000Z",
"num_tokens": 7739,
"size": 17300
} |
------------------------------------------------------------------------------
-- FOTC version of a nested recursive function
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
-- From: Ana Bove and Venanzio Capretta. Nested general recursion and
-- partiality in type theory. Vol. 2152 of LNCS. 2001.
module FOT.FOTC.Program.Nest.PropertiesI where
open import Common.FOL.Relation.Binary.EqReasoning
open import FOTC.Base
open import FOTC.Data.Nat.Type
open import FOTC.Program.Nest.Nest
------------------------------------------------------------------------------
nestCong : ∀ {m n} → m ≡ n → nest m ≡ nest n
nestCong refl = refl
nest-x≡0 : ∀ {n} → N n → nest n ≡ zero
nest-x≡0 nzero = nest-0
nest-x≡0 (nsucc {n} Nn) =
nest (succ₁ n) ≡⟨ nest-S n ⟩
nest (nest n) ≡⟨ nestCong (nest-x≡0 Nn) ⟩
nest zero ≡⟨ nest-0 ⟩
zero ∎
nest-N : ∀ {n} → N n → N (nest n)
nest-N Nn = subst N (sym (nest-x≡0 Nn)) nzero
| {
"alphanum_fraction": 0.4881057269,
"avg_line_length": 31.5277777778,
"ext": "agda",
"hexsha": "d4e9e2fb51d324ee2bfc0dbbb9dfdb6b62cfd0b7",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z",
"max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/fotc",
"max_forks_repo_path": "notes/FOT/FOTC/Program/Nest/PropertiesI.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/fotc",
"max_issues_repo_path": "notes/FOT/FOTC/Program/Nest/PropertiesI.agda",
"max_line_length": 78,
"max_stars_count": 11,
"max_stars_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/fotc",
"max_stars_repo_path": "notes/FOT/FOTC/Program/Nest/PropertiesI.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-12T16:09:54.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:53:42.000Z",
"num_tokens": 315,
"size": 1135
} |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.Bouquet
{-
Various lemmas that will be used in cohomology.DisjointlyPointedSet.
Many of them, for example the choice lemma about coproducts, should be
put into core/.
-}
module homotopy.DisjointlyPointedSet where
module _ {i} where
is-separable : (X : Ptd i) → Type i
is-separable X = has-dec-onesided-eq (pt X)
abstract
is-separable-is-prop : {X : Ptd i}
→ is-prop (is-separable X)
is-separable-is-prop = has-dec-onesided-eq-is-prop
MinusPoint : (X : Ptd i) → Type i
MinusPoint X = Σ (de⊙ X) (pt X ≠_)
MinusPoint-prop : (X : Ptd i) → SubtypeProp (de⊙ X) i
MinusPoint-prop X = (pt X ≠_) , ⟨⟩
abstract
MinusPoint-has-dec-eq : {X : Ptd i}
→ has-dec-eq (de⊙ X)
→ has-dec-eq (MinusPoint X)
MinusPoint-has-dec-eq {X} X-dec =
Subtype-has-dec-eq (MinusPoint-prop X) X-dec
unite-pt : (X : Ptd i) → (⊤ ⊔ MinusPoint X → de⊙ X)
unite-pt X (inl _) = pt X
unite-pt X (inr (x , _)) = x
separate-pt : {X : Ptd i}
→ is-separable X
→ (de⊙ X → ⊤ ⊔ (Σ (de⊙ X) (pt X ≠_)))
separate-pt dec x with dec x
separate-pt dec x | inl _ = inl unit
separate-pt dec x | inr ¬p = inr (x , ¬p)
has-disjoint-pt : (X : Ptd i) → Type i
has-disjoint-pt X = is-equiv (unite-pt X)
separable-has-disjoint-pt : {X : Ptd i}
→ is-separable X → has-disjoint-pt X
separable-has-disjoint-pt {X} dec =
is-eq _ (separate-pt dec) unite-sep sep-unite where
abstract
sep-unite : ∀ x → separate-pt dec (unite-pt X x) == x
sep-unite (inl _) with dec (pt X)
sep-unite (inl _) | inl _ = idp
sep-unite (inl _) | inr ¬p = ⊥-rec (¬p idp)
sep-unite (inr (x , ¬p)) with dec x
sep-unite (inr (x , ¬p)) | inl p = ⊥-rec (¬p p)
sep-unite (inr (x , ¬p)) | inr ¬p' = ap inr $ pair= idp (prop-has-all-paths ¬p' ¬p)
unite-sep : ∀ x → unite-pt X (separate-pt dec x) == x
unite-sep x with dec x
unite-sep x | inl p = p
unite-sep x | inr ¬p = idp
disjoint-pt-is-separable : {X : Ptd i}
→ has-disjoint-pt X → is-separable X
disjoint-pt-is-separable unite-ise x with unite.g x | unite.f-g x
where module unite = is-equiv unite-ise
disjoint-pt-is-separable unite-ise x | inl unit | p = inl p
disjoint-pt-is-separable unite-ise x | inr (y , pt≠y) | y=x = inr λ pt=x → pt≠y (pt=x ∙ ! y=x)
separable-unite-equiv : ∀ {X}
→ is-separable X
→ (⊤ ⊔ MinusPoint X ≃ de⊙ X)
separable-unite-equiv dX = _ , separable-has-disjoint-pt dX
module _ {i j k} n (A : Type i) (B : Type j) where
{- Hmm. Where should we put this lemma? -}
abstract
⊔-has-choice-implies-inr-has-choice : has-choice n (A ⊔ B) k → has-choice n B k
⊔-has-choice-implies-inr-has-choice ⊔-ac W =
transport is-equiv (λ= lemma₃)
(snd lemma₂ ∘ise ⊔-ac W' ∘ise is-equiv-inverse (snd (Trunc-emap lemma₁))) where
W' : A ⊔ B → Type k
W' (inl _) = Lift {j = k} ⊤
W' (inr b) = W b
lemma₁ : Π (A ⊔ B) W' ≃ Π B W
lemma₁ = equiv to from to-from from-to where
to : Π (A ⊔ B) W' → Π B W
to f b = f (inr b)
from : Π B W → Π (A ⊔ B) W'
from f (inl a) = lift tt
from f (inr b) = f b
abstract
to-from : ∀ f → to (from f) == f
to-from f = λ= λ b → idp
from-to : ∀ f → from (to f) == f
from-to f = λ= λ{(inl a) → idp; (inr b) → idp}
lemma₂ : Π (A ⊔ B) (Trunc n ∘ W') ≃ Π B (Trunc n ∘ W)
lemma₂ = equiv to from to-from from-to where
to : Π (A ⊔ B) (Trunc n ∘ W') → Π B (Trunc n ∘ W)
to f b = f (inr b)
from : Π B (Trunc n ∘ W) → Π (A ⊔ B) (Trunc n ∘ W')
from f (inl a) = [ lift tt ]
from f (inr b) = f b
abstract
to-from : ∀ f → to (from f) == f
to-from f = λ= λ b → idp
from-to : ∀ f → from (to f) == f
from-to f = λ= λ{
(inl a) → Trunc-elim
{P = λ t → [ lift tt ] == t}
(λ _ → idp) (f (inl a));
(inr b) → idp}
lemma₃ : ∀ f → –> lemma₂ (unchoose (<– (Trunc-emap lemma₁) f)) == unchoose f
lemma₃ = Trunc-elim
{P = λ f → –> lemma₂ (unchoose (<– (Trunc-emap lemma₁) f)) == unchoose f}
(λ f → λ= λ b → idp)
module _ {i j} {n} {X : Ptd i} (X-sep : is-separable X) where
abstract
MinusPoint-has-choice : has-choice n (de⊙ X) j → has-choice n (MinusPoint X) j
MinusPoint-has-choice X-ac =
⊔-has-choice-implies-inr-has-choice n ⊤ (MinusPoint X) $
transport! (λ A → has-choice n A j) (ua (_ , separable-has-disjoint-pt X-sep)) X-ac
module _ {i} {X : Ptd i} (X-sep : is-separable X) where
Bouquet-equiv-X : Bouquet (MinusPoint X) 0 ≃ de⊙ X
Bouquet-equiv-X = equiv to from to-from from-to where
from : de⊙ X → BigWedge {A = MinusPoint X} (λ _ → ⊙Bool)
from x with X-sep x
from x | inl p = bwbase
from x | inr ¬p = bwin (x , ¬p) false
module To = BigWedgeRec {A = MinusPoint X} {X = λ _ → ⊙Bool}
(pt X) (λ{_ true → pt X; (x , _) false → x}) (λ _ → idp)
to = To.f
abstract
from-to : ∀ x → from (to x) == x
from-to = BigWedge-elim base* in* glue* where
base* : from (pt X) == bwbase
base* with X-sep (pt X)
base* | inl _ = idp
base* | inr ¬p = ⊥-rec (¬p idp)
in* : (wp : MinusPoint X) (b : Bool)
→ from (to (bwin wp b)) == bwin wp b
in* wp true with X-sep (pt X)
in* wp true | inl _ = bwglue wp
in* wp true | inr pt≠pt = ⊥-rec (pt≠pt idp)
in* (x , pt≠x) false with X-sep x
in* (x , pt≠x) false | inl pt=x = ⊥-rec (pt≠x pt=x)
in* (x , pt≠x) false | inr pt≠'x =
ap (λ ¬p → bwin (x , ¬p) false) $ prop-has-all-paths pt≠'x pt≠x
glue* : (wp : MinusPoint X)
→ base* == in* wp true [ (λ x → from (to x) == x) ↓ bwglue wp ]
glue* wp = ↓-∘=idf-from-square from to $ ap (ap from) (To.glue-β wp) ∙v⊡ square where
square : Square base* idp (bwglue wp) (in* wp true)
square with X-sep (pt X)
square | inl _ = br-square (bwglue wp)
square | inr ¬p = ⊥-rec (¬p idp)
to-from : ∀ x → to (from x) == x
to-from x with X-sep x
to-from x | inl pt=x = pt=x
to-from x | inr pt≠x = idp
Bouquet-⊙equiv-X : ⊙Bouquet (MinusPoint X) 0 ⊙≃ X
Bouquet-⊙equiv-X = ≃-to-⊙≃ Bouquet-equiv-X idp
| {
"alphanum_fraction": 0.5173774473,
"avg_line_length": 35.4247311828,
"ext": "agda",
"hexsha": "fa2c77fe215254d73e6a753f940d09531a5f2805",
"lang": "Agda",
"max_forks_count": 50,
"max_forks_repo_forks_event_max_datetime": "2022-02-14T03:03:25.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-10T01:48:08.000Z",
"max_forks_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "timjb/HoTT-Agda",
"max_forks_repo_path": "theorems/homotopy/DisjointlyPointedSet.agda",
"max_issues_count": 31,
"max_issues_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e",
"max_issues_repo_issues_event_max_datetime": "2021-10-03T19:15:25.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-03-05T20:09:00.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "timjb/HoTT-Agda",
"max_issues_repo_path": "theorems/homotopy/DisjointlyPointedSet.agda",
"max_line_length": 96,
"max_stars_count": 294,
"max_stars_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "timjb/HoTT-Agda",
"max_stars_repo_path": "theorems/homotopy/DisjointlyPointedSet.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-20T13:54:45.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T16:23:23.000Z",
"num_tokens": 2489,
"size": 6589
} |
------------------------------------------------------------------------
-- Normalisation by evaluation
------------------------------------------------------------------------
import Axiom.Extensionality.Propositional as E
import Level
open import Data.Universe
-- The code makes use of the assumption that propositional equality of
-- functions is extensional.
module README.DependentlyTyped.NBE
(Uni₀ : Universe Level.zero Level.zero)
(ext : E.Extensionality Level.zero Level.zero)
where
open import Data.Empty
open import Data.Product renaming (curry to c)
open import deBruijn.Substitution.Data
open import Function hiding (_∋_) renaming (const to k)
import README.DependentlyTyped.NormalForm as NF
open NF Uni₀ renaming ([_] to [_]n)
import README.DependentlyTyped.Term as Term; open Term Uni₀
import README.DependentlyTyped.Term.Substitution as S; open S Uni₀
import Relation.Binary.PropositionalEquality as P
open import Relation.Nullary using (¬_)
open P.≡-Reasoning
-- The values that are used by the NBE algorithm.
import README.DependentlyTyped.NBE.Value as Value
open Value Uni₀ public
-- Weakening for the values.
import README.DependentlyTyped.NBE.Weakening as Weakening
open Weakening Uni₀ ext public
-- Application.
infix 9 [_]_·̌_
[_]_·̌_ : ∀ {Γ sp₁ sp₂} σ →
V̌alue Γ (π sp₁ sp₂ , σ) → (v : V̌alue Γ (fst σ)) →
V̌alue Γ (snd σ /̂ ŝub ⟦̌ v ⟧)
[ _ ] f ·̌ v = proj₁ f ε v
abstract
-- Lifting can be expressed using žero.
∘̂-ŵk-▻̂-žero : ∀ {Γ Δ} (ρ̂ : Γ ⇨̂ Δ) σ →
ρ̂ ∘̂ ŵk ▻̂[ σ ] ⟦ žero _ (proj₂ σ /̂I ρ̂) ⟧n ≅-⇨̂ ρ̂ ↑̂ σ
∘̂-ŵk-▻̂-žero ρ̂ σ = begin
[ ρ̂ ∘̂ ŵk ▻̂ ⟦ žero _ _ ⟧n ] ≡⟨ ▻̂-cong P.refl P.refl (ňeutral-to-normal-identity _ (var zero)) ⟩
[ ρ̂ ∘̂ ŵk ▻̂ ⟦ var zero ⟧ ] ≡⟨ P.refl ⟩
[ ρ̂ ↑̂ ] ∎
mutual
-- Evaluation.
eval : ∀ {Γ Δ σ} {ρ̂ : Γ ⇨̂ Δ} →
Γ ⊢ σ → Sub V̌al ρ̂ → V̌alue Δ (σ /̂ ρ̂)
eval (var x) ρ = x /∋ ρ
eval (ƛ t) ρ = (eval[ƛ t ] ρ) , eval[ƛ t ] ρ well-behaved
eval (t₁ · t₂) ρ = eval[ t₁ · t₂ ] ρ
-- Some abbreviations.
eval[ƛ_] : ∀ {Γ Δ σ τ} {ρ̂ : Γ ⇨̂ Δ} →
Γ ▻ σ ⊢ τ → Sub V̌al ρ̂ → V̌alue-π Δ _ _ (IType-π σ τ /̂I ρ̂)
eval[ƛ t ] ρ Γ₊ v = eval t (V̌al-subst.wk-subst₊ Γ₊ ρ ▻ v)
eval[_·_] : ∀ {Γ Δ sp₁ sp₂ σ} {ρ̂ : Γ ⇨̂ Δ} →
Γ ⊢ (π sp₁ sp₂ , σ) → (t₂ : Γ ⊢ fst σ) → Sub V̌al ρ̂ →
V̌alue Δ (snd σ /̂ ŝub ⟦ t₂ ⟧ ∘̂ ρ̂)
eval[_·_] {σ = σ} t₁ t₂ ρ =
cast ([ σ /I ρ ] eval t₁ ρ ·̌ eval t₂ ρ)
where
cast = P.subst (λ v → V̌alue _ (snd σ /̂ ⟦ ρ ⟧⇨ ↑̂ /̂ ŝub v))
(≅-Value-⇒-≡ $ P.sym $ eval-lemma t₂ ρ)
abstract
-- The ƛ case is well-behaved.
eval[ƛ_]_well-behaved :
∀ {Γ Δ σ τ} {ρ̂ : Γ ⇨̂ Δ} (t : Γ ▻ σ ⊢ τ) (ρ : Sub V̌al ρ̂) →
W̌ell-behaved _ _ (IType-π σ τ /I ρ) (eval[ƛ t ] ρ)
eval[ƛ_]_well-behaved {σ = σ} {τ = τ} t ρ Γ₊ v =
let υ = IType-π σ τ /I ρ in begin
[ (⟦̌ υ ∣ eval[ƛ t ] ρ ⟧-π /̂Val ŵk₊ Γ₊) ˢ ⟦̌ v ⟧ ] ≡⟨ ˢ-cong (/̂Val-cong (P.sym $ eval-lemma-ƛ t ρ) P.refl) P.refl ⟩
[ (c ⟦ t ⟧ /̂Val ⟦ ρ ⟧⇨ ∘̂ ŵk₊ Γ₊) ˢ ⟦̌ v ⟧ ] ≡⟨ P.refl ⟩
[ ⟦ t ⟧ /̂Val (⟦ ρ ⟧⇨ ∘̂ ŵk₊ Γ₊ ▻̂ ⟦̌ v ⟧) ] ≡⟨ eval-lemma t _ ⟩
[ ⟦̌ eval t (V̌al-subst.wk-subst₊ Γ₊ ρ ▻ v) ⟧ ] ∎
-- An unfolding lemma.
eval-· :
∀ {Γ Δ sp₁ sp₂ σ} {ρ̂ : Γ ⇨̂ Δ}
(t₁ : Γ ⊢ π sp₁ sp₂ , σ) (t₂ : Γ ⊢ fst σ) (ρ : Sub V̌al ρ̂) →
eval[ t₁ · t₂ ] ρ ≅-V̌alue [ σ /I ρ ] eval t₁ ρ ·̌ eval t₂ ρ
eval-· {σ = σ} t₁ t₂ ρ =
drop-subst-V̌alue (λ v → snd σ /̂ ⟦ ρ ⟧⇨ ↑̂ /̂ ŝub v)
(≅-Value-⇒-≡ $ P.sym $ eval-lemma t₂ ρ)
-- The evaluator is correct (with respect to the standard
-- semantics).
eval-lemma : ∀ {Γ Δ σ} {ρ̂ : Γ ⇨̂ Δ} (t : Γ ⊢ σ) (ρ : Sub V̌al ρ̂) →
⟦ t ⟧ /Val ρ ≅-Value ⟦̌ eval t ρ ⟧
eval-lemma (var x) ρ = V̌al-subst./̂∋-⟦⟧⇨ x ρ
eval-lemma (ƛ t) ρ = eval-lemma-ƛ t ρ
eval-lemma (_·_ {σ = σ} t₁ t₂) ρ = begin
[ ⟦ t₁ · t₂ ⟧ /Val ρ ] ≡⟨ P.refl ⟩
[ (⟦ t₁ ⟧ /Val ρ) ˢ (⟦ t₂ ⟧ /Val ρ) ] ≡⟨ ˢ-cong (eval-lemma t₁ ρ) (eval-lemma t₂ ρ) ⟩
[ ⟦̌_⟧ {σ = σ /I ρ} (eval t₁ ρ) ˢ ⟦̌ eval t₂ ρ ⟧ ] ≡⟨ proj₂ (eval t₁ ρ) ε (eval t₂ ρ) ⟩
[ ⟦̌ [ σ /I ρ ] eval t₁ ρ ·̌ eval t₂ ρ ⟧ ] ≡⟨ ⟦̌⟧-cong (P.sym $ eval-· t₁ t₂ ρ) ⟩
[ ⟦̌ eval[ t₁ · t₂ ] ρ ⟧ ] ∎
private
eval-lemma-ƛ :
∀ {Γ Δ σ τ} {ρ̂ : Γ ⇨̂ Δ} (t : Γ ▻ σ ⊢ τ) (ρ : Sub V̌al ρ̂) →
⟦ ƛ t ⟧ /Val ρ ≅-Value ⟦̌ IType-π σ τ /I ρ ∣ eval[ƛ t ] ρ ⟧-π
eval-lemma-ƛ {σ = σ} {τ = τ} t ρ =
let υ = IType-π σ τ /I ρ
ρ↑ = V̌al-subst.wk-subst₊ (σ / ρ ◅ ε) ρ ▻ v̌ar ⊙ zero
in begin
[ c ⟦ t ⟧ /Val ρ ] ≡⟨ P.refl ⟩
[ c (⟦ t ⟧ /̂Val ⟦ ρ ⟧⇨ ↑̂) ] ≡⟨ curry-cong $ /̂Val-cong (P.refl {x = [ ⟦ t ⟧ ]})
(P.sym $ ∘̂-ŵk-▻̂-žero ⟦ ρ ⟧⇨ _) ⟩
[ c (⟦ t ⟧ /Val ρ↑) ] ≡⟨ curry-cong (eval-lemma t ρ↑) ⟩
[ c ⟦̌ eval t ρ↑ ⟧ ] ≡⟨ P.sym $ unfold-⟦̌∣⟧-π υ (eval[ƛ t ] ρ) ⟩
[ ⟦̌ υ ∣ eval[ƛ t ] ρ ⟧-π ] ∎
-- Normalisation.
normalise : ∀ {Γ σ} → Γ ⊢ σ → Γ ⊢ σ ⟨ no ⟩
normalise t = řeify _ (eval t V̌al-subst.id)
-- Normalisation is semantics-preserving.
normalise-lemma : ∀ {Γ σ} (t : Γ ⊢ σ) → ⟦ t ⟧ ≅-Value ⟦ normalise t ⟧n
normalise-lemma t = eval-lemma t V̌al-subst.id
-- Some congruence lemmas.
·̌-cong :
∀ {Γ₁ sp₁₁ sp₂₁ σ₁}
{f₁ : V̌alue Γ₁ (π sp₁₁ sp₂₁ , σ₁)} {v₁ : V̌alue Γ₁ (fst σ₁)}
{Γ₂ sp₁₂ sp₂₂ σ₂}
{f₂ : V̌alue Γ₂ (π sp₁₂ sp₂₂ , σ₂)} {v₂ : V̌alue Γ₂ (fst σ₂)} →
σ₁ ≅-IType σ₂ → _≅-V̌alue_ {σ₁ = -, σ₁} f₁ {σ₂ = -, σ₂} f₂ →
v₁ ≅-V̌alue v₂ →
[ σ₁ ] f₁ ·̌ v₁ ≅-V̌alue [ σ₂ ] f₂ ·̌ v₂
·̌-cong P.refl P.refl P.refl = P.refl
eval-cong :
∀ {Γ₁ Δ₁ σ₁} {ρ̂₁ : Γ₁ ⇨̂ Δ₁} {t₁ : Γ₁ ⊢ σ₁} {ρ₁ : Sub V̌al ρ̂₁}
{Γ₂ Δ₂ σ₂} {ρ̂₂ : Γ₂ ⇨̂ Δ₂} {t₂ : Γ₂ ⊢ σ₂} {ρ₂ : Sub V̌al ρ̂₂} →
t₁ ≅-⊢ t₂ → ρ₁ ≅-⇨ ρ₂ → eval t₁ ρ₁ ≅-V̌alue eval t₂ ρ₂
eval-cong P.refl P.refl = P.refl
normalise-cong :
∀ {Γ₁ σ₁} {t₁ : Γ₁ ⊢ σ₁}
{Γ₂ σ₂} {t₂ : Γ₂ ⊢ σ₂} →
t₁ ≅-⊢ t₂ → normalise t₁ ≅-⊢n normalise t₂
normalise-cong P.refl = P.refl
abstract
-- Note that we can /not/ prove that normalise takes semantically
-- equal terms to identical normal forms, assuming extensionality
-- and the existence of a universe code which decodes to an empty
-- type:
normal-forms-not-unique :
E.Extensionality Level.zero Level.zero →
(∃ λ (bot : U₀) → ¬ El₀ bot) →
¬ (∀ {Γ σ} (t₁ t₂ : Γ ⊢ σ) →
⟦ t₁ ⟧ ≅-Value ⟦ t₂ ⟧ → normalise t₁ ≅-⊢n normalise t₂)
normal-forms-not-unique ext (bot , empty) hyp = ⊥-elim (x₁≇x₂ x₁≅x₂)
where
Γ : Ctxt
Γ = ε ▻ (⋆ , _) ▻ (⋆ , _) ▻ (el , k bot)
x₁ : Γ ∋ (⋆ , _)
x₁ = suc (suc zero)
x₂ : Γ ∋ (⋆ , _)
x₂ = suc zero
x₁≇x₂ : ¬ (ne ⋆ (var x₁) ≅-⊢n ne ⋆ (var x₂))
x₁≇x₂ ()
⟦x₁⟧≡⟦x₂⟧ : ⟦ var x₁ ⟧ ≅-Value ⟦ var x₂ ⟧
⟦x₁⟧≡⟦x₂⟧ = P.cong [_] (ext λ γ → ⊥-elim $ empty $ proj₂ γ)
norm-x₁≅norm-x₂ : normalise (var x₁) ≅-⊢n normalise (var x₂)
norm-x₁≅norm-x₂ = hyp (var x₁) (var x₂) ⟦x₁⟧≡⟦x₂⟧
lemma : (x : Γ ∋ (⋆ , _)) → normalise (var x) ≅-⊢n ne ⋆ (var x)
lemma x = begin
[ normalise (var x) ]n ≡⟨ P.refl ⟩
[ ne ⋆ (x /∋ V̌al-subst.id) ]n ≡⟨ ne-cong $ ≅-Value-⋆-⇒-≅-⊢n $ V̌al-subst./∋-id x ⟩
[ ne ⋆ (var x) ]n ∎
x₁≅x₂ : ne ⋆ (var x₁) ≅-⊢n ne ⋆ (var x₂)
x₁≅x₂ = begin
[ ne ⋆ (var x₁) ]n ≡⟨ P.sym $ lemma x₁ ⟩
[ normalise (var x₁) ]n ≡⟨ norm-x₁≅norm-x₂ ⟩
[ normalise (var x₂) ]n ≡⟨ lemma x₂ ⟩
[ ne ⋆ (var x₂) ]n ∎
| {
"alphanum_fraction": 0.4743921366,
"avg_line_length": 35.4678899083,
"ext": "agda",
"hexsha": "23f2816284495c7828793df5804b81a580c84e57",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/dependently-typed-syntax",
"max_forks_repo_path": "README/DependentlyTyped/NBE.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/dependently-typed-syntax",
"max_issues_repo_path": "README/DependentlyTyped/NBE.agda",
"max_line_length": 125,
"max_stars_count": 5,
"max_stars_repo_head_hexsha": "498f8aefc570f7815fd1d6616508eeb92c52abce",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/dependently-typed-syntax",
"max_stars_repo_path": "README/DependentlyTyped/NBE.agda",
"max_stars_repo_stars_event_max_datetime": "2020-07-08T22:51:36.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-16T12:14:44.000Z",
"num_tokens": 3844,
"size": 7732
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Showing natural numbers
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Nat.Show where
open import Data.Nat
open import Relation.Nullary.Decidable using (True)
open import Data.String.Base as String using (String)
open import Data.Digit
open import Data.Product using (proj₁)
open import Function
open import Data.List.Base
-- showInBase b n is a string containing the representation of n in
-- base b.
showInBase : (base : ℕ)
{base≥2 : True (2 ≤? base)}
{base≤16 : True (base ≤? 16)} →
ℕ → String
showInBase base {base≥2} {base≤16} n =
String.fromList $
map (showDigit {base≤16 = base≤16}) $
reverse $
proj₁ $ toDigits base {base≥2 = base≥2} n
-- show n is a string containing the decimal expansion of n (starting
-- with the most significant digit).
show : ℕ → String
show = showInBase 10
| {
"alphanum_fraction": 0.5795121951,
"avg_line_length": 27.7027027027,
"ext": "agda",
"hexsha": "3b2233c93f4d5c67e1ea6b7c2b4f467c9be412f0",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "omega12345/agda-mode",
"max_forks_repo_path": "test/asset/agda-stdlib-1.0/Data/Nat/Show.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "omega12345/agda-mode",
"max_issues_repo_path": "test/asset/agda-stdlib-1.0/Data/Nat/Show.agda",
"max_line_length": 72,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "omega12345/agda-mode",
"max_stars_repo_path": "test/asset/agda-stdlib-1.0/Data/Nat/Show.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 249,
"size": 1025
} |
module Issue641 where
Foo : Set
Foo = Set
| {
"alphanum_fraction": 0.7380952381,
"avg_line_length": 10.5,
"ext": "agda",
"hexsha": "6d8376d264b145f056535de8694c2910275f0fef",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/interaction/Issue641.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/interaction/Issue641.agda",
"max_line_length": 21,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/interaction/Issue641.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 13,
"size": 42
} |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Group.Subgroup where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Data.Sigma
open import Cubical.Algebra
open import Cubical.Algebra.Group.Morphism
open import Cubical.Algebra.Monoid.Submonoid
open import Cubical.Relation.Unary
open import Cubical.Relation.Unary.Subtype
open import Cubical.HITs.PropositionalTruncation
record IsSubgroup {c ℓ} (G : Group c) (Member : Pred ⟨ G ⟩ ℓ) : Type (ℓ-max c ℓ) where
constructor issubgroup
private module G = Group G
field
preservesOp : G._•_ Preserves₂ Member
preservesInv : G._⁻¹ Preserves Member
preservesId : G.ε ∈ Member
isSubmonoid : IsSubmonoid G.monoid Member
isSubmonoid = record
{ preservesOp = preservesOp
; preservesId = preservesId
}
open IsSubmonoid isSubmonoid hiding (preservesOp; preservesId; _^_) public
_⁻¹ : Op₁ Carrier
(x , subx) ⁻¹ = x G.⁻¹ , preservesInv subx
inverseˡ : LeftInverse ε _⁻¹ _•_
inverseˡ _ = ΣPathTransport→PathΣ _ _ (G.inverseˡ _ , isProp[ Member ] _ _ _)
inverseʳ : RightInverse ε _⁻¹ _•_
inverseʳ _ = ΣPathTransport→PathΣ _ _ (G.inverseʳ _ , isProp[ Member ] _ _ _)
inverse : Inverse ε _⁻¹ _•_
inverse = inverseˡ , inverseʳ
isGroup : IsGroup Carrier _•_ ε _⁻¹
isGroup = record
{ isMonoid = isMonoid
; inverse = inverse
}
group : Group _
group = record { isGroup = isGroup }
open Group group using
( _^_
; _/_
; _/ˡ_
; inv-uniqueˡ
; inv-uniqueʳ
; cancelˡ
; cancelʳ
) public
record Subgroup {c} (G : Group c) ℓ : Type (ℓ-max c (ℓ-suc ℓ)) where
constructor mksubgroup
private module G = Group G
field
Member : Pred ⟨ G ⟩ ℓ
isSubgroup : IsSubgroup G Member
open IsSubgroup isSubgroup public
submonoid : Submonoid G.monoid ℓ
submonoid = record { isSubmonoid = isSubmonoid }
open Submonoid submonoid using (submagma; subsemigroup)
instance
SubgroupCarrier : ∀ {c ℓ} {G : Group c} → HasCarrier (Subgroup G ℓ) _
SubgroupCarrier = record { ⟨_⟩ = Subgroup.Carrier }
private
variable
c ℓ : Level
G : Group c
module _ {G : Group c} where
open Group G
ε-isSubgroup : IsSubgroup G ｛ ε ｝
ε-isSubgroup = record
{ preservesOp = map2 λ p q → cong₂ _•_ p q ∙ identityʳ ε
; preservesInv = map λ p → cong _⁻¹ p ∙ cancelʳ ε (inverseˡ ε ∙ sym (identityʳ ε))
; preservesId = ∣ refl ∣
}
ε-subgroup : Subgroup G _
ε-subgroup = record { isSubgroup = ε-isSubgroup }
U-isSubgroup : IsSubgroup G U
U-isSubgroup = record {} -- trivial
U-subgroup : Subgroup G _
U-subgroup = record { isSubgroup = U-isSubgroup }
IsNormal : Subgroup G ℓ → Type _
IsNormal {G = G} N =
∀ ((n , _) : ⟨ N ⟩) (g : ⟨ G ⟩) → g • n • g ⁻¹ ∈ Subgroup.Member N
where
open Group G
NormalSubgroup : Group c → (ℓ : Level) → Type _
NormalSubgroup G ℓ = Σ (Subgroup G ℓ) IsNormal | {
"alphanum_fraction": 0.6733735748,
"avg_line_length": 23.6666666667,
"ext": "agda",
"hexsha": "819cb2cd7193bc4830150da229a4a71564c21e3f",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "737f922d925da0cd9a875cb0c97786179f1f4f61",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "bijan2005/univalent-foundations",
"max_forks_repo_path": "Cubical/Algebra/Group/Subgroup.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "737f922d925da0cd9a875cb0c97786179f1f4f61",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "bijan2005/univalent-foundations",
"max_issues_repo_path": "Cubical/Algebra/Group/Subgroup.agda",
"max_line_length": 86,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "737f922d925da0cd9a875cb0c97786179f1f4f61",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "bijan2005/univalent-foundations",
"max_stars_repo_path": "Cubical/Algebra/Group/Subgroup.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1019,
"size": 2982
} |
-- An ATP definition must be used with functions.
-- This error is detected by Syntax.Translation.ConcreteToAbstract.
module ATPBadDefinition1 where
data Bool : Set where
false true : Bool
{-# ATP definition false #-}
| {
"alphanum_fraction": 0.7544642857,
"avg_line_length": 20.3636363636,
"ext": "agda",
"hexsha": "fa02c7b8cd5ed225cc23a65cff54d33cc44d6b00",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_head_hexsha": "7220bebfe9f64297880ecec40314c0090018fdd0",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "asr/eagda",
"max_forks_repo_path": "test/fail/ATPBadDefinition1.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7220bebfe9f64297880ecec40314c0090018fdd0",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "asr/eagda",
"max_issues_repo_path": "test/fail/ATPBadDefinition1.agda",
"max_line_length": 67,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "7220bebfe9f64297880ecec40314c0090018fdd0",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "asr/eagda",
"max_stars_repo_path": "test/fail/ATPBadDefinition1.agda",
"max_stars_repo_stars_event_max_datetime": "2016-03-17T01:45:59.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-03-17T01:45:59.000Z",
"num_tokens": 48,
"size": 224
} |
-- Andreas, 2017-01-20, issue #2329
-- Neutral sizes cannot be used by the size solver,
-- thus, should be handled by coerceSize.
-- {-# OPTIONS -v tc:10 #-}
-- {-# OPTIONS -v tc.conv.coerce:20 #-}
-- {-# OPTIONS -v tc.size:20 #-}
-- {-# OPTIONS -v tc.size.solve:50 #-}
open import Agda.Builtin.Size
record R (i : Size) : Set where
field
j : Size< i
postulate
f : ∀ i → R i
works : ∀ i → R i
R.j (works i) = R.j {i} (f i)
test : ∀ i → R i
R.j (test i) = R.j (f i)
-- Error WAS:
-- Unsolved constraint:
-- ↑ R.j (f i) =< i : Size
| {
"alphanum_fraction": 0.5651376147,
"avg_line_length": 18.7931034483,
"ext": "agda",
"hexsha": "20be4f0630f18af1ca5786bcecfc58203b373d8f",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2015-09-15T14:36:15.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-09-15T14:36:15.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue2329.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2019-04-01T19:39:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2018-11-14T15:31:44.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue2329.agda",
"max_line_length": 51,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue2329.agda",
"max_stars_repo_stars_event_max_datetime": "2015-12-07T20:14:00.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-03-28T14:51:03.000Z",
"num_tokens": 192,
"size": 545
} |
module VecMap where
open import Prelude
map : forall {A B n} -> (A -> B) -> Vec A n -> Vec B n
map f xs = {!!}
| {
"alphanum_fraction": 0.5663716814,
"avg_line_length": 16.1428571429,
"ext": "agda",
"hexsha": "740bc3e199add219e2a6ab5a4b7e5f0c39648692",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "baf979ef78b5ec0f4783240b03f9547490bc5d42",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "carlostome/martin",
"max_forks_repo_path": "data/test-files/VecMap.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "baf979ef78b5ec0f4783240b03f9547490bc5d42",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "carlostome/martin",
"max_issues_repo_path": "data/test-files/VecMap.agda",
"max_line_length": 54,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "baf979ef78b5ec0f4783240b03f9547490bc5d42",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "carlostome/martin",
"max_stars_repo_path": "data/test-files/VecMap.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 38,
"size": 113
} |
open import Relation.Binary.PropositionalEquality using (_≡_; refl; sym)
open import Function.Equivalence using (_⇔_; equivalence; Equivalence)
open import Data.Bool using (Bool; true; false; if_then_else_)
open import Data.Product using (_×_; _,_; proj₁; proj₂)
open import Data.Sum using (_⊎_)
open import IMP
open import OperationalSemantics
open import Hoare
wp : ∀{l} → com → assn {l} → assn {l}
wp c Q s = ∀ t → ⦅ c , s ⦆⇒ t → Q t
fatto : ∀{P Q : assn} {c}
→ ⊨[ P ] c [ Q ]
→ (∀ s → P s → wp c Q s)
fatto = λ z s z₁ t → z z₁
fatto-converse : ∀{P Q : assn} {c}
→ (∀ s → P s → wp c Q s)
→ ⊨[ P ] c [ Q ]
fatto-converse = (λ z {s} {t} z₁ → z s z₁ t)
wp-hoare : ∀ c {l} {Q : assn {l}}
→ ⊢[ wp c Q ] c [ Q ]
wp-hoare SKIP = Conseq (λ s z → z s Skip) Skip (λ s z → z)
wp-hoare (x ::= a) = Conseq (λ s wpe → wpe (s [ x ::= aval a s ]) Loc) Loc (λ s r → r)
wp-hoare (c :: c₁) = Comp (Conseq (λ s z x x₁ x₂ x₃ → z x₂ (Comp x₁ x₃)) (wp-hoare c) (λ s z → z)) (wp-hoare c₁)
wp-hoare (IF x THEN c ELSE c₁) = If (Conseq (λ s z x x₁ → proj₁ z x (IfTrue (proj₂ z) x₁)) (wp-hoare c) (λ s z → z))
(Conseq (λ s z x x₁ → proj₁ z x (IfFalse (proj₂ z) x₁)) (wp-hoare c₁) (λ s z → z))
wp-hoare (WHILE b DO c) =
Conseq (λ s x → x)
(While (Conseq (λ s z x x₁ x₂ x₃ → proj₁ z x₂ (WhileTrue (proj₂ z) x₁ x₃))
(wp-hoare c)
(λ s z → z)))
(λ s z → proj₁ z s (WhileFalse (proj₂ z)))
completeness : ∀ c {P Q : assn}
→ ⊨[ P ] c [ Q ]
→ ⊢[ P ] c [ Q ]
completeness c cc = Conseq (fatto cc) (wp-hoare c) (λ r x → x)
| {
"alphanum_fraction": 0.5267363245,
"avg_line_length": 38.7380952381,
"ext": "agda",
"hexsha": "0876315b0f5e07413e9b76fd39e03fb5317d2f7b",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "cb98e3b3b93362654b79152bfdf2c21eb4951fcc",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "iwilare/imp-semantics",
"max_forks_repo_path": "HoareCompleteness.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "cb98e3b3b93362654b79152bfdf2c21eb4951fcc",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "iwilare/imp-semantics",
"max_issues_repo_path": "HoareCompleteness.agda",
"max_line_length": 118,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "cb98e3b3b93362654b79152bfdf2c21eb4951fcc",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "iwilare/imp-semantics",
"max_stars_repo_path": "HoareCompleteness.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-24T22:29:44.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-09-08T11:54:07.000Z",
"num_tokens": 663,
"size": 1627
} |
{-# OPTIONS --type-in-type #-}
module DescFix where
open import DescTT
aux : (C : Desc)(D : Desc)(P : Mu C -> Set)(x : [| D |] (Mu C)) -> Set
aux C id P (con y) = P (con y) * aux C C P y
aux C (const K) P k = Unit
aux C (prod D D') P (s , t) = aux C D P s * aux C D' P t
aux C (sigma S T) P (s , t) = aux C (T s) P t
aux C (pi S T) P f = (s : S) -> aux C (T s) P (f s)
gen : (C : Desc)(D : Desc)(P : Mu C -> Set)
(rec : (y : [| C |] Mu C) -> aux C C P y -> P (con y))
(x : [| D |] Mu C) -> aux C D P x
gen C id P rec (con x) = rec x (gen C C P rec x) , gen C C P rec x
gen C (const K) P rec k = Void
gen C (prod D D') P rec (s , t) = gen C D P rec s , gen C D' P rec t
gen C (sigma S T) P rec (s , t) = gen C (T s) P rec t
gen C (pi S T) P rec f = \ s -> gen C (T s) P rec (f s)
fix : (D : Desc)(P : Mu D -> Set)
(rec : (y : [| D |] Mu D) -> aux D D P y -> P (con y))
(x : Mu D) -> P x
fix D P rec (con x) = rec x (gen D D P rec x)
plus : Nat -> Nat -> Nat
plus (con (Ze , Void)) n = n
plus (con (Suc , m)) n = suc (plus m n)
fib : Nat -> Nat
fib = fix NatD (\ _ -> Nat) help
where
help : (m : [| NatD |] Nat) -> aux NatD NatD (\ _ -> Nat) m -> Nat
help (Ze , x) a = suc ze
help (Suc , con (Ze , _)) a = suc ze
help (Suc , con (Suc , con n)) (fib-n , (fib-sn , a)) = plus fib-n fib-sn | {
"alphanum_fraction": 0.464,
"avg_line_length": 31.976744186,
"ext": "agda",
"hexsha": "0178a67fd129f47ed17d7eba8efcc324ffd95217",
"lang": "Agda",
"max_forks_count": 12,
"max_forks_repo_forks_event_max_datetime": "2022-02-11T01:57:40.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-08-14T21:36:35.000Z",
"max_forks_repo_head_hexsha": "8c46f766bddcec2218ddcaa79996e087699a75f2",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "mietek/epigram",
"max_forks_repo_path": "models/DescFix.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "8c46f766bddcec2218ddcaa79996e087699a75f2",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "mietek/epigram",
"max_issues_repo_path": "models/DescFix.agda",
"max_line_length": 77,
"max_stars_count": 48,
"max_stars_repo_head_hexsha": "8c46f766bddcec2218ddcaa79996e087699a75f2",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "mietek/epigram",
"max_stars_repo_path": "models/DescFix.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-11T01:55:28.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-01-09T17:36:19.000Z",
"num_tokens": 561,
"size": 1375
} |
-- Andreas, 2014-09-23
-- Syntax declaration for overloaded constructor.
-- {-# OPTIONS -v scope.operators:50 #-}
syntax c x = ⟦ x ⟧
data D1 : Set where
c : D1
data D2 : Set where
c : D1 → D2
test : D2
test = ⟦ c ⟧
-- Should work.
| {
"alphanum_fraction": 0.6058091286,
"avg_line_length": 13.3888888889,
"ext": "agda",
"hexsha": "9758f755207d822e5a7d58d8ca1f1d9cc18846fc",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue1194c.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue1194c.agda",
"max_line_length": 49,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue1194c.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 86,
"size": 241
} |
-- P: (vcd) <E[send c v]> | <F[recv d]> --> (vcd) <E[c]> | <F[(d,v)]>
-- P: (vcd) <E[close c]> | <F[wait d]> --> (vcd) <E[()]> | <F[()]>
module Properties.StepCloseWait 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 Syntax
open import Global
open import Channel
open import Values
open import Session
open import Schedule
open import ProcessSyntax
open import ProcessRun
open import Properties.Base
mkclose : ∀ {Φ} → Expr (TUnit ∷ Φ) TUnit → Expr (TChan send! ∷ Φ) TUnit
mkclose = λ e → letbind (left (split-all-right _)) (close (here [])) e
mkwait : ∀ {Φ} → Expr (TUnit ∷ Φ) TUnit → Expr (TChan send? ∷ Φ) TUnit
mkwait = λ e → letbind (left (split-all-right _)) (wait (here [])) e
module General where
mklhs : ∀ {Φ Φ₁ Φ₂}
→ Split Φ Φ₁ Φ₂
→ Expr (TUnit ∷ Φ₁) TUnit
→ Expr (TUnit ∷ Φ₂) TUnit
→ Proc Φ
mklhs sp e f =
res (delay send!)
(par (left (rght sp))
(exp (mkclose e)) (exp (mkwait f)))
mkrhs : ∀ {Φ Φ₁ Φ₂}
→ Split Φ Φ₁ Φ₂
→ Expr (TUnit ∷ Φ₁) TUnit
→ Expr (TUnit ∷ Φ₂) TUnit
→ Proc Φ
mkrhs sp e f =
par sp (exp (letbind (split-all-right _) (unit []) e))
(exp (letbind (split-all-right _) (unit []) f))
-- obviously true, but requires a nasty inductive proof
postulate
weaken2-ident : ∀ {G Φ} (ϱ : VEnv G Φ) → weaken2-venv [] [] ϱ ≡ ϱ
postulate
weaken1-ident : ∀ {G Φ} (ϱ : VEnv G Φ) → weaken1-venv [] ϱ ≡ ϱ
reductionT : Set
reductionT =
∀ { Φ Φ₁ Φ₂ }
(sp : Split Φ Φ₁ Φ₂)
(ϱ : VEnv [] Φ)
(p : ∃ λ ϱ₁ → ∃ λ ϱ₂ →
split-env sp (lift-venv ϱ) ≡ (((nothing ∷ []) , (nothing ∷ [])) , (ss-both ss-[]) , ϱ₁ , ϱ₂))
(e : Expr (TUnit ∷ Φ₁) TUnit)
(f : Expr (TUnit ∷ Φ₂) TUnit) →
let lhs = (runProc [] (mklhs sp e f) ϱ) in
let rhs = (runProc [] (mkrhs sp e f) ϱ) in
one-step lhs ≡
(Closed , nothing ∷ proj₁ rhs , lift-threadpool (proj₂ rhs))
reduction : reductionT
reduction{Φ}{Φ₁}{Φ₂} sp ϱ p e f
with ssplit-refl-left-inactive []
... | G' , ina-G' , ss-GG'
with split-env-lemma-2 sp ϱ
... | ϱ₁ , ϱ₂ , spe== , sp==
rewrite spe== | sp==
with ssplit-compose{just (send! , POSNEG) ∷ []} (ss-posneg ss-[]) (ss-left ss-[])
... | ssc
rewrite split-env-right-lemma ϱ₁
with ssplit-compose{just (send! , POSNEG) ∷ []} (ss-left ss-[]) (ss-left ss-[])
... | ssc-ll
rewrite split-env-right-lemma ϱ₂
with ssplit-compose2 (ss-both ss-[]) (ss-both ss-[])
... | ssc2
rewrite weaken2-ident (lift-venv ϱ₁)
| split-rotate-lemma {Φ₁}
| split-rotate-lemma {Φ₂}
| split-env-right-lemma0 ϱ₁
| split-env-right-lemma0 ϱ₂
| weaken2-ident ϱ₁
| weaken1-ident (lift-venv ϱ₂)
| weaken1-ident ϱ₂
= refl
module ClosedWithContext where
mklhs : Expr (TUnit ∷ []) TUnit
→ Expr (TUnit ∷ []) TUnit
→ Proc []
mklhs e f =
res (delay send!)
(par (left (rght []))
(exp (mkclose e)) (exp (mkwait f)))
mkrhs : Expr (TUnit ∷ []) TUnit
→ Expr (TUnit ∷ []) TUnit
→ Proc []
mkrhs e f =
par [] (exp (letbind [] (unit []) e))
(exp (letbind [] (unit []) f))
reduction :
(e f : Expr (TUnit ∷ []) TUnit) →
let lhs = (runProc [] (mklhs e f) (vnil []-inactive)) in
let rhs = (runProc [] (mkrhs e f) (vnil []-inactive)) in
one-step lhs ≡
(Closed , nothing ∷ proj₁ rhs , lift-threadpool (proj₂ rhs))
reduction e f
with ssplit-refl-left-inactive []
... | G' , ina-G' , ss-GG'
= refl
| {
"alphanum_fraction": 0.5641163793,
"avg_line_length": 29,
"ext": "agda",
"hexsha": "3efed919c078141230db123d6f14c3e6a219fca6",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "c2213909c8a308fb1c1c1e4e789d65ba36f6042c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "peterthiemann/definitional-session",
"max_forks_repo_path": "src/Properties/StepCloseWait.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c2213909c8a308fb1c1c1e4e789d65ba36f6042c",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "peterthiemann/definitional-session",
"max_issues_repo_path": "src/Properties/StepCloseWait.agda",
"max_line_length": 104,
"max_stars_count": 9,
"max_stars_repo_head_hexsha": "c2213909c8a308fb1c1c1e4e789d65ba36f6042c",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "peterthiemann/definitional-session",
"max_stars_repo_path": "src/Properties/StepCloseWait.agda",
"max_stars_repo_stars_event_max_datetime": "2021-01-18T08:10:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-01-19T16:33:27.000Z",
"num_tokens": 1392,
"size": 3712
} |
module Prelude.Level where
open import Agda.Primitive public
using (Level)
renaming (lzero to zero; lsuc to suc; _⊔_ to max)
| {
"alphanum_fraction": 0.7293233083,
"avg_line_length": 22.1666666667,
"ext": "agda",
"hexsha": "80fe213f5d17930aa11cc27d7f10a2101d3db14d",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "masondesu/agda",
"max_forks_repo_path": "test/epic/Prelude/Level.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "masondesu/agda",
"max_issues_repo_path": "test/epic/Prelude/Level.agda",
"max_line_length": 51,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "redfish64/autonomic-agda",
"max_stars_repo_path": "test/epic/Prelude/Level.agda",
"max_stars_repo_stars_event_max_datetime": "2018-10-10T17:08:44.000Z",
"max_stars_repo_stars_event_min_datetime": "2018-10-10T17:08:44.000Z",
"num_tokens": 40,
"size": 133
} |
open import Everything
module Test.Symmetrical where
test-𝓢ymmetrical𝓢ymmetry : ∀
{𝔬} {𝔒 : Ø 𝔬}
{ℓ} {_∼_ : 𝔒 → 𝔒 → Ø ℓ}
⦃ _ : Symmetry.class _∼_ ⦄
→ Symmetry.type _∼_
-- test-𝓢ymmetrical𝓢ymmetry = symmetrical _ _ -- FIXME no longer works after 𝓢ymmetrical𝓢ymmetry was "rationalised"
test-𝓢ymmetrical𝓢ymmetry {𝔒 = 𝔒} = symmetrical {𝔄 = 𝔒} _ _
test-𝓢ymmetrical𝓢ymmetry-alternate : ∀
{𝔬} {𝔒 : Ø 𝔬}
{ℓ} {_∼_ : 𝔒 → 𝔒 → Ø ℓ}
⦃ _ : Symmetry.class _∼_ ⦄
→ Symmetry.type _∼_
test-𝓢ymmetrical𝓢ymmetry-alternate {x = x} = symmetrical x _
lhs-test1 : ∀ {𝔬} {𝔒 : Ø 𝔬}
{ℓ} {_∼_ : 𝔒 → 𝔒 → Ø ℓ}
⦃ _ : Symmetry.class _∼_ ⦄
{_∼'_ : 𝔒 → 𝔒 → Ø ℓ}
⦃ _ : Symmetry.class _∼'_ ⦄
→ ∀ x y → _
lhs-test1 {_∼_ = _∼_} = symmetrical⟦ _∼_ / (λ x y → x → y) ⟧
module OverlappingInstances
{𝔞} {𝔄 : Ø 𝔞}
{𝔟} {𝔅 : Ø 𝔟}
{ℓ} {_↦_ : 𝔅 → 𝔅 → Ø ℓ}
{_↦'_ : 𝔅 → 𝔅 → Ø ℓ}
{_∼1_ : 𝔄 → 𝔄 → 𝔅}
{_∼2_ : 𝔄 → 𝔄 → 𝔅}
⦃ _ : Symmetrical _∼1_ _↦_ ⦄
⦃ _ : Symmetrical _∼1_ _↦'_ ⦄
⦃ _ : Symmetrical _∼2_ _↦_ ⦄
⦃ _ : Symmetrical _∼2_ _↦'_ ⦄
(x y : 𝔄)
where
test1 = symmetrical {_∼_ = _∼1_} {_↦_ = _↦_} x y
test2 : (x ∼1 y) ↦ (y ∼1 x)
test2 = symmetrical⟦ _ / _↦_ ⟧ x y
test2a : (x ∼1 y) ↦ (y ∼1 x)
test2a = symmetrical x y
test3 = symmetrical⟦ _∼1_ / _↦_ ⟧ x y
lhs-test2a : ∀
{𝔞} {𝔄 : Ø 𝔞}
{𝔟} {𝔅 : Ø 𝔟}
(_∼_ : 𝔄 → 𝔄 → 𝔅)
{ℓ} (_↦_ : 𝔅 → 𝔅 → Ø ℓ)
⦃ _ : Symmetrical _∼_ _↦_ ⦄
→ ∀ (x y : 𝔄) → _ ↦ _
lhs-test2a _∼_ _↦_ x y =
symmetrical x y -- works
-- symmetrical⟦ _∼_ / _↦_ ⟧ x y -- works
-- symmetrical⟦ _ / _↦_ ⟧ x y -- works
-- symmetrical⟦ _∼_ / _ ⟧ x y -- works
open import Oscar.Data.Proposequality
lhs-test2a' : ∀
{𝔞} {𝔄 : Ø 𝔞}
{𝔟} {𝔅 : Ø 𝔟}
(_∼_ : 𝔄 → 𝔄 → 𝔅) {_∼'_ : 𝔄 → 𝔄 → 𝔅}
{ℓ} (_↦_ : 𝔅 → 𝔅 → Ø ℓ) {_↦'_ : 𝔅 → 𝔅 → Ø ℓ}
⦃ _ : Symmetrical _∼_ _↦_ ⦄
⦃ _ : Symmetrical _∼'_ _↦_ ⦄
⦃ _ : Symmetrical _∼_ _↦'_ ⦄
⦃ _ : Symmetrical _∼'_ _↦'_ ⦄
→ ∀ (x y : 𝔄) → -- _
_ ↦ _
-- (x ∼ y) ↦ (y ∼ x)
lhs-test2a' _∼_ _↦_ x y =
symmetrical⟦ _∼_ / _ ⟧ x y
-- symmetrical x y -- fails, as expected
-- symmetrical⟦ _ / _ ⟧ x y -- fails, as expected
-- symmetrical⟦ _ / _↦_ ⟧ x y -- fails, as expected
lhs-test2a'' : ∀
{𝔞} {𝔄 : Ø 𝔞}
{𝔟} {𝔅 : Ø 𝔟}
(_∼_ : 𝔄 → 𝔄 → 𝔅) {_∼'_ : 𝔄 → 𝔄 → 𝔅}
{ℓ} (_↦_ : 𝔅 → 𝔅 → Ø ℓ) {_↦'_ : 𝔅 → 𝔅 → Ø ℓ}
⦃ _ : Symmetrical _∼_ _↦_ ⦄
⦃ _ : Symmetrical _∼'_ _↦_ ⦄
⦃ _ : Symmetrical _∼_ _↦'_ ⦄
⦃ _ : Symmetrical _∼'_ _↦'_ ⦄
→ ∀ (x y : 𝔄) → -- _
-- _ ↦ _
(x ∼ y) ↦ (y ∼ x)
lhs-test2a'' _∼_ _↦_ x y =
symmetrical {_∼_ = _∼_} x y
-- symmetrical'' {_↦_ = _↦_} x y
-- symmetrical'' {_∼_ = _∼_} {_↦_ = _↦_} x y
-- symmetrical'' x y
| {
"alphanum_fraction": 0.4566655064,
"avg_line_length": 28.1666666667,
"ext": "agda",
"hexsha": "9f5621fb2409415adcebcdf89e7d43ef3cdb9e76",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_forks_repo_licenses": [
"RSA-MD"
],
"max_forks_repo_name": "m0davis/oscar",
"max_forks_repo_path": "archive/agda-3/src/Test/Symmetrical.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_issues_repo_issues_event_max_datetime": "2019-05-11T23:33:04.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-04-29T00:35:04.000Z",
"max_issues_repo_licenses": [
"RSA-MD"
],
"max_issues_repo_name": "m0davis/oscar",
"max_issues_repo_path": "archive/agda-3/src/Test/Symmetrical.agda",
"max_line_length": 117,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_stars_repo_licenses": [
"RSA-MD"
],
"max_stars_repo_name": "m0davis/oscar",
"max_stars_repo_path": "archive/agda-3/src/Test/Symmetrical.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1570,
"size": 2873
} |
{-# OPTIONS --rewriting #-}
module DualLMRefined where
open import Data.Bool
open import Data.Nat hiding (compare)
open import Data.Nat.Properties
open import Data.Fin hiding (_+_)
open import Data.Product
open import Function
open import Relation.Binary.PropositionalEquality hiding (Extensionality)
open import Agda.Builtin.Equality
open import Agda.Builtin.Equality.Rewrite
open import Extensionality
open import Direction
-- variables
variable
n m : ℕ
----------------------------------------------------------------------
-- auxiliaries for automatic rewriting
n+1=suc-n : n + 1 ≡ suc n
n+1=suc-n {zero} = refl
n+1=suc-n {suc n} = cong suc (n+1=suc-n {n})
{-# REWRITE n+1=suc-n #-}
n+0=n : n + 0 ≡ n
n+0=n {zero} = refl
n+0=n {suc n} = cong suc (n+0=n {n})
{-# REWRITE n+0=n #-}
inject+0-x=x : {x : Fin m} → inject+ 0 x ≡ x
inject+0-x=x {x = zero} = refl
inject+0-x=x {x = suc x} = cong suc inject+0-x=x
{-# REWRITE inject+0-x=x #-}
n+sucm : n + suc m ≡ suc (n + m)
n+sucm {0} = refl
n+sucm {suc n} = cong suc (n+sucm{n})
{-# REWRITE n+sucm #-}
n=fromℕtoℕn : (toℕ (fromℕ n)) ≡ n
n=fromℕtoℕn {zero} = refl
n=fromℕtoℕn {suc n} = cong suc (n=fromℕtoℕn {n})
{-# REWRITE n=fromℕtoℕn #-}
sucn∸suctoℕx≡n∸toℕx : {n : ℕ} {x : Fin n} → suc (n ∸ suc (toℕ x)) ≡ n ∸ (toℕ x)
sucn∸suctoℕx≡n∸toℕx {suc n} {zero} = refl
sucn∸suctoℕx≡n∸toℕx {suc n} {suc x} = sucn∸suctoℕx≡n∸toℕx{n}{x}
sym-sucn∸suctoℕx≡n∸toℕx : {n : ℕ} {x : Fin n} → n ∸ (toℕ x) ≡ suc (n ∸ suc (toℕ x))
sym-sucn∸suctoℕx≡n∸toℕx {n} {x} = sym (sucn∸suctoℕx≡n∸toℕx{n}{x})
{-# REWRITE sym-sucn∸suctoℕx≡n∸toℕx #-}
n∸n≡0F : n ∸ n ≡ 0
n∸n≡0F {0} = refl
n∸n≡0F {suc n} = n∸n≡0F{n}
{-# REWRITE n∸n≡0F #-}
{-# REWRITE m+n∸n≡m #-}
----------------------------------------------------------------------
-- some more required properties on natural numbers and fin
toℕx≤n : {n : ℕ} {x : Fin n} → Data.Nat._≤_ (toℕ x) n
toℕx≤n {suc n} {zero} = z≤n
toℕx≤n {suc n} {suc x} = s≤s toℕx≤n
toℕx≤n' : {n : ℕ} {x : Fin (suc n)} → Data.Nat._≤_ (toℕ x) n
toℕx≤n' {0} {zero} = z≤n
toℕx≤n' {suc n} {zero} = z≤n
toℕx≤n' {suc n} {suc x} = s≤s (toℕx≤n'{n}{x})
n∸x+x≡n : {n x : ℕ} → Data.Nat._≤_ x n → n ∸ x + x ≡ n
n∸x+x≡n {0} {zero} le = refl
n∸x+x≡n {0} {suc x} ()
n∸x+x≡n {suc n} {zero} le = refl
n∸x+x≡n {suc n} {suc x} (s≤s le) = cong suc (n∸x+x≡n le)
toℕx<n : {n : ℕ} {x : Fin n} → Data.Nat._<_ (toℕ x) n
toℕx<n {suc n} {zero} = s≤s z≤n
toℕx<n {suc n} {suc x} = s≤s toℕx<n
n∸x≡suc[n∸sucx] : {n x : ℕ} → Data.Nat._<_ x n → n ∸ x ≡ suc (n ∸ (suc x))
n∸x≡suc[n∸sucx] {suc n} {0} le = refl
n∸x≡suc[n∸sucx] {suc n} {suc x} (s≤s le) = n∸x≡suc[n∸sucx] le
suc[n+x]≡n+sucx : {n x : ℕ} → suc (n + x) ≡ (n + suc x)
suc[n+x]≡n+sucx {0} {x} = refl
suc[n+x]≡n+sucx {suc n} {x} = refl
suc[n∸sucx+x]≡n : {n x : ℕ} → Data.Nat._<_ x n → suc (n ∸ (suc x) + x) ≡ n
suc[n∸sucx+x]≡n {suc n} {0} le = refl
suc[n∸sucx+x]≡n {suc n} {suc x} (s≤s le) = cong suc (suc[n∸sucx+x]≡n {n} {x} le)
suc[n∸suc[toℕi]+toℕi]≡n : {n : ℕ} {i : Fin n} → suc (n ∸ (suc (toℕ i)) + toℕ i) ≡ n
suc[n∸suc[toℕi]+toℕi]≡n {n} {i} = suc[n∸sucx+x]≡n{n}{toℕ i} toℕx<n
{-# REWRITE suc[n∸suc[toℕi]+toℕi]≡n #-}
m∸toℕ+toℕ≡m : {n : ℕ} {i : Fin (suc n)} → n ∸ (toℕ i) + (toℕ i) ≡ n
m∸toℕ+toℕ≡m {n} {i} = m∸n+n≡m{n}{toℕ i} toℕx≤n'
{-# REWRITE m∸toℕ+toℕ≡m #-}
<suc : {n x : ℕ} → Data.Nat._<_ x n → Data.Nat._<_ x (suc n)
<suc {suc n} {0} le = s≤s z≤n
<suc {suc n} {suc x} (s≤s le) = s≤s (<suc {n} {x} le)
≤suc : {n x : ℕ} → Data.Nat._≤_ x n → Data.Nat._≤_ x (suc n)
≤suc {n} {0} le = z≤n
≤suc {suc n} {suc x} (s≤s le) = s≤s (≤suc {n} {x} le)
----------------------------------------------------------------------
module IND where
mutual
data Type (n : ℕ) : Set where
TUnit TInt : Type n
TPair : Type n → Type n → Type n
TChan : SType n → Type n
data SType (n : ℕ) : Set where
gdd : (gst : GType n) → SType n
rec : (gst : GType (suc n)) → SType n
var : (x : Fin n) → SType n
data GType (n : ℕ) : Set where
transmit : (d : Dir) (t : Type n) (s : SType n) → GType n
choice : (d : Dir) (m : ℕ) (alt : Fin m → SType n) → GType n
end : GType n
data MClType (n : ℕ) : Set where
MClTUnit MClTInt : MClType n
MClTPair : MClType n → MClType n → MClType n
MClTChan : SType 0 → MClType n
data MClSType (n : ℕ) : Set where
tgdd : (tgst : MClGType n) → MClSType n
trec : (tgst : MClGType (suc n)) → MClSType n
tvar : (x : Fin n) → MClSType n
data MClGType (n : ℕ) : Set where
ttransmit : (d : Dir) (t : MClType n) (s : MClSType n) → MClGType n
tchoice : (d : Dir) (m : ℕ) (alt : Fin m → MClSType n) → MClGType n
end : MClGType n
----------------------------------------------------------------------
weaken1'N : Fin (suc n) → Fin n → Fin (suc n)
weaken1'N zero x = suc x
weaken1'N (suc i) zero = zero
weaken1'N (suc i) (suc x) = suc (weaken1'N i x)
weaken1'S : Fin (suc n) → SType n → SType (suc n)
weaken1'G : Fin (suc n) → GType n → GType (suc n)
weaken1'T : Fin (suc n) → Type n → Type (suc n)
weaken1'S i (gdd gst) = gdd (weaken1'G i gst)
weaken1'S i (rec gst) = rec (weaken1'G (suc i) gst)
weaken1'S i (var x) = var (weaken1'N i x)
weaken1'G i (transmit d t s) = transmit d (weaken1'T i t) (weaken1'S i s)
weaken1'G i (choice d m alt) = choice d m (weaken1'S i ∘ alt)
weaken1'G i end = end
weaken1'T i TUnit = TUnit
weaken1'T i TInt = TInt
weaken1'T i (TPair t₁ t₂) = TPair (weaken1'T i t₁) (weaken1'T i t₂)
weaken1'T i (TChan x) = TChan (weaken1'S i x)
weaken1S : SType n → SType (suc n)
weaken1G : GType n → GType (suc n)
weaken1T : Type n → Type (suc n)
weaken1S = weaken1'S zero
weaken1G = weaken1'G zero
weaken1T = weaken1'T zero
weakenS : (n : ℕ) → SType m → SType (m + n)
weakenG : (n : ℕ) → GType m → GType (m + n)
weakenT : (n : ℕ) → Type m → Type (m + n)
weakenS n (gdd gst) = gdd (weakenG n gst)
weakenS n (rec gst) = rec (weakenG n gst)
weakenS n (var x) = var (inject+ n x)
weakenG n (transmit d t s) = transmit d (weakenT n t) (weakenS n s)
weakenG n (choice d m alt) = choice d m (λ i → weakenS n (alt i))
weakenG n end = end
weakenT n TUnit = TUnit
weakenT n TInt = TInt
weakenT n (TPair ty ty₁) = TPair (weakenT n ty) (weakenT n ty₁)
weakenT n (TChan x) = TChan (weakenS n x)
----------------------------------------------------------------------
-- Single substitution with SType 0
st-substS : SType (suc n) → Fin (suc n) → SType 0 → SType n
st-substG : GType (suc n) → Fin (suc n) → SType 0 → GType n
st-substT : Type (suc n) → Fin (suc n) → SType 0 → Type n
st-substS (gdd gst) i st0 = gdd (st-substG gst i st0)
st-substS (rec gst) i st0 = rec (st-substG gst (suc i) st0)
st-substS {n} (var zero) zero st0 = weakenS n st0
st-substS {suc n} (var zero) (suc i) st0 = var zero
st-substS {suc n} (var (suc x)) zero st0 = var x
st-substS {suc n} (var (suc x)) (suc i) st0 = weaken1S (st-substS (var x) i st0)
st-substG (transmit d t s) i st0 = transmit d (st-substT t i st0) (st-substS s i st0)
st-substG (choice d m alt) i st0 = choice d m (λ j → st-substS (alt j) i st0)
st-substG end i st0 = end
st-substT TUnit i st0 = TUnit
st-substT TInt i st0 = TInt
st-substT (TPair ty ty₁) i st0 = TPair (st-substT ty i st0) (st-substT ty₁ i st0)
st-substT (TChan st) i st0 = TChan (st-substS st i st0)
-- Single substitution with SType n
st-substS' : Fin (suc n) → SType n → SType (suc n) → SType n
st-substG' : Fin (suc n) → SType n → GType (suc n) → GType n
st-substT' : Fin (suc n) → SType n → Type (suc n) → Type n
st-substS' i st (gdd gst) = gdd (st-substG' i st gst)
st-substS' i st (rec gst) = rec (st-substG' (suc i) (weaken1S st) gst)
st-substS' i st (var x)
with compare x i
st-substS' i st (var .(inject least)) | less .i least = var (inject! least)
st-substS' .x st (var x) | equal .x = st
st-substS' .(inject least) st (var (suc x)) | greater .(suc x) least = var x
st-substG' i st (transmit d t s) = transmit d (st-substT' i st t) (st-substS' i st s)
st-substG' i st (choice d m alt) = choice d m (λ j → st-substS' i st (alt j))
st-substG' i st end = end
st-substT' i st TUnit = TUnit
st-substT' i st TInt = TInt
st-substT' i st (TPair ty ty₁) = TPair (st-substT' i st ty) (st-substT' i st ty₁)
st-substT' i st (TChan s) = TChan (st-substS' i st s)
----------------------------------------------------------------------
----------------------------------------------------------------------
----------------------------------------------------------------------
open IND
data Stack : ℕ → Set where
ε : Stack 0
⟪_,_⟫ : Stack n → IND.GType (suc n) → Stack (suc n)
data StackS : ℕ → Set where
ε : StackS 0
⟪_,_⟫ : StackS n → IND.SType n → StackS (suc n)
data StackS0 : ℕ → Set where
ε : StackS0 0
⟪_,_⟫ : StackS0 n → IND.SType 0 → StackS0 (suc n)
data StackMCl : ℕ → Set where
ε : StackMCl 0
⟪_,_⟫ : StackMCl n → IND.MClGType (suc n) → StackMCl (suc n)
-- Stack of length m starting at arbitrary type size n
data Stack' : ℕ → ℕ → Set where
ε : Stack' n 0
⟪_,_⟫ : Stack' n m → IND.GType (suc (n + m)) → Stack' n (suc m)
data Stack'S : ℕ → ℕ → Set where
ε : Stack'S n 0
⟪_,_⟫ : Stack'S n m → IND.SType (n + m) → Stack'S n (suc m)
data Stack'Sn : ℕ → ℕ → Set where
ε : Stack'Sn n 0
⟪_,_⟫ : Stack'Sn n m → IND.SType n → Stack'Sn n (suc m)
get : {n : ℕ} → (i : Fin n) → Stack n → Stack (n ∸ (suc (toℕ i))) × IND.GType (n ∸ (toℕ i))
get {suc n} zero ⟪ σ , x ⟫ = σ , x
get {suc n} (suc i) ⟪ σ , x ⟫ = get i σ
getS : {n : ℕ} → (i : Fin n) → StackS n → StackS (n ∸ (suc (toℕ i))) × IND.SType (n ∸ (suc (toℕ i)))
getS {suc n} zero ⟪ σ , x ⟫ = σ , x
getS {suc n} (suc i) ⟪ σ , x ⟫ = getS i σ
getS0 : {n : ℕ} → (i : Fin n) → StackS0 n → StackS0 (n ∸ (suc (toℕ i))) × IND.SType 0
getS0 {suc n} zero ⟪ σ , x ⟫ = σ , x
getS0 {suc n} (suc i) ⟪ σ , x ⟫ = getS0 i σ
getMCl : {n : ℕ} → (i : Fin n) → StackMCl n → StackMCl (n ∸ (suc (toℕ i))) × IND.MClGType (n ∸ (toℕ i))
getMCl {suc n} zero ⟪ σ , x ⟫ = σ , x
getMCl {suc n} (suc i) ⟪ σ , x ⟫ = getMCl i σ
get' : {n m : ℕ} → (i : Fin m) → Stack' n m → Stack' n (m ∸ (suc (toℕ i))) × IND.GType (n + (m ∸ (toℕ i)))
get' {n} {suc m} zero ⟪ σ , x ⟫ = σ , x
get' {n} {suc m} (suc i) ⟪ σ , x ⟫ = get' i σ
get'S : {n m : ℕ} → (i : Fin m) → Stack'S n m → Stack'S n (m ∸ (suc (toℕ i))) × IND.SType (n + (m ∸ (suc (toℕ i))))
get'S {n} {suc m} zero ⟪ σ , x ⟫ = σ , x
get'S {n} {suc m} (suc i) ⟪ σ , x ⟫ = get'S i σ
get'Sn : {n m : ℕ} → (i : Fin m) → Stack'Sn n m → Stack'Sn n (m ∸ (suc (toℕ i))) × IND.SType n
get'Sn {n} {suc m} zero ⟪ σ , x ⟫ = σ , x
get'Sn {n} {suc m} (suc i) ⟪ σ , x ⟫ = get'Sn i σ
----------------------------------------------------------------------
stack-split : (i : Fin (suc n)) → Stack n → Stack (n ∸ toℕ i) × Stack' (n ∸ toℕ i) (toℕ i)
stack-split zero σ = σ , ε
stack-split{n} (suc i) ⟪ σ , x ⟫
with stack-split i σ
... | σ' , σ'' = σ' , ⟪ σ'' , x ⟫
-- couldn't achieve this by rewriting alone
suc[n+[m∸sucx]+x]≡n+m : {n m x : ℕ} → Data.Nat._<_ x m → suc (n + (m ∸ suc x) + x) ≡ n + m
suc[n+[m∸sucx]+x]≡n+m {0} {m} {x} le = suc[n∸sucx+x]≡n{m}{x} le
suc[n+[m∸sucx]+x]≡n+m {suc n} {suc m} {0} le = refl
suc[n+[m∸sucx]+x]≡n+m {suc n} {suc m} {suc x} (s≤s le) = cong suc (cong suc (suc[n+[m∸sucx]+x]≡n+m le))
-- i from the top of the stack
stack'-m-i : {n m : ℕ} → (i : Fin m) → Stack' n m → Stack' (n + (m ∸ (toℕ i))) (toℕ i)
stack'-m-i {n} {m} zero σ = ε
stack'-m-i {n} {suc m} (suc i) ⟪ σ , x ⟫ rewrite (sym (suc[n+[m∸sucx]+x]≡n+m{n}{m}{toℕ i} toℕx<n)) = ⟪ (stack'-m-i i σ) , x ⟫
weaken1-Stack' : (i : Fin (suc n)) → Stack' n m → Stack' (suc n) m
weaken1-Stack' i ε = ε
weaken1-Stack'{n}{m} i ⟪ σ , x ⟫ = ⟪ (weaken1-Stack' i σ) , (weaken1'G (inject+ m i) x) ⟫
weaken1-Stack'Sn : (i : Fin (suc n)) → Stack'Sn n m → Stack'Sn (suc n) m
weaken1-Stack'Sn i ε = ε
weaken1-Stack'Sn{n}{m} i ⟪ σ , x ⟫ = ⟪ (weaken1-Stack'Sn i σ) , (weaken1'S i x) ⟫
-- substitute after index i, required for rec case
stack-sim-substS-i> : (i : Fin n) → StackS0 (n ∸ (toℕ (suc i))) → SType n → SType (toℕ (suc i))
stack-sim-substG-i> : (i : Fin n) → StackS0 (n ∸ (toℕ (suc i))) → GType n → GType (toℕ (suc i))
stack-sim-substT-i> : (i : Fin n) → StackS0 (n ∸ (toℕ (suc i))) → Type n → Type (toℕ (suc i))
stack-sim-substS-i> i σ (gdd gst) = gdd (stack-sim-substG-i> i σ gst)
stack-sim-substS-i> i σ (rec gst) = rec (stack-sim-substG-i> (suc i) σ gst)
stack-sim-substS-i>{suc n} zero σ (var zero) = var zero
stack-sim-substS-i> zero σ (var (suc x))
with getS0 x σ
... | σ' , s = weaken1S s
stack-sim-substS-i> (suc i) σ (var zero) = var zero
stack-sim-substS-i> (suc i) σ (var (suc x)) = weaken1S (stack-sim-substS-i> i σ (var x))
stack-sim-substG-i> i σ (transmit d t s) = transmit d (stack-sim-substT-i> i σ t) (stack-sim-substS-i> i σ s)
stack-sim-substG-i> i σ (choice d m alt) = choice d m (λ x → stack-sim-substS-i> i σ (alt x))
stack-sim-substG-i> i σ end = end
stack-sim-substT-i> i σ TUnit = TUnit
stack-sim-substT-i> i σ TInt = TInt
stack-sim-substT-i> i σ (TPair t t₁) = TPair (stack-sim-substT-i> i σ t) (stack-sim-substT-i> i σ t₁)
stack-sim-substT-i> i σ (TChan x) = TChan (stack-sim-substS-i> i σ x)
-- substitute stack
stack-sim-substS : StackS0 n → SType n → SType 0
stack-sim-substG : StackS0 n → GType n → GType 0
stack-sim-substT : StackS0 n → Type n → Type 0
stack-sim-substS σ (gdd gst) = gdd (stack-sim-substG σ gst)
stack-sim-substS σ (rec gst) = rec (stack-sim-substG-i> zero σ gst) -- Apply stack substitution to variables 1, ..., suc n; keep 0F; can't extend StackS0 since only SType 0F allowed
stack-sim-substS σ (var x)
with getS0 x σ
... | σ' , s = s
stack-sim-substG σ (transmit d t s) = transmit d (stack-sim-substT σ t) (stack-sim-substS σ s)
stack-sim-substG σ (choice d m alt) = choice d m (λ x → stack-sim-substS σ (alt x))
stack-sim-substG σ end = end
stack-sim-substT σ TUnit = TUnit
stack-sim-substT σ TInt = TInt
stack-sim-substT σ (TPair t t₁) = TPair (stack-sim-substT σ t) (stack-sim-substT σ t₁)
stack-sim-substT σ (TChan x) = TChan (stack-sim-substS σ x)
stack-sim-substS'-i≥ : (i : Fin (suc m)) → Stack'Sn n (m ∸ toℕ i) → SType m → SType (n + toℕ i)
stack-sim-substG'-i≥ : (i : Fin (suc m)) → Stack'Sn n (m ∸ toℕ i) → GType m → GType (n + toℕ i)
stack-sim-substT'-i≥ : (i : Fin (suc m)) → Stack'Sn n (m ∸ toℕ i) → Type m → Type (n + toℕ i)
stack-sim-substS'-i≥ i σ (gdd gst) = gdd (stack-sim-substG'-i≥ i σ gst)
stack-sim-substS'-i≥ i σ (rec gst) = rec (stack-sim-substG'-i≥ (suc i) σ gst)
stack-sim-substS'-i≥ zero σ (var x)
with get'Sn x σ
... | σ' , y = y
stack-sim-substS'-i≥ (suc i) σ (var zero) = var zero
stack-sim-substS'-i≥ (suc i) σ (var (suc x)) = weaken1S (stack-sim-substS'-i≥ i σ (var x))
stack-sim-substG'-i≥ i σ (transmit d t s) = transmit d (stack-sim-substT'-i≥ i σ t) (stack-sim-substS'-i≥ i σ s)
stack-sim-substG'-i≥ i σ (choice d m alt) = choice d m (λ x → stack-sim-substS'-i≥ i σ (alt x))
stack-sim-substG'-i≥ i σ end = end
stack-sim-substT'-i≥ i σ TUnit = TUnit
stack-sim-substT'-i≥ i σ TInt = TInt
stack-sim-substT'-i≥ i σ (TPair t t₁) = TPair (stack-sim-substT'-i≥ i σ t) (stack-sim-substT'-i≥ i σ t₁)
stack-sim-substT'-i≥ i σ (TChan x) = TChan (stack-sim-substS'-i≥ i σ x)
-- substitute stack'
stack-sim-substS' : Stack'Sn n m → SType m → SType n
stack-sim-substG' : Stack'Sn n m → GType m → GType n
stack-sim-substT' : Stack'Sn n m → Type m → Type n
stack-sim-substS' σ (gdd gst) = gdd (stack-sim-substG' σ gst)
stack-sim-substS'{n}{m} σ (rec gst) = rec (stack-sim-substG'-i≥ (suc zero) σ gst)
stack-sim-substS' σ (var x)
with get'Sn x σ
... | σ' , s = s
stack-sim-substG' σ (transmit d t s) = transmit d (stack-sim-substT' σ t) (stack-sim-substS' σ s)
stack-sim-substG' σ (choice d m alt) = choice d m (λ x → stack-sim-substS' σ (alt x))
stack-sim-substG' σ end = end
stack-sim-substT' σ TUnit = TUnit
stack-sim-substT' σ TInt = TInt
stack-sim-substT' σ (TPair t t₁) = TPair (stack-sim-substT' σ t) (stack-sim-substT' σ t₁)
stack-sim-substT' σ (TChan x) = TChan (stack-sim-substS' σ x)
{- required for alt. def. of rec case of stack-sim-substS'-top
stack-sim-substS'-top-i≥ : (i : Fin (suc m)) → Stack'Sn n (m ∸ toℕ i) → SType (n + m) → SType (n + toℕ i)
stack-sim-substG'-top-i≥ : (i : Fin (suc m)) → Stack'Sn n (m ∸ toℕ i) → GType (n + m) → GType (n + toℕ i)
stack-sim-substT'-top-i≥ : (i : Fin (suc m)) → Stack'Sn n (m ∸ toℕ i) → Type (n + m) → Type (n + toℕ i)
stack-sim-substS'-top-i≥ i σ (gdd gst) = {!!}
stack-sim-substS'-top-i≥ i σ (rec gst) = rec (stack-sim-substG'-top-i≥ (suc i) σ gst)
stack-sim-substS'-top-i≥ i σ (var x) = {!!}
stack-sim-substS'-top-i≥' : (i : Fin (suc m)) → Stack'Sn (n + toℕ i) (toℕ i) → SType (n + m) → SType (n + m ∸ toℕ i)
stack-sim-substG'-top-i≥' : (i : Fin (suc m)) → Stack'Sn (n + toℕ i) (toℕ i) → GType (n + m) → GType (n + m ∸ toℕ i)
stack-sim-substS'-top-i≥'{m = m}{n = suc n} i σ (rec gst) = rec (stack-sim-substG'-top-i≥' {!!} {!!} gst)
-}
-- substitute top variables from stack'
stack-sim-substS'-top : Stack'Sn n m → SType (n + m) → SType n
stack-sim-substG'-top : Stack'Sn n m → GType (n + m) → GType n
stack-sim-substT'-top : Stack'Sn n m → Type (n + m) → Type n
stack-sim-substS'-top σ (gdd gst) = gdd (stack-sim-substG'-top σ gst)
stack-sim-substS'-top{n}{m} σ (rec gst) = rec (stack-sim-substG'-top{m = m} (weaken1-Stack'Sn zero σ) gst) -- alternative: rec (stack-sim-substG'-top-i≥ 1 σ gst)
stack-sim-substS'-top{n}{m} σ (var x) = {!!} -- <= n => var n, > n => substitute
-- Transform Stack of STypes to Stack of closed STypes by substitution
-- ⟪ ε , SType 0 , SType 1 , SType 2 , ⋯ ⟫
-- ⟪ ε , SType 0 , SType 1 [0 ↦ SType 0], SType 2 [0 ↦ SType 0, 1 ↦ SType 1 [0 ↦ SType 0]], ⋯ ⟫
-- ⟪ ε , SType 0 , SType 0 , SType 0 , ⋯ ⟫
stack-transform : StackS n → StackS0 n
stack-transform ε = ε
stack-transform ⟪ σ , x ⟫
with stack-transform σ
... | σ' = ⟪ σ' , (stack-sim-substS σ' x) ⟫
stack-transform' : Stack'S n m → Stack'Sn n m
stack-transform' ε = ε
stack-transform'{n} ⟪ σ , x ⟫
with stack-transform' σ
... | σ' = ⟪ σ' , stack-sim-substS'-top σ' x ⟫
stack-cat : Stack n → Stack' n m → Stack (n + m)
stack-cat σ ε = σ
stack-cat σ ⟪ σ' , x ⟫ = ⟪ (stack-cat σ σ') , x ⟫
stack-cat' : Stack' 0 n → Stack' n m → Stack' 0 (n + m)
stack-cat' σ ε = σ
stack-cat' σ ⟪ σ' , x ⟫ = ⟪ (stack-cat' σ σ') , x ⟫
stack-sim-substS-refl : (s : SType 0) → stack-sim-substS ε s ≡ s
stack-sim-substG-refl : (g : GType 0) → stack-sim-substG ε g ≡ g
stack-sim-substT-refl : (t : Type 0) → stack-sim-substT ε t ≡ t
stack-sim-substS-refl (gdd gst) = cong gdd (stack-sim-substG-refl gst)
stack-sim-substS-refl (rec gst) = {!!} -- requires stack-sim-substG-i>-refl
stack-sim-substG-refl (transmit d t s) = cong₂ (transmit d) (stack-sim-substT-refl t) (stack-sim-substS-refl s)
stack-sim-substG-refl (choice d m alt) = cong (choice d m) (ext (λ x → stack-sim-substS-refl (alt x)))
stack-sim-substG-refl end = refl
stack-sim-substT-refl TUnit = refl
stack-sim-substT-refl TInt = refl
stack-sim-substT-refl (TPair t t₁) = cong₂ TPair (stack-sim-substT-refl t) (stack-sim-substT-refl t₁)
stack-sim-substT-refl (TChan x) = cong TChan (stack-sim-substS-refl x)
----------------------------------------------------------------------
-- Message closure
mclS : (σ : StackS n) → SType n → MClSType n
mclG : (σ : StackS n) → GType n → MClGType n
mclT : (σ : StackS n) → Type n → MClType n
mclS σ (gdd gst) = tgdd (mclG σ gst)
mclS σ (rec gst) = trec (mclG ⟪ σ , (rec gst) ⟫ gst)
mclS σ (var x) = tvar x
mclG σ (transmit d t s) = ttransmit d (mclT σ t) (mclS σ s)
mclG σ (choice d m alt) = tchoice d m (λ x → mclS σ (alt x))
mclG σ end = end
mclT σ TUnit = MClTUnit
mclT σ TInt = MClTInt
mclT σ (TPair t t₁) = MClTPair (mclT σ t) (mclT σ t₁)
mclT σ (TChan x) = MClTChan (stack-sim-substS (stack-transform σ) x)
----------------------------------------------------------------------
-- Any mcl type is a normal type with weakening
mcl2indS : MClSType n → SType n
mcl2indG : MClGType n → GType n
mcl2indT : MClType n → Type n
mcl2indS (tgdd tgst) = gdd (mcl2indG tgst)
mcl2indS (trec tgst) = rec (mcl2indG tgst)
mcl2indS (tvar x) = var x
mcl2indG (ttransmit d t s) = transmit d (mcl2indT t) (mcl2indS s)
mcl2indG (tchoice d m alt) = choice d m (λ x → mcl2indS (alt x))
mcl2indG end = end
mcl2indT MClTUnit = TUnit
mcl2indT MClTInt = TInt
mcl2indT (MClTPair t t₁) = TPair (mcl2indT t) (mcl2indT t₁)
mcl2indT{n} (MClTChan x) = TChan (weakenS n x)
----------------------------------------------------------------------
stack2StackS : Stack n → StackS n
stack2StackS ε = ε
stack2StackS ⟪ σ , x ⟫ = ⟪ (stack2StackS σ) , (rec x) ⟫
stackMCl2Stack : StackMCl n → Stack n
stackMCl2Stack ε = ε
stackMCl2Stack ⟪ σ , x ⟫ = ⟪ (stackMCl2Stack σ) , (mcl2indG x) ⟫
stackMCl2StackS : StackMCl n → StackS n
stackMCl2StackS ε = ε
stackMCl2StackS ⟪ σ , x ⟫ = ⟪ (stackMCl2StackS σ) , (rec (mcl2indG x)) ⟫
stack2StackMCl : Stack n → StackMCl n
stack2StackMCl ε = ε
stack2StackMCl ⟪ σ , x ⟫ = ⟪ (stack2StackMCl σ) , (mclG ⟪ stack2StackS σ , rec x ⟫ x) ⟫
stack2Stack' : Stack n → Stack' 0 n
stack2Stack' ε = ε
stack2Stack' ⟪ σ , x ⟫ = ⟪ stack2Stack' σ , x ⟫
stack'2Stack : Stack' 0 n → Stack n
stack'2Stack ε = ε
stack'2Stack ⟪ σ , x ⟫ = ⟪ stack'2Stack σ , x ⟫
stack'2Stack'S : Stack' n m → Stack'S n m
stack'2Stack'S ε = ε
stack'2Stack'S ⟪ σ , x ⟫ = ⟪ (stack'2Stack'S σ) , (rec x) ⟫
stack-stack'-refl : (σ : Stack n) → (stack'2Stack (stack2Stack' σ)) ≡ σ
stack-stack'-refl ε = refl
stack-stack'-refl ⟪ σ , x ⟫ rewrite (stack-stack'-refl σ) = refl
{-# REWRITE stack-stack'-refl #-}
----------------------------------------------------------------------
naive-dualS : SType n → SType n
naive-dualG : GType n → GType n
naive-dualT : Type n → Type n
naive-dualS (gdd gst) = gdd (naive-dualG gst)
naive-dualS (rec gst) = rec (naive-dualG gst)
naive-dualS (var x) = var x
naive-dualG (transmit d t s) = transmit (dual-dir d) (naive-dualT t) (naive-dualS s)
naive-dualG (choice d m alt) = choice (dual-dir d) m (λ x → naive-dualS (alt x))
naive-dualG end = end
naive-dualT TUnit = TUnit
naive-dualT TInt = TInt
naive-dualT (TPair t t₁) = TPair (naive-dualT t) (naive-dualT t₁)
naive-dualT (TChan x) = TChan (naive-dualS x)
naive-dualSt : MClSType n → MClSType n
naive-dualGt : MClGType n → MClGType n
naive-dualTt : MClType n → MClType n
naive-dualSt (tgdd tgst) = tgdd (naive-dualGt tgst)
naive-dualSt (trec tgst) = trec (naive-dualGt tgst)
naive-dualSt (tvar x) = tvar x
naive-dualGt (ttransmit d t s) = ttransmit (dual-dir d) (naive-dualTt t) (naive-dualSt s)
naive-dualGt (tchoice d m alt) = tchoice (dual-dir d) m (λ x → naive-dualSt (alt x))
naive-dualGt end = end
naive-dualTt MClTUnit = MClTUnit
naive-dualTt MClTInt = MClTInt
naive-dualTt (MClTPair t t₁) = MClTPair (naive-dualTt t) (naive-dualTt t₁)
naive-dualTt (MClTChan x) = MClTChan (naive-dualS x)
----------------------------------------------------------------------
dualS : (σ : StackS n) → SType n → MClSType n
dualG : (σ : StackS n) → GType n → MClGType n
dualT : (σ : StackS n) → Type n → MClType n
dualS σ (gdd gst) = tgdd (dualG σ gst)
dualS σ (rec gst) = trec (dualG ⟪ σ , (rec gst) ⟫ gst)
dualS σ (var x) = (tvar x)
dualG{n} σ (transmit d t s) = ttransmit (dual-dir d) (dualT σ t) (dualS σ s)
dualG σ (choice d m alt) = tchoice (dual-dir d) m ((dualS σ) ∘ alt)
dualG σ end = end
dualT σ TUnit = MClTUnit
dualT σ TInt = MClTInt
dualT σ (TPair t t₁) = MClTPair (dualT σ t) (dualT σ t₁)
dualT σ (TChan x) = MClTChan (stack-sim-substS (stack-transform σ) x)
module sanity-check where
-- μx.!x.x → μx.?(μx.!x.x).x
S : SType 0
S = rec (transmit SND (TChan (var zero)) (var zero))
DS = rec (transmit RCV (weaken1T (TChan S)) (var zero))
_ : mclS ε DS ≡ dualS ε S
_ = refl
-- μx.!x.!x.x → μx.?(μx.!x.!x.x).?(μx.!x.!x.x).x
S' : SType 0
S' = rec (transmit SND (TChan (var zero)) (gdd ((transmit SND (TChan (var zero)) (var zero)))))
DS' = rec (transmit RCV (weaken1T (TChan S')) (gdd ((transmit RCV (weaken1T (TChan S')) (var zero)))))
_ : mclS ε DS' ≡ dualS ε S'
_ = refl
-- μx.!x.(μy.!y.y) → μx.?(μx.!x.(μy.!y.y)).(μy.?(μy.!y.y).y)
S'' : SType 0
S'' = rec (transmit SND (TChan (var zero)) (rec (transmit SND (TChan (var zero)) (var zero))))
DS'' = rec (transmit RCV (weaken1T (TChan S'')) (weaken1S DS))
_ : mclS ε DS'' ≡ dualS ε S''
_ = refl
----------------------------------------------------------------------
open import DualCoinductive hiding (n ; m)
_≈_ = COI._≈_
_≈'_ = COI._≈'_
_≈ᵗ_ = COI._≈ᵗ_
-- IND to Coinductive using two stacks
-- e.g. i = 0 => σ
-- i = 1 => σ , g -- g = get σ' 0
-- i = 2F => σ , g' , g -- g = get σ' 0; g' = get σ' 1
-- i = n => σ'
ind2coiS' : (i : Fin (suc n)) → Stack (n ∸ toℕ i) → Stack' (n ∸ toℕ i) (toℕ i) → IND.SType n → COI.SType
ind2coiG' : (i : Fin (suc n)) → Stack (n ∸ toℕ i) → Stack' (n ∸ toℕ i) (toℕ i) → IND.GType n → COI.STypeF COI.SType
ind2coiT' : (i : Fin (suc n)) → Stack (n ∸ toℕ i) → Stack' (n ∸ toℕ i) (toℕ i) → IND.Type n → COI.Type
COI.SType.force (ind2coiS' i σ σ' (gdd gst)) = ind2coiG' i σ σ' gst
COI.SType.force (ind2coiS'{n} i σ σ' (rec gst)) = ind2coiG' (suc i) σ ⟪ σ' , gst ⟫ gst
COI.SType.force (ind2coiS' i σ σ' (var x)) = {!!}
-- IND to Coinductive
ind2coiS : Stack n → IND.SType n → COI.SType
ind2coiG : Stack n → IND.GType n → COI.STypeF COI.SType
ind2coiT : Stack n → IND.Type n → COI.Type
ind2coiT σ TUnit = COI.TUnit
ind2coiT σ TInt = COI.TInt
ind2coiT σ (TPair t t₁) = COI.TPair (ind2coiT σ t) (ind2coiT σ t₁)
ind2coiT σ (TChan x) = COI.TChan (ind2coiS σ x)
COI.SType.force (ind2coiS σ (gdd gst)) = ind2coiG σ gst
COI.SType.force (ind2coiS σ (rec gst)) = ind2coiG ⟪ σ , gst ⟫ gst
COI.SType.force (ind2coiS{n} σ (var x))
with get x σ
... | σ' , gxs rewrite (n∸x≡suc[n∸sucx]{n}{toℕ x} toℕx<n) = ind2coiG ⟪ σ' , gxs ⟫ gxs
ind2coiG σ (transmit d t s) = COI.transmit d (ind2coiT σ t) (ind2coiS σ s)
ind2coiG σ (choice d m alt) = COI.choice d m (λ x → ind2coiS σ (alt x))
ind2coiG σ end = COI.end
-- IND to Coinductive using StackS0
ind2coiS'' : StackS0 n → IND.SType n → COI.SType
ind2coiG'' : StackS0 n → IND.GType n → COI.STypeF COI.SType
COI.SType.force (ind2coiS'' σ (gdd gst)) = ind2coiG'' σ gst
COI.SType.force (ind2coiS''{n} σ (rec gst)) = ind2coiG''{suc n} ⟪ σ , stack-sim-substS σ (rec gst) ⟫ gst
ind2coiS'' σ (var x)
with getS0 x σ
... | σ' , gxs = ind2coiS'' ε gxs
-- Equivalence of IND to COI with one stack and IND to COI with two stacks
ind2coiS≈ind2coiS' : (σ : Stack' 0 n) (s : IND.SType n)
→ ind2coiS' (fromℕ n) ε σ s ≈ ind2coiS (stack'2Stack σ) s
ind2coiG≈ind2coiG' : (σ : Stack' 0 n) (g : IND.GType n)
→ ind2coiG' (fromℕ n) ε σ g ≈' ind2coiG (stack'2Stack σ) g
COI.Equiv.force (ind2coiS≈ind2coiS' σ (gdd gst)) = ind2coiG≈ind2coiG' σ gst
COI.Equiv.force (ind2coiS≈ind2coiS'{n} σ (rec gst)) = ind2coiG≈ind2coiG'{suc n} ⟪ σ , gst ⟫ gst
COI.Equiv.force (ind2coiS≈ind2coiS' σ (var x)) = {!!}
-- Message closure to Coinductive
mcl2coiT : StackMCl n → MClType n → COI.Type
mcl2coiS : StackMCl n → MClSType n → COI.SType
mcl2coiG : StackMCl n → MClGType n → COI.STypeF COI.SType
mcl2coiT σ MClTUnit = COI.TUnit
mcl2coiT σ MClTInt = COI.TInt
mcl2coiT σ (MClTPair t t₁) = COI.TPair (mcl2coiT σ t) (mcl2coiT σ t₁)
mcl2coiT σ (MClTChan s) = COI.TChan (ind2coiS ε s)
COI.SType.force (mcl2coiS σ (tgdd g)) = mcl2coiG σ g
COI.SType.force (mcl2coiS σ (trec g)) = mcl2coiG ⟪ σ , g ⟫ g
COI.SType.force (mcl2coiS{n} σ (tvar x))
with getMCl x σ
... | σ' , gxs rewrite (n∸x≡suc[n∸sucx]{n}{toℕ x} toℕx<n) = mcl2coiG ⟪ σ' , gxs ⟫ gxs
mcl2coiG σ (ttransmit d t s) = COI.transmit d (mcl2coiT σ t) (mcl2coiS σ s)
mcl2coiG σ (tchoice d m alt) = COI.choice d m (mcl2coiS σ ∘ alt)
mcl2coiG σ end = COI.end
----------------------------------------------------------------------
-- lemm 1
-- stack-sim-substS (stack-transform ⟪ stack2StackS σ , (rec x) ⟫) s ≡ stack-sim-substS (stack-transform (stack2StackS σ)) (st-substS' 0 (rec x) s)
-- lemm 2
-- ind2coiS ⟪ σ , x ⟫ s ≈ ind2coiS σ (st-substS' 0 (rec x) s)
-- unfolding vs single substitution
ind2coi-substS : (σ : Stack n) (g : GType (suc n)) (s : SType (suc n)) →
ind2coiS ⟪ σ , g ⟫ s ≈ ind2coiS σ (st-substS' zero (rec g) s)
ind2coi-substG : (σ : Stack n) (g : GType (suc n)) (g' : GType (suc n)) →
ind2coiG ⟪ σ , g ⟫ g' ≈' ind2coiG σ (st-substG' zero (rec g) g')
COI.Equiv.force (ind2coi-substS σ g (gdd gst)) = ind2coi-substG σ g gst
COI.Equiv.force (ind2coi-substS σ g (rec gst)) = {!!}
-- the following line for rec-case is a contradiction for gst = transmit d t (var 1)
-- COI.≈'-trans (COI.≈'-trans (ind2coi-substG ⟪ σ , g ⟫ gst gst) (ind2coi-substG σ g (st-substG' 0 (rec gst) gst))) (COI.≈'-trans {!!} (COI.≈'-symm (ind2coi-substG σ (st-substG' 1 (weaken1S (rec g)) gst) (st-substG' 1 (weaken1S (rec g)) gst))))
COI.Equiv.force (ind2coi-substS σ g (var zero)) = COI.≈'-refl
COI.Equiv.force (ind2coi-substS {n} σ g (var (suc x))) = {!!}
ind2coi-substG σ g (transmit d t s) = COI.eq-transmit d {!!} (ind2coi-substS σ g s)
ind2coi-substG σ g (choice d m alt) = COI.eq-choice d λ i → ind2coi-substS σ g (alt i)
ind2coi-substG σ g end = COI.eq-end
-- unfolding vs simultaneous substitution: special, needed case
st-unfold : {n : ℕ} (σ : Stack n) (s : IND.SType n) →
ind2coiS ε (stack-sim-substS (stack-transform (stack2StackS σ)) s) ≈ ind2coiS σ s
st-unfold {0} ε s rewrite (stack-sim-substS-refl s) = COI.≈-refl
st-unfold {suc n} ⟪ σ , x ⟫ s = {!st-unfold σ (st-substS' 0 (rec x) s)!} -- provable if lemm 1 & lemm 2 hold
-- unfolding vs simultaneous substitution: general case
stack-unfoldS : (σ : Stack n) (σ' : Stack' n m) (s : IND.SType (n + m)) →
ind2coiS σ (stack-sim-substS'-top (stack-transform' (stack'2Stack'S σ')) s) ≈ ind2coiS (stack-cat σ σ') s
COI.Equiv.force (stack-unfoldS {n} σ σ' (gdd gst)) = {!!}
COI.Equiv.force (stack-unfoldS σ σ' (rec gst)) = {!!}
COI.Equiv.force (stack-unfoldS {n} σ σ' (var x)) = {!!}
-- unfolding vs simultaneous substition: general case w/ alt. def. for ind2coiS
stack-unfoldS' : (i : Fin (suc n)) (σ : Stack (n ∸ toℕ i)) (σ' : Stack' (n ∸ toℕ i) (toℕ i)) (s : IND.SType n) →
ind2coiS σ (stack-sim-substS'-top (stack-transform' (stack'2Stack'S σ')) s) ≈ ind2coiS' i σ σ' s
COI.Equiv.force (stack-unfoldS' i σ σ' (gdd gst)) = {!!}
COI.Equiv.force (stack-unfoldS' i σ σ' (rec gst)) = {!!} -- req. first lemma from graveyard of lemmas
COI.Equiv.force (stack-unfoldS' i σ σ' (var x)) = {!!}
----------------------------------------------------------------------
-- proof idea for var case:
-- mcl2coiS (stack2StackMCl σ) (tvar x)
-------- getMCl x (stack2StackMCl σ) = σ' , g
-- => mcl2coiG ⟪ σ' , g ⟫ g
-------- getMCl x (stack2StackMCl σ) = (stack2StackMCl (get x σ).1 , mclG ⟪ stack2StackS (get x σ).1 , rec (get x σ).2 ⟫ (get x σ).2
-- => mcl2coiG ⟪ (stack2StackMCl (get x σ).1 , mclG ⟪ stack2StackS (get x σ).1 , rec (get x σ).2 ⟫ (get x σ).2 ⟫ (mclG ⟪ stack2StackS (get x σ).1 , rec (get x σ).2 ⟫ (get x σ).2)
------- which by definition of stack2StackMCl and stack2StackS is equivalent to
-- = mcl2coiG (stack2StackMCl ⟪ (get x σ).1 , (get x σ).2 ⟫) (mclG (stack2StackS ⟪ (get x σ).1 , (get x σ).2 ⟫) g)
------- which, by mcl-equiv-G
-- ≈' ind2coiG ⟪ (get x σ).1 , (get x σ).2 ⟫ (get x σ).2
-- = ind2coiG σ (var x)
getMCl-get : (x : Fin n) (σ : Stack n)
→ getMCl x (stack2StackMCl σ) ≡ (stack2StackMCl (proj₁ (get x σ)) , mclG ⟪ stack2StackS (proj₁ (get x σ)) , rec (proj₂ (get x σ)) ⟫ (proj₂ (get x σ)))
getMCl-get zero ⟪ σ , x ⟫ = refl
getMCl-get (suc x) ⟪ σ , x₁ ⟫ = getMCl-get x σ
----------------------------------------------------------------------
mcl-equiv-S : (σ : Stack n) (s : IND.SType n) →
mcl2coiS (stack2StackMCl σ) (mclS (stack2StackS σ) s) ≈ ind2coiS σ s
mcl-equiv-G : (σ : Stack n) (g : IND.GType n) →
mcl2coiG (stack2StackMCl σ) (mclG (stack2StackS σ) g) ≈' ind2coiG σ g
mcl-equiv-T : (σ : Stack n) (t : IND.Type n) →
mcl2coiT (stack2StackMCl σ) (mclT (stack2StackS σ) t) ≈ᵗ ind2coiT σ t
COI.Equiv.force (mcl-equiv-S σ (gdd gst)) = mcl-equiv-G σ gst
COI.Equiv.force (mcl-equiv-S σ (rec gst)) = mcl-equiv-G ⟪ σ , gst ⟫ gst
COI.Equiv.force (mcl-equiv-S{n} σ (var x))
rewrite (getMCl-get x σ)
with (proj₁ (get x σ)) | (proj₂ (get x σ))
... | σ' | g rewrite (n∸x≡suc[n∸sucx]{n}{toℕ x} toℕx<n) = mcl-equiv-G ⟪ σ' , g ⟫ g
mcl-equiv-G σ (transmit d t s) = COI.eq-transmit d (mcl-equiv-T σ t) (mcl-equiv-S σ s)
mcl-equiv-G σ (choice d m alt) = COI.eq-choice d (λ i → mcl-equiv-S σ (alt i))
mcl-equiv-G σ end = COI.eq-end
mcl-equiv-T σ TUnit = COI.eq-unit
mcl-equiv-T σ TInt = COI.eq-int
mcl-equiv-T σ (TPair t t₁) = COI.eq-pair (mcl-equiv-T σ t) (mcl-equiv-T σ t₁)
mcl-equiv-T {n} σ (TChan x) = COI.eq-chan {!!}
σ : Stack 1
σ = ⟪ ε , end ⟫
g : GType 2
g = transmit SND TInt (var (suc zero))
s : COI.SType
s = ind2coiS σ (rec g)
s' : COI.SType
s' = ind2coiS ε (stack-sim-substS (stack-transform (stack2StackS σ)) (rec g))
s≈s' : s ≈ s'
COI.Equiv.force s≈s' = COI.eq-transmit SND COI.eq-int (record { force = COI.eq-end })
-- naive-mcl-dual : (σ : StackMCl n) (s : IND.SType n) →
-- mcl2coiS σ (naive-dualSt (mclS (stackTail2StackS σ) s)) ≈ mcl2coiS σ (dualS (stackTail2StackS σ) s)
{- graveyard of attempted lemmas
-- idea: "move" a substitution that is done at stack unfolding to a simultaneous subtitution before unfolding
-- problem: cannot formulate this for SType since Stack requires a GType
stack-unfold-lemmaG : {m n : ℕ} (σ : Stack n) (σ' : Stack' n m) (g : GType (suc (n + m))) →
ind2coiG ⟪ σ , stack-sim-substG'-top (weaken1-Stack'Sn 0 (stack-transform' (stack'2Stack'S σ'))) g ⟫ (stack-sim-substG'-top (weaken1-Stack'Sn 0 (stack-transform' (stack'2Stack'S σ'))) g)
≈'
ind2coiG σ (stack-sim-substG'-top (stack-transform' (stack'2Stack'S ⟪ σ' , g ⟫)) g)
stack-unfold-lemmaG {m} {n} σ σ' (transmit d t s) = {!!}
stack-unfold-lemmaG {m} {n} σ σ' (choice d m₁ alt) = {!!}
stack-unfold-lemmaG {m} {n} σ σ' end = {!!}
------------------------------------------------------------
-- won't work for the same reason as below
stack-unfoldS-i : (i : Fin n) (σ : Stack n) (s : IND.SType (suc (n ∸ suc (toℕ i) + toℕ i)))
→ ind2coiS (proj₁ (stack-split i σ)) (stack-sim-substS'-top (stack-transform' (stack'2Stack'S (proj₂ (stack-split i σ)))) s) ≈ ind2coiS σ (rewrfixS{n}{i} s)
stack-unfoldG-i : (i : Fin n) (σ : Stack n) (g : IND.GType (suc (n ∸ suc (toℕ i) + toℕ i)))
→ ind2coiG (proj₁ (stack-split i σ)) (stack-sim-substG'-top (stack-transform' (stack'2Stack'S (proj₂ (stack-split i σ)))) g) ≈' ind2coiG σ (rewrfixG{n}{i} g)
COI.Equiv.force (stack-unfoldS-i i σ (gdd gst)) = {!!}
COI.Equiv.force (stack-unfoldS-i{n} i σ (rec gst)) = {!stack-unfoldG-i (suc i) ? gst!}
COI.Equiv.force (stack-unfoldS-i i σ (var x)) = {!!}
-- won't work. rec case adds something to σ on the left side, but something at the end of (stack-cat σ σ') on the right side.
stack-unfoldS' : (σ : Stack n) (σ' : Stack' n m) (s : IND.SType (n + m)) →
ind2coiS σ (stack-sim-substS'-top (stack-transform' (stack'2Stack'S σ')) s) ≈ ind2coiS (stack-cat σ σ') s
stack-unfoldG' : (σ : Stack n) (σ' : Stack' n m) (g : IND.GType (n + m)) →
ind2coiG σ (stack-sim-substG'-top (stack-transform' (stack'2Stack'S σ')) g) ≈' ind2coiG (stack-cat σ σ') g
COI.Equiv.force (stack-unfoldS' σ σ' (gdd gst)) = {!!}
COI.Equiv.force (stack-unfoldS'{n}{m} σ σ' (rec gst)) = {!!} -- {!stack-unfoldG'{suc n}{m} ⟪ σ , stack-sim-substG'-top-i≥ 1 (stack-transform' (stack'2Stack'S σ')) gst ⟫ (weaken1-Stack' 0 σ') gst!}
COI.Equiv.force (stack-unfoldS' σ σ' (var x)) = {!!}
-}
| {
"alphanum_fraction": 0.5814800291,
"avg_line_length": 40.0246636771,
"ext": "agda",
"hexsha": "234a6affb8e5961024afba6d03f3eee8693eabf4",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "cd41919582013e75463308c32750e2712cf2de86",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "kcaliban/dual-session",
"max_forks_repo_path": "src/DualLMRefined.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "cd41919582013e75463308c32750e2712cf2de86",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "kcaliban/dual-session",
"max_issues_repo_path": "src/DualLMRefined.agda",
"max_line_length": 244,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "cd41919582013e75463308c32750e2712cf2de86",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "kcaliban/dual-session",
"max_stars_repo_path": "src/DualLMRefined.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 15757,
"size": 35702
} |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.RingSolver.Solver where
open import Cubical.Foundations.Prelude
open import Cubical.Data.FinData
open import Cubical.Data.Nat using (ℕ)
open import Cubical.Data.Nat.Order using (zero-≤)
open import Cubical.Data.Vec.Base
open import Cubical.Algebra.RingSolver.AlmostRing
open import Cubical.Algebra.RingSolver.RawRing renaming (⟨_⟩ to ⟨_⟩ᵣ)
open import Cubical.Algebra.RingSolver.RingExpression
open import Cubical.Algebra.RingSolver.HornerForms
open import Cubical.Algebra.RingSolver.EvaluationHomomorphism
private
variable
ℓ : Level
module EqualityToNormalform (R : AlmostRing {ℓ}) where
νR = AlmostRing→RawRing R
open AlmostRing R
open Theory R
open Eval νR
open IteratedHornerOperations νR
open HomomorphismProperties R
normalize : (n : ℕ) → Expr ⟨ R ⟩ n → IteratedHornerForms νR n
normalize n (K r) = Constant n νR r
normalize n (∣ k) = Variable n νR k
normalize n (x ⊕ y) =
(normalize n x) +ₕ (normalize n y)
normalize n (x ⊗ y) =
(normalize n x) ·ₕ (normalize n y)
normalize n (⊝ x) = -ₕ (normalize n x)
isEqualToNormalform :
(n : ℕ)
(e : Expr ⟨ R ⟩ n) (xs : Vec ⟨ R ⟩ n)
→ eval n (normalize n e) xs ≡ ⟦ e ⟧ xs
isEqualToNormalform ℕ.zero (K r) [] = refl
isEqualToNormalform (ℕ.suc n) (K r) (x ∷ xs) =
eval (ℕ.suc n) (Constant (ℕ.suc n) νR r) (x ∷ xs) ≡⟨ refl ⟩
eval (ℕ.suc n) (0ₕ ·X+ Constant n νR r) (x ∷ xs) ≡⟨ refl ⟩
eval (ℕ.suc n) 0ₕ (x ∷ xs) · x + eval n (Constant n νR r) xs
≡⟨ cong (λ u → u · x + eval n (Constant n νR r) xs) (eval0H _ (x ∷ xs)) ⟩
0r · x + eval n (Constant n νR r) xs
≡⟨ cong (λ u → u + eval n (Constant n νR r) xs) (0LeftAnnihilates _) ⟩
0r + eval n (Constant n νR r) xs ≡⟨ +Lid _ ⟩
eval n (Constant n νR r) xs
≡⟨ isEqualToNormalform n (K r) xs ⟩
r ∎
isEqualToNormalform (ℕ.suc n) (∣ zero) (x ∷ xs) =
eval (ℕ.suc n) (1ₕ ·X+ 0ₕ) (x ∷ xs) ≡⟨ refl ⟩
eval (ℕ.suc n) 1ₕ (x ∷ xs) · x + eval n 0ₕ xs ≡⟨ cong (λ u → u · x + eval n 0ₕ xs)
(eval1ₕ _ (x ∷ xs)) ⟩
1r · x + eval n 0ₕ xs ≡⟨ cong (λ u → 1r · x + u ) (eval0H _ xs) ⟩
1r · x + 0r ≡⟨ +Rid _ ⟩
1r · x ≡⟨ ·Lid _ ⟩
x ∎
isEqualToNormalform (ℕ.suc n) (∣ (suc k)) (x ∷ xs) =
eval (ℕ.suc n) (0ₕ ·X+ Variable n νR k) (x ∷ xs) ≡⟨ refl ⟩
eval (ℕ.suc n) 0ₕ (x ∷ xs) · x + eval n (Variable n νR k) xs
≡⟨ cong (λ u → u · x + eval n (Variable n νR k) xs) (eval0H _ (x ∷ xs)) ⟩
0r · x + eval n (Variable n νR k) xs
≡⟨ cong (λ u → u + eval n (Variable n νR k) xs) (0LeftAnnihilates _) ⟩
0r + eval n (Variable n νR k) xs ≡⟨ +Lid _ ⟩
eval n (Variable n νR k) xs
≡⟨ isEqualToNormalform n (∣ k) xs ⟩
⟦ ∣ (suc k) ⟧ (x ∷ xs) ∎
isEqualToNormalform ℕ.zero (⊝ e) [] =
eval ℕ.zero (-ₕ (normalize ℕ.zero e)) [] ≡⟨ -evalDist ℕ.zero
(normalize ℕ.zero e)
[] ⟩
- eval ℕ.zero (normalize ℕ.zero e) [] ≡⟨ cong -_
(isEqualToNormalform
ℕ.zero e [] ) ⟩
- ⟦ e ⟧ [] ∎
isEqualToNormalform (ℕ.suc n) (⊝ e) (x ∷ xs) =
eval (ℕ.suc n) (-ₕ (normalize (ℕ.suc n) e)) (x ∷ xs) ≡⟨ -evalDist (ℕ.suc n)
(normalize
(ℕ.suc n) e)
(x ∷ xs) ⟩
- eval (ℕ.suc n) (normalize (ℕ.suc n) e) (x ∷ xs) ≡⟨ cong -_
(isEqualToNormalform
(ℕ.suc n) e (x ∷ xs) ) ⟩
- ⟦ e ⟧ (x ∷ xs) ∎
isEqualToNormalform ℕ.zero (e ⊕ e₁) [] =
eval ℕ.zero (normalize ℕ.zero e +ₕ normalize ℕ.zero e₁) []
≡⟨ +Homeval ℕ.zero (normalize ℕ.zero e) _ [] ⟩
eval ℕ.zero (normalize ℕ.zero e) []
+ eval ℕ.zero (normalize ℕ.zero e₁) []
≡⟨ cong (λ u → u + eval ℕ.zero (normalize ℕ.zero e₁) [])
(isEqualToNormalform ℕ.zero e []) ⟩
⟦ e ⟧ []
+ eval ℕ.zero (normalize ℕ.zero e₁) []
≡⟨ cong (λ u → ⟦ e ⟧ [] + u) (isEqualToNormalform ℕ.zero e₁ []) ⟩
⟦ e ⟧ [] + ⟦ e₁ ⟧ [] ∎
isEqualToNormalform (ℕ.suc n) (e ⊕ e₁) (x ∷ xs) =
eval (ℕ.suc n) (normalize (ℕ.suc n) e
+ₕ normalize (ℕ.suc n) e₁) (x ∷ xs)
≡⟨ +Homeval (ℕ.suc n) (normalize (ℕ.suc n) e) _ (x ∷ xs) ⟩
eval (ℕ.suc n) (normalize (ℕ.suc n) e) (x ∷ xs)
+ eval (ℕ.suc n) (normalize (ℕ.suc n) e₁) (x ∷ xs)
≡⟨ cong (λ u → u + eval (ℕ.suc n) (normalize (ℕ.suc n) e₁) (x ∷ xs))
(isEqualToNormalform (ℕ.suc n) e (x ∷ xs)) ⟩
⟦ e ⟧ (x ∷ xs)
+ eval (ℕ.suc n) (normalize (ℕ.suc n) e₁) (x ∷ xs)
≡⟨ cong (λ u → ⟦ e ⟧ (x ∷ xs) + u)
(isEqualToNormalform (ℕ.suc n) e₁ (x ∷ xs)) ⟩
⟦ e ⟧ (x ∷ xs) + ⟦ e₁ ⟧ (x ∷ xs) ∎
isEqualToNormalform ℕ.zero (e ⊗ e₁) [] =
eval ℕ.zero (normalize ℕ.zero e ·ₕ normalize ℕ.zero e₁) []
≡⟨ ·Homeval ℕ.zero (normalize ℕ.zero e) _ [] ⟩
eval ℕ.zero (normalize ℕ.zero e) []
· eval ℕ.zero (normalize ℕ.zero e₁) []
≡⟨ cong (λ u → u · eval ℕ.zero (normalize ℕ.zero e₁) [])
(isEqualToNormalform ℕ.zero e []) ⟩
⟦ e ⟧ []
· eval ℕ.zero (normalize ℕ.zero e₁) []
≡⟨ cong (λ u → ⟦ e ⟧ [] · u) (isEqualToNormalform ℕ.zero e₁ []) ⟩
⟦ e ⟧ [] · ⟦ e₁ ⟧ [] ∎
isEqualToNormalform (ℕ.suc n) (e ⊗ e₁) (x ∷ xs) =
eval (ℕ.suc n) (normalize (ℕ.suc n) e
·ₕ normalize (ℕ.suc n) e₁) (x ∷ xs)
≡⟨ ·Homeval (ℕ.suc n) (normalize (ℕ.suc n) e) _ (x ∷ xs) ⟩
eval (ℕ.suc n) (normalize (ℕ.suc n) e) (x ∷ xs)
· eval (ℕ.suc n) (normalize (ℕ.suc n) e₁) (x ∷ xs)
≡⟨ cong (λ u → u · eval (ℕ.suc n) (normalize (ℕ.suc n) e₁) (x ∷ xs))
(isEqualToNormalform (ℕ.suc n) e (x ∷ xs)) ⟩
⟦ e ⟧ (x ∷ xs)
· eval (ℕ.suc n) (normalize (ℕ.suc n) e₁) (x ∷ xs)
≡⟨ cong (λ u → ⟦ e ⟧ (x ∷ xs) · u)
(isEqualToNormalform (ℕ.suc n) e₁ (x ∷ xs)) ⟩
⟦ e ⟧ (x ∷ xs) · ⟦ e₁ ⟧ (x ∷ xs) ∎
solve :
{n : ℕ} (e₁ e₂ : Expr ⟨ R ⟩ n) (xs : Vec ⟨ R ⟩ n)
(p : eval n (normalize n e₁) xs ≡ eval n (normalize n e₂) xs)
→ ⟦ e₁ ⟧ xs ≡ ⟦ e₂ ⟧ xs
solve e₁ e₂ xs p =
⟦ e₁ ⟧ xs ≡⟨ sym (isEqualToNormalform _ e₁ xs) ⟩
eval _ (normalize _ e₁) xs ≡⟨ p ⟩
eval _ (normalize _ e₂) xs ≡⟨ isEqualToNormalform _ e₂ xs ⟩
⟦ e₂ ⟧ xs ∎
| {
"alphanum_fraction": 0.4652130254,
"avg_line_length": 46.1655629139,
"ext": "agda",
"hexsha": "7eac9627c0ceceabd863a633b4a950ed728ffc41",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "dan-iel-lee/cubical",
"max_forks_repo_path": "Cubical/Algebra/RingSolver/Solver.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "dan-iel-lee/cubical",
"max_issues_repo_path": "Cubical/Algebra/RingSolver/Solver.agda",
"max_line_length": 93,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "dan-iel-lee/cubical",
"max_stars_repo_path": "Cubical/Algebra/RingSolver/Solver.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2641,
"size": 6971
} |
{-# OPTIONS --cubical --no-import-sorts #-}
module Number.Instances.Nat 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.Structures.Ring
-- open import Cubical.Structures.Group
-- open import Cubical.Structures.AbGroup
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.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.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.Nat as Nat renaming (_*_ to _·_)
open import Cubical.Data.Nat.Order renaming (_<_ to _<ᵗ_)
open import Cubical.Data.Nat.Properties using
( inj-*sm
; inj-sm*
) renaming
( *-distribʳ to ·-distribʳ
; *-distribˡ to ·-distribˡ
; *-assoc to ·-assoc
; *-comm to ·-comm
; *-identityʳ to ·-identityʳ
; *-identityˡ to ·-identityˡ
)
-- open import Data.Nat.Properties using (+-assoc)
open import Data.Nat.Base using () renaming
( _⊔_ to max
; _⊓_ to min
)
-- _<_ as an hProp-valued relation
_<_ : (x y : ℕ) → hProp ℓ-zero
(x < y) .fst = x <ᵗ y
(x < y) .snd (k₁ , k₁+sx≡y) (k₂ , k₂+sx≡y) = φ where
abstract φ = Σ≡Prop (λ k → isSetℕ _ _) (inj-+m (k₁+sx≡y ∙ sym k₂+sx≡y))
0<suc : ∀ a → 0 <ᵗ suc a
0<suc a = a , +-comm a 1
·-nullifiesˡ : ∀ x → 0 · x ≡ 0
·-nullifiesˡ x = refl
·-nullifiesʳ : ∀ x → x · 0 ≡ 0
·-nullifiesʳ zero = refl
·-nullifiesʳ (suc x) = ·-nullifiesʳ x
abstract
lemma10 : ∀ n → (n <ᵗ 0) ≡ [ ⊥ ]
lemma10 n = isoToPath (iso (λ{ (k , p) → snotz (sym (+-suc k n) ∙ p) }) ⊥-elim (λ b → isProp⊥ _ _) (λ a → isProp[] (n < 0) _ _))
lemma10'' : ∀ n → (n < 0) ≡ ⊥
lemma10'' n = ⇔toPath (transport (lemma10 n)) (transport (sym (lemma10 n)))
lemma12 : ∀ n → [ 0 < suc n ] ≡ [ ⊤ ]
lemma12 n = isoToPath (iso (λ _ → tt) (λ _ → n , +-suc n 0 ∙ (λ i → suc (+-zero n i))) (λ b → isProp⊤ _ _) (λ a → isProp[] (0 < suc n) _ _))
lemma12'' : ∀ n → (0 < suc n) ≡ ⊤
lemma12'' n = ⇔toPath (transport (lemma12 n)) (transport (sym (lemma12 n)))
abstract
<-irrefl : (a : ℕ) → [ ¬ (a < a) ]
<-irrefl zero q = transp (λ i → [ lemma10'' 0 i ]) i0 q
<-irrefl (suc a) (k , p) =
snotz (inj-m+ {a} (+-suc a k ∙ (λ i → suc (+-comm a k i)) ∙ sym (+-suc k a) ∙ inj-m+ {1} (sym (+-suc k (suc a)) ∙ p) ∙ sym (+-zero a)))
suc-creates-< : ∀ a b → [ a < b ⇔ suc a < suc b ]
suc-creates-< a b .fst (k , p) = k , (+-suc k (suc a)) ∙ (λ i → suc (p i))
suc-creates-< a b .snd (k , p) = k , inj-m+ {1} (sym (+-suc k (suc a)) ∙ p)
+-createsˡ-< : ∀ a b x → [ a < b ⇔ (x + a) < (x + b) ]
+-createsˡ-< a b zero .fst a<b = a<b
+-createsˡ-< a b (suc x) .fst a<b = suc-creates-< (x + a) (x + b) .fst $ +-createsˡ-< a b x .fst a<b
+-createsˡ-< a b zero .snd a<b = a<b
+-createsˡ-< a b (suc x) .snd p = +-createsˡ-< a b x .snd (suc-creates-< (x + a) (x + b) .snd p)
+-createsʳ-< : ∀ a b x → [ a < b ⇔ (a + x) < (b + x) ]
+-createsʳ-< a b x .fst p = transport (λ i → [ +-comm x a i < +-comm x b i ]) $ +-createsˡ-< a b x .fst p
+-createsʳ-< a b x .snd p = +-createsˡ-< a b x .snd (transport (λ i → [ +-comm a x i < +-comm b x i ]) p)
<-cotrans : (a b : ℕ) → [ a < b ] → (x : ℕ) → [ (a < x) ⊔ (x < b) ]
<-cotrans zero zero q c = ⊥-elim {A = λ _ → [ (zero < c) ⊔ (c < zero) ]} (<-irrefl _ q)
<-cotrans zero (suc b) q zero = inrᵖ q
<-cotrans zero (suc b) q (suc c) = inlᵖ (c , +-comm c 1)
<-cotrans (suc a) zero (k , p) c = ⊥-elim {A = λ _ → [ (suc a < c) ⊔ (c < zero) ]} (snotz (sym (+-suc k (suc a)) ∙ p))
<-cotrans (suc a) (suc b) q zero = inrᵖ (b , +-comm b 1)
<-cotrans (suc a) (suc b) q (suc c) = transport (λ i → [ r i ⊔ s i ]) (<-cotrans a b (suc-creates-< a b .snd q) c)
where r : (a < c) ≡ (suc a < suc c)
s : (c < b) ≡ (suc c < suc b)
r = ⇔toPath (suc-creates-< a c .fst) (suc-creates-< a c .snd)
s = ⇔toPath (suc-creates-< c b .fst) (suc-creates-< c b .snd)
·-reflects-≡ʳ : ∀ a b x → [ 0 < x ] → a · x ≡ b · x → a ≡ b
·-reflects-≡ʳ a b zero p q = ⊥-elim {A = λ _ → a ≡ b} $ <-irrefl 0 p
·-reflects-≡ʳ a b (suc x) p q = inj-*sm {l = a} {m = x} {n = b} q
·-reflects-≡ˡ : ∀ a b x → [ 0 < x ] → x · a ≡ x · b → a ≡ b
·-reflects-≡ˡ a b zero p q = ⊥-elim {A = λ _ → a ≡ b} $ <-irrefl 0 p
·-reflects-≡ˡ a b (suc x) p q = inj-sm* {m = x} {l = a} {n = b} q
¬suc<0 : ∀ x → [ ¬ (suc x < 0) ]
¬suc<0 x (k , p) = snotz $ sym (+-suc k (suc x)) ∙ p
·-reflects-< : ∀ a b x → [ 0 < x ] → [ (a · x) < (b · x) ] → [ a < b ]
·-reflects-< zero zero x p q = q
·-reflects-< zero (suc b) x p q = 0<suc b
·-reflects-< (suc a) zero x p q = ⊥-elim {A = λ _ → [ suc a < 0 ]} $ ¬-<-zero q
·-reflects-< (suc a) (suc b) x p q = suc-creates-< a b .fst $ ·-reflects-< a b x p (+-createsˡ-< (a · x) (b · x) x .snd q)
min-comm : ∀ x y → min x y ≡ min y x
min-comm zero zero = refl
min-comm zero (suc y) = refl
min-comm (suc x) zero = refl
min-comm (suc x) (suc y) i = suc $ min-comm x y i
min-tightˡ : ∀ x y → [ x < y ] → min x y ≡ x
min-tightˡ zero zero x<y = refl
min-tightˡ zero (suc y) x<y = refl
min-tightˡ (suc x) zero x<y = ⊥-elim {A = λ _ → zero ≡ suc x} (¬suc<0 x x<y)
min-tightˡ (suc x) (suc y) x<y i = suc $ min-tightˡ x y (suc-creates-< x y .snd x<y) i
min-tightʳ : ∀ x y → [ y < x ] → min x y ≡ y
min-tightʳ x y y<x = min-comm x y ∙ min-tightˡ y x y<x
min-identity : ∀ x → min x x ≡ x
min-identity zero = refl
min-identity (suc x) i = suc $ min-identity x i
max-comm : ∀ x y → max x y ≡ max y x
max-comm zero zero = refl
max-comm zero (suc y) = refl
max-comm (suc x) zero = refl
max-comm (suc x) (suc y) i = suc $ max-comm x y i
max-tightˡ : ∀ x y → [ y < x ] → max x y ≡ x
max-tightˡ zero zero y<x = refl
max-tightˡ zero (suc y) y<x = ⊥-elim {A = λ _ → suc y ≡ zero} (¬suc<0 y y<x)
max-tightˡ (suc x) zero y<x = refl
max-tightˡ (suc x) (suc y) y<x i = suc $ max-tightˡ x y (suc-creates-< y x .snd y<x) i
max-tightʳ : ∀ x y → [ x < y ] → max x y ≡ y
max-tightʳ x y x<y = max-comm x y ∙ max-tightˡ y x x<y
max-identity : ∀ x → max x x ≡ x
max-identity zero = refl
max-identity (suc x) i = suc $ max-identity x i
-- +-reflects-< : ∀ a b x → [ a + x < b + x ] → [ a < b ]
-- +-reflects-< a b x
-- suc-preserves-min : ∀ x y → suc (min x y) ≡ min (suc x) (suc y)
-- suc-preserves-min zero y = refl
-- suc-preserves-min (suc x) zero = refl
-- suc-preserves-min (suc x) (suc y) = refl
--
-- min-dichotomy : ∀ x y → (min x y ≡ x) ⊎ (min x y ≡ y)
-- min-dichotomy zero y = inl refl
-- min-dichotomy (suc x) zero = inr refl
-- min-dichotomy (suc x) (suc y) with min-dichotomy x y
-- ... | inl p = inl λ i → suc (p i)
-- ... | inr p = inr λ i → suc (p i)
data MinTrichtotomy (x y : ℕ) : Type where
min-lt : min x y ≡ x → [ x < y ] → MinTrichtotomy x y
min-gt : min x y ≡ y → [ y < x ] → MinTrichtotomy x y
min-eq : min x y ≡ x → min x y ≡ y → MinTrichtotomy x y
data MaxTrichtotomy (x y : ℕ) : Type where
max-lt : max x y ≡ y → [ x < y ] → MaxTrichtotomy x y
max-gt : max x y ≡ x → [ y < x ] → MaxTrichtotomy x y
max-eq : max x y ≡ x → max x y ≡ y → MaxTrichtotomy x y
abstract
min-trichotomy : ∀ x y → MinTrichtotomy x y
min-trichotomy zero zero = min-eq refl refl
min-trichotomy zero (suc y) = min-lt refl (y , (+-comm y 1))
min-trichotomy (suc x) zero = min-gt refl (x , (+-comm x 1))
min-trichotomy (suc x) (suc y) with min-trichotomy x y
... | min-lt p (k , q) = min-lt (λ i → suc (p i)) (k , (+-assoc k 1 (suc x) ∙ (λ i → +-comm k 1 i + suc x) ∙ (λ i → 1 + q i)))
... | min-gt p (k , q) = min-gt (λ i → suc (p i)) (k , (+-assoc k 1 (suc y) ∙ (λ i → +-comm k 1 i + suc y) ∙ (λ i → 1 + q i)))
... | min-eq p q = min-eq (λ i → suc (p i)) (λ i → suc (q i))
max-trichotomy : ∀ x y → MaxTrichtotomy x y
max-trichotomy zero zero = max-eq refl refl
max-trichotomy zero (suc y) = max-lt refl (y , (+-comm y 1))
max-trichotomy (suc x) zero = max-gt refl (x , (+-comm x 1))
max-trichotomy (suc x) (suc y) with max-trichotomy x y
... | max-lt p (k , q) = max-lt (λ i → suc (p i)) (k , (+-assoc k 1 (suc x) ∙ (λ i → +-comm k 1 i + suc x) ∙ (λ i → 1 + q i)))
... | max-gt p (k , q) = max-gt (λ i → suc (p i)) (k , (+-assoc k 1 (suc y) ∙ (λ i → +-comm k 1 i + suc y) ∙ (λ i → 1 + q i)))
... | max-eq p q = max-eq (λ i → suc (p i)) (λ i → suc (q i))
is-min : (x y z : ℕ) → [ ¬ᵖ (min x y < z) ⇔ ¬ᵖ (x < z) ⊓ ¬ᵖ (y < z) ]
is-min x y z .fst z≤minxy with min-trichotomy x y
... | min-lt p x<y = (λ x<z → z≤minxy $ pathTo⇐ (λ i → p i < z) x<z)
, (λ y<z → z≤minxy $ pathTo⇐ (λ i → p i < z) $ <-trans {x} {y} {z} x<y y<z)
... | min-gt p y<x = (λ x<z → z≤minxy $ pathTo⇐ (λ i → p i < z) $ <-trans {y} {x} {z} y<x x<z)
, (λ y<z → z≤minxy $ pathTo⇐ (λ i → p i < z) y<z)
... | min-eq p q = (λ x<z → z≤minxy $ pathTo⇐ (λ i → p i < z) x<z)
, (λ y<z → z≤minxy $ pathTo⇐ (λ i → q i < z) y<z)
is-min x y z .snd (z≤x , z≤y) minxy<z with min-trichotomy x y
... | min-lt p _ = z≤x $ pathTo⇒ (λ i → p i < z) minxy<z
... | min-gt p _ = z≤y $ pathTo⇒ (λ i → p i < z) minxy<z
... | min-eq p q = z≤x $ pathTo⇒ (λ i → p i < z) minxy<z
is-max : (x y z : ℕ) → [ ¬ᵖ (z < max x y) ⇔ ¬ᵖ (z < x) ⊓ ¬ᵖ (z < y) ]
is-max x y z .fst maxxy≤z with max-trichotomy x y
... | max-gt p y<x = (λ z<x → maxxy≤z $ pathTo⇐ (λ i → z < p i) z<x )
, (λ z<y → maxxy≤z $ pathTo⇐ (λ i → z < p i) $ <-trans {z} {y} {x} z<y y<x )
... | max-lt p x<y = (λ z<x → maxxy≤z $ pathTo⇐ (λ i → z < p i) $ <-trans {z} {x} {y} z<x x<y )
, (λ z<y → maxxy≤z $ pathTo⇐ (λ i → z < p i) z<y )
... | max-eq p q = (λ z<x → maxxy≤z $ pathTo⇐ (λ i → z < p i) z<x )
, (λ z<y → maxxy≤z $ pathTo⇐ (λ i → z < q i) z<y )
is-max x y z .snd (z≤x , z≤y) maxxy<z with max-trichotomy x y
... | max-gt p _ = z≤x $ pathTo⇒ (λ i → z < p i) maxxy<z
... | max-lt p _ = z≤y $ pathTo⇒ (λ i → z < p i) maxxy<z
... | max-eq p q = z≤x $ pathTo⇒ (λ i → z < p i) maxxy<z
abstract
-- NOTE: maybe some clever use of cotrans makes this a bit shorter
+-<-ext : (w x y z : ℕ) → [ (w + x) < (y + z) ] → [ (w < y) ⊔ (x < z) ]
+-<-ext w x y z (k , k+suc[w+x]≡y+z) with w ≟ y | x ≟ z
... | lt w<y | q = ∣ inl w<y ∣
... | gt (l , l+suc[y]≡w) | q = inrᵖ (k + suc l , inj-m+ ((
y + ((k + suc l) + suc x) ≡⟨ +-assoc y (k + suc l) (suc x) ⟩
(y + (k + suc l)) + suc x ≡⟨ (λ i → +-assoc y k (suc l) i + suc x) ⟩
((y + k) + suc l) + suc x ≡⟨ (λ i → (+-comm y k i + suc l) + suc x) ⟩
((k + y) + suc l) + suc x ≡⟨ (λ i → +-assoc k y (suc l) (~ i) + suc x) ⟩
(k + (y + suc l)) + suc x ≡⟨ sym $ +-assoc k (y + suc l) (suc x) ⟩
k + ((y + suc l) + suc x) ≡⟨ (λ i → k + (+-suc y l i + suc x)) ⟩
k + (suc (y + l) + suc x) ≡⟨ (λ i → k + (suc (+-comm y l i) + suc x)) ⟩
k + (suc (l + y) + suc x) ≡⟨ (λ i → k + (+-suc l y (~ i) + suc x)) ⟩
k + ((l + suc y) + suc x) ≡⟨ (λ i → k + +-suc (l + suc y) x i) ⟩
k + suc ((l + suc y) + x) ≡⟨ (λ i → k + suc (l+suc[y]≡w i + x)) ⟩
k + suc (w + x) ∎) ∙ k+suc[w+x]≡y+z))
... | eq w≡y | q = inrᵖ (k , inj-m+ ((
y + (k + suc x) ≡⟨ +-assoc y k (suc x) ⟩
(y + k) + suc x ≡⟨ (λ i → +-comm y k i + suc x) ⟩
(k + y) + suc x ≡⟨ sym $ +-assoc k y (suc x) ⟩
k + (y + suc x) ≡⟨ (λ i → k + +-suc y x i) ⟩
k + suc (y + x) ≡⟨ (λ i → k + suc (w≡y (~ i) + x)) ⟩
k + suc (w + x) ∎) ∙ k+suc[w+x]≡y+z))
-- NOTE: instead of equational reasoning, this might follow more easily from induction on `z`?
·-preserves-< : (x y z : ℕ) → [ 0 < z ] → [ x < y ] → [ (x · z) < (y · z) ]
·-preserves-< x y z (k , k+1≡z) (l , l+suc[x]≡y) = l · z + k , (
(l · z + k) + suc (x · z) ≡⟨ sym $ +-assoc (l · z) k (suc (x · z)) ⟩
l · z + (k + suc (x · z)) ≡⟨ refl ⟩ -- 1 + x ≡ suc x holds definitionally
l · z + (k + (1 + x · z)) ≡⟨ (λ i → l · z + +-assoc k 1 (x · z) i) ⟩
l · z + ((k + 1) + x · z) ≡⟨ (λ i → l · z + (k+1≡z i + x · z)) ⟩
l · z + (z + x · z) ≡⟨ refl ⟩ -- suc x · z ≡ z + x · z holds definitionally
l · z + (suc x) · z ≡⟨ ·-distribʳ l (suc x) z ⟩
(l + suc x) · z ∎) ∙ (λ i → l+suc[x]≡y i · z) ∙ refl
-- ·-reflects-< : (x y z : ℕ) → [ 0 < z ] → [ (x · z) < (y · z) ] → [ x < y ]
-- ·-reflects-< x y zero (k , k+1≡z) _ = ⊥-elim {A = λ _ → [ x < y ]} $ snotz (sym (+-comm k 1) ∙ k+1≡z)
-- ·-reflects-< x y (suc zero) _ (l , l+suc[xz]≡yz) = l , (λ i → l + suc (·-identityʳ x (~ i))) ∙ l+suc[xz]≡yz ∙ ·-identityʳ y
-- ·-reflects-< x y (suc (suc z)) _ p@(l , l+suc[xz]≡yz) =
-- let ind = {! ·-reflects-< x y (suc z) (0<suc z) !}
-- -- (x · suc (suc z)) < (y · suc (suc z))
-- -- x + x · suc z < y + y · suc z
-- -- (x + x · suc z) + < (y + y · suc z)
-- in {! ·-suc x (suc z) !}
-- -- ·-reflects-< x y zero 0<z xz<yz = {! !} -- ·-suc x z
-- -- ·-reflects-< x y (suc z) 0<z xz<yz = {! ·-reflects-< x y z !}
-- -- (x · suc z) < (y · suc z)
+-Semigroup : [ isSemigroup _+_ ]
+-Semigroup .IsSemigroup.is-set = isSetℕ
+-Semigroup .IsSemigroup.is-assoc = +-assoc
·-Semigroup : [ isSemigroup _·_ ]
·-Semigroup .IsSemigroup.is-set = isSetℕ
·-Semigroup .IsSemigroup.is-assoc = ·-assoc
+-Monoid : [ isMonoid 0 _+_ ]
+-Monoid .IsMonoid.is-Semigroup = +-Semigroup
+-Monoid .IsMonoid.is-identity x = +-zero x , refl
·-Monoid : [ isMonoid 1 _·_ ]
·-Monoid .IsMonoid.is-Semigroup = ·-Semigroup
·-Monoid .IsMonoid.is-identity x = ·-identityʳ x , ·-identityˡ x
is-Semiring : [ isSemiring 0 1 _+_ _·_ ]
is-Semiring .IsSemiring.+-Monoid = +-Monoid
is-Semiring .IsSemiring.·-Monoid = ·-Monoid
is-Semiring .IsSemiring.+-comm = +-comm
is-Semiring .IsSemiring.is-dist x y z = sym (·-distribˡ x y z) , sym (·-distribʳ x y z)
is-CommSemiring : [ isCommSemiring 0 1 _+_ _·_ ]
is-CommSemiring .IsCommSemiring.is-Semiring = is-Semiring
is-CommSemiring .IsCommSemiring.·-comm = ·-comm
<-StrictLinearOrder : [ isStrictLinearOrder _<_ ]
<-StrictLinearOrder .IsStrictLinearOrder.is-irrefl = <-irrefl
<-StrictLinearOrder .IsStrictLinearOrder.is-trans a b c = <-trans {a} {b} {c}
<-StrictLinearOrder .IsStrictLinearOrder.is-tricho a b with a ≟ b
... | lt a<b = inl (inl a<b)
... | eq a≡b = inr ∣ a≡b ∣
... | gt b<a = inl (inr b<a)
≤-Lattice : [ isLattice (λ x y → ¬ᵖ (y < x)) min max ]
≤-Lattice .IsLattice.≤-PartialOrder = linearorder⇒partialorder _ (≤'-isLinearOrder <-StrictLinearOrder)
≤-Lattice .IsLattice.is-min = is-min
≤-Lattice .IsLattice.is-max = is-max
is-LinearlyOrderedCommSemiring : [ isLinearlyOrderedCommSemiring 0 1 _+_ _·_ _<_ min max ]
is-LinearlyOrderedCommSemiring .IsLinearlyOrderedCommSemiring.is-CommSemiring = is-CommSemiring
is-LinearlyOrderedCommSemiring .IsLinearlyOrderedCommSemiring.<-StrictLinearOrder = <-StrictLinearOrder
is-LinearlyOrderedCommSemiring .IsLinearlyOrderedCommSemiring.≤-Lattice = ≤-Lattice
is-LinearlyOrderedCommSemiring .IsLinearlyOrderedCommSemiring.+-<-ext = +-<-ext
is-LinearlyOrderedCommSemiring .IsLinearlyOrderedCommSemiring.·-preserves-< = ·-preserves-<
bundle : LinearlyOrderedCommSemiring {ℓ-zero} {ℓ-zero}
bundle .LinearlyOrderedCommSemiring.Carrier = ℕ
bundle .LinearlyOrderedCommSemiring.0f = 0
bundle .LinearlyOrderedCommSemiring.1f = 1
bundle .LinearlyOrderedCommSemiring._+_ = _+_
bundle .LinearlyOrderedCommSemiring._·_ = _·_
bundle .LinearlyOrderedCommSemiring.min = min
bundle .LinearlyOrderedCommSemiring.max = max
bundle .LinearlyOrderedCommSemiring._<_ = _<_
bundle .LinearlyOrderedCommSemiring.is-LinearlyOrderedCommSemiring = is-LinearlyOrderedCommSemiring
| {
"alphanum_fraction": 0.5270805812,
"avg_line_length": 48.2724637681,
"ext": "agda",
"hexsha": "337a3a286b9e52ae0d2582d657309315f76dafc7",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "10206b5c3eaef99ece5d18bf703c9e8b2371bde4",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "mchristianl/synthetic-reals",
"max_forks_repo_path": "agda/Number/Instances/Nat.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "10206b5c3eaef99ece5d18bf703c9e8b2371bde4",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "mchristianl/synthetic-reals",
"max_issues_repo_path": "agda/Number/Instances/Nat.agda",
"max_line_length": 143,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "10206b5c3eaef99ece5d18bf703c9e8b2371bde4",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "mchristianl/synthetic-reals",
"max_stars_repo_path": "agda/Number/Instances/Nat.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-19T12:15:21.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-07-31T18:15:26.000Z",
"num_tokens": 7347,
"size": 16654
} |
{- https://lists.chalmers.se/pipermail/agda/2013/006033.html http://code.haskell.org/~Saizan/unification/ 18-Nov-2013 Andrea Vezzosi -}
module Unify-monolithic-EnhancedTerm where
-- some equivalences needed to adapt Tactic.Nat to the standard library
module EquivalenceOf≤ where
open import Agda.Builtin.Equality
open import Agda.Builtin.Nat
open import Data.Nat using (less-than-or-equal) renaming (_≤_ to _≤s_)
open import Data.Nat.Properties using (≤⇒≤″; ≤″⇒≤)
open import Prelude using (diff; id) renaming (_≤_ to _≤p_)
open import Tactic.Nat.Generic (quote _≤p_) (quote id) (quote id) using (by)
≤p→≤s : ∀ {a b} → a ≤p b → a ≤s b
≤p→≤s (diff k b₊₁≡k₊₁+a) = ≤″⇒≤ (less-than-or-equal {k = k} (by b₊₁≡k₊₁+a))
≤s→≤p : ∀ {a b} → a ≤s b → a ≤p b
≤s→≤p a≤sb with ≤⇒≤″ a≤sb
≤s→≤p _ | less-than-or-equal {k = k} a+k≡b = diff k (by a+k≡b)
module _ where
open EquivalenceOf≤
open import Data.Nat
open import Tactic.Nat.Generic (quote _≤_) (quote ≤s→≤p) (quote ≤p→≤s) public
open import Data.Fin using (Fin; suc; zero)
open import Data.Nat hiding (_≤_)
--open import Relation.Binary.PropositionalEquality
open import Relation.Binary.PropositionalEquality hiding ([_])
open import Function
open import Relation.Nullary
--open import Data.Product
open import Data.Product renaming (map to _***_)
open import Data.Empty
open import Data.List renaming (_++_ to _++L_)
{- -- not enhanced
data Term (n : ℕ) : Set where
i : (x : Fin n) -> Term n
leaf : Term n
_fork_ : (s t : Term n) -> Term n
-}
data Term (n : _) : Set where
i : (x : Fin n) -> Term n
function : ℕ → List (Term n) → Term n
term-function-inj₁ : ∀ {x₁ x₂} {n} {ts₁ : List (Term n)} {ts₂} → Term.function x₁ ts₁ ≡ function x₂ ts₂ → x₁ ≡ x₂
term-function-inj₁ refl = refl
term-function-inj₂ : ∀ {x₁ x₂} {n} {ts₁ : List (Term n)} {ts₂} → Term.function x₁ ts₁ ≡ function x₂ ts₂ → ts₁ ≡ ts₂
term-function-inj₂ refl = refl
--data Term (n : ℕ) (I : Size) : Set where
-- i : (x : Fin n) -> Term n I
-- function : ℕ → (J : Size< I) → SizedList J (Term n J) → Term n I
{-
data Term : ℕ -> Set where
i : ∀ ..{n} -> (x : Fin n) -> Term n
leaf : ∀ ..{n} -> Term n
_fork_ : ∀ ..{n} -> (s t : Term n) -> Term n
-}
_~>_ : (m n : ℕ) -> Set
(m ~> n) = Fin m -> Term n
▹ : ∀ {m n} -> (r : Fin m -> Fin n) -> Fin m -> Term n
▹ r = i ∘ r
mutual
infixr 20 _◃s_
_◃s_ : ∀ {m n} -> (f : m ~> n) -> List (Term m) -> List (Term n)
_◃s_ f [] = []
_◃s_ f (x ∷ xs) = (f ◃ x) ∷ f ◃s xs
_◃_ : ∀ {m n} -> (f : m ~> n) -> Term m -> Term n
f ◃ (i x) = f x
f ◃ (function n ts) = function n (f ◃s ts)
{-
_◃_ : ∀ {m n} -> (f : m ~> n) -> Term m -> Term n
_◃_ = _◃
-}
_≐_ : {m n : ℕ} -> (Fin m -> Term n) -> (Fin m -> Term n) -> Set
f ≐ g = ∀ x -> f x ≡ g x
mutual
◃ext : ∀ {m n} {f g : Fin m -> Term n} -> f ≐ g -> ∀ t -> f ◃ t ≡ g ◃ t
◃ext p (i x) = p x
◃ext p (function x ts) = cong (function x) (◃exts p ts)
◃exts : ∀ {m n} {f g : Fin m -> Term n} -> f ≐ g -> ∀ ts -> f ◃s ts ≡ g ◃s ts
◃exts p [] = refl
◃exts p (t ∷ ts) = cong₂ _∷_ (◃ext p t) (◃exts p ts)
_◇_ : ∀ {l m n : ℕ } -> (f : Fin m -> Term n) (g : Fin l -> Term m) -> Fin l -> Term n
f ◇ g = (f ◃_) ∘ g
≐-cong : ∀ {m n o} {f : m ~> n} {g} (h : _ ~> o) -> f ≐ g -> (h ◇ f) ≐ (h ◇ g)
≐-cong h f≐g t = cong (h ◃_) (f≐g t)
≐-sym : ∀ {m n} {f : m ~> n} {g} -> f ≐ g -> g ≐ f
≐-sym f≐g = sym ∘ f≐g
module Sub where
mutual
fact1 : ∀ {n} -> (t : Term n) -> i ◃ t ≡ t
fact1 (i x) = refl
fact1 (function x ts) = cong (function x) (fact1s ts)
fact1s : ∀ {n} -> (ts : List (Term n)) -> i ◃s ts ≡ ts
fact1s [] = refl
fact1s (t ∷ ts) = cong₂ _∷_ (fact1 t) (fact1s ts)
mutual
fact2 : ∀ {l m n} -> (f : Fin m -> Term n) (g : _) (t : Term l)
-> (f ◇ g) ◃ t ≡ f ◃ (g ◃ t)
fact2 f g (i x) = refl
fact2 f g (function x ts) = cong (function x) (fact2s f g ts)
fact2s : ∀ {l m n} -> (f : Fin m -> Term n) (g : _) (ts : List (Term l))
-> (f ◇ g) ◃s ts ≡ f ◃s g ◃s ts
fact2s f g [] = refl
fact2s f g (t ∷ ts) = cong₂ _∷_ (fact2 f g t) (fact2s f g ts)
fact3 : ∀ {l m n} (f : Fin m -> Term n) (r : Fin l -> Fin m) -> (f ◇ (▹ r)) ≡ (f ∘ r)
fact3 f r = refl -- ext (λ _ -> refl)
◃ext' : ∀ {m n o} {f : Fin m -> Term n}{g : Fin m -> Term o}{h} -> f ≐ (h ◇ g) -> ∀ t -> f ◃ t ≡ h ◃ (g ◃ t)
◃ext' p t = trans (◃ext p t) (Sub.fact2 _ _ t)
s : ℕ -> ℕ
s = suc
thin : ∀ {n} -> (x : Fin (s n)) (y : Fin n) -> Fin (s n)
thin zero y = suc y
thin (suc x) zero = zero
thin (suc x) (suc y) = suc (thin x y)
p : ∀ {n} -> Fin (suc (suc n)) -> Fin (suc n)
p (suc x) = x
p zero = zero
module Thin where
fact1 : ∀ {n} x y z -> thin {n} x y ≡ thin x z -> y ≡ z
fact1 zero y .y refl = refl
fact1 (suc x) zero zero r = refl
fact1 (suc x) zero (suc z) ()
fact1 (suc x) (suc y) zero ()
fact1 (suc x) (suc y) (suc z) r = cong suc (fact1 x y z (cong p r))
fact2 : ∀ {n} x y -> ¬ thin {n} x y ≡ x
fact2 zero y ()
fact2 (suc x) zero ()
fact2 (suc x) (suc y) r = fact2 x y (cong p r)
fact3 : ∀{n} x y -> ¬ x ≡ y -> ∃ λ y' -> thin {n} x y' ≡ y
fact3 zero zero ne = ⊥-elim (ne refl)
fact3 zero (suc y) _ = y , refl
fact3 {zero} (suc ()) _ _
fact3 {suc n} (suc x) zero ne = zero , refl
fact3 {suc n} (suc x) (suc y) ne with y | fact3 x y (ne ∘ cong suc)
... | .(thin x y') | y' , refl = suc y' , refl
open import Data.Maybe
open import Category.Functor
open import Category.Monad
import Level
open RawMonad (Data.Maybe.monad {Level.zero})
thick : ∀ {n} -> (x y : Fin (suc n)) -> Maybe (Fin n)
thick zero zero = nothing
thick zero (suc y) = just y
thick {zero} (suc ()) _
thick {suc _} (suc x) zero = just zero
thick {suc _} (suc x) (suc y) = suc <$> (thick x y)
open import Data.Sum
_≡Fin_ : ∀ {n} -> (x y : Fin n) -> Dec (x ≡ y)
zero ≡Fin zero = yes refl
zero ≡Fin suc y = no λ ()
suc x ≡Fin zero = no λ ()
suc {suc _} x ≡Fin suc y with x ≡Fin y
... | yes r = yes (cong suc r)
... | no r = no λ e -> r (cong p e)
suc {zero} () ≡Fin _
module Thick where
half1 : ∀ {n} (x : Fin (suc n)) -> thick x x ≡ nothing
half1 zero = refl
half1 {suc _} (suc x) = cong (_<$>_ suc) (half1 x)
half1 {zero} (suc ())
half2 : ∀ {n} (x : Fin (suc n)) y -> ∀ y' -> thin x y' ≡ y -> thick x y ≡ just y'
half2 zero zero y' ()
half2 zero (suc y) .y refl = refl
half2 {suc n} (suc x) zero zero refl = refl
half2 {suc _} (suc _) zero (suc _) ()
half2 {suc n} (suc x) (suc y) zero ()
half2 {suc n} (suc x) (suc .(thin x y')) (suc y') refl with thick x (thin x y') | half2 x (thin x y') y' refl
... | .(just y') | refl = refl
half2 {zero} (suc ()) _ _ _
fact1 : ∀ {n} (x : Fin (suc n)) y r
-> thick x y ≡ r
-> x ≡ y × r ≡ nothing ⊎ ∃ λ y' -> thin x y' ≡ y × r ≡ just y'
fact1 x y .(thick x y) refl with x ≡Fin y
fact1 x .x ._ refl | yes refl = inj₁ (refl , half1 x)
... | no el with Thin.fact3 x y el
... | y' , thinxy'=y = inj₂ (y' , ( thinxy'=y , half2 x y y' thinxy'=y ))
mutual
check : ∀{n} (x : Fin (suc n)) (t : Term (suc n)) -> Maybe (Term n)
check x (i y) = i <$> thick x y
check x (function v ts) = (function v) <$> checks x ts
checks : ∀{n} (x : Fin (suc n)) (t : List (Term (suc n))) -> Maybe (List (Term n))
checks x [] = just []
checks x (t ∷ ts) = _∷_ <$> check x t ⊛ checks x ts
_for_ : ∀ {n} (t' : Term n) (x : Fin (suc n)) -> Fin (suc n) -> Term n
(t' for x) y = maybe′ i t' (thick x y)
data AList : ℕ -> ℕ -> Set where
anil : ∀ {n} -> AList n n
_asnoc_/_ : ∀ {m n} (σ : AList m n) (t' : Term m) (x : Fin (suc m))
-> AList (suc m) n
sub : ∀ {m n} (σ : AList m n) -> Fin m -> Term n
sub anil = i
sub (σ asnoc t' / x) = sub σ ◇ (t' for x)
_++_ : ∀ {l m n} (ρ : AList m n) (σ : AList l m) -> AList l n
ρ ++ anil = ρ
ρ ++ (σ asnoc t' / x) = (ρ ++ σ) asnoc t' / x
++-assoc : ∀ {l m n o} (ρ : AList l m) (σ : AList n _) (τ : AList o _) -> ρ ++ (σ ++ τ) ≡ (ρ ++ σ) ++ τ
++-assoc ρ σ anil = refl
++-assoc ρ σ (τ asnoc t / x) = cong (λ s -> s asnoc t / x) (++-assoc ρ σ τ)
module SubList where
anil-id-l : ∀ {m n} (σ : AList m n) -> anil ++ σ ≡ σ
anil-id-l anil = refl
anil-id-l (σ asnoc t' / x) = cong (λ σ -> σ asnoc t' / x) (anil-id-l σ)
fact1 : ∀ {l m n} (ρ : AList m n) (σ : AList l m) -> sub (ρ ++ σ) ≐ (sub ρ ◇ sub σ)
fact1 ρ anil v = refl
fact1 {suc l} {m} {n} r (s asnoc t' / x) v = trans hyp-on-terms ◃-assoc
where
t = (t' for x) v
hyp-on-terms = ◃ext (fact1 r s) t
◃-assoc = Sub.fact2 (sub r) (sub s) t
_∃asnoc_/_ : ∀ {m} (a : ∃ (AList m)) (t' : Term m) (x : Fin (suc m))
-> ∃ (AList (suc m))
(n , σ) ∃asnoc t' / x = n , σ asnoc t' / x
flexFlex : ∀ {m} (x y : Fin m) -> ∃ (AList m)
flexFlex {suc m} x y with thick x y
... | just y' = m , anil asnoc i y' / x
... | nothing = suc m , anil
flexFlex {zero} () _
flexRigid : ∀ {m} (x : Fin m) (t : Term m) -> Maybe (∃(AList m))
flexRigid {suc m} x t with check x t
... | just t' = just (m , anil asnoc t' / x)
... | nothing = nothing
flexRigid {zero} () _
mutual
amgu : ∀ {m} (s t : Term m) (acc : ∃ (AList m)) -> Maybe (∃ (AList m))
amgu (function x ts) (function x' ts') acc with x ≟ x'
… | yes refl = amgus ts ts' acc
… | no neq = nothing
amgu (i x) (i y) (m , anil) = just (flexFlex x y)
amgu (i x) t (m , anil) = flexRigid x t
amgu t (i x) (m , anil) = flexRigid x t
amgu s t (n , σ asnoc r / z) =
(λ σ -> σ ∃asnoc r / z) <$>
amgu ((r for z) ◃ s) ((r for z) ◃ t) (n , σ)
amgus : ∀ {m} (ss ts : List (Term m)) (acc : ∃ (AList m)) -> Maybe (∃ (AList m))
amgus [] [] acc = just acc
amgus [] (_ ∷ _) acc = nothing
amgus (_ ∷ _) [] acc = nothing
amgus (s ∷ ss) (t ∷ ts) acc = amgus ss ts =<< amgu s t acc
mgu : ∀ {m} -> (s t : Term m) -> Maybe (∃ (AList m))
mgu {m} s t = amgu s t (m , anil)
{-
open import Data.Fin using (Fin; suc; zero)
open import Data.Nat hiding (_≤_)
open import Relation.Binary.PropositionalEquality hiding ([_])
open import Function
open import Relation.Nullary
open import Data.Product renaming (map to _***_)
open import Data.Empty
-}
open import Data.Maybe using (maybe; maybe′; nothing; just; monad; Maybe)
open import Data.Sum
--open import Unify
--open import Data.List renaming (_++_ to _++L_)
open ≡-Reasoning
open import Category.Functor
open import Category.Monad
import Level as L
--open RawMonad (Data.Maybe.monad {L.zero})
record Σ₁ (A : Set1) (F : A -> Set) : Set1 where
field
π₁ : A
π₂ : F π₁
_,,_ : ∀ {A F} (x : A) -> F x -> Σ₁ A F
x ,, b = record{ π₁ = x; π₂ = b }
open Σ₁
Property⋆ : (m : ℕ) -> Set1
Property⋆ m = ∀ {n} -> (Fin m -> Term n) -> Set
Extensional : {m : ℕ} -> Property⋆ m -> Set
Extensional P = ∀ {m f g} -> f ≐ g -> P {m} f -> P g
Property : (m : ℕ) -> Set1
Property m = Σ₁ (Property⋆ m) Extensional
prop-id : ∀ {m n} {f : _ ~> n} {P : Property m} -> π₁ P f -> π₁ P (i ◇ f)
prop-id {_} {_} {f} {P'} Pf = π₂ P' (λ x → sym (Sub.fact1 (f x))) Pf
Unifies⋆ : ∀ {m} (s t : Term m) -> Property⋆ m
Unifies⋆ s t f = f ◃ s ≡ f ◃ t
Unifies : ∀ {m} (s t : Term m) -> Property m
Unifies s t = (λ {_} -> Unifies⋆ s t) ,, λ {_} {f} {g} f≐g f◃s=f◃t ->
begin
g ◃ s
≡⟨ sym (◃ext f≐g s) ⟩
f ◃ s
≡⟨ f◃s=f◃t ⟩
f ◃ t
≡⟨ ◃ext f≐g t ⟩
g ◃ t
∎
_∧⋆_ : ∀{m} -> (P Q : Property⋆ m) -> Property⋆ m
P ∧⋆ Q = (λ f -> P f × Q f)
_∧_ : ∀{m} -> (P Q : Property m) -> Property m
P ∧ Q = (λ {_} f -> π₁ P f × π₁ Q f) ,, λ {_} {_} {_} f≐g Pf×Qf -> π₂ P f≐g (proj₁ Pf×Qf) , π₂ Q f≐g (proj₂ Pf×Qf)
_⇔⋆_ : ∀{m} -> (P Q : Property⋆ m) -> Set
P ⇔⋆ Q = ∀ {n} f -> (P {n} f -> Q f) × (Q f -> P f)
_⇔_ : ∀{m} -> (P Q : Property m) -> Set
P ⇔ Q = ∀ {n} f -> (π₁ P {n} f -> π₁ Q f) × (π₁ Q f -> π₁ P f)
switch⋆ : ∀ {m} (P Q : Property⋆ m) -> P ⇔⋆ Q -> Q ⇔⋆ P
switch⋆ _ _ P⇔Q f = proj₂ (P⇔Q f) , proj₁ (P⇔Q f)
switch : ∀ {m} (P Q : Property m) -> P ⇔ Q -> Q ⇔ P
switch _ _ P⇔Q f = proj₂ (P⇔Q f) , proj₁ (P⇔Q f)
Nothing⋆ : ∀{m} -> (P : Property⋆ m) -> Set
Nothing⋆ P = ∀{n} f -> P {n} f -> ⊥
Nothing : ∀{m} -> (P : Property m) -> Set
Nothing P = ∀{n} f -> π₁ P {n} f -> ⊥
_[-◇⋆_] : ∀{m n} (P : Property⋆ m) (f : Fin m -> Term n) -> Property⋆ n
(P [-◇⋆ f ]) g = P (g ◇ f)
_[-◇_] : ∀{m n} (P : Property m) (f : Fin m -> Term n) -> Property n
P [-◇ f ] = (λ {_} g -> π₁ P (g ◇ f)) ,, λ {_} {f'} {g'} f'≐g' Pf'◇f -> π₂ P (◃ext f'≐g' ∘ f) Pf'◇f
module Properties where
fact1 : ∀ {m} {s t : Term m} -> (Unifies s t) ⇔ (Unifies t s)
fact1 _ = sym , sym
{-
fact1'⋆ : ∀ {m} {x1 x2} {s1 t1 : Term m} {s2 t2 : List (Term m)}
-> Unifies⋆ (function x1 (s1 ∷ s2)) (function x2 (t1 ∷ t2)) ⇔⋆ (Unifies⋆ s1 t1 ∧⋆ Unifies⋆ (function x1 s2) (function x2 t2))
fact1'⋆ f = (λ x → {!deconstr!}) , {!!} -- deconstr _ _ _ _ _ _ _ , {!uncurry (cong₂ function)!}
where deconstr : ∀ {m} x1 x2 (s1 t1 : Term m) (s2 t2 : List (Term m))
-> function x1 (s1 ∷ s2) ≡ function x2 (t1 ∷ t2)
-> (x1 ≡ x2) × (s1 ≡ t1) × (s2 ≡ t2)
deconstr x1 .x1 s1 .s1 s2 .s2 refl = refl , refl , refl
-}
{-
fact1' : ∀ {m} {s1 s2 t1 t2 : Term m}
-> Unifies (s1 fork s2) (t1 fork t2) ⇔ (Unifies s1 t1 ∧ Unifies s2 t2)
fact1' f = deconstr _ _ _ _ , uncurry (cong₂ _fork_)
where deconstr : ∀ {m} (s1 s2 t1 t2 : Term m)
-> (s1 fork s2) ≡ (t1 fork t2)
-> (s1 ≡ t1) × (s2 ≡ t2)
deconstr s1 s2 .s1 .s2 refl = refl , refl
-}
fact2⋆ : ∀ {m} (P Q : Property⋆ m) -> P ⇔⋆ Q -> Nothing⋆ P -> Nothing⋆ Q
fact2⋆ P Q iff notp f q with iff f
... | (p2q , q2p) = notp f (q2p q)
fact2 : ∀ {m} (P Q : Property m) -> P ⇔ Q -> Nothing P -> Nothing Q
fact2 P Q iff notp f q with iff f
... | (p2q , q2p) = notp f (q2p q)
fact3 : ∀ {m} {P : Property m} -> P ⇔ (P [-◇ i ])
fact3 f = id , id
fact4 : ∀{m n} {P : Property m} (f : _ -> Term n)
-> Nothing P -> Nothing (P [-◇ f ])
fact4 f nop g = nop (g ◇ f)
fact5⋆ : ∀{m n} (P Q : Property⋆ _) (f : m ~> n) -> P ⇔⋆ Q -> (P [-◇⋆ f ]) ⇔⋆ (Q [-◇⋆ f ])
fact5⋆ _ _ f P⇔Q f' = P⇔Q (f' ◇ f)
fact5 : ∀{m n} (P Q : Property _) (f : m ~> n) -> P ⇔ Q -> (P [-◇ f ]) ⇔ (Q [-◇ f ])
fact5 _ _ f P⇔Q f' = P⇔Q (f' ◇ f)
fact6 : ∀{m n} P {f g : m ~> n} -> f ≐ g -> (P [-◇ f ]) ⇔ (P [-◇ g ])
fact6 P f≐g h = π₂ P (≐-cong h f≐g) , π₂ P (≐-sym (≐-cong h f≐g))
{-
fact5 : ∀ {l m n} {f : Fin n -> Term l} {g : Fin m -> Term n}
{P : Property _ }
-> (P [-◇ g ]) [-◇ f ] ⇔ P [-◇ (f ◇ g) ]
fact5 h = {!!} , {!!}
-}
_≤_ : ∀ {m n n'} (f : Fin m -> Term n) (g : Fin m -> Term n') -> Set
f ≤ g = ∃ λ f' -> f ≐ (f' ◇ g)
module Order where
reflex : ∀ {m n} {f : Fin m -> Term n} -> f ≤ f
reflex = i , λ _ -> sym (Sub.fact1 _)
transitivity : ∀ {l m n o} {f : Fin l -> Term m}{g : _ -> Term n}
{h : _ -> Term o}
-> f ≤ g -> g ≤ h -> f ≤ h
transitivity {l} {_} {_} {_} {f} {g} {h} (fg , pfg) (gh , pgh) =
fg ◇ gh , proof
where
proof : (x : Fin l) → f x ≡ (λ x' → fg ◃ (gh x')) ◃ (h x)
proof x = trans z (sym (Sub.fact2 fg gh (h x)))
where z = trans (pfg x) (cong (fg ◃_) (pgh x))
i-max : ∀ {m n} (f : Fin m -> Term n) -> f ≤ i
i-max f = f , λ _ -> refl
dist : ∀{l m n o}{f : Fin l -> Term m}{g : _ -> Term n}(h : Fin o -> _) -> f ≤ g -> (f ◇ h) ≤ (g ◇ h)
dist h (fg , pfg) = fg , λ x -> trans (◃ext pfg (h x)) (Sub.fact2 _ _ (h x))
Max⋆ : ∀ {m} (P : Property⋆ m) -> Property⋆ m
Max⋆ P f = P f × (∀ {n} f' -> P {n} f' -> f' ≤ f)
Max : ∀ {m} (P : Property m) -> Property m
Max P' = (λ {_} → Max⋆ P) ,, λ {_} {_} {_} -> lemma1
where
open Σ₁ P' renaming (π₁ to P; π₂ to Peq)
lemma1 : {m : ℕ} {f : Fin _ → Term m} {g : Fin _ → Term m} →
f ≐ g →
P f × ({n : ℕ} (f' : Fin _ → Term n) → P f' → f' ≤ f) →
P g × ({n : ℕ} (f' : Fin _ → Term n) → P f' → f' ≤ g)
lemma1 {_} {f} {g} f≐g (Pf , MaxPf) = Peq f≐g Pf , λ {_} -> lemma2
where
lemma2 : ∀ {n} f' → P {n} f' → ∃ λ f0 → f' ≐ (f0 ◇ g)
lemma2 f' Pf' = f0 , λ x -> trans (f'≐f0◇f x) (cong (f0 ◃_) (f≐g x))
where
f0 = proj₁ (MaxPf f' Pf')
f'≐f0◇f = proj₂ (MaxPf f' Pf')
module Max where
fact : ∀{m}(P Q : Property m) -> P ⇔ Q -> Max P ⇔ Max Q
fact {m} P Q a f =
(λ maxp → pq (proj₁ maxp) , λ f' → proj₂ maxp f' ∘ qp)
, λ maxq → qp (proj₁ maxq) , λ f' → proj₂ maxq f' ∘ pq
where
pq : {n : ℕ} {f0 : Fin m → Term n} → (π₁ P f0 → π₁ Q f0)
pq {_} {f} = proj₁ (a f)
qp : {n : ℕ} {f0 : Fin m → Term n} → (π₁ Q f0 → π₁ P f0)
qp {_} {f} = proj₂ (a f)
DClosed : ∀{m} (P : Property m) -> Set
DClosed P = ∀ {n} f {o} g -> f ≤ g -> π₁ P {o} g -> π₁ P {n} f
module DClosed where
fact1 : ∀ {m} s t -> DClosed {m} (Unifies s t)
fact1 s t f g (f≤g , p) gs=gt =
begin
f ◃ s
≡⟨ ◃ext' p s ⟩
f≤g ◃ (g ◃ s)
≡⟨ cong (f≤g ◃_) gs=gt ⟩
f≤g ◃ (g ◃ t)
≡⟨ sym (◃ext' p t) ⟩
f ◃ t
∎
optimist : ∀ {l m n o} (a : Fin _ -> Term n) (p : Fin _ -> Term o)
(q : Fin _ -> Term l) (P Q : Property m)
-> DClosed P -> π₁ (Max (P [-◇ a ])) p
-> π₁ (Max (Q [-◇ (p ◇ a) ])) q
-> π₁ (Max ((P ∧ Q) [-◇ a ])) (q ◇ p)
optimist a p q P' Q' DCP (Ppa , pMax) (Qqpa , qMax) =
(Peq (sym ∘ (Sub.fact2 _ _) ∘ a) (DCP (q ◇ (p ◇ a)) (p ◇ a) (q , λ _ -> refl) Ppa)
, Qeq (sym ∘ (Sub.fact2 _ _) ∘ a) Qqpa )
, λ {_} -> aux
where
open Σ₁ P' renaming (π₁ to P; π₂ to Peq)
open Σ₁ Q' renaming (π₁ to Q; π₂ to Qeq)
aux : ∀ {n} (f : _ -> Term n) -> P (f ◇ a) × Q (f ◇ a) -> f ≤ (q ◇ p)
aux f (Pfa , Qfa) = h ,
λ x -> trans (f≐g◇p x) (◃ext' g≐h◇q (p x))
where
one = pMax f Pfa
g = proj₁ one
f≐g◇p = proj₂ one
Qgpa : Q (g ◇ (p ◇ a))
Qgpa = Qeq (λ x -> ◃ext' f≐g◇p (a x)) Qfa
g≤q = qMax g Qgpa
h = proj₁ g≤q
g≐h◇q = proj₂ g≤q
module failure-propagation where
first⋆ : ∀ {m n} (a : _ ~> n) (P Q : Property⋆ m) ->
Nothing⋆ (P [-◇⋆ a ]) -> Nothing⋆ ((P ∧⋆ Q) [-◇⋆ a ])
first⋆ a P' Q' noP-a f (Pfa , Qfa) = noP-a f Pfa
first : ∀ {m n} (a : _ ~> n) (P Q : Property m) ->
Nothing (P [-◇ a ]) -> Nothing ((P ∧ Q) [-◇ a ])
first a P' Q' noP-a f (Pfa , Qfa) = noP-a f Pfa
{-
second⋆ : ∀ {m n o} (a : _ ~> n) (p : _ ~> o)(P Q : Property⋆ m) ->
(Max⋆ (P [-◇⋆ a ])) p -> Nothing⋆ (Q [-◇⋆ (p ◇ a)])
-> Nothing⋆ ((P ∧⋆ Q) [-◇⋆ a ])
second⋆ a p P' Q' (Ppa , pMax) noQ-p◇a f (Pfa , Qfa) = noQ-p◇a g Qgpa
where
f≤p = pMax f Pfa
g = proj₁ f≤p
f≐g◇p = proj₂ f≤p
Qgpa : Q' (g ◇ (p ◇ a))
Qgpa = {!!}
{-
noQ-p◇a g Qgpa
where
f≤p = pMax f Pfa
g = proj₁ f≤p
f≐g◇p = proj₂ f≤p
Qgpa : π₁ Q' (g ◇ (p ◇ a))
Qgpa = π₂ Q' (◃ext' f≐g◇p ∘ a) Qfa
-}
-}
second⋆ : ∀ {m n o} (a : _ ~> n) (p : _ ~> o)(P : Property⋆ m)(Q : Property m) ->
(Max⋆ (P [-◇⋆ a ])) p -> Nothing⋆ (π₁ Q [-◇⋆ (p ◇ a)])
-> Nothing⋆ ((P ∧⋆ π₁ Q) [-◇⋆ a ])
second⋆ a p P' Q' (Ppa , pMax) noQ-p◇a f (Pfa , Qfa) = noQ-p◇a g Qgpa
where
f≤p = pMax f Pfa
g = proj₁ f≤p
f≐g◇p = proj₂ f≤p
Qgpa : π₁ Q' (g ◇ (p ◇ a))
Qgpa = π₂ Q' (◃ext' f≐g◇p ∘ a) Qfa
second : ∀ {m n o} (a : _ ~> n) (p : _ ~> o)(P Q : Property m) ->
π₁ (Max (P [-◇ a ])) p -> Nothing (Q [-◇ (p ◇ a)])
-> Nothing ((P ∧ Q) [-◇ a ])
second a p P' Q' (Ppa , pMax) noQ-p◇a f (Pfa , Qfa) =
noQ-p◇a g Qgpa
where
f≤p = pMax f Pfa
g = proj₁ f≤p
f≐g◇p = proj₂ f≤p
Qgpa : π₁ Q' (g ◇ (p ◇ a))
Qgpa = π₂ Q' (◃ext' f≐g◇p ∘ a) Qfa
trivial-problem : ∀ {m n t} {f : m ~> n} -> π₁ (Max ((Unifies t t) [-◇ f ])) i
trivial-problem = refl , λ f' _ → f' , λ _ → refl
var-elim : ∀ {m} (x : Fin (suc m)) (t' : Term _)
-> π₁ (Max ((Unifies (i x) ((▹ (thin x) ◃_) t')))) (t' for x)
var-elim x t' = first , \{_} -> second
where
lemma : ∀{m}(x : Fin (suc m)) t → i ≐ ((t for x) ◇ (▹ (thin x)))
lemma x t x' = sym (cong (maybe i t) (Thick.half2 x _ x' refl))
first = begin
(t' for x) ◃ (i x) ≡⟨ cong (maybe i t') (Thick.half1 x) ⟩
t' ≡⟨ sym (Sub.fact1 t') ⟩
i ◃ t' ≡⟨ ◃ext' (lemma x t') t' ⟩
(t' for x) ◃ ((▹ (thin x) ◃_) t') ∎
second : ∀ {n} (f : _ ~> n) → f x ≡ f ◃ ((▹ (thin x) ◃_) t') → f ≤ (t' for x)
second f Unifiesf = (f ∘ thin x) , third
where
third : ((x' : Fin _) → f x' ≡ (f ∘ thin x) ◃ (maybe′ i t' (thick x x')))
third x' with thick x x' | Thick.fact1 x x' (thick x x') refl
third .x | .nothing | inj₁ (refl , refl) =
sym (begin
(f ∘ thin x) ◃ t' ≡⟨ cong (λ g -> (g ◃_) t') (sym (Sub.fact3 f (thin x))) ⟩
(f ◇ (▹ (thin x))) ◃ t' ≡⟨ Sub.fact2 f (▹ (thin x)) t' ⟩
f ◃ ((▹ (thin x) ◃_) t') ≡⟨ sym Unifiesf ⟩
f x ∎)
third x' | .(just y) | inj₂ (y , ( thinxy≡x' , refl)) = sym (cong f thinxy≡x')
var-elim-i : ∀ {m} (x : Fin (suc m)) (t' : Term _)
-> π₁ (Max ((Unifies (i x) ((▹ (thin x) ◃_) t')))) (i ◇ (t' for x))
var-elim-i {m} x t = prop-id {_} {_} {t for x} {Max (Unifies (i x) ((▹ (thin x) ◃_) t))} (var-elim {m} x t)
var-elim-i-≡ : ∀ {m} {t'} (x : Fin (suc m)) t1 -> t1 ≡ (i ∘ thin x) ◃ t' -> π₁ (Max (Unifies (i x) t1)) (i ◇ (t' for x))
var-elim-i-≡ {_} {t'} x .((i ∘ thin x) ◃ t') refl = var-elim-i x t'
data Step (n : ℕ) : Set where
step : ℕ → List (Term n) → List (Term n) → Step n
open Data.List using () renaming (map to mapL)
fmapS : ∀ {n m} (f : Term n -> Term m) (s : Step n) -> Step m
fmapS f (step x ls rs) = step x (mapL f ls) (mapL f rs)
infixl 10 _⊹_
_⊹_ : ∀ {n} (ps : List (Step n)) (t : Term n) -> Term n
([] ⊹ t) = t
((step x ls rs ∷ ps) ⊹ t) = function x (ls ++L (ps ⊹ t ∷ rs))
_◃S_ : ∀ {n m} (f : n ~> m) -> List (Step n) -> List (Step m)
_◃S_ f = mapL (fmapS (f ◃_))
map-[] : ∀ {n m} (f : n ~> m) ps -> f ◃S ps ≡ [] -> ps ≡ []
map-[] f [] _ = refl
map-[] f (x ∷ xs) ()
module StepM where
lemma1 : ∀ {n} (x : Step n) xs t -> [ x ] ⊹ ( xs ⊹ t ) ≡ (x ∷ xs) ⊹ t
lemma1 (step x ls rs) xs t = refl
lemma2 : ∀ {n} {r} {t} {xs} (x : Step n) -> xs ⊹ t ≡ r -> ((x ∷ xs) ⊹ t ) ≡ [ x ] ⊹ r
lemma2 (step x ls rs) eq = cong (λ t → function x (ls ++L t ∷ rs)) eq -- cong (λ t -> t fork y) eq
fact1 : ∀ {n} ps qs (t : Term n) -> (ps ++L qs) ⊹ t ≡ ps ⊹ (qs ⊹ t)
fact1 [] qs t = refl
fact1 (p ∷ ps) qs t = begin (p ∷ (ps ++L qs)) ⊹ t ≡⟨ lemma2 p (fact1 ps qs t) ⟩
[ p ] ⊹ (ps ⊹ (qs ⊹ t)) ≡⟨ lemma1 p ps (qs ⊹ t) ⟩
(p ∷ ps) ⊹ (qs ⊹ t) ∎
lemma3 : ∀ {m n} (f : m ~> n) ls rs → f ◃s (ls ++L rs) ≡ mapL (f ◃_) ls ++L mapL (f ◃_) rs
lemma3 f [] (r ∷ rs) = cong (f ◃ r ∷_) (lemma3 f [] rs)
lemma3 f (l ∷ ls) rs = cong (f ◃ l ∷_) (lemma3 f ls rs)
lemma3 f [] [] = refl
fact2 : ∀ {m n} (f : m ~> n) t ps ->
f ◃ (ps ⊹ t) ≡ f ◃S ps ⊹ f ◃ t
fact2 f t [] = refl
fact2 f t (step x [] [] ∷ xs) = cong (function x) (cong (λ section → section ∷ []) (fact2 f t xs))
fact2 f t (step x [] (r ∷ rs) ∷ xs) rewrite lemma3 f [] rs = cong (function x) (cong₂ _∷_ (fact2 f t xs) refl)
fact2 f t (step x (l ∷ ls) rs ∷ xs) rewrite sym $ fact2 f t xs | lemma3 f ls (xs ⊹ t ∷ rs) = cong (function x) (cong (f ◃ l ∷_) refl)
mutual
check-prop : ∀ {m} (x : Fin (suc m)) t ->
(∃ λ t' -> t ≡ ▹ (thin x) ◃ t' × check x t ≡ just t')
⊎ (∃ λ ps -> t ≡ (ps ⊹ i x) × check x t ≡ nothing)
check-prop x (i x') with Thick.fact1 x x' (thick x x') refl
check-prop x (i .x) | inj₁ (refl , e) = inj₂ ([] , refl , cong (_<$>_ i) e)
... | inj₂ (y , thinxy≡x' , thickxx'≡justy')
= inj₁ (i y
, cong i (sym (thinxy≡x'))
, cong (_<$>_ i) thickxx'≡justy' )
check-prop x (function xx ts) with checks-prop x ts
… | inj₁ (asdf , df , er) rewrite df | er = inj₁ (function xx asdf , refl , refl)
… | inj₂ (ls , ps , rs , ts= , checks=) rewrite ts= | checks= = inj₂ (step xx ls rs ∷ ps , refl , refl)
checks-prop : ∀ {m} (x : Fin (suc m)) ts ->
(∃ λ ts' -> ts ≡ (▹ (thin x) ◃s_) ts' × checks x ts ≡ just ts')
⊎ ∃ λ ls → ∃ λ ps → ∃ λ rs -> ts ≡ ls ++L (ps ⊹ i x) ∷ rs × checks x ts ≡ nothing -- (∃ λ pss -> ts ≡ (pss ⊹s i x) × checks x ts ≡ nothing)
checks-prop x [] = inj₁ ([] , refl , refl)
checks-prop x (t ∷ ts) with check-prop x t | checks-prop x ts
… | inj₁ (t' , t= , check=) | inj₁ (ts' , ts= , checks=)
rewrite t= | check= | ts= | checks=
= inj₁ (t' ∷ ts' , refl , refl)
… | inj₂ (ps , t= , check=) | _
rewrite t= | check=
= inj₂ ([] , ps , ts , refl , refl)
… | _ | inj₂ (ls , ps , rs , ts= , checks=)
rewrite ts= | checks=
= inj₂ (t ∷ ls , ps , rs , refl , lemma (_ <$> check _ t))
where
lemma : ∀ {a b : Set} {y : b} (x : Maybe a) -> maybe (λ _ → y) y x ≡ y
lemma (just x') = refl
lemma nothing = refl
function++ : ∀ {m} {x} {t : Term m} {ls rs : List (Term m)} ps ->
(ps ⊹ (function x (ls ++L t ∷ rs)) ≡ (ps ++L [ step x ls rs ]) ⊹ t)
function++ [] = refl
function++ (step x ls rs ∷ ps) = cong (function x) (cong (λ t → ls ++L t ∷ rs)
(sym $ StepM.fact1 ps (step _ _ _ ∷ []) _))
open import Data.List.Properties using (∷-injective; ∷ʳ-injective)
list-craz : ∀ {a} {A : Set a} {x : A} {xs} → x ∷ xs ≡ [] → ⊥
list-craz ()
listʳ-craz : ∀ {a} {A : Set a} {x : A} {xs} → xs ∷ʳ x ≡ [] → ⊥
listʳ-craz {x = x} {[]} ()
listʳ-craz {x = x} {x₁ ∷ xs} ()
mutual
termSize : ∀ {m} → Term m → ℕ
termSize (i x₁) = 1
termSize (function x₁ x₂) = suc (termsSize x₂)
termsSize : ∀ {m} → List (Term m) → ℕ
termsSize [] = 0
termsSize (x₁ ∷ x₂) = termSize x₁ + termsSize x₂
sizeFact1 : ∀ {m} (ls rs : List (Term m)) → termsSize (ls ++L rs) ≡ termsSize ls + termsSize rs
sizeFact1 [] rs = refl
sizeFact1 (x ∷ ls) rs rewrite sizeFact1 ls rs = auto
sizeFact2a : ∀ {m} (p : Step m) (ps : List (Step m)) (t : Term m)
→ termSize (ps ⊹ t) Data.Nat.≤ termSize ((p ∷ ps) ⊹ t)
sizeFact2a (step x x₁ x₂) ps t rewrite sizeFact1 x₁ (ps ⊹ t ∷ x₂) = auto
≤-trans : ∀ {x y z} → x Data.Nat.≤ y → y Data.Nat.≤ z → x Data.Nat.≤ z
≤-trans z≤n z≤n = auto
≤-trans z≤n (s≤s x₂) = auto
≤-trans (s≤s x₁) (s≤s x₂) = by (≤-trans x₁ x₂)
sizeFact2 : ∀ {m} (ps : List (Step m)) x (t : Term m) (ts : List (Term m))
→ suc (termSize t + termsSize ts) Data.Nat.≤ termSize (ps ⊹ function x (t ∷ ts))
sizeFact2 [] x t ts = auto
sizeFact2 (p ∷ ps) x t ts
with sizeFact2 ps x t ts | sizeFact2a p ps (function x (t ∷ ts))
… | siz1 | siz2 = ≤-trans siz1 siz2 where
open import Data.Nat.Properties
No-Cycle : ∀{m} (t : Term m) ps -> t ≡ ps ⊹ t -> ps ≡ []
No-Cycle _ [] ref = refl
No-Cycle (i x) (step x₁ x₂ x₃ ∷ ps) ()
No-Cycle (function x []) (step x' [] rs ∷ ps) ()
No-Cycle (function x []) (step x' (x₁ ∷ ls) rs ∷ ps) ()
No-Cycle (function x (t ∷ ts)) (step x' [] rs ∷ ps) r
with No-Cycle t (ps ++L step x [] ts ∷ []) $ trans (proj₁ ∘ ∷-injective $ term-function-inj₂ r) (function++ {x = x} {t = t} {ls = []} {rs = ts} ps)
… | dfsd = ⊥-elim (listʳ-craz {x = step x [] ts} {xs = ps} dfsd)
No-Cycle (function x (t ∷ ts)) (step x' ls@(l ∷ ls') rs ∷ ps) r
with (proj₂ ∘ ∷-injective $ term-function-inj₂ r)
… | ts=ls+ps+rs with cong termsSize ts=ls+ps+rs
… | sizs with sizeFact1 ls' (ps ⊹ function x (t ∷ ts) ∷ rs)
… | siz1 rewrite siz1 | sizs with sizeFact2 ps x t ts
… | siz2 with termsSize ts | termSize t | termsSize rs | termsSize ls' | termSize (ps ⊹ function x (t ∷ ts))
… | a | b | c | d | e rewrite sizs = refute siz2 where
module Step2 where
fact : ∀{m} (x : Fin m) p ps -> Nothing (Unifies (i x) ((p ∷ ps) ⊹ i x))
fact x p ps f r with No-Cycle (f x) (f ◃S (p ∷ ps)) (trans r (StepM.fact2 f (i x) (p ∷ ps)))
... | ()
◇-assoc : ∀ {l m n o} (f : l ~> m) (g : n ~> _) (h : o ~> _) ->
(f ◇ (g ◇ h)) ≐ ((f ◇ g) ◇ h)
◇-assoc f g h x = sym (Sub.fact2 f g (h x))
bind-assoc : ∀ {l m n o} (f : l ~> m) (g : n ~> _) (h : o ~> _) t -> (f ◇ g) ◃ (h ◃ t) ≡ (f ◇ (g ◇ h)) ◃ t
bind-assoc f g h t = sym (begin
(f ◇ (g ◇ h)) ◃ t ≡⟨ ◃ext (◇-assoc f g h) t ⟩
((f ◇ g) ◇ h) ◃ t ≡⟨ Sub.fact2 (f ◇ g) h t ⟩
(f ◇ g) ◃ (h ◃ t)
∎)
step-prop : ∀ {m n} (s t : Term (suc m)) (σ : AList m n) r z ->
(Unifies s t [-◇ sub (σ asnoc r / z) ]) ⇔ (Unifies ((r for z) ◃ s) ((r for z) ◃ t) [-◇ sub σ ])
step-prop s t σ r z f = to , from
where
lemma1 : ∀ t -> (f ◇ sub σ) ◃ ((r for z) ◃ t) ≡ (f ◇ (sub σ ◇ (r for z))) ◃ t
lemma1 t = bind-assoc f (sub σ) (r for z) t
to = λ a → begin
(f ◇ sub σ) ◃ ((r for z) ◃ s) ≡⟨ lemma1 s ⟩
(f ◇ (sub σ ◇ (r for z))) ◃ s ≡⟨ a ⟩
(f ◇ (sub σ ◇ (r for z))) ◃ t ≡⟨ sym (lemma1 t) ⟩
(f ◇ sub σ) ◃ ((r for z) ◃ t) ∎
from = λ a → begin
(f ◇ (sub σ ◇ (r for z))) ◃ s ≡⟨ sym (lemma1 s) ⟩
(f ◇ sub σ) ◃ ((r for z) ◃ s) ≡⟨ a ⟩
(f ◇ sub σ) ◃ ((r for z) ◃ t) ≡⟨ lemma1 t ⟩
(f ◇ (sub σ ◇ (r for z))) ◃ t ∎
-- We use a view so that we need to handle fewer cases in the main proof
data Amgu : {m : ℕ} -> (s t : Term m) -> ∃ (AList m) -> Maybe (∃ (AList m)) -> Set where
Flip : ∀ {m s t acc} -> amgu t s acc ≡ amgu s t acc ->
Amgu {m} t s acc (amgu t s acc) -> Amgu s t acc (amgu s t acc)
fn-neq : ∀ {m x y ss ts acc} -> x ≢ y → Amgu {m} (function x ss) (function y ts) acc nothing
leaf-leaf : ∀ {m x acc} -> Amgu {m} (function x []) (function x []) acc (just acc)
leaf-fork : ∀ {m x t ts acc} -> Amgu {m} (function x []) (function x (t ∷ ts)) acc nothing
fork-leaf : ∀ {m x s ss acc} -> Amgu {m} (function x (s ∷ ss)) (function x []) acc nothing
fork-fork : ∀ {m x s ss t ts acc} → Amgu {m} (function x (s ∷ ss)) (function x (t ∷ ts)) acc (amgus ss ts =<< amgu s t acc)
var-var : ∀ {m x y} -> Amgu (i x) (i y) (m , anil) (just (flexFlex x y))
var-t : ∀ {m x t} -> i x ≢ t -> Amgu (i x) t (m , anil) (flexRigid x t)
s-t : ∀{m s t n σ r z} -> Amgu {suc m} s t (n , σ asnoc r / z) ((λ σ -> σ ∃asnoc r / z) <$>
amgu ((r for z) ◃ s) ((r for z) ◃ t) (n , σ))
view : ∀ {m : ℕ} -> (s t : Term m) -> (acc : ∃ (AList m)) -> Amgu s t acc (amgu s t acc)
view (function x ss) (function y ts) acc with x ≟ y
view (function x []) (function .x []) acc | yes refl = leaf-leaf
view (function x []) (function .x (x₁ ∷ ts)) acc | yes refl = leaf-fork
view (function x (x₁ ∷ ss)) (function .x []) acc | yes refl = fork-leaf
view (function x (s ∷ ss)) (function .x (t ∷ ts)) acc | yes refl = fork-fork
… | no neq = fn-neq neq
view (i x) (i x₁) (proj₃ , anil) = var-var
view (i x) (i x₁) (proj₃ , (proj₄ asnoc t' / x₂)) = s-t
view (i x) (function x₁ x₂) (proj₃ , anil) = var-t (λ ())
view (i x) (function x₁ x₂) (proj₃ , (proj₄ asnoc t' / x₃)) = s-t
view (function x x₁) (i x₂) (proj₃ , anil) = Flip refl (var-t (λ ()))
view (function x x₁) (i x₂) (proj₃ , (proj₄ asnoc t' / x₃)) = s-t
amgu-Correctness : {m : ℕ} -> (s t : Term m) -> ∃ (AList m) -> Set
amgu-Correctness s t (l , ρ) =
(∃ λ n → ∃ λ σ → π₁ (Max (Unifies s t [-◇ sub ρ ])) (sub σ) × amgu s t (l , ρ) ≡ just (n , σ ++ ρ ))
⊎ (Nothing ((Unifies s t) [-◇ sub ρ ]) × amgu s t (l , ρ) ≡ nothing)
amgu-Correctness⋆ : {m : ℕ} -> (s t : Term m) -> ∃ (AList m) -> Set
amgu-Correctness⋆ s t (l , ρ) =
(∃ λ n → ∃ λ σ → π₁ (Max (Unifies s t [-◇ sub ρ ])) (sub σ) × amgu s t (l , ρ) ≡ just (n , σ ++ ρ ))
⊎ (Nothing ((Unifies s t) [-◇ sub ρ ]) × amgu s t (l , ρ) ≡ nothing)
amgu-Ccomm : ∀ {m} s t acc -> amgu {m} s t acc ≡ amgu t s acc -> amgu-Correctness s t acc -> amgu-Correctness t s acc
amgu-Ccomm s t (l , ρ) st≡ts = lemma
where
Unst = (Unifies s t) [-◇ sub ρ ]
Unts = (Unifies t s) [-◇ sub ρ ]
Unst⇔Unts : ((Unifies s t) [-◇ sub ρ ]) ⇔ ((Unifies t s) [-◇ sub ρ ])
Unst⇔Unts = Properties.fact5 (Unifies s t) (Unifies t s) (sub ρ) (Properties.fact1 {_} {s} {t})
lemma : amgu-Correctness s t (l , ρ) -> amgu-Correctness t s (l , ρ)
lemma (inj₁ (n , σ , MaxUnst , amgu≡just)) =
inj₁ (n , σ , proj₁ (Max.fact Unst Unts Unst⇔Unts (sub σ)) MaxUnst , trans (sym st≡ts) amgu≡just)
lemma (inj₂ (NoUnst , amgu≡nothing)) =
inj₂ ((λ {_} → Properties.fact2 Unst Unts Unst⇔Unts NoUnst) , trans (sym st≡ts) amgu≡nothing)
amgu-Ccomm⋆ : ∀ {m} s t acc -> amgu {m} s t acc ≡ amgu t s acc -> amgu-Correctness⋆ s t acc -> amgu-Correctness⋆ t s acc
amgu-Ccomm⋆ s t (l , ρ) st≡ts = lemma
where
Unst = (Unifies s t) [-◇ sub ρ ]
Unts = (Unifies t s) [-◇ sub ρ ]
Unst⇔Unts : ((Unifies s t) [-◇ sub ρ ]) ⇔ ((Unifies t s) [-◇ sub ρ ])
Unst⇔Unts = Properties.fact5 (Unifies s t) (Unifies t s) (sub ρ) (Properties.fact1 {_} {s} {t})
lemma : amgu-Correctness s t (l , ρ) -> amgu-Correctness t s (l , ρ)
lemma (inj₁ (n , σ , MaxUnst , amgu≡just)) =
inj₁ (n , σ , proj₁ (Max.fact Unst Unts Unst⇔Unts (sub σ)) MaxUnst , trans (sym st≡ts) amgu≡just)
lemma (inj₂ (NoUnst , amgu≡nothing)) =
inj₂ ((λ {_} → Properties.fact2 Unst Unts Unst⇔Unts NoUnst) , trans (sym st≡ts) amgu≡nothing)
amgu-c⋆ : ∀ {m s t l ρ} -> Amgu s t (l , ρ) (amgu s t (l , ρ)) ->
(∃ λ n → ∃ λ σ → (Max⋆ ((Unifies⋆ s t) [-◇⋆ sub ρ ])) (sub σ) × amgu {m} s t (l , ρ) ≡ just (n , σ ++ ρ ))
⊎ (Nothing⋆ ((Unifies⋆ s t) [-◇⋆ sub ρ ]) × amgu {m} s t (l , ρ) ≡ nothing)
amgu-c⋆ {m} {s} {t} {l} {ρ} amg with amgu s t (l , ρ)
amgu-c⋆ {m} {l = l} {ρ} leaf-leaf | _ = inj₁ (l , anil , (refl , λ f' x → f' , λ x₁ → refl) , cong (just ∘ _,_ l) (sym $ SubList.anil-id-l ρ))
amgu-c⋆ {m} {s} {t} {l} {ρ} (Flip amguts≡amgust amguts) | _ = amgu-Ccomm⋆ t s (l , ρ) amguts≡amgust (amgu-c⋆ amguts)
amgu-c⋆ {m} {l = l} {ρ} (fn-neq x₁) | _ = inj₂ ((λ f x → x₁ (term-function-inj₁ x)) , refl)
amgu-c⋆ {m} {l = l} {ρ} leaf-fork | _ = inj₂ ((λ f x → case term-function-inj₂ x of λ ()) , refl)
amgu-c⋆ {m} {l = l} {ρ} fork-leaf | _ = inj₂ (((λ f x → case term-function-inj₂ x of λ ()) , refl))
amgu-c⋆ {m} {function x1 (s1 ∷ s1s)} {function .x1 (t1 ∷ t1s)} {l = l} {ρ} fork-fork | _
with amgu s1 t1 (l , ρ) | amgu-c⋆ $ view s1 t1 (l , ρ)
… | nothing | inj₂ (nounify , refl) = inj₂ ((λ {n} f x → {!!}) , refl)
{-
where
P = Unifies⋆ (function x1 (s1 ∷ s1s)) (function x1 (t1 ∷ t1s))
Q = (Unifies⋆ s1 t1 ∧⋆ {!Unifies⋆ s2 t2!})
Q⇔P : Q ⇔⋆ P
Q⇔P = switch⋆ P Q (Properties.fact1' {_} {s1} {s2} {t1} {t2})
No[Q◇ρ]→No[P◇ρ] : Nothing⋆ (Q [-◇⋆ sub ρ ]) -> Nothing⋆ (P [-◇⋆ sub ρ ])
No[Q◇ρ]→No[P◇ρ] = Properties.fact2⋆ (Q [-◇⋆ sub ρ ]) (P [-◇⋆ sub ρ ]) (Properties.fact5⋆ Q P (sub ρ) Q⇔P)
No[Q◇ρ] : Nothing⋆ (Q [-◇⋆ sub ρ ])
No[Q◇ρ] = failure-propagation.first⋆ (sub ρ) (Unifies⋆ s1 t1) (Unifies⋆ s2 t2) nounify
-}
… | just x | (inj₁ x₁) = {!!}
… | nothing | inj₁ (_ , _ , _ , ())
… | just x | (inj₂ (_ , ()))
amgu-c⋆ {m} var-var | _ = {!!}
amgu-c⋆ {m} {t = t} (var-t x₁) | _ = {!!}
amgu-c⋆ {s = s} {t} {l} s-t | _ = {!!}
-- amgu-c⋆ {m} {s} {t} {l} {ρ} amg with amgu s t (l , ρ)
-- amgu-c⋆ {l = l} {ρ} leaf-leaf | ._
-- = inj₁ (l , anil , trivial-problem {_} {_} {leaf} {sub ρ} , cong (λ x -> just (l , x)) (sym (SubList.anil-id-l ρ)) )
-- amgu-c⋆ leaf-fork | .nothing = inj₂ ((λ _ () ) , refl)
-- amgu-c⋆ {m} {s1 fork s2} {t1 fork t2} {l} {ρ} fork-fork | ._
-- with amgu s1 t1 (l , ρ) | amgu-c⋆ $ view s1 t1 (l , ρ)
-- ... | .nothing | inj₂ (nounify , refl) = inj₂ ((λ {_} -> No[Q◇ρ]→No[P◇ρ] No[Q◇ρ]) , refl)
-- where
-- P = Unifies⋆ (s1 fork s2) (t1 fork t2)
-- Q = (Unifies⋆ s1 t1 ∧⋆ Unifies⋆ s2 t2)
-- Q⇔P : Q ⇔⋆ P
-- Q⇔P = switch⋆ P Q (Properties.fact1' {_} {s1} {s2} {t1} {t2})
-- No[Q◇ρ]→No[P◇ρ] : Nothing⋆ (Q [-◇⋆ sub ρ ]) -> Nothing⋆ (P [-◇⋆ sub ρ ])
-- No[Q◇ρ]→No[P◇ρ] = Properties.fact2⋆ (Q [-◇⋆ sub ρ ]) (P [-◇⋆ sub ρ ]) (Properties.fact5⋆ Q P (sub ρ) Q⇔P)
-- No[Q◇ρ] : Nothing⋆ (Q [-◇⋆ sub ρ ])
-- No[Q◇ρ] = failure-propagation.first⋆ (sub ρ) (Unifies⋆ s1 t1) (Unifies⋆ s2 t2) nounify
-- ... | .(just (n , σ ++ ρ)) | inj₁ (n , σ , a , refl)
-- with amgu s2 t2 (n , σ ++ ρ) | amgu-c⋆ (view s2 t2 (n , (σ ++ ρ)))
-- ... | .nothing | inj₂ (nounify , refl) = inj₂ ( (λ {_} -> No[Q◇ρ]→No[P◇ρ]⋆ No[Q◇ρ]⋆) , refl)
-- where
-- P⋆ = Unifies⋆ (s1 fork s2) (t1 fork t2)
-- Q⋆ = (Unifies⋆ s1 t1 ∧⋆ Unifies⋆ s2 t2)
-- Q⇔P⋆ : Q⋆ ⇔⋆ P⋆
-- Q⇔P⋆ = switch⋆ P⋆ Q⋆ (Properties.fact1'⋆ {_} {s1} {s2} {t1} {t2})
-- No[Q◇ρ]→No[P◇ρ]⋆ : Nothing⋆ (Q⋆ [-◇⋆ sub ρ ]) -> Nothing⋆ (P⋆ [-◇⋆ sub ρ ])
-- No[Q◇ρ]→No[P◇ρ]⋆ = Properties.fact2⋆ (Q⋆ [-◇⋆ sub ρ ]) (P⋆ [-◇⋆ sub ρ ]) (Properties.fact5⋆ Q⋆ P⋆ (sub ρ) Q⇔P⋆)
-- No[Q◇ρ]⋆ : Nothing⋆ (Q⋆ [-◇⋆ sub ρ ])
-- No[Q◇ρ]⋆ = failure-propagation.second⋆ (sub ρ) (sub σ) (Unifies⋆ s1 t1) (Unifies s2 t2) a
-- (λ f → nounify f ∘ π₂ (Unifies s2 t2) (cong (f ◃) ∘ sym ∘ SubList.fact1 σ ρ))
-- {-
-- No[Q◇ρ]⋆ = failure-propagation.second (sub ρ) (sub σ) (Unifies s1 t1) (Unifies s2 t2) a
-- -- (λ f Unifs2t2-f◇σ◇ρ → nounify f ((π₂ (Unifies s2 t2) (λ t → cong (f ◃) (sym (SubList.fact1 σ ρ t))) Unifs2t2-f◇σ◇ρ)))
-- -- (λ f → nounify f ∘ π₂ (Unifies s2 t2) (λ t → cong (f ◃) (sym (SubList.fact1 σ ρ t))))
-- (λ f → nounify f ∘ π₂ (Unifies s2 t2) (cong (f ◃) ∘ sym ∘ SubList.fact1 σ ρ))
-- -}
-- P = Unifies (s1 fork s2) (t1 fork t2)
-- Q = (Unifies s1 t1 ∧ Unifies s2 t2)
-- Q⇔P : Q ⇔ P
-- Q⇔P = switch P Q (Properties.fact1' {_} {s1} {s2} {t1} {t2})
-- No[Q◇ρ]→No[P◇ρ] : Nothing (Q [-◇ sub ρ ]) -> Nothing (P [-◇ sub ρ ])
-- No[Q◇ρ]→No[P◇ρ] = Properties.fact2 (Q [-◇ sub ρ ]) (P [-◇ sub ρ ]) (Properties.fact5 Q P (sub ρ) Q⇔P)
-- No[Q◇ρ] : Nothing (Q [-◇ sub ρ ])
-- No[Q◇ρ] = failure-propagation.second (sub ρ) (sub σ) (Unifies s1 t1) (Unifies s2 t2) a
-- (λ f Unifs2t2-f◇σ◇ρ → nounify f (π₂ (Unifies s2 t2) (λ t → cong (f ◃) (sym (SubList.fact1 σ ρ t))) Unifs2t2-f◇σ◇ρ))
-- ... | .(just (n1 , σ1 ++ (σ ++ ρ))) | inj₁ (n1 , σ1 , b , refl)
-- = inj₁ (n1 , σ1 ++ σ , Max[P∧Q◇ρ][σ1++σ] , cong (λ σ -> just (n1 , σ)) (++-assoc σ1 σ ρ))
-- where
-- P = Unifies s1 t1
-- Q = Unifies s2 t2
-- P∧Q = P ∧ Q
-- C = Unifies (s1 fork s2) (t1 fork t2)
-- Max[C◇ρ]⇔Max[P∧Q◇ρ] : Max (C [-◇ sub ρ ]) ⇔ Max (P∧Q [-◇ sub ρ ])
-- Max[C◇ρ]⇔Max[P∧Q◇ρ] = Max.fact (C [-◇ sub ρ ]) (P∧Q [-◇ sub ρ ]) (Properties.fact5 C P∧Q (sub ρ)
-- (Properties.fact1' {_} {s1} {s2} {t1} {t2}))
-- Max[Q◇σ++ρ]⇔Max[Q◇σ◇ρ] : Max (Q [-◇ sub (σ ++ ρ)]) ⇔ Max (Q [-◇ sub σ ◇ sub ρ ])
-- Max[Q◇σ++ρ]⇔Max[Q◇σ◇ρ] = Max.fact (Q [-◇ sub (σ ++ ρ)]) (Q [-◇ sub σ ◇ sub ρ ]) (Properties.fact6 Q (SubList.fact1 σ ρ))
-- Max[P∧Q◇ρ][σ1++σ] : π₁ (Max (C [-◇ sub ρ ])) (sub (σ1 ++ σ))
-- Max[P∧Q◇ρ][σ1++σ] = π₂ (Max (C [-◇ sub ρ ])) (≐-sym (SubList.fact1 σ1 σ))
-- (proj₂ (Max[C◇ρ]⇔Max[P∧Q◇ρ] (sub σ1 ◇ sub σ))
-- (optimist (sub ρ) (sub σ) (sub σ1) P Q (DClosed.fact1 s1 t1) a (proj₁ (Max[Q◇σ++ρ]⇔Max[Q◇σ◇ρ] (sub σ1)) b)))
-- amgu-c⋆ {suc l} {i x} {i y} (var-var) | .(just (flexFlex x y))
-- with thick x y | Thick.fact1 x y (thick x y) refl
-- ... | .(just y') | inj₂ (y' , thinxy'≡y , refl )
-- = inj₁ (l , anil asnoc i y' / x , var-elim-i-≡ x (i y) (sym (cong i thinxy'≡y)) , refl )
-- ... | .nothing | inj₁ ( x≡y , refl ) rewrite sym x≡y
-- = inj₁ (suc l , anil , trivial-problem {_} {_} {i x} {sub anil} , refl)
-- amgu-c⋆ {suc l} {i x} {t} (var-t ix≢t) | .(flexRigid x t)
-- with check x t | check-prop x t
-- ... | .nothing | inj₂ ( ps , r , refl) = inj₂ ( (λ {_} -> No-Unifier ) , refl)
-- where
-- No-Unifier : {n : ℕ} (f : Fin (suc l) → Term n) → f x ≡ f ◃ t → ⊥
-- No-Unifier f fx≡f◃t = ix≢t (sym (trans r (cong (λ ps -> ps ⊹ i x) ps≡[])))
-- where
-- ps≡[] : ps ≡ []
-- ps≡[] = map-[] f ps (No-Cycle (f x) ((f ◃S) ps)
-- (begin f x ≡⟨ fx≡f◃t ⟩
-- f ◃ t ≡⟨ cong (f ◃) r ⟩
-- f ◃ (ps ⊹ i x) ≡⟨ StepM.fact2 f (i x) ps ⟩
-- (f ◃S) ps ⊹ f x ∎))
-- ... | .(just t') | inj₁ (t' , r , refl) = inj₁ ( l , anil asnoc t' / x , var-elim-i-≡ x t r , refl )
-- amgu-c⋆ {suc m} {s} {t} {l} {ρ asnoc r / z} s-t
-- | .((λ x' → x' ∃asnoc r / z) <$>
-- (amgu ((r for z) ◃ s) ((r for z) ◃ t) (l , ρ)))
-- with amgu-c⋆ (view ((r for z) ◃ s) ((r for z) ◃ t) (l , ρ))
-- ... | inj₂ (nounify , ra) = inj₂ ( (λ {_} -> NoQ→NoP nounify) , cong (_<$>_ (λ x' → x' ∃asnoc r / z)) ra )
-- where
-- P = Unifies s t [-◇ sub (ρ asnoc r / z) ]
-- Q = Unifies ((r for z) ◃ s) ((r for z) ◃ t) [-◇ sub ρ ]
-- NoQ→NoP : Nothing Q → Nothing P
-- NoQ→NoP = Properties.fact2 Q P (switch P Q (step-prop s t ρ r z))
-- ... | inj₁ (n , σ , a , ra) = inj₁ (n , σ , proj₂ (MaxP⇔MaxQ (sub σ)) a , cong (_<$>_ (λ x' → x' ∃asnoc r / z)) ra)
-- where
-- P = Unifies s t [-◇ sub (ρ asnoc r / z) ]
-- Q = Unifies ((r for z) ◃ s) ((r for z) ◃ t) [-◇ sub ρ ]
-- MaxP⇔MaxQ : Max P ⇔ Max Q
-- MaxP⇔MaxQ = Max.fact P Q (step-prop s t ρ r z)
-- amgu-c⋆ {m} {s} {t} {l} {ρ} (Flip amguts≡amgust amguts) | ._ = amgu-Ccomm⋆ t s (l , ρ) amguts≡amgust (amgu-c⋆ amguts)
-- amgu-c⋆ {zero} {i ()} _ | _
mgu-c⋆ : ∀ {m} (s t : Term m) ->
(∃ λ n → ∃ λ σ → (Max⋆ (Unifies⋆ s t)) (sub σ) × mgu s t ≡ just (n , σ))
⊎ (Nothing⋆ (Unifies⋆ s t) × mgu s t ≡ nothing)
mgu-c⋆ {m} s t = amgu-c⋆ (view s t (m , anil))
| {
"alphanum_fraction": 0.460938415,
"avg_line_length": 41.8109696376,
"ext": "agda",
"hexsha": "b31f3bfa821a2e72c8c35b5fe7ffe7d64c5d3ef4",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_forks_repo_licenses": [
"RSA-MD"
],
"max_forks_repo_name": "m0davis/oscar",
"max_forks_repo_path": "archive/agda-1/Unify-monolithic-EnhancedTerm.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_issues_repo_issues_event_max_datetime": "2019-05-11T23:33:04.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-04-29T00:35:04.000Z",
"max_issues_repo_licenses": [
"RSA-MD"
],
"max_issues_repo_name": "m0davis/oscar",
"max_issues_repo_path": "archive/agda-1/Unify-monolithic-EnhancedTerm.agda",
"max_line_length": 157,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_stars_repo_licenses": [
"RSA-MD"
],
"max_stars_repo_name": "m0davis/oscar",
"max_stars_repo_path": "archive/agda-1/Unify-monolithic-EnhancedTerm.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 19355,
"size": 42689
} |
------------------------------------------------------------------------------
-- The Collatz function: A function without a termination proof
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module FOT.FOTC.Program.Collatz.CollatzConditionals where
open import FOTC.Base
open import FOTC.Data.Nat
open import FOTC.Data.Nat.UnaryNumbers
open import FOTC.Program.Collatz.Data.Nat
------------------------------------------------------------------------------
-- The Collatz function.
postulate
collatz : D → D
collatz-eq : ∀ n → collatz n ≡
(if (iszero₁ n)
then 1'
else (if (iszero₁ (pred₁ n))
then 1'
else (if (even n)
then collatz (div n 2')
else collatz (3' * n + 1'))))
{-# ATP axiom collatz-eq #-}
| {
"alphanum_fraction": 0.390070922,
"avg_line_length": 37.6,
"ext": "agda",
"hexsha": "70aeb1fd3d156f9b069618f73d938bfc933a4e15",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z",
"max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/fotc",
"max_forks_repo_path": "notes/FOT/FOTC/Program/Collatz/CollatzConditionals.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/fotc",
"max_issues_repo_path": "notes/FOT/FOTC/Program/Collatz/CollatzConditionals.agda",
"max_line_length": 78,
"max_stars_count": 11,
"max_stars_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/fotc",
"max_stars_repo_path": "notes/FOT/FOTC/Program/Collatz/CollatzConditionals.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-12T16:09:54.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:53:42.000Z",
"num_tokens": 214,
"size": 1128
} |
module STLC.Kovacs.Completeness where
open import STLC.Kovacs.Normalisation public
open import STLC.Kovacs.Convertibility public
--------------------------------------------------------------------------------
-- (_≈_)
infix 3 _≫_
_≫_ : ∀ {A Γ} → Γ ⊢ A → Γ ⊩ A → Set
_≫_ {⎵} {Γ} M N = M ∼ embⁿᶠ N
_≫_ {A ⇒ B} {Γ} M f = ∀ {Γ′} → (η : Γ′ ⊇ Γ) {N : Γ′ ⊢ A} {a : Γ′ ⊩ A}
(p : N ≫ a)
→ ren η M ∙ N ≫ f η a
-- (_≈ᶜ_)
infix 3 _≫⋆_
data _≫⋆_ : ∀ {Γ Ξ} → Γ ⊢⋆ Ξ → Γ ⊩⋆ Ξ → Set
where
∅ : ∀ {Γ} → ∅ {Γ = Γ} ≫⋆ ∅
_,_ : ∀ {Γ Ξ A} → {σ : Γ ⊢⋆ Ξ} {ρ : Γ ⊩⋆ Ξ} {M : Γ ⊢ A} {a : Γ ⊩ A}
→ (χ : σ ≫⋆ ρ) (p : M ≫ a)
→ σ , M ≫⋆ ρ , a
--------------------------------------------------------------------------------
-- (_∼◾≈_)
coe≫ : ∀ {A Γ} → {M₁ M₂ : Γ ⊢ A} {a : Γ ⊩ A}
→ M₁ ∼ M₂ → M₁ ≫ a
→ M₂ ≫ a
coe≫ {⎵} p q = p ⁻¹ ⦙ q
coe≫ {A ⇒ B} p f = λ η q →
coe≫ (ren∼ η p ∙∼ refl∼)
(f η q)
--------------------------------------------------------------------------------
-- (≈ₑ)
acc≫ : ∀ {A Γ Γ′} → (η : Γ′ ⊇ Γ)
→ {M : Γ ⊢ A} {a : Γ ⊩ A}
→ M ≫ a
→ ren η M ≫ acc η a
acc≫ {⎵} η {M} {N} p = coe ((λ N′ → ren η M ∼ N′) & (natembⁿᶠ η N ⁻¹))
(ren∼ η p)
acc≫ {A ⇒ B} η {M} {f} g η′
rewrite ren○ η′ η M ⁻¹
= g (η ○ η′)
-- (≈ᶜₑ)
-- NOTE: _⬖≫_ = ∂acc≫⋆
_⬖≫_ : ∀ {Γ Γ′ Ξ} → {σ : Γ ⊢⋆ Ξ} {ρ : Γ ⊩⋆ Ξ}
→ (χ : σ ≫⋆ ρ) (η : Γ′ ⊇ Γ)
→ σ ◐ η ≫⋆ ρ ⬖ η
∅ ⬖≫ η = ∅
(χ , p) ⬖≫ η = χ ⬖≫ η , acc≫ η p
--------------------------------------------------------------------------------
-- (∈≈)
get≫ : ∀ {Γ Ξ A} → {σ : Γ ⊢⋆ Ξ} {ρ : Γ ⊩⋆ Ξ}
→ σ ≫⋆ ρ → (i : Ξ ∋ A)
→ getₛ σ i ≫ getᵥ ρ i
get≫ (χ , p) zero = p
get≫ (χ , p) (suc i) = get≫ χ i
-- (Tm≈)
eval≫ : ∀ {Γ Ξ A} → {σ : Γ ⊢⋆ Ξ} {ρ : Γ ⊩⋆ Ξ}
→ σ ≫⋆ ρ → (M : Ξ ⊢ A)
→ sub σ M ≫ eval ρ M
eval≫ χ (𝓋 i)
= get≫ χ i
eval≫ {σ = σ} χ (ƛ M) η {N} q
= coe≫ (coe (((ƛ (ren (liftₑ η) (sub (liftₛ σ) M)) ∙ N) ∼_)
& ( sub◑ (idₛ , N) (liftₑ η) (sub (liftₛ σ) M) ⁻¹
⦙ sub● (liftₑ η ◑ (idₛ , N)) (liftₛ σ) M ⁻¹
⦙ (λ σ′ → sub (σ′ , N) M)
& ( comp●◑ (η ◑ idₛ , N) (wkₑ idₑ) σ
⦙ (σ ●_) & lid◑ (η ◑ idₛ)
⦙ comp●◑ idₛ η σ ⁻¹
⦙ rid● (σ ◐ η)
)
))
(red⇒ (ren (liftₑ η) (sub (liftₛ σ) M)) N) ⁻¹)
(eval≫ (χ ⬖≫ η , q) M)
eval≫ {σ = σ} χ (M ∙ N)
rewrite idren (sub σ M) ⁻¹
= eval≫ χ M idₑ (eval≫ χ N)
--------------------------------------------------------------------------------
mutual
-- (q≈)
reify≫ : ∀ {A Γ} → {M : Γ ⊢ A} {a : Γ ⊩ A}
→ (p : M ≫ a)
→ M ∼ embⁿᶠ (reify a)
reify≫ {⎵} {M = M} p = p
reify≫ {A ⇒ B} {M = M} f = exp⇒ M
⦙ ƛ∼ (reify≫ (f (wkₑ idₑ) (reflect≫ 0)))
-- (u≈)
reflect≫ : ∀ {A Γ} → (M : Γ ⊢ⁿᵉ A)
→ embⁿᵉ M ≫ reflect M
reflect≫ {⎵} M = refl∼
reflect≫ {A ⇒ B} M η {N} {a} p
rewrite natembⁿᵉ η M ⁻¹
= coe≫ (refl∼ ∙∼ reify≫ p ⁻¹)
(reflect≫ (renⁿᵉ η M ∙ reify a))
-- (uᶜ≈)
id≫⋆ : ∀ {Γ} → idₛ {Γ} ≫⋆ idᵥ
id≫⋆ {∅} = ∅
id≫⋆ {Γ , A} = id≫⋆ ⬖≫ wkₑ idₑ , reflect≫ 0
complete : ∀ {Γ A} → (M : Γ ⊢ A)
→ M ∼ embⁿᶠ (nf M)
complete M = coe ((_∼ embⁿᶠ (reify (eval idᵥ M))) & idsub M)
(reify≫ (eval≫ id≫⋆ M))
--------------------------------------------------------------------------------
| {
"alphanum_fraction": 0.2620087336,
"avg_line_length": 27.4154929577,
"ext": "agda",
"hexsha": "9bd8b56a10f14863dec9d4ca99087118ad008866",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "bd626509948fbf8503ec2e31c1852e1ac6edcc79",
"max_forks_repo_licenses": [
"X11"
],
"max_forks_repo_name": "mietek/coquand-kovacs",
"max_forks_repo_path": "src/STLC/Kovacs/Completeness.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "bd626509948fbf8503ec2e31c1852e1ac6edcc79",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"X11"
],
"max_issues_repo_name": "mietek/coquand-kovacs",
"max_issues_repo_path": "src/STLC/Kovacs/Completeness.agda",
"max_line_length": 80,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "bd626509948fbf8503ec2e31c1852e1ac6edcc79",
"max_stars_repo_licenses": [
"X11"
],
"max_stars_repo_name": "mietek/coquand-kovacs",
"max_stars_repo_path": "src/STLC/Kovacs/Completeness.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1802,
"size": 3893
} |
------------------------------------------------------------------------
-- Upper bounds of colists containing natural numbers
------------------------------------------------------------------------
module Upper-bounds where
open import Equality.Propositional
open import Logical-equivalence using (_⇔_)
open import Prelude
open import Prelude.Size
open import Colist equality-with-J as Colist
open import Conat equality-with-J as Conat
hiding (pred) renaming (_+_ to _⊕_; _∸_ to _⊖_)
open import Equality.Decision-procedures equality-with-J
open import Function-universe equality-with-J as F hiding (id; _∘_)
open import Nat equality-with-J as Nat using (_≤_; _<_; pred)
open import Omniscience equality-with-J
------------------------------------------------------------------------
-- Upper bounds
-- [ ∞ ] ms ⊑ n means that n is an upper bound of every number in ms.
infix 4 [_]_⊑_ [_]_⊑′_
[_]_⊑_ : Size → Colist ℕ ∞ → Conat ∞ → Type
[ i ] ms ⊑ n = □ i (λ m → [ ∞ ] ⌜ m ⌝ ≤ n) ms
[_]_⊑′_ : Size → Colist ℕ ∞ → Conat ∞ → Type
[ i ] ms ⊑′ n = □′ i (λ m → [ ∞ ] ⌜ m ⌝ ≤ n) ms
-- The conatural number infinity is always an upper bound.
infix 4 _⊑infinity
_⊑infinity : ∀ {i} ns → [ i ] ns ⊑ infinity
_⊑infinity = □-replicate (_≤infinity ∘ ⌜_⌝)
-- A form of transitivity.
transitive-⊑≤ :
∀ {i ms n o} → [ i ] ms ⊑ n → [ ∞ ] n ≤ o → [ i ] ms ⊑ o
transitive-⊑≤ p q = □-map (flip transitive-≤ q) p
-- Another form of transitivity.
transitive-◇≤⊑ :
∀ {m ns o i} → ◇ i (m ≤_) ns → [ i ] ns ⊑ o → [ i ] ⌜ m ⌝ ≤ o
transitive-◇≤⊑ {m} {ns} {o} {i} = curry (
◇ i (m ≤_) ns × [ i ] ns ⊑ o ↝⟨ Σ-map id swap ∘ uncurry □◇-witness ∘ swap ⟩
(∃ λ n → m ≤ n × [ i ] ⌜ n ⌝ ≤ o) ↝⟨ (λ { (_ , m≤n , n≤o) → transitive-≤ (⌜⌝-mono m≤n) n≤o }) ⟩□
[ i ] ⌜ m ⌝ ≤ o □)
-- If m is an upper bound of ms, and no natural number is an upper
-- bound, then m is bisimilar to infinity.
no-finite→infinite :
∀ {m ms} →
(∀ n → ¬ [ ∞ ] ms ⊑ ⌜ n ⌝) →
[ ∞ ] ms ⊑ m →
Conat.[ ∞ ] m ∼ infinity
no-finite→infinite {m} {ms} no-finite =
[ ∞ ] ms ⊑ m ↝⟨ (λ ms⊑n → uncurry λ n →
Conat.[ ∞ ] m ∼ ⌜ n ⌝ ↝⟨ ∼→≤ ⟩
[ ∞ ] m ≤ ⌜ n ⌝ ↝⟨ transitive-⊑≤ ms⊑n ⟩
[ ∞ ] ms ⊑ ⌜ n ⌝ ↝⟨ no-finite n ⟩□
⊥ □) ⟩
Infinite m ↝⟨ Infinite→∼infinity ⟩□
Conat.[ ∞ ] m ∼ infinity □
-- No natural number is an upper bound of nats.
nats⋢ : ∀ n → ¬ [ ∞ ] nats ⊑ ⌜ n ⌝
nats⋢ zero =
[ ∞ ] nats ⊑ ⌜ 0 ⌝ ↝⟨ □-head ∘ □-tail ⟩
Conat.[ ∞ ] ⌜ 1 ⌝ ≤ ⌜ 0 ⌝ ↝⟨ ≮0 ⟩□
⊥ □
nats⋢ (suc n) =
[ ∞ ] nats ⊑ ⌜ suc n ⌝ ↝⟨ □-tail ⟩
[ ∞ ] map suc nats ⊑ ⌜ suc n ⌝ ↝⟨ □-map′ (⌜⌝-mono ∘ Nat.suc≤suc⁻¹ ∘ ⌜⌝-mono⁻¹) ⟩
[ ∞ ] map id nats ⊑ ⌜ id n ⌝ ↝⟨ □-∼ (map-id _) ⟩
[ ∞ ] nats ⊑ ⌜ n ⌝ ↝⟨ nats⋢ n ⟩□
⊥ □
-- The number ⌜ n ⌝ is an upper bound of replicate m n.
replicate⊑ : ∀ {i} m {n} → [ i ] replicate m n ⊑ ⌜ n ⌝
replicate⊑ {i} zero {n} = []
replicate⊑ {i} (suc m) {n} = $⟨ (λ { _ refl → reflexive-≤ _ }) ⟩
(∀ o → o ≡ n → [ ∞ ] ⌜ o ⌝ ≤ ⌜ n ⌝) ↝⟨ (λ hyp _ → hyp _ ∘ _⇔_.to ◇-replicate-suc⇔) ⟩
(∀ o → ◇ i (o ≡_) (replicate (suc m) n) → [ ∞ ] ⌜ o ⌝ ≤ ⌜ n ⌝) ↔⟨⟩
(∀ o → [ i ] o ∈ replicate (suc m) n → [ ∞ ] ⌜ o ⌝ ≤ ⌜ n ⌝) ↝⟨ _⇔_.from □⇔∈→ ⟩
□ i (λ o → [ ∞ ] ⌜ o ⌝ ≤ ⌜ n ⌝) (replicate (suc m) n) ↝⟨ id ⟩□
[ i ] replicate (suc m) n ⊑ ⌜ n ⌝ □
------------------------------------------------------------------------
-- Least upper bounds
-- The least upper bound of a colist of natural numbers.
LUB : Colist ℕ ∞ → Conat ∞ → Type
LUB ns n =
[ ∞ ] ns ⊑ n
×
(∀ n′ → [ ∞ ] ns ⊑ n′ → [ ∞ ] n ≤ n′)
-- Least upper bounds are unique.
lub-unique :
∀ {ns n₁ n₂ i} →
LUB ns n₁ → LUB ns n₂ → Conat.[ i ] n₁ ∼ n₂
lub-unique (lub₁₁ , lub₁₂) (lub₂₁ , lub₂₂) =
antisymmetric-≤ (lub₁₂ _ lub₂₁) (lub₂₂ _ lub₁₁)
-- LUB respects bisimilarity.
LUB-∼ :
∀ {ms ns m n} →
Colist.[ ∞ ] ms ∼ ns → Conat.[ ∞ ] m ∼ n →
LUB ms m → LUB ns n
LUB-∼ {ms} {ns} {m} {n} p q = Σ-map
([ ∞ ] ms ⊑ m ↝⟨ □-∼ p ⟩
[ ∞ ] ns ⊑ m ↝⟨ □-map (flip transitive-≤ (∼→≤ q)) ⟩□
[ ∞ ] ns ⊑ n □)
(λ hyp n′ →
[ ∞ ] ns ⊑ n′ ↝⟨ □-∼ (Colist.symmetric-∼ p) ⟩
[ ∞ ] ms ⊑ n′ ↝⟨ hyp n′ ⟩
[ ∞ ] m ≤ n′ ↝⟨ transitive-≤ (∼→≤ (Conat.symmetric-∼ q)) ⟩□
[ ∞ ] n ≤ n′ □)
-- The least upper bound of the empty colist is 0.
lub-[] : LUB [] ⌜ 0 ⌝
lub-[] = [] , λ _ _ → zero
-- Some lemmas that can be used to establish the least upper bound of
-- a non-empty colist.
lub-∷ˡ :
∀ {m ms n} →
[ ∞ ] n ≤ ⌜ m ⌝ →
LUB (ms .force) n →
LUB (m ∷ ms) ⌜ m ⌝
lub-∷ˡ {m} {ms} {n} n≤m = Σ-map
([ ∞ ] ms .force ⊑ n ↝⟨ (λ hyp → reflexive-≤ _ ∷ λ { .force → □-map (flip transitive-≤ n≤m) hyp }) ⟩□
[ ∞ ] m ∷ ms ⊑ ⌜ m ⌝ □)
((∀ n′ → [ ∞ ] ms .force ⊑ n′ → [ ∞ ] n ≤ n′) ↝⟨ (λ _ _ → □-head) ⟩□
(∀ n′ → [ ∞ ] m ∷ ms ⊑ n′ → [ ∞ ] ⌜ m ⌝ ≤ n′) □)
lub-∷ʳ :
∀ {m ms n} →
[ ∞ ] ⌜ m ⌝ ≤ n →
LUB (ms .force) n →
LUB (m ∷ ms) n
lub-∷ʳ {m} {ms} {n} m≤n = Σ-map
([ ∞ ] ms .force ⊑ n ↝⟨ (λ hyp → m≤n ∷ λ { .force → hyp }) ⟩□
[ ∞ ] m ∷ ms ⊑ n □)
((∀ n′ → [ ∞ ] ms .force ⊑ n′ → [ ∞ ] n ≤ n′) ↝⟨ (λ hyp n′ → hyp n′ ∘ □-tail) ⟩□
(∀ n′ → [ ∞ ] m ∷ ms ⊑ n′ → [ ∞ ] n ≤ n′) □)
-- If m ∷ ms has a least upper bound, then cycle m ms has the same
-- least upper bound.
lub-cycle :
∀ {m ms n} →
LUB (m ∷ ms) n →
LUB (cycle m ms) n
lub-cycle {m} {ms} {n} = Σ-map
([ ∞ ] m ∷ ms ⊑ n ↝⟨ _⇔_.from □-cycle⇔ ⟩□
[ ∞ ] cycle m ms ⊑ n □)
((∀ n′ → [ ∞ ] m ∷ ms ⊑ n′ → [ ∞ ] n ≤ n′) ↝⟨ (∀-cong _ λ _ → →-cong-→ (_⇔_.to □-cycle⇔) id) ⟩□
(∀ n′ → [ ∞ ] cycle m ms ⊑ n′ → [ ∞ ] n ≤ n′) □)
-- The least upper bound of nats is infinity.
lub-nats-infinity : LUB nats Conat.infinity
lub-nats-infinity =
(nats ⊑infinity)
, λ n →
[ ∞ ] nats ⊑ n ↝⟨ flip no-finite→infinite ⟩
((∀ n → ¬ [ ∞ ] nats ⊑ ⌜ n ⌝) → Conat.[ ∞ ] n ∼ infinity) ↝⟨ _$ nats⋢ ⟩
Conat.[ ∞ ] n ∼ infinity ↝⟨ Conat.symmetric-∼ ⟩
Conat.[ ∞ ] infinity ∼ n ↝⟨ ∼→≤ ⟩□
[ ∞ ] infinity ≤ n □
-- If WLPO holds, then the least upper bound of a colist of natural
-- numbers can be determined.
--
-- (In fact, WLPO is logically equivalent to the codomain of this
-- lemma, see Unbounded-space.wlpo⇔lub.)
--
-- I received help with this proof from Andreas Abel and Ulf Norell: I
-- had presented a proof that used LPO. Andreas Abel came up with the
-- idea for the following, less complicated proof, and Ulf Norell
-- suggested that one could get away with WLPO instead of LPO.
wlpo→lub : WLPO → (∀ ms → ∃ λ n → LUB ms n)
wlpo→lub wlpo = λ ms → lub ms , □ˢ∞→□∞ (upper-bound ms) , least ms
where
-- The boolean >0 ms n is true if the n-th number (counting from
-- zero) of ms is positive.
>0 : Colist ℕ ∞ → ℕ → Bool
>0 [] _ = false
>0 (m ∷ ms) (suc n) = >0 (ms .force) n
>0 (zero ∷ ms) zero = false
>0 (suc m ∷ ms) zero = true
-- The number lub ms is the least upper bound of ms.
lub : ∀ {i} → Colist ℕ ∞ → Conat i
lub ms with wlpo (>0 ms)
... | inj₁ _ = zero
... | inj₂ _ = suc λ { .force → lub (map pred ms) }
-- Zero is an upper bound of ms iff >0 ms is universally false.
⊑0⇔≡false : ∀ ms → [ ∞ ] ms ⊑ zero ⇔ (∀ n → >0 ms n ≡ false)
⊑0⇔≡false = λ ms → record { to = to ms; from = from ms }
where
to : ∀ ms → [ ∞ ] ms ⊑ zero → (∀ n → >0 ms n ≡ false)
to _ [] _ = refl
to (zero ∷ ms) _ zero = refl
to (suc _ ∷ _) (() ∷ _) _
to (m ∷ ms) (_ ∷ ms⊑0) (suc n) = to (ms .force) (ms⊑0 .force) n
from : ∀ {i} ms → (∀ n → >0 ms n ≡ false) → [ i ] ms ⊑ zero
from [] _ = []
from (suc m ∷ ms) ≡false = ⊥-elim (Bool.true≢false (≡false zero))
from (zero ∷ ms) ≡false =
zero ∷ λ { .force → from (ms .force) (≡false ∘ suc) }
-- If n .force is an upper bound of map pred ms, then suc n is an
-- upper bound of ms. Note that the lemma is size-preserving and
-- takes □ˢ′ to □ˢ.
pred-lemma₁ :
∀ {i n} ms →
□ˢ′ i (λ i m → [ i ] ⌜ m ⌝ ≤ n .force) (map pred ms) →
□ˢ i (λ i m → [ i ] ⌜ m ⌝ ≤ suc n) ms
pred-lemma₁ [] hyp = []
pred-lemma₁ (m ∷ ms) hyp =
helper m hyp
∷ λ { .force →
pred-lemma₁ (ms .force) λ { .force → □ˢ-tail (hyp .force) }}
where
helper :
∀ {i n} m →
□ˢ′ i (λ i m → [ i ] ⌜ m ⌝ ≤ n .force) (map pred (m ∷ ms)) →
[ i ] ⌜ m ⌝ ≤ suc n
helper zero hyp = zero
helper (suc m) hyp = suc λ { .force → □ˢ-head (hyp .force) }
-- If suc n is an upper bound of ms, then n .force is an upper bound
-- of map pred ms.
pred-lemma₂ :
∀ {n ms i} →
[ i ] ms ⊑ suc n →
[ i ] map pred ms ⊑ n .force
pred-lemma₂ [] = []
pred-lemma₂ {n} (_∷_ {x = m} m≤1+n ms⊑1+n) =
(⌜ pred m ⌝ ∼⟨ ⌜⌝-pred m ⟩≤
Conat.pred ⌜ m ⌝ ≤⟨ pred-mono m≤1+n ⟩∎
n .force ∎≤)
∷ λ { .force →
pred-lemma₂ (ms⊑1+n .force) }
-- The number lub ms is an upper bound of ms.
upper-bound : ∀ {i} ms → □ˢ i (λ i m → [ i ] ⌜ m ⌝ ≤ lub ms) ms
upper-bound {i} ms with wlpo (>0 ms)
... | inj₂ _ =
pred-lemma₁ _ (λ { .force → upper-bound (map pred ms) })
... | inj₁ ≡false = $⟨ ≡false ⟩
(∀ n → >0 ms n ≡ false) ↝⟨ _⇔_.from (⊑0⇔≡false ms) ⟩
[ ∞ ] ms ⊑ zero ↝⟨ id ⟩
[ i ] ms ⊑ zero ↝⟨ _⇔_.from □ˢ⇔□ ⟩
□ˢ i (λ _ m → [ ∞ ] ⌜ m ⌝ ≤ zero) ms ↝⟨ id ⟩□
□ˢ i (λ i m → [ i ] ⌜ m ⌝ ≤ zero) ms □
-- The number lub ms is less than or equal to every number that is
-- an upper bound of ms.
least :
∀ {i} ms ub →
[ ∞ ] ms ⊑ ub →
[ i ] lub ms ≤ ub
least ms ub ms⊑ub with wlpo (>0 ms)
least ms ub ms⊑ub | inj₁ _ = zero
least ms (suc ub) ms⊑1+ub | inj₂ _ =
suc λ { .force →
least (map pred ms) (ub .force) (pred-lemma₂ ms⊑1+ub) }
least ms zero ms⊑0 | inj₂ ¬≡false =
$⟨ ms⊑0 ⟩
[ ∞ ] ms ⊑ zero ↝⟨ _⇔_.to (⊑0⇔≡false _) ⟩
(∀ n → >0 ms n ≡ false) ↝⟨ ¬≡false ⟩
⊥ ↝⟨ ⊥-elim ⟩□
_ □
------------------------------------------------------------------------
-- A relation that can be used to relate the least upper bounds of two
-- colists
-- [ ∞ ] ms ≲ ns means that every upper bound of ns is also an upper
-- bound of ms.
infix 4 [_]_≲_ [_]_≲′_
[_]_≲_ : Size → Colist ℕ ∞ → Colist ℕ ∞ → Type
[ i ] ms ≲ ns = ∀ {n} → [ ∞ ] ns ⊑ n → [ i ] ms ⊑ n
[_]_≲′_ : Size → Colist ℕ ∞ → Colist ℕ ∞ → Type
[ i ] ms ≲′ ns = ∀ {n} → [ ∞ ] ns ⊑ n → [ i ] ms ⊑′ n
-- Bounded m ns means that m is smaller than or equal to some element
-- in ns, or equal to zero.
Bounded : ℕ → Colist ℕ ∞ → Type
Bounded m ns = ◇ ∞ (m ≤_) ns ⊎ m ≡ zero
-- If Bounded m ns holds, then m is less than or equal to every upper
-- bound of ns.
bounded-lemma :
∀ {m ns n} →
Bounded m ns → [ ∞ ] ns ⊑ n → [ ∞ ] ⌜ m ⌝ ≤ n
bounded-lemma (inj₁ ◇m≤ns) = transitive-◇≤⊑ ◇m≤ns
bounded-lemma (inj₂ refl) = const zero
-- The empty colist is bounded by any other.
[]≲ : ∀ {ns i} → [ i ] [] ≲ ns
[]≲ = λ _ → []
-- Some derived cons-like operations.
consʳ-≲ :
∀ {ms ns n i} →
[ i ] ms ≲ ns .force →
[ i ] ms ≲ n ∷ ns
consʳ-≲ = _∘ □-tail
consˡ-≲ :
∀ {i m ms ns} →
Bounded m ns →
[ i ] ms .force ≲′ ns →
[ i ] m ∷ ms ≲ ns
consˡ-≲ ◇m≤ns ms≲′ns ns⊑n =
bounded-lemma ◇m≤ns ns⊑n ∷ λ { .force →
ms≲′ns ns⊑n .force }
cons-≲ :
∀ {i m ms n ns} →
Bounded m (n ∷ ns) →
[ i ] ms .force ≲′ ns .force →
[ i ] m ∷ ms ≲ n ∷ ns
cons-≲ {i} {m} {ms} {n} {ns} ◇m≤n∷ns =
[ i ] ms .force ≲′ ns .force ↝⟨ (λ { ms≲′ns hyp .force → consʳ-≲ (λ hyp → ms≲′ns hyp .force) hyp }) ⟩
[ i ] ms .force ≲′ n ∷ ns ↝⟨ consˡ-≲ ◇m≤n∷ns ⟩□
[ i ] m ∷ ms ≲ n ∷ ns □
cons′-≲ :
∀ {i m ms ns} →
[ i ] ms .force ≲′ ns .force →
[ i ] m ∷ ms ≲ m ∷ ns
cons′-≲ = cons-≲ (inj₁ (here Nat.≤-refl))
-- If the combinator consʳ-≲ had taken the primed variant of the
-- relation as an argument instead of the unprimed variant, then any
-- colist would have been bounded by any infinite colist.
consʳ-≲′→≲-infinite :
(∀ {i ms ns n} → [ i ] ms ≲′ ns .force → [ i ] ms ≲ n ∷ ns) →
(∀ {i ms ns} → Conat.[ ∞ ] length ns ∼ infinity → [ i ] ms ≲ ns)
consʳ-≲′→≲-infinite consʳ-≲′ {ns = []} ()
consʳ-≲′→≲-infinite consʳ-≲′ {ns = _ ∷ _} (suc p) =
consʳ-≲′ λ { hyp .force →
consʳ-≲′→≲-infinite consʳ-≲′ (p .force) hyp }
-- Thus one cannot make this argument's type primed.
¬-consʳ-≲′ :
¬ (∀ {i ms ns n} → [ i ] ms ≲′ ns .force → [ i ] ms ≲ n ∷ ns)
¬-consʳ-≲′ =
(∀ {i ms ns n} → [ i ] ms ≲′ ns .force → [ i ] ms ≲ n ∷ ns) ↝⟨ consʳ-≲′→≲-infinite ⟩
(∀ {i ms ns} → Conat.[ ∞ ] length ns ∼ infinity → [ i ] ms ≲ ns) ↝⟨ (λ hyp → hyp (length-replicate _)) ⟩
[ ∞ ] repeat 1 ≲ repeat 0 ↝⟨ _$ replicate⊑ _ ⟩
[ ∞ ] repeat 1 ⊑ zero ↝⟨ □-head ⟩
[ ∞ ] ⌜ 1 ⌝ ≤ ⌜ 0 ⌝ ↝⟨ ≮0 ⟩□
⊥ □
-- Bisimilarity is contained in the relation.
∼→≲ : ∀ {i ms ns} → Colist.[ i ] ms ∼ ns → [ i ] ms ≲ ns
∼→≲ [] = []≲
∼→≲ (refl ∷ ps) = cons′-≲ λ { hyp .force → ∼→≲ (ps .force) hyp }
-- "Equational" reasoning combinators.
infix -1 _□≲ finally-≲ finally-≲∼
infixr -2 step-≲ step-≡≲ _≡⟨⟩≲_ step-∼≲
step-≲ : ∀ {i} ms {ns os} →
[ ∞ ] ns ≲ os → [ i ] ms ≲ ns → [ i ] ms ≲ os
step-≲ {i} ms {ns} {os} ns≲os ms≲ns {n = n} =
[ ∞ ] os ⊑ n ↝⟨ ns≲os ⟩
[ ∞ ] ns ⊑ n ↝⟨ ms≲ns ⟩□
[ i ] ms ⊑ n □
syntax step-≲ ms ns≲os ms≲ns = ms ≲⟨ ms≲ns ⟩ ns≲os
step-≡≲ : ∀ {i} ms {ns os} → [ i ] ns ≲ os → ms ≡ ns → [ i ] ms ≲ os
step-≡≲ _ ns≲os refl = ns≲os
syntax step-≡≲ ms ns≲os ms≡ns = ms ≡⟨ ms≡ns ⟩≲ ns≲os
_≡⟨⟩≲_ : ∀ {i} ms {ns} → [ i ] ms ≲ ns → [ i ] ms ≲ ns
_ ≡⟨⟩≲ ms≲ns = ms≲ns
step-∼≲ : ∀ {i} ms {ns os} →
[ i ] ns ≲ os → Colist.[ i ] ms ∼ ns → [ i ] ms ≲ os
step-∼≲ {i} ms {ns} {os} ns≲os ms∼ns {n} =
[ ∞ ] os ⊑ n ↝⟨ ns≲os ⟩
[ i ] ns ⊑ n ↝⟨ □-∼ (Colist.symmetric-∼ ms∼ns) ⟩□
[ i ] ms ⊑ n □
syntax step-∼≲ ms ns≲os ms∼ns = ms ∼⟨ ms∼ns ⟩≲ ns≲os
finally-≲ : ∀ {i} ms ns → [ i ] ms ≲ ns → [ i ] ms ≲ ns
finally-≲ _ _ = id
syntax finally-≲ ms ns ms≲ns = ms ≲⟨ ms≲ns ⟩□ ns
finally-≲∼ : ∀ {i} ms ns → Colist.[ i ] ms ∼ ns → [ i ] ms ≲ ns
finally-≲∼ _ _ = ∼→≲
syntax finally-≲∼ ms ns ms∼ns = ms ∼⟨ ms∼ns ⟩□≲ ns
_□≲ : ∀ {i} ns → [ i ] ns ≲ ns
_□≲ {i} ns {n} =
[ ∞ ] ns ⊑ n ↝⟨ id ⟩□
[ i ] ns ⊑ n □
-- The transitivity proof can not be made size-preserving in the other
-- argument.
¬-transitivity-size-preservingʳ :
¬ (∀ {i ms ns os} → [ ∞ ] ms ≲ ns → [ i ] ns ≲ os → [ i ] ms ≲ os)
¬-transitivity-size-preservingʳ trans = contradiction
where
ones : ∀ {i} → Colist′ ℕ i
ones .force = repeat 1
bad : ∀ {i} → [ i ] 0 ∷ ones ≲ repeat 0
bad {n = n} hyp = zero ∷ λ { .force {j} → $⟨ (λ {_} → consʳ-≲ (repeat 1 □≲)) ⟩
[ ∞ ] repeat 1 ≲ 0 ∷ ones ↝⟨ flip trans bad ⟩
[ j ] repeat 1 ≲ repeat 0 ↝⟨ (λ f → f hyp) ⟩□
[ j ] repeat 1 ⊑ n □ }
contradiction = $⟨ (λ {_} → bad) ⟩
[ ∞ ] 0 ∷ ones ≲ repeat 0 ↝⟨ _$ replicate⊑ _ ⟩
[ ∞ ] 0 ∷ ones ⊑ zero ↝⟨ □-head ∘ □-tail ⟩
[ ∞ ] ⌜ 1 ⌝ ≤ ⌜ 0 ⌝ ↝⟨ ≮0 ⟩□
⊥ □
-- The transitivity proof can not be made size-preserving in both
-- arguments.
¬-transitivity-size-preserving :
¬ (∀ {i ms ns os} → [ i ] ms ≲ ns → [ i ] ns ≲ os → [ i ] ms ≲ os)
¬-transitivity-size-preserving = ¬-transitivity-size-preservingʳ
-- If the least upper bound of ms is m and the least upper bound of ns
-- is n, then [ ∞ ] ms ≲ ns holds if and only if [ ∞ ] m ≤ n holds.
≲⇔least-upper-bounds-≤ :
∀ {m n ms ns} →
LUB ms m → LUB ns n →
[ ∞ ] ms ≲ ns ⇔ [ ∞ ] m ≤ n
≲⇔least-upper-bounds-≤ {⨆ms} {⨆ns} {ms} {ns} ⨆ms-lub ⨆ns-lub = record
{ to = λ ms≲ns → $⟨ proj₁ ⨆ns-lub ⟩
[ ∞ ] ns ⊑ ⨆ns ↝⟨ ms≲ns ⟩
[ ∞ ] ms ⊑ ⨆ns ↝⟨ proj₂ ⨆ms-lub _ ⟩□
[ ∞ ] ⨆ms ≤ ⨆ns □
; from = λ ⨆ms≤⨆ns {n} →
[ ∞ ] ns ⊑ n ↝⟨ proj₂ ⨆ns-lub n ⟩
[ ∞ ] ⨆ns ≤ n ↝⟨ transitive-≤ ⨆ms≤⨆ns ⟩
[ ∞ ] ⨆ms ≤ n ↝⟨ transitive-⊑≤ (proj₁ ⨆ms-lub) ⟩□
[ ∞ ] ms ⊑ n □
}
------------------------------------------------------------------------
-- Another relation that can be used to relate the least upper bounds
-- of two colists
-- [ ∞ ] ms ≂ ns means that every upper bound of ns is also an upper
-- bound of ms, and vice versa.
infix 4 [_]_≂_ [_]_≂′_
[_]_≂_ : Size → Colist ℕ ∞ → Colist ℕ ∞ → Type
[ i ] ms ≂ ns = [ i ] ms ≲ ns × [ i ] ns ≲ ms
[_]_≂′_ : Size → Colist ℕ ∞ → Colist ℕ ∞ → Type
[ i ] ms ≂′ ns = [ i ] ms ≲′ ns × [ i ] ns ≲′ ms
-- The relation is symmetric.
symmetric-≂ : ∀ {i ms ns} → [ i ] ms ≂ ns → [ i ] ns ≂ ms
symmetric-≂ = swap
-- Some derived cons-like operations.
consʳ-≂ :
∀ {i ms n ns} →
Bounded n ms →
[ i ] ms ≂ ns .force →
[ i ] ms ≂ n ∷ ns
consʳ-≂ ◇n≤ms = Σ-map
consʳ-≲
(λ ns≲ms → consˡ-≲ ◇n≤ms λ hyp → λ { .force → ns≲ms hyp })
consˡ-≂ :
∀ {i m ms ns} →
Bounded m ns →
[ i ] ms .force ≂ ns →
[ i ] m ∷ ms ≂ ns
consˡ-≂ ◇m≤ns = symmetric-≂ ∘ consʳ-≂ ◇m≤ns ∘ symmetric-≂
cons-≂ :
∀ {i m ms n ns} →
Bounded m (n ∷ ns) →
Bounded n (m ∷ ms) →
[ i ] ms .force ≂′ ns .force →
[ i ] m ∷ ms ≂ n ∷ ns
cons-≂ ◇m≤n∷ns ◇n≤m∷ms = Σ-map (cons-≲ ◇m≤n∷ns) (cons-≲ ◇n≤m∷ms)
cons′-≂ :
∀ {i m ms ns} →
[ i ] ms .force ≂′ ns .force →
[ i ] m ∷ ms ≂ m ∷ ns
cons′-≂ = Σ-map cons′-≲ cons′-≲
cons″-≂ :
∀ {i m ms ns} →
[ i ] ms .force ≂ ns .force →
[ i ] m ∷ ms ≂ m ∷ ns
cons″-≂ = cons′-≂ ∘ Σ-map (λ { ms≲ns hyp .force → ms≲ns hyp })
(λ { ns≲ms hyp .force → ns≲ms hyp })
-- Bisimilarity is contained in the relation.
∼→≂ : ∀ {i ms ns} → Colist.[ i ] ms ∼ ns → [ i ] ms ≂ ns
∼→≂ ms∼ns = ∼→≲ ms∼ns , ∼→≲ (Colist.symmetric-∼ ms∼ns)
-- "Equational" reasoning combinators.
infix -1 _□≂ finally-≂ finally-≂∼
infixr -2 step-≂ step-≡≂ _≡⟨⟩≂_ step-∼≂ step-≂∼
step-≂ : ∀ {i} ms {ns os} →
[ ∞ ] ns ≂ os → [ ∞ ] ms ≂ ns → [ i ] ms ≂ os
step-≂ _ = Σ-zip (step-≲ _) (flip (step-≲ _))
syntax step-≂ ms ns≂os ms≂ns = ms ≂⟨ ms≂ns ⟩ ns≂os
step-≡≂ : ∀ {i} ms {ns os} → [ i ] ns ≂ os → ms ≡ ns → [ i ] ms ≂ os
step-≡≂ _ ns≂os refl = ns≂os
syntax step-≡≂ ms ns≂os ms≡ns = ms ≡⟨ ms≡ns ⟩≂ ns≂os
_≡⟨⟩≂_ : ∀ {i} ms {ns} → [ i ] ms ≂ ns → [ i ] ms ≂ ns
_ ≡⟨⟩≂ ms≂ns = ms≂ns
step-∼≂ : ∀ {i} ms {ns os} →
[ i ] ns ≂ os → Colist.[ ∞ ] ms ∼ ns → [ i ] ms ≂ os
step-∼≂ {i} ms {ns} {os} (ns≲os , os≲ns) ms∼ns =
step-∼≲ ms ns≲os ms∼ns
, λ {n} →
[ ∞ ] ms ⊑ n ↝⟨ □-∼ ms∼ns ⟩
[ ∞ ] ns ⊑ n ↝⟨ os≲ns ⟩□
[ i ] os ⊑ n □
syntax step-∼≂ ms ns≂os ms∼ns = ms ∼⟨ ms∼ns ⟩≂ ns≂os
step-≂∼ : ∀ {i} ms {ns os} →
Colist.[ ∞ ] ns ∼ os → [ i ] ms ≂ ns → [ i ] ms ≂ os
step-≂∼ _ ns∼os ms≂ns =
symmetric-≂
(step-∼≂ _ (symmetric-≂ ms≂ns) (Colist.symmetric-∼ ns∼os))
syntax step-≂∼ ms ns∼os ms≂ns = ms ≂⟨ ms≂ns ⟩∼ ns∼os
finally-≂ : ∀ {i} ms ns → [ i ] ms ≂ ns → [ i ] ms ≂ ns
finally-≂ _ _ = id
syntax finally-≂ ms ns ms≂ns = ms ≂⟨ ms≂ns ⟩□ ns
finally-≂∼ : ∀ {i} ms ns → Colist.[ i ] ms ∼ ns → [ i ] ms ≂ ns
finally-≂∼ _ _ = ∼→≂
syntax finally-≂∼ ms ns ms∼ns = ms ∼⟨ ms∼ns ⟩□≂ ns
_□≂ : ∀ {i} ns → [ i ] ns ≂ ns
ns □≂ = (ns □≲) , (ns □≲)
-- If the least upper bound of ms is m and the least upper bound of ns
-- is n, then [ ∞ ] ms ≂ ns holds if and only if m and n are
-- bisimilar.
≂⇔least-upper-bounds-∼ :
∀ {m n ms ns} →
LUB ms m → LUB ns n →
[ ∞ ] ms ≂ ns ⇔ Conat.[ ∞ ] m ∼ n
≂⇔least-upper-bounds-∼ {⨆ms} {⨆ns} {ms} {ns} ⨆ms-lub ⨆ns-lub =
[ ∞ ] ms ≂ ns ↝⟨ ≲⇔least-upper-bounds-≤ ⨆ms-lub ⨆ns-lub
×-cong
≲⇔least-upper-bounds-≤ ⨆ns-lub ⨆ms-lub ⟩
[ ∞ ] ⨆ms ≤ ⨆ns × [ ∞ ] ⨆ns ≤ ⨆ms ↝⟨ record { to = uncurry antisymmetric-≤
; from = λ hyp → ∼→≤ hyp , ∼→≤ (Conat.symmetric-∼ hyp)
} ⟩□
Conat.[ ∞ ] ⨆ms ∼ ⨆ns □
-- The predicate flip LUB n respects [ ∞ ]_≂_.
LUB-≂ : ∀ {ms ns n} → [ ∞ ] ms ≂ ns → LUB ms n → LUB ns n
LUB-≂ {ms} {ns} {n} (ms≲ns , ns≲ms) = Σ-map
([ ∞ ] ms ⊑ n ↝⟨ ns≲ms ⟩□
[ ∞ ] ns ⊑ n □)
((∀ n′ → [ ∞ ] ms ⊑ n′ → [ ∞ ] n ≤ n′) ↝⟨ (λ hyp n′ → hyp n′ ∘ ms≲ns) ⟩□
(∀ n′ → [ ∞ ] ns ⊑ n′ → [ ∞ ] n ≤ n′) □)
-- If [ ∞ ] ms ≂ ns holds, then ms and ns have the same least upper
-- bounds.
LUB-cong : ∀ {ms ns n} → [ ∞ ] ms ≂ ns → LUB ms n ⇔ LUB ns n
LUB-cong ms≂ns = record
{ to = LUB-≂ ms≂ns
; from = LUB-≂ (symmetric-≂ ms≂ns)
}
-- A workaround for what might be an Agda bug.
cast-≂ :
∀ {i} {j : Size< i} {ms ns} →
[ i ] ms ≂ ns → [ j ] ms ≂ ns
cast-≂ p = proj₁ p , proj₂ p
------------------------------------------------------------------------
-- Variants of [_]_≲′_ and [_]_≂′_ that are intended to make certain
-- proofs easier to write
-- Using consˡ-≲/cons-≲/cons′-≲ in recursive proofs can be awkward.
-- [_]_≲″_ is intended to make it a little easier.
infix 4 [_]_≲″_
record [_]_≲″_ (i : Size) (ms ns : Colist ℕ ∞) : Type where
coinductive
field
force : {j : Size< i} → [ j ] ms ≲ ns
open [_]_≲″_ public
-- Interprets [_]_≲″_.
⌊_⌋≲″ : ∀ {i ms ns} → [ i ] ms ≲″ ns → [ i ] ms ≲′ ns
⌊ p ⌋≲″ hyp .force = p .force hyp
-- [_]_≲′_ and [_]_≲″_ are pointwise logically equivalent.
≲′⇔≲″ : ∀ {i ms ns} → [ i ] ms ≲′ ns ⇔ [ i ] ms ≲″ ns
≲′⇔≲″ = record
{ to = λ { p .force hyp → p hyp .force }
; from = λ { p hyp .force → p .force hyp }
}
-- Using cons-≂/cons′-≂ in recursive proofs can be awkward. [_]_≂″_ is
-- intended to make it a little easier.
infix 4 [_]_≂″_
record [_]_≂″_ (i : Size) (ms ns : Colist ℕ ∞) : Type where
coinductive
field
force : {j : Size< i} → [ j ] ms ≂ ns
open [_]_≂″_ public
-- [_]_≂′_ and [_]_≂″_ are pointwise logically equivalent.
≂′⇔≂″ : ∀ {i ms ns} → [ i ] ms ≂′ ns ⇔ [ i ] ms ≂″ ns
≂′⇔≂″ = record
{ to = λ { p .force → (λ hyp → proj₁ p hyp .force)
, (λ hyp → proj₂ p hyp .force)
}
; from = λ p → (λ { hyp .force → proj₁ (p .force) hyp })
, (λ { hyp .force → proj₂ (p .force) hyp })
}
| {
"alphanum_fraction": 0.444297608,
"avg_line_length": 32.1089108911,
"ext": "agda",
"hexsha": "93e2c7dcc2f0e29f570fbdc03a78a5963d293075",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "dec8cd2d2851340840de25acb0feb78f7b5ffe96",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nad/definitional-interpreters",
"max_forks_repo_path": "src/Upper-bounds.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "dec8cd2d2851340840de25acb0feb78f7b5ffe96",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nad/definitional-interpreters",
"max_issues_repo_path": "src/Upper-bounds.agda",
"max_line_length": 114,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "dec8cd2d2851340840de25acb0feb78f7b5ffe96",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nad/definitional-interpreters",
"max_stars_repo_path": "src/Upper-bounds.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 10578,
"size": 22701
} |
{-# OPTIONS --without-K #-}
open import Base
module Algebra.FreeGroupAsReducedWords {i} (A : Set i) (eq : has-dec-eq A) where
A-is-set : is-set A
A-is-set = dec-eq-is-set eq
data word : Set i where
ε : word
_∷_ : A → word → word
_′∷_ : A → word → word
is-reduced : word → Set i
is-reduced ε = unit
is-reduced (x ∷ ε) = unit
is-reduced (x ∷ (y ∷ w)) = is-reduced (y ∷ w)
is-reduced (x ∷ (y ′∷ w)) = (x ≢ y) × is-reduced (y ′∷ w)
is-reduced (x ′∷ ε) = unit
is-reduced (x ′∷ (y ∷ w)) = (x ≢ y) × is-reduced (y ∷ w)
is-reduced (x ′∷ (y ′∷ w)) = is-reduced (y ′∷ w)
is-reduced-is-prop : (w : word) → is-prop (is-reduced w)
is-reduced-is-prop ε = unit-is-prop
is-reduced-is-prop (x ∷ ε) = unit-is-prop
is-reduced-is-prop (x ∷ (y ∷ w)) = is-reduced-is-prop (y ∷ w)
is-reduced-is-prop (x ∷ (y ′∷ w)) =
×-is-truncated _ (Π-is-truncated _ (λ _ → λ ())) (is-reduced-is-prop (y ′∷ w))
is-reduced-is-prop (x ′∷ ε) = unit-is-prop
is-reduced-is-prop (x ′∷ (y ∷ w)) =
×-is-truncated _ (Π-is-truncated _ (λ _ → λ ())) (is-reduced-is-prop (y ∷ w))
is-reduced-is-prop (x ′∷ (y ′∷ w)) = is-reduced-is-prop (y ′∷ w)
reduced-word : Set i
reduced-word = Σ word is-reduced
word-total-path : {x y : A} (p : x ≡ y) {v w : word} (q : v ≡ w)
→ (x ∷ v ≡ y ∷ w)
word-total-path refl refl = refl
word'-total-path : {x y : A} (p : x ≡ y) {v w : word} (q : v ≡ w)
→ (x ′∷ v ≡ y ′∷ w)
word'-total-path refl refl = refl
-- The following six functions prove things like if [x ∷ v ≡ y ∷ w],
-- then [x ≡ y].
-- This is not as easy as it sounds, you cannot directly induct on the equality
-- (because [x ∷ v] is not a general element of type word), so you have to
-- extract the head, but it’s not always possible…
word-comp-path-type : (v w : word) → Set i
word-comp-path-type ε ε = unit
word-comp-path-type ε (y ∷ w) = ⊥
word-comp-path-type ε (y ′∷ w) = ⊥
word-comp-path-type (x ∷ v) ε = ⊥
word-comp-path-type (x ∷ v) (y ∷ w) = (x ≡ y) × (v ≡ w)
word-comp-path-type (x ∷ v) (y ′∷ w) = ⊥
word-comp-path-type (x ′∷ v) ε = ⊥
word-comp-path-type (x ′∷ v) (y ∷ w) = ⊥
word-comp-path-type (x ′∷ v) (y ′∷ w) = (x ≡ y) × (v ≡ w)
word-comp-path : {v w : word} (p : v ≡ w) → word-comp-path-type v w
word-comp-path {v = ε} refl = tt
word-comp-path {v = x ∷ v} refl = (refl , refl)
word-comp-path {v = x ′∷ v} refl = (refl , refl)
word-base-path : {x y : A} {v w : word} (p : x ∷ v ≡ y ∷ w) → x ≡ y
word-base-path p = π₁ (word-comp-path p)
word-fiber-path : {x y : A} {v w : word} (p : x ∷ v ≡ y ∷ w) → v ≡ w
word-fiber-path p = π₂ (word-comp-path p)
word'-base-path : {x y : A} {v w : word} (p : x ′∷ v ≡ y ′∷ w) → x ≡ y
word'-base-path p = π₁ (word-comp-path p)
word'-fiber-path : {x y : A} {v w : word} (p : x ′∷ v ≡ y ′∷ w) → v ≡ w
word'-fiber-path p = π₂ (word-comp-path p)
-- This one goes to Set and is used to prove that the constructors of [word] are
-- disjoint
word-cst-dis : (v w : word) → Set
word-cst-dis ε ε = unit
word-cst-dis ε (y ∷ w) = ⊥
word-cst-dis ε (y ′∷ w) = ⊥
word-cst-dis (x ∷ v) ε = ⊥
word-cst-dis (x ∷ v) (y ∷ w) = unit
word-cst-dis (x ∷ v) (y ′∷ w) = ⊥
word-cst-dis (x ′∷ v) ε = ⊥
word-cst-dis (x ′∷ v) (y ∷ w) = ⊥
word-cst-dis (x ′∷ v) (y ′∷ w) = unit
word-has-dec-eq : has-dec-eq word
word-has-dec-eq ε ε = inl refl
word-has-dec-eq ε (x ∷ w) = inr (λ p → transport (word-cst-dis ε) p tt)
word-has-dec-eq ε (x ′∷ w) = inr (λ p → transport (word-cst-dis ε) p tt)
word-has-dec-eq (x ∷ v) ε = inr (λ p → transport (word-cst-dis (x ∷ v)) p tt)
word-has-dec-eq (x ∷ v) (y ∷ w) with (eq x y)
word-has-dec-eq (x ∷ v) (y ∷ w) | inl x≡y with (word-has-dec-eq v w)
word-has-dec-eq (x ∷ v) (y ∷ w) | inl x≡y | inl v≡w =
inl (word-total-path x≡y v≡w)
word-has-dec-eq (x ∷ v) (y ∷ w) | inl x≡y | inr v≢w =
inr (λ p → v≢w (word-fiber-path p))
word-has-dec-eq (x ∷ v) (y ∷ w) | inr x≢y = inr (λ p → x≢y (word-base-path p))
word-has-dec-eq (x ∷ v) (y ′∷ w) =
inr (λ p → transport (word-cst-dis (x ∷ v)) p tt)
word-has-dec-eq (x ′∷ v) ε = inr (λ p → transport (word-cst-dis (x ′∷ v)) p tt)
word-has-dec-eq (x ′∷ v) (y ∷ w) =
inr (λ p → transport (word-cst-dis (x ′∷ v)) p tt)
word-has-dec-eq (x ′∷ v) (y ′∷ w) with (eq x y)
word-has-dec-eq (x ′∷ v) (y ′∷ w) | inl x≡y with (word-has-dec-eq v w)
word-has-dec-eq (x ′∷ v) (y ′∷ w) | inl x≡y | inl v≡w =
inl (word'-total-path x≡y v≡w)
word-has-dec-eq (x ′∷ v) (y ′∷ w) | inl x≡y | inr v≢w =
inr (λ p → v≢w (word'-fiber-path p))
word-has-dec-eq (x ′∷ v) (y ′∷ w) | inr x≢y =
inr (λ p → x≢y (word'-base-path p))
word-is-set : is-set word
word-is-set = dec-eq-is-set word-has-dec-eq
abstract
reduced-is-set : is-set reduced-word
reduced-is-set =
subtype-truncated-S-is-truncated-S _ word-is-set is-reduced-is-prop
tail-is-reduced : (x : A) (w : word) (r : is-reduced (x ∷ w)) → is-reduced w
tail-is-reduced x ε red = tt
tail-is-reduced x (y ∷ w) red = red
tail-is-reduced x (y ′∷ w) red = π₂ red
tail'-is-reduced : (x : A) (w : word) (r : is-reduced (x ′∷ w)) → is-reduced w
tail'-is-reduced x ε red = tt
tail'-is-reduced x (y ∷ w) red = π₂ red
tail'-is-reduced x (y ′∷ w) red = red
import Algebra.FreeGroup as F
open F A
import Algebra.FreeGroupProps as Fp
open Fp A
reduced-to-freegroup : reduced-word → freegroup
reduced-to-freegroup (ε , _) = e
reduced-to-freegroup ((x ∷ w) , r) =
x · reduced-to-freegroup (w , tail-is-reduced x w r)
reduced-to-freegroup ((x ′∷ w) , r) =
x ⁻¹· reduced-to-freegroup (w , tail'-is-reduced x w r)
mul-reduce : A → reduced-word → reduced-word
mul-reduce x (ε , red) = ((x ∷ ε) , tt)
mul-reduce x ((y ∷ w) , red) = ((x ∷ (y ∷ w)) , red)
mul-reduce x ((y ′∷ w) , red) with (eq x y)
mul-reduce x ((y ′∷ w) , red) | inl equal = (w , tail'-is-reduced y w red)
mul-reduce x ((y ′∷ w) , red) | inr different =
((x ∷ (y ′∷ w)) , (different , red))
mul'-reduce : A → reduced-word → reduced-word
mul'-reduce x (ε , red) = ((x ′∷ ε) , tt)
mul'-reduce x ((y ∷ w) , red) with (eq x y)
mul'-reduce x ((y ∷ w) , red) | inl equal = (w , tail-is-reduced y w red)
mul'-reduce x ((y ∷ w) , red) | inr different =
((x ′∷ (y ∷ w)) , (different , red))
mul'-reduce x ((y ′∷ w) , red) = (x ′∷ (y ′∷ w)) , red
abstract
mul-mul'-reduce : (x : A) (w : reduced-word)
→ mul-reduce x (mul'-reduce x w) ≡ w
mul-mul'-reduce x (ε , red) with (eq x x)
mul-mul'-reduce x (ε , red) | inl obvious = refl
mul-mul'-reduce x (ε , red) | inr absurd = abort-nondep (absurd refl)
mul-mul'-reduce x ((y ∷ w) , red) with (eq x y)
mul-mul'-reduce x ((y ∷ ε) , red) | inl equal = ap _ equal
mul-mul'-reduce x ((y ∷ (z ∷ w)) , red) | inl equal = ap _ equal
mul-mul'-reduce x ((y ∷ (z ′∷ w)) , red) | inl equal with (eq x z)
mul-mul'-reduce x ((y ∷ (z ′∷ w)) , red) | inl equal | inl absurd =
abort-nondep (π₁ red (! equal ∘ absurd))
mul-mul'-reduce x ((y ∷ (z ′∷ w)) , red) | inl equal | inr obvious =
Σ-eq (ap _ equal) (π₁ (is-reduced-is-prop (y ∷ (z ′∷ w)) _ _))
mul-mul'-reduce x ((y ∷ w) , red) | inr different with (eq x x)
mul-mul'-reduce x ((y ∷ w) , red) | inr different | inl obvious = refl
mul-mul'-reduce x ((y ∷ w) , red) | inr different | inr absurd =
abort-nondep (absurd refl)
mul-mul'-reduce x ((y ′∷ w) , red) with (eq x x)
mul-mul'-reduce x ((y ′∷ w) , red) | inl obvious = refl
mul-mul'-reduce x ((y ′∷ w) , red) | inr absurd =
abort-nondep (absurd refl)
abstract
mul'-mul-reduce : (x : A) (w : reduced-word)
→ mul'-reduce x (mul-reduce x w) ≡ w
mul'-mul-reduce x (ε , red) with (eq x x)
mul'-mul-reduce x (ε , red) | inl obvious = refl
mul'-mul-reduce x (ε , red) | inr absurd = abort-nondep (absurd refl)
mul'-mul-reduce x ((y ′∷ w) , red) with (eq x y)
mul'-mul-reduce x ((y ′∷ ε) , red) | inl equal = ap _ equal
mul'-mul-reduce x ((y ′∷ (z ′∷ w)) , red) | inl equal = ap _ equal
mul'-mul-reduce x ((y ′∷ (z ∷ w)) , red) | inl equal with (eq x z)
mul'-mul-reduce x ((y ′∷ (z ∷ w)) , red) | inl equal | inl absurd =
abort-nondep (π₁ red (! equal ∘ absurd))
mul'-mul-reduce x ((y ′∷ (z ∷ w)) , red) | inl equal | inr obvious =
Σ-eq (ap _ equal) (π₁ (is-reduced-is-prop (y ′∷ (z ∷ w)) _ _))
mul'-mul-reduce x ((y ′∷ w) , red) | inr different with (eq x x)
mul'-mul-reduce x ((y ′∷ w) , red) | inr different | inl obvious = refl
mul'-mul-reduce x ((y ′∷ w) , red) | inr different | inr absurd =
abort-nondep (absurd refl)
mul'-mul-reduce x ((y ∷ w) , red) with (eq x x)
mul'-mul-reduce x ((y ∷ w) , red) | inl obvious = refl
mul'-mul-reduce x ((y ∷ w) , red) | inr absurd =
abort-nondep (absurd refl)
freegroup-to-reduced : freegroup → reduced-word
freegroup-to-reduced = freegroup-rec-nondep reduced-word
(ε , tt)
mul-reduce
mul'-reduce
mul-mul'-reduce
mul'-mul-reduce
reduced-is-set
abstract
mul-reduce-reduced : (x : A) (w : word) (red : is-reduced (x ∷ w))
→ mul-reduce x (w , tail-is-reduced x w red) ≡ ((x ∷ w) , red)
mul-reduce-reduced x ε red = refl
mul-reduce-reduced x (y ∷ w) red = refl
mul-reduce-reduced x (y ′∷ w) red with (eq x y)
mul-reduce-reduced x (y ′∷ w) red | inl absurd = abort-nondep (π₁ red absurd)
mul-reduce-reduced x (y ′∷ w) red | inr obvious =
Σ-eq refl (π₁ (is-reduced-is-prop (x ∷ (y ′∷ w)) _ _))
abstract
mul'-reduce-reduced : (x : A) (w : word) (red : is-reduced (x ′∷ w))
→ mul'-reduce x (w , tail'-is-reduced x w red) ≡ ((x ′∷ w) , red)
mul'-reduce-reduced x ε red = refl
mul'-reduce-reduced x (y ∷ w) red with (eq x y)
mul'-reduce-reduced x (y ∷ w) red | inl absurd = abort-nondep (π₁ red absurd)
mul'-reduce-reduced x (y ∷ w) red | inr obvious =
Σ-eq refl (π₁ (is-reduced-is-prop (x ′∷ (y ∷ w)) _ _))
mul'-reduce-reduced x (y ′∷ w) red = refl
inv₁ : (w : reduced-word) → freegroup-to-reduced (reduced-to-freegroup w) ≡ w
inv₁ (ε , red) = refl
inv₁ ((x ∷ w) , red) = ap (mul-reduce x) (inv₁ (w , tail-is-reduced x w red))
∘ mul-reduce-reduced x w red
inv₁ ((x ′∷ w) , red) =
ap (mul'-reduce x) (inv₁ (w , tail'-is-reduced x w red))
∘ mul'-reduce-reduced x w red
reduced-to-freegroup-mul-reduce : (x : A) (v : reduced-word)
→ reduced-to-freegroup (mul-reduce x v) ≡ x · (reduced-to-freegroup v)
reduced-to-freegroup-mul-reduce x (ε , red) = refl
reduced-to-freegroup-mul-reduce x ((y ∷ v) , red) = refl
reduced-to-freegroup-mul-reduce x ((y ′∷ v) , red) with (eq x y)
reduced-to-freegroup-mul-reduce x ((.x ′∷ v) , red) | inl refl =
! (right-inverse-· x (reduced-to-freegroup (v , tail'-is-reduced x v red)))
reduced-to-freegroup-mul-reduce x ((y ′∷ v) , red) | inr different = refl
reduced-to-freegroup-mul'-reduce : (x : A) (v : reduced-word)
→ reduced-to-freegroup (mul'-reduce x v) ≡ x ⁻¹· (reduced-to-freegroup v)
reduced-to-freegroup-mul'-reduce x (ε , red) = refl
reduced-to-freegroup-mul'-reduce x ((y ∷ v) , red) with (eq x y)
reduced-to-freegroup-mul'-reduce x ((.x ∷ v) , red) | inl refl =
! (left-inverse-· x (reduced-to-freegroup (v , tail-is-reduced x v red)))
reduced-to-freegroup-mul'-reduce x ((y ∷ v) , red) | inr different = refl
reduced-to-freegroup-mul'-reduce x ((y ′∷ v) , red) = refl
inv₂ : (a : freegroup) → reduced-to-freegroup (freegroup-to-reduced a) ≡ a
inv₂ = freegroup-rec _
refl
(λ x u p → reduced-to-freegroup-mul-reduce x (freegroup-to-reduced u)
∘ ap (λ t → x · t) {y = u} p)
(λ x u p → reduced-to-freegroup-mul'-reduce x (freegroup-to-reduced u)
∘ ap (λ t → x ⁻¹· t) {y = u} p)
(λ x u t → π₁ (freegroup-is-set _ _ _ _))
(λ x u t → π₁ (freegroup-is-set _ _ _ _))
(λ u → truncated-is-truncated-S _ (freegroup-is-set _ _))
freegroup-equiv-reduced : freegroup ≃ reduced-word
freegroup-equiv-reduced =
(freegroup-to-reduced , iso-is-eq _ reduced-to-freegroup inv₁ inv₂)
| {
"alphanum_fraction": 0.5769131888,
"avg_line_length": 41.675,
"ext": "agda",
"hexsha": "0e6a9aa1ef2e36f2dfd66ad80034cbf7ef4f7dff",
"lang": "Agda",
"max_forks_count": 50,
"max_forks_repo_forks_event_max_datetime": "2022-02-14T03:03:25.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-10T01:48:08.000Z",
"max_forks_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nicolaikraus/HoTT-Agda",
"max_forks_repo_path": "old/Algebra/FreeGroupAsReducedWords.agda",
"max_issues_count": 31,
"max_issues_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_issues_repo_issues_event_max_datetime": "2021-10-03T19:15:25.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-03-05T20:09:00.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nicolaikraus/HoTT-Agda",
"max_issues_repo_path": "old/Algebra/FreeGroupAsReducedWords.agda",
"max_line_length": 80,
"max_stars_count": 294,
"max_stars_repo_head_hexsha": "66f800adef943afdf08c17b8ecfba67340fead5e",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "timjb/HoTT-Agda",
"max_stars_repo_path": "old/Algebra/FreeGroupAsReducedWords.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-20T13:54:45.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T16:23:23.000Z",
"num_tokens": 4865,
"size": 11669
} |
{-
Types Summer School 2007
Bertinoro
Aug 19 - 31, 2007
Agda
Ulf Norell
-}
module Filter where
open import Nat
data Bool : Set where
false : Bool
true : Bool
infixr 40 _::_
data List (A : Set) : Set where
[] : List A
_::_ : A -> List A -> List A
filter : {A : Set} -> (A -> Bool) -> List A -> List A
filter p [] = []
filter p (x :: xs) with p x
filter p (x :: xs) | true = x :: filter p xs
filter p (x :: xs) | false = filter p xs
infix 20 _⊆_
data _⊆_ {A : Set} : List A -> List A -> Set where
stop : [] ⊆ []
drop : forall {xs y ys} -> xs ⊆ ys -> xs ⊆ y :: ys
keep : forall {x xs ys} -> xs ⊆ ys -> x :: xs ⊆ x :: ys
subset : {A : Set}(p : A -> Bool)(xs : List A) -> filter p xs ⊆ xs
subset p [] = stop
subset p (x :: xs) with p x
... | true = keep (subset p xs)
... | false = drop (subset p xs)
{-
subset p (x :: xs) with p x
subset p (x :: xs) | true = keep (subset p xs)
subset p (x :: xs) | false = drop (subset p xs)
-}
| {
"alphanum_fraction": 0.4961685824,
"avg_line_length": 19.6981132075,
"ext": "agda",
"hexsha": "d5a4ab741e949572bd2caebb13922bf097195665",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "masondesu/agda",
"max_forks_repo_path": "examples/SummerSchool07/Lecture/Filter.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "masondesu/agda",
"max_issues_repo_path": "examples/SummerSchool07/Lecture/Filter.agda",
"max_line_length": 66,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/agda-kanso",
"max_stars_repo_path": "examples/SummerSchool07/Lecture/Filter.agda",
"max_stars_repo_stars_event_max_datetime": "2019-11-27T04:41:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-11-27T04:41:05.000Z",
"num_tokens": 367,
"size": 1044
} |
module local where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
infixr 15 _::_
data List (A : Set) : Set where
nil : List A
_::_ : A -> List A -> List A
reverse : {A : Set} -> List A -> List A
reverse {A} xs = rev xs nil
where
rev : List A -> List A -> List A
rev nil ys = ys
rev (x :: xs) ys = rev xs (x :: ys)
postulate
xs : List Nat
| {
"alphanum_fraction": 0.5382585752,
"avg_line_length": 15.7916666667,
"ext": "agda",
"hexsha": "82d4598f7a2edb3371a0f7acd08d85a29e1e80d8",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/Succeed/local.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/Succeed/local.agda",
"max_line_length": 39,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/Succeed/local.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 135,
"size": 379
} |
{-
This file contains:
- Rijke finiteness is closed under forming Σ-type.
-}
{-# OPTIONS --safe #-}
module Cubical.Data.FinType.Sigma where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.HITs.SetTruncation as Set
open import Cubical.HITs.SetTruncation.Fibers
open import Cubical.Data.Nat
open import Cubical.Data.Sigma
open import Cubical.Data.FinSet
open import Cubical.Data.FinSet.DecidablePredicate
open import Cubical.Data.FinSet.Constructors
open import Cubical.Data.FinSet.Quotients
open import Cubical.Data.FinType
open import Cubical.Relation.Nullary
open import Cubical.Relation.Nullary.DecidablePropositions
hiding (DecProp) renaming (DecProp' to DecProp)
private
variable
ℓ ℓ' : Level
module _
(X : Type ℓ )
(Y : Type ℓ') (h : isFinType 1 Y)
(f : X → Y)
(q : (y : Y) → isFinType 0 (fiber f y)) where
private
∥f∥₂ : ∥ X ∥₂ → ∥ Y ∥₂
∥f∥₂ = Set.map f
module _ (y : Y) where
isDecPropFiberRel : (x x' : ∥ fiber f y ∥₂) → isDecProp (fiberRel f y x x')
isDecPropFiberRel x x' =
isDecPropRespectEquiv (fiberRel1≃2 f y x x')
(isDecProp∃ (_ , h .snd y y) (λ _ → _ , isDecProp≡ (_ , q y) _ _))
isFinSetFiber∥∥₂' : isFinSet (fiber ∥f∥₂ ∣ y ∣₂)
isFinSetFiber∥∥₂' =
EquivPresIsFinSet (∥fiber∥₂/R≃fiber∥∥₂ f y)
(isFinSetQuot (_ , q y) (fiberRel f y) (isEquivRelFiberRel f y) isDecPropFiberRel)
isFinSetFiber∥∥₂ : (y : ∥ Y ∥₂) → isFinSet (fiber ∥f∥₂ y)
isFinSetFiber∥∥₂ = Set.elim (λ _ → isProp→isSet isPropIsFinSet) isFinSetFiber∥∥₂'
isFinType0Total : isFinType 0 X
isFinType0Total = isFinSetTotal ∥ X ∥₂ (∥ Y ∥₂ , h .fst) ∥f∥₂ isFinSetFiber∥∥₂
module _
(X : FinType ℓ 1)
(Y : X .fst → FinType ℓ' 0) where
isFinType0Σ : isFinType 0 (Σ (X .fst) (λ x → Y x .fst))
isFinType0Σ =
isFinType0Total (Σ (X .fst) (λ x → Y x .fst)) (X .fst) (X .snd) fst
(λ x → EquivPresIsFinType 0 (fiberProjEquiv _ _ x) (Y x .snd))
-- the main result
isFinTypeΣ : {n : ℕ}
(X : FinType ℓ (1 + n))
(Y : X .fst → FinType ℓ' n)
→ isFinType n (Σ (X .fst) (λ x → Y x .fst))
isFinTypeΣ {n = 0} = isFinType0Σ
isFinTypeΣ {n = suc n} X Y .fst =
isFinType0Σ (_ , isFinTypeSuc→isFinType1 {n = suc n} (X .snd))
(λ x → _ , isFinType→isFinType0 {n = suc n} (Y x .snd))
isFinTypeΣ {n = suc n} X Y .snd a b =
EquivPresIsFinType n (ΣPathTransport≃PathΣ a b)
(isFinTypeΣ {n = n} (_ , X .snd .snd _ _) (λ _ → _ , Y _ .snd .snd _ _))
| {
"alphanum_fraction": 0.6500809061,
"avg_line_length": 29.4285714286,
"ext": "agda",
"hexsha": "eb3f949c70600faf769c793b1cf0ac43d1e64d13",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "thomas-lamiaux/cubical",
"max_forks_repo_path": "Cubical/Data/FinType/Sigma.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "thomas-lamiaux/cubical",
"max_issues_repo_path": "Cubical/Data/FinType/Sigma.agda",
"max_line_length": 90,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "thomas-lamiaux/cubical",
"max_stars_repo_path": "Cubical/Data/FinType/Sigma.agda",
"max_stars_repo_stars_event_max_datetime": "2021-10-31T17:32:49.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-10-31T17:32:49.000Z",
"num_tokens": 1018,
"size": 2472
} |
------------------------------------------------------------------------------
-- Comparing styles for equational reasoning
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module FOT.Common.FOL.Relation.Binary.PreorderReasoning.Comparison where
infix 7 _≡_
infixl 9 _+_
data _≡_ {A : Set}(x : A) : A → Set where
refl : x ≡ x
trans : {A : Set}{x y z : A} → x ≡ y → y ≡ z → x ≡ z
trans refl refl = refl
postulate
ℕ : Set
zero : ℕ
_+_ : ℕ → ℕ → ℕ
+-comm : (m n : ℕ) → m + n ≡ n + m
+-rightIdentity : (n : ℕ) → n + zero ≡ n
module Thesis where
-- From Ulf's thesis (p. 112).
infix 7 _≃_
infix 6 chain>_
infixl 5 _===_by_
infix 4 _qed
data _≃_ (x y : ℕ) : Set where
prf : x ≡ y → x ≃ y
chain>_ : (x : ℕ) → x ≃ x
chain> x = prf refl
_===_by_ : {x y : ℕ} → x ≃ y → (z : ℕ) → y ≡ z → x ≃ z
prf p === z by q = prf (trans {_} {_} {_} p q)
_qed : {x y : ℕ} → x ≃ y → x ≡ y
prf p qed = p
-- Example.
+-leftIdentity : (n : ℕ) → zero + n ≡ n
+-leftIdentity n =
chain> zero + n
=== n + zero by +-comm zero n
=== n by +-rightIdentity n
qed
module SL where
-- Adapted from the Agda standard library 0.8.1 (see
-- Relation/Binary/PreorderReasoning.agda).
infix 7 _≃_
infix 4 begin_
infixr 5 _≡⟨_⟩_
infix 6 _∎
data _≃_ (x y : ℕ) : Set where
prf : x ≡ y → x ≃ y
begin_ : {x y : ℕ} → x ≃ y → x ≡ y
begin prf x≡y = x≡y
_≡⟨_⟩_ : (x : ℕ){y z : ℕ} → x ≡ y → y ≃ z → x ≃ z
_ ≡⟨ x≡y ⟩ prf y≡z = prf (trans x≡y y≡z)
_∎ : (x : ℕ) → x ≃ x
_∎ _ = prf refl
-- Example.
+-leftIdentity : (n : ℕ) → zero + n ≡ n
+-leftIdentity n =
begin
zero + n ≡⟨ +-comm zero n ⟩
n + zero ≡⟨ +-rightIdentity n ⟩
n
∎
module NonWrapper where
-- A set of combinators without request a wrapper data type (Mu,
-- S.-C., Ko, H.-S. and Jansson, P. (2009)).
infixr 5 _≡⟨_⟩_
infix 6 _∎
_≡⟨_⟩_ : (x : ℕ){y z : ℕ} → x ≡ y → y ≡ z → x ≡ z
_ ≡⟨ x≡y ⟩ y≡z = trans x≡y y≡z
_∎ : (x : ℕ) → x ≡ x
_∎ _ = refl
-- Example.
+-leftIdentity : (n : ℕ) → zero + n ≡ n
+-leftIdentity n = zero + n ≡⟨ +-comm zero n ⟩
n + zero ≡⟨ +-rightIdentity n ⟩
n ∎
------------------------------------------------------------------------------
-- References
--
-- Mu, S.-C., Ko, H.-S. and Jansson, P. (2009). Algebra of programming
-- in Agda: Dependent types for relational program derivation. Journal
-- of Functional Programming 19.5, pp. 545–579.
| {
"alphanum_fraction": 0.4527959332,
"avg_line_length": 24.8108108108,
"ext": "agda",
"hexsha": "fe949cdc997178e2299d47b9405593b00f354b06",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z",
"max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/fotc",
"max_forks_repo_path": "notes/FOT/Common/FOL/Relation/Binary/PreorderReasoning/Comparison.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/fotc",
"max_issues_repo_path": "notes/FOT/Common/FOL/Relation/Binary/PreorderReasoning/Comparison.agda",
"max_line_length": 78,
"max_stars_count": 11,
"max_stars_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/fotc",
"max_stars_repo_path": "notes/FOT/Common/FOL/Relation/Binary/PreorderReasoning/Comparison.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-12T16:09:54.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:53:42.000Z",
"num_tokens": 1040,
"size": 2754
} |
module _ where
data N : Set where
zero : N
suc : N → N
record P : Set where
constructor p
field fst : N
snd : N
open P
-- f = λ z → z internally
f : P → P
f z = p (fst z) (snd z)
-- This should also be λ z → z, but was not due to #2157.
g : P → P
g (p x y) = p x y
| {
"alphanum_fraction": 0.5344827586,
"avg_line_length": 13.1818181818,
"ext": "agda",
"hexsha": "b5111526055bfe24310a2e603a42bcfeba5dd6d1",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue2571.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue2571.agda",
"max_line_length": 57,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue2571.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 112,
"size": 290
} |
{-# OPTIONS --safe --without-K #-}
module JVM.Types where
open import Data.Empty using (⊥)
open import Data.Unit using (⊤; tt)
open import Data.Product
open import Data.List
open import Data.String
open import Relation.Binary
open import Relation.Binary.PropositionalEquality
open import Relation.Nullary.Decidable
open import Relation.Nullary
-- Primitive types
data Ty : Set where
boolean : Ty
byte short int long char : Ty
ref : String → Ty
array : Ty → Ty
Integer = ref "java/lang/Integer"
Boolean = ref "java/lang/Boolean"
data Ret : Set where
ty : Ty → Ret
void : Ret -- clearly void is not a type... right? (Spec accurate)
IsIntegral : Ty → Set
IsIntegral boolean = ⊤ -- int instructions compatible with boolean
IsIntegral byte = ⊤
IsIntegral short = ⊤
IsIntegral int = ⊤
IsIntegral long = ⊤
IsIntegral char = ⊤
IsIntegral _ = ⊥
StackTy = List Ty
LocalsTy = List Ty
Labels = List StackTy
_:?:_ : Ret → StackTy → StackTy
ty a :?: ψ = a ∷ ψ
void :?: ψ = ψ
record Fun : Set where
constructor _/_:⟨_⟩_
field
cls : String
name : String
sf_args : List Ty
sf_ret : Ret
record Fld : Set where
constructor _/_∶_
field
fld_cls : String
fld_name : String
fld_ty : Ty
data Constant : Set where
class : String → Constant
fieldref : Fld → Constant
staticref : Fld → Constant -- in the actual constant pool static fields are fields
virtual : Fun → Constant
staticfun : Fun → Constant
Constantpool = List Constant
FrameTy = LocalsTy
variable
𝑪 : Constantpool
𝑹₁ 𝑹₂ 𝑹₃ 𝑹₄ 𝑹 : LocalsTy
𝑭₁ 𝑭₂ 𝑭₃ 𝑭₄ 𝑭 : FrameTy
𝑎 𝑏 : Fld
𝑐 𝑛 𝑚 : String
𝑓 𝑔 : Fun
a b c r s t : Ty
as bs cs : List Ty
ψ₁ ψ₂ ψ₃ ψ : StackTy -- stack typings
| {
"alphanum_fraction": 0.6162420382,
"avg_line_length": 23.2592592593,
"ext": "agda",
"hexsha": "a78b6a6c3dd39529300103082172ce560cde1b09",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-12-28T17:37:15.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-12-28T17:37:15.000Z",
"max_forks_repo_head_hexsha": "c84bc6b834295ac140ff30bfc8e55228efbf6d2a",
"max_forks_repo_licenses": [
"Apache-2.0"
],
"max_forks_repo_name": "ajrouvoet/jvm.agda",
"max_forks_repo_path": "src/JVM/Types.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c84bc6b834295ac140ff30bfc8e55228efbf6d2a",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"Apache-2.0"
],
"max_issues_repo_name": "ajrouvoet/jvm.agda",
"max_issues_repo_path": "src/JVM/Types.agda",
"max_line_length": 84,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "c84bc6b834295ac140ff30bfc8e55228efbf6d2a",
"max_stars_repo_licenses": [
"Apache-2.0"
],
"max_stars_repo_name": "ajrouvoet/jvm.agda",
"max_stars_repo_path": "src/JVM/Types.agda",
"max_stars_repo_stars_event_max_datetime": "2021-02-28T21:49:08.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-10-07T14:07:17.000Z",
"num_tokens": 593,
"size": 1884
} |
{-
The Existence of Smith Normal Form for Integer Matrices (KANG Rongji, Jan. 2022)
-}
{-# OPTIONS --safe #-}
module Cubical.Algebra.IntegerMatrix.Smith.Normalization where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Data.Nat
hiding (_·_)
renaming (_+_ to _+ℕ_ ; +-assoc to +Assocℕ)
open import Cubical.Data.Nat.Order
open import Cubical.Data.Nat.Divisibility
using (m∣n→m≤n)
renaming (∣-trans to ∣ℕ-trans)
open import Cubical.Data.Int
hiding (_+_ ; _·_ ; _-_ ; -_ ; addEq)
open import Cubical.Data.Int.Divisibility
open import Cubical.Data.FinData
open import Cubical.Data.Empty as Empty
open import Cubical.Data.Sum
open import Cubical.Algebra.Matrix
open import Cubical.Algebra.Matrix.CommRingCoefficient
open import Cubical.Algebra.Matrix.Elementaries
open import Cubical.Algebra.IntegerMatrix.Base
open import Cubical.Algebra.IntegerMatrix.Elementaries
open import Cubical.Algebra.IntegerMatrix.Smith.NormalForm
open import Cubical.Algebra.CommRing
open import Cubical.Algebra.CommRing.Instances.Int
renaming (ℤ to ℤRing)
open import Cubical.Relation.Nullary
open import Cubical.Induction.WellFounded
private
variable
m n k : ℕ
open CommRingStr (ℤRing .snd)
open Coefficient ℤRing
open Sim
-- The elementary transformations needed
open ElemTransformation ℤRing
open ElemTransformationℤ
open SwapFirstRow
open SwapPivot
open AddFirstRow
open RowsImproved
open ColsImproved
-- Operations used in the reduction step
record RowsImprovedTrick (M : Mat (suc m) (suc n)) : Type where
field
sim : Sim M
div : (i : Fin (suc m)) → sim .result zero zero ∣ M i zero
const : (i : Fin m) → sim .result (suc i) zero ≡ sim .result zero zero
nonZero : ¬ sim .result zero zero ≡ 0
open RowsImprovedTrick
improveRowsTrick : (M : Mat (suc m) (suc n))(p : ¬ M zero zero ≡ 0) → RowsImprovedTrick M
improveRowsTrick M p =
let improveM = improveRows M p
trickM = addFirstRow (improveM .sim .result)
inv₀₀ = (λ t → trickM .inv₀ t zero)
in record
{ sim = compSim (improveM .sim) (trickM .sim)
; div = (λ i → subst (λ a → a ∣ M i zero) inv₀₀ (improveM .div i))
; const =
(λ i → sym (trickM .addEq i zero)
∙ (λ t → improveM .sim .result zero zero + improveM .vanish i t)
∙ +Rid _ ∙ inv₀₀)
; nonZero = (λ r → improveM .nonZero (inv₀₀ ∙ r)) }
-- Reduce the pivot
record PivotReduced (M : Mat (suc m) (suc n)) : Type where
field
sim : Sim M
nonZero : ¬ sim .result zero zero ≡ 0
div : (i : Fin (suc m))(j : Fin (suc n)) → sim .result zero zero ∣ sim .result i j
open PivotReduced
simPivotReduced : {M : Mat (suc m) (suc n)}
(SimM : Sim M)(prSimM : PivotReduced (SimM .result)) → PivotReduced M
simPivotReduced simM prSimM .sim = compSim simM (prSimM .sim)
simPivotReduced _ prSimM .nonZero = prSimM .nonZero
simPivotReduced _ prSimM .div = prSimM .div
-- Helpers to do structural recursion
record RowsImprovedTrickHelper (M : Mat (suc m) (suc n)) : Type where
field
sim : Sim M
const : (i : Fin m) → sim .result (suc i) zero ≡ sim .result zero zero
nonZero : ¬ sim .result zero zero ≡ 0
open RowsImprovedTrickHelper
record InductionHelper (M : Mat (suc m) (suc n)) : Type where
field
improved : RowsImprovedTrickHelper M
normIneq : abs (improved .sim .result zero zero) < abs (M zero zero)
open InductionHelper
private
reducePivot-induction-helper :
(M : Mat (suc m) (suc n))
→ (p : ¬ M zero zero ≡ 0)
→ (j : Fin n)(q : ¬ M zero zero ∣ M zero (suc j))
→ InductionHelper M
reducePivot-induction-helper M p j q =
let improveColsM = improveCols M p
improveM = improveRowsTrick (improveColsM .sim .result) (improveColsM .nonZero)
in record
{ improved =
record
{ sim = compSim (improveColsM .sim) (improveM .sim)
; const = improveM .const
; nonZero = improveM .nonZero }
; normIneq =
≤<-trans
(m∣n→m≤n (¬x≡0→¬abs≡0 (improveColsM .nonZero)) (∣→∣ℕ (improveM .div zero)))
(stDivIneq p q (improveColsM .div zero) (improveColsM .div (suc j))) }
reducePivot-helper :
(M : Mat (suc m) (suc n))
→ (p : ¬ M zero zero ≡ 0)(h : Norm (M zero zero))
→ (cst : (i : Fin m) → M (suc i) zero ≡ M zero zero)
→ (pivot? : PivotOrNot (M zero zero) M)
→ PivotReduced M
reducePivot-helper M _ _ _ (noPivot q) .sim = idSim M
reducePivot-helper _ p _ _ (noPivot q) .nonZero = p
reducePivot-helper _ _ _ _ (noPivot q) .div = q
reducePivot-helper _ _ _ _ (pivot zero zero q) =
Empty.rec (q (∣-refl refl))
reducePivot-helper M _ _ cst (pivot (suc i) zero q) =
Empty.rec (q (subst (λ a → (M zero zero) ∣ a) (sym (cst i)) (∣-refl refl)))
reducePivot-helper M p (acc ind) _ (pivot zero (suc j) q) =
let helperM = reducePivot-induction-helper M p j q
reduceM =
reducePivot-helper
(helperM .improved .sim .result)
(helperM .improved .nonZero)
(ind _ (helperM .normIneq))
(helperM .improved .const) (findPivot _ _)
in simPivotReduced (helperM .improved .sim) reduceM
reducePivot-helper M p (acc ind) cst (pivot (suc i) (suc j) q) =
let swapM = swapFirstRow i M
swapNonZero = (λ r → p (sym (cst i) ∙ (swapM .swapEq zero) ∙ r))
swapDiv =
(transport ((λ t → ¬ cst i (~ t) ∣ M (suc i) (suc j))
∙ (λ t → ¬ swapM .swapEq zero t ∣ swapM .swapEq (suc j) t)) q)
helperM = reducePivot-induction-helper _ swapNonZero j swapDiv
swapNorm =
subst (λ a → abs (helperM . improved .sim .result zero zero) < abs a)
(sym (sym (cst i) ∙ (swapM .swapEq zero))) (helperM .normIneq)
reduceM =
reducePivot-helper
(helperM .improved .sim .result)
(helperM .improved .nonZero)
(ind _ swapNorm)
(helperM .improved .const) (findPivot _ _)
in simPivotReduced (compSim (swapM .sim) (helperM .improved .sim)) reduceM
-- The reduction of pivot
reducePivot : (M : Mat (suc m) (suc n))(p : ¬ M zero zero ≡ 0) → PivotReduced M
reducePivot M p =
let improveM = improveRowsTrick M p
reduceM =
reducePivot-helper
(improveM .sim .result)
(improveM .nonZero)
(<-wellfounded _)
(improveM .const) (findPivot _ _)
in simPivotReduced (improveM .sim) reduceM
-- One induction step towards normal form
open isSmithNormal
open Smith
record SmithStep (M : Mat (suc m) (suc n)) : Type where
field
sim : Sim M
firstColClean : (i : Fin m) → sim .result (suc i) zero ≡ 0
firstRowClean : (j : Fin n) → sim .result zero (suc j) ≡ 0
nonZero : ¬ sim .result zero zero ≡ 0
div : (i : Fin m)(j : Fin n) → sim .result zero zero ∣ sim .result (suc i) (suc j)
open SmithStep
private
smithStep-helper : (M : Mat (suc m) (suc n)) → NonZeroOrNot M → SmithStep M ⊎ (M ≡ 𝟘)
smithStep-helper _ (allZero p) = inr p
smithStep-helper M (hereIs i j p) =
let swapM = swapPivot i j M
swapNonZero = (λ r → p (swapM .swapEq ∙ r))
reduceM = reducePivot (swapM .sim .result) swapNonZero
improveColM = improveCols (reduceM .sim .result) (reduceM .nonZero)
divCol = (λ i j → bézoutRows-commonDivInv _ (reduceM .nonZero) (λ i j → reduceM .div j i) j i)
improveRowM = improveRows (improveColM .sim .result) (improveColM .nonZero)
invCol = bézoutRows-inv _ (improveColM .nonZero) (λ i → divCol (suc i) zero)
in inl record
{ sim = compSim (swapM .sim) (compSim (reduceM .sim) (compSim (improveColM .sim) (improveRowM .sim)))
; firstColClean = improveRowM .vanish
; firstRowClean = (λ j → (λ t → invCol (~ t) (suc j)) ∙ improveColM .vanish j)
; nonZero = improveRowM .nonZero
; div = (λ i j → bézoutRows-commonDivInv _ (improveColM .nonZero) divCol (suc i) (suc j)) }
smithStep : (M : Mat (suc m) (suc n)) → SmithStep M ⊎ (M ≡ 𝟘)
smithStep M = smithStep-helper M (findNonZero _)
-- The main procedure
private
smithReduction-helper :
(M : Mat (suc m) (suc n))(step : SmithStep M)
→ step .sim .result ≡ step .sim .result zero zero ⊕ sucMat (step .sim .result)
smithReduction-helper M step t zero zero = step .sim .result zero zero
smithReduction-helper M step t zero (suc j) = step .firstRowClean j t
smithReduction-helper M step t (suc i) zero = step .firstColClean i t
smithReduction-helper M step t (suc i) (suc j) = step .sim .result (suc i) (suc j)
consIsSmithNormal :
(a : ℤ)(M : Mat m n)
→ (p : ¬ a ≡ 0)
→ (div : (i : Fin m)(j : Fin n) → a ∣ M i j)
→ isSmithNormal M → isSmithNormal (a ⊕ M)
consIsSmithNormal a _ p d isNorm .divs = cons a (isNorm .divs) (smith∣ a isNorm p d)
consIsSmithNormal _ _ _ _ isNorm .rowNull = isNorm .rowNull
consIsSmithNormal _ _ _ _ isNorm .colNull = isNorm .colNull
consIsSmithNormal _ _ _ _ isNorm .rowEq = (λ t → suc (isNorm .rowEq t))
consIsSmithNormal _ _ _ _ isNorm .colEq = (λ t → suc (isNorm .colEq t))
consIsSmithNormal a _ _ _ isNorm .matEq = (λ t → a ⊕ isNorm .matEq t)
smithReduction :
(a : ℤ)(M : Mat m n)
→ (p : ¬ a ≡ 0)
→ (div : (i : Fin m)(j : Fin n) → a ∣ M i j)
→ Smith M → Smith (a ⊕ M)
smithReduction a _ _ _ smithnorm .sim = ⊕Sim a (smithnorm .sim)
smithReduction a _ p d smithnorm .isnormal =
consIsSmithNormal a _ p (sim∣ _ _ (smithnorm .sim) d) (smithnorm .isnormal)
-- The Existence of Smith Normal Form
smith : (M : Mat m n) → Smith M
smith {m = 0} = smithEmpty
smith {m = suc m} {n = 0} = smithEmptyᵗ
smith {m = suc m} {n = suc n} M = helper (smithStep _)
where
helper : SmithStep M ⊎ (M ≡ 𝟘) → Smith M
helper (inr p) = subst Smith (sym p) smith𝟘
helper (inl stepM) =
let sucM = sucMat (stepM .sim .result)
smithM = smithReduction _ _ (stepM .nonZero) (stepM .div) (smith sucM)
in simSmith (compSim (stepM .sim) (≡Sim (smithReduction-helper _ stepM))) smithM
-- TODO: The uniqueness of Smith normal form up to unit multiplication.
| {
"alphanum_fraction": 0.6367588933,
"avg_line_length": 35.8865248227,
"ext": "agda",
"hexsha": "a3a2a33d1b0bba75e41095a7d73d2abb4beb5e2f",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "howsiyu/cubical",
"max_forks_repo_path": "Cubical/Algebra/IntegerMatrix/Smith/Normalization.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "howsiyu/cubical",
"max_issues_repo_path": "Cubical/Algebra/IntegerMatrix/Smith/Normalization.agda",
"max_line_length": 109,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "1b9c97a2140fe96fe636f4c66beedfd7b8096e8f",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "howsiyu/cubical",
"max_stars_repo_path": "Cubical/Algebra/IntegerMatrix/Smith/Normalization.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 3444,
"size": 10120
} |
{-# OPTIONS --cubical #-}
module SolutionsSession1 where
open import Part1 hiding (B)
variable
B : A → Type ℓ
-- Solutions to ExerciseSession1
-- Exercise 1:
funExtDep : {f g : (x : A) → B x}
→ ((x : A) → f x ≡ g x)
→ f ≡ g
funExtDep p i x = p x i
-- Exercise 2:
congP : {x y : A} {B : A → Type ℓ'}
(f : (a : A) → B a) (p : x ≡ y) →
PathP (λ i → B (p i)) (f x) (f y)
congP f p i = f (p i)
-- Exercise 3:
isContrInhProp : isProp A → A → isContr A
isContrInhProp p x = x , p x
-- We could have stated isProp as follows:
isProp' : Type ℓ → Type ℓ
isProp' A = (x y : A) → isContr (x ≡ y)
-- Exercise 4:
isProp'→isProp : isProp' A → isProp A
isProp'→isProp h = λ x y → h x y .fst
-- Exercise 5:
isPropΠ : (h : (x : A) → isProp (B x)) → isProp ((x : A) → B x)
isPropΠ h p q i x = h x (p x) (q x) i
-- Exercise 6:
funExt⁻ : {f g : (x : A) → B x} → f ≡ g → ((x : A) → f x ≡ g x)
funExt⁻ eq x i = eq i x
-- Exercise 7:
isSetΠ : (h : (x : A) → isSet (B x)) → isSet ((x : A) → B x)
isSetΠ h f g p q i j x = h x (f x) (g x) (funExt⁻ p x) (funExt⁻ q x) i j
-- We could have defined the type of singletons as follows
singl' : {A : Type ℓ} (a : A) → Type ℓ
singl' {A = A} a = Σ[ x ∈ A ] x ≡ a
-- Exercise 8:
isContrSingl' : (x : A) → isContr (singl' x)
isContrSingl' x = ctr , prf
where
ctr : singl' x
ctr = x , refl
prf : (s : singl' x) → ctr ≡ s
prf (y , pax) i = (pax (~ i)) , λ j → pax (~ i ∨ j)
| {
"alphanum_fraction": 0.5175983437,
"avg_line_length": 23.3709677419,
"ext": "agda",
"hexsha": "964c6e4e0b22728db2f86ea5d9621872df96fb8b",
"lang": "Agda",
"max_forks_count": 14,
"max_forks_repo_forks_event_max_datetime": "2022-03-22T19:37:21.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-03-19T12:36:53.000Z",
"max_forks_repo_head_hexsha": "19d72759e18e05d2c509f62d23a998573270140c",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "williamdemeo/EPIT-2020",
"max_forks_repo_path": "04-cubical-type-theory/material/SolutionsSession1.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "19d72759e18e05d2c509f62d23a998573270140c",
"max_issues_repo_issues_event_max_datetime": "2021-04-13T09:03:56.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-03-31T18:27:23.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "williamdemeo/EPIT-2020",
"max_issues_repo_path": "04-cubical-type-theory/material/SolutionsSession1.agda",
"max_line_length": 72,
"max_stars_count": 97,
"max_stars_repo_head_hexsha": "19d72759e18e05d2c509f62d23a998573270140c",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "williamdemeo/EPIT-2020",
"max_stars_repo_path": "04-cubical-type-theory/material/SolutionsSession1.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-15T13:58:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-03-19T14:13:37.000Z",
"num_tokens": 638,
"size": 1449
} |
{-# OPTIONS --cubical --no-import-sorts --postfix-projections --safe #-}
module Cubical.Categories.TypesOfCategories.TypeCategory where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Equiv
open import Cubical.Data.Sigma
import Cubical.Functions.Fibration as Fibration
open import Cubical.Categories.Category
open import Cubical.Categories.Functor
open import Cubical.Categories.Presheaf
open import Cubical.Categories.Limits.Pullback
open import Cubical.Categories.NaturalTransformation
open import Cubical.Categories.Instances.Sets
open Fibration.ForSets
record isTypeCategory {ℓ ℓ' ℓ''} (C : Precategory ℓ ℓ')
: Type (ℓ-max ℓ (ℓ-max ℓ' (ℓ-suc ℓ''))) where
open Precategory C
open Cospan
open PullbackLegs
open isPullback
field
-- a Type of types over a context
Ty[_] : ob → Type ℓ''
-- extend a context with a type
cext : ∀ (Γ : _) → (A : Ty[ Γ ]) → Σ[ ΓA ∈ ob ] (C [ ΓA , Γ ])
-- the new object from a context extension
_⍮_ : (Γ : _) → (A : Ty[ Γ ]) → ob
Γ ⍮ A = fst (cext Γ A)
-- the projection from the extended context to the original
π : (Γ : _) → (A : Ty[ Γ ]) → C [ Γ ⍮ A , Γ ]
π Γ A = snd (cext Γ A)
field
-- pullback over context extentions
reindex : ∀ {Γ' Γ}
→ C [ Γ' , Γ ]
→ (Ty[ Γ ] → Ty[ Γ' ])
q⟨_,_⟩ : ∀ {Γ' Γ}
→ (f : C [ Γ' , Γ ])
→ (A : Ty[ Γ ])
→ C [ Γ' ⍮ (reindex f A) , Γ ⍮ A ]
isPB : ∀ {Γ' Γ : ob} (f : C [ Γ' , Γ ]) (A : Ty[ Γ ])
→ isPullback {C = C} (cospan Γ' Γ (Γ ⍮ A) f (π Γ A))
(pblegs (π Γ' (reindex f A)) q⟨ f , A ⟩)
-- presheaves are type contexts
module _ {ℓ ℓ' ℓ'' : Level} (C : Precategory ℓ ℓ') where
open isTypeCategory
open Precategory
open Functor
open NatTrans
open isPullback
private
-- types over Γ are types with a "projection" (aka surjection) to Γ
PSTy[_] : PreShv C ℓ'' .ob → Type _
PSTy[ Γ ] = Σ[ ΓA ∈ PreShv C ℓ'' .ob ]
Σ[ π ∈ ΓA ⇒ Γ ]
(∀ (c : C .ob)
→ isSurjSET {A = ΓA ⟅ c ⟆} {Γ ⟅ c ⟆} (π ⟦ c ⟧))
-- just directly use types from above as context extensions
PSCext : (Γ : _) → PSTy[ Γ ] → Σ[ ΓA ∈ PreShv C ℓ'' .ob ] ΓA ⇒ Γ
PSCext Γ (ΓA , π , _) = ΓA , π
-- the pullback or reindexed set is the disjoint union of the fibers
-- from the projection
module _ {Δ Γ : PreShv C ℓ'' .ob} (γ : Δ ⇒ Γ)
(A'@(ΓA , π , isSurjπ) : PSTy[ Γ ]) where
ΔA : PreShv C ℓ'' .ob
ΔA .F-ob c = ΔATy , isSetΔA
where
ΔATy = (Σ[ x ∈ fst (Δ ⟅ c ⟆) ] fiber (π ⟦ c ⟧) ((γ ⟦ c ⟧) x))
isSetΔA : isSet ΔATy
isSetΔA = isOfHLevelΣ 2 (snd (Δ ⟅ c ⟆)) λ Γc → isOfHLevelΣ 2 (snd (ΓA ⟅ c ⟆)) λ ΓAc → isProp→isSet (snd (Γ ⟅ c ⟆) _ _)
-- for morphisms, we apply Δ ⟪ f ⟫ to the first component
-- and ΓA ⟪ f ⟫ to the second
-- the fiber rule
ΔA .F-hom {c} {d} f (δax , γax , eq)
= ((Δ ⟪ f ⟫) δax)
, (((ΓA ⟪ f ⟫) γax)
, ((π ⟦ d ⟧) ((ΓA ⟪ f ⟫) γax)
≡[ i ]⟨ π .N-hom f i γax ⟩
(Γ ⟪ f ⟫) ((π ⟦ c ⟧) γax)
≡[ i ]⟨ (Γ ⟪ f ⟫) (eq i) ⟩
(Γ ⟪ f ⟫) ((γ ⟦ c ⟧) δax)
≡[ i ]⟨ γ .N-hom f (~ i) δax ⟩
(γ ⟦ d ⟧) ((Δ ⟪ f ⟫) δax)
∎))
ΔA .F-id {x = c}
= funExt λ (δax , γax , eq)
→ ΣPathP ((λ i → Δ .F-id i δax)
, fibersEqIfRepsEq {isSetB = snd (Γ ⟅ c ⟆)} _
(λ i → ΓA .F-id i γax))
ΔA .F-seq {a} {b} {c} f g
= funExt λ (δax , γax , eq)
→ ΣPathP ((λ i → Δ .F-seq f g i δax)
, fibersEqIfRepsEq {isSetB = snd (Γ ⟅ c ⟆)} _
λ i → ΓA .F-seq f g i γax)
π' : ΔA ⇒ Δ
π' .N-ob c (x , snd) = x
π' .N-hom f = refl
PSReindex : PSTy[ Δ ]
PSReindex = ΔA , (π' , isSurj)
where
isSurj : ∀ (c : C .ob) → isSurjSET {A = ΔA ⟅ c ⟆} {B = Δ ⟅ c ⟆} (π' ⟦ c ⟧)
isSurj c δx = (δx , isSurjπ c ((γ ⟦ c ⟧) δx)) , refl
PSq : ΔA ⇒ ΓA
PSq .N-ob c (δax , γax , eq) = γax
PSq .N-hom {c} {d} f = funExt λ (δax , γax , eq) → refl
PSIsPB : isPullback {C = PreShv C ℓ''}
(cospan Δ Γ (fst (PSCext Γ A')) γ (snd (PSCext Γ A')))
(pblegs (snd (PSCext Δ PSReindex)) (PSq))
PSIsPB .sq = makeNatTransPath (funExt sqExt)
where
sqExt : ∀ (c : C .ob) → _
sqExt c = funExt λ (δax , γax , eq) → sym eq
PSIsPB .up {Θ} (cone (pblegs p₁ p₂) sq)
= ((α , eq)
, unique)
where
α : Θ ⇒ ΔA
α .N-ob c t = ((p₁ ⟦ c ⟧) t)
, (((p₂ ⟦ c ⟧) t)
, (λ i → (sq (~ i) ⟦ c ⟧) t))
α .N-hom {d} {c} f = funExt αHomExt
where
αHomExt : ∀ (t : fst (Θ ⟅ d ⟆))
→ ((p₁ ⟦ c ⟧) ((Θ ⟪ f ⟫) t) , (p₂ ⟦ c ⟧) ((Θ ⟪ f ⟫) t), _)
≡ ((Δ ⟪ f ⟫) ((p₁ ⟦ d ⟧) t) , (ΓA ⟪ f ⟫) ((p₂ ⟦ d ⟧) t) , _)
αHomExt t = ΣPathP ((λ i → p₁ .N-hom f i t)
, fibersEqIfRepsEq {isSetB = snd (Γ ⟅ c ⟆)} _
(λ i → p₂ .N-hom f i t))
eq : _
eq = makeNatTransPath (funExt (λ _ → funExt λ _ → refl))
, makeNatTransPath (funExt (λ _ → funExt λ _ → refl))
unique : ∀ (βeq : Σ[ β ∈ Θ ⇒ ΔA ] _)
→ (α , eq) ≡ βeq
unique (β , eqβ) = ΣPathP (α≡β , eq≡eqβ)
where
α≡β : α ≡ β
α≡β = makeNatTransPath (funExt λ c → funExt λ t → eqExt c t)
where
eqβ1 = eqβ .fst
eqβ2 = eqβ .snd
eqExt : ∀ (c : C .ob)
→ (t : fst (Θ ⟅ c ⟆))
→ (α ⟦ c ⟧) t ≡ (β ⟦ c ⟧) t
eqExt c t = ΣPathP ((λ i → (eqβ1 i ⟦ c ⟧) t)
, fibersEqIfRepsEq {isSetB = snd (Γ ⟅ c ⟆)} _
(λ i → (eqβ2 i ⟦ c ⟧) t))
eq≡eqβ : PathP (λ i
→ (p₁ ≡ (α≡β i) ●ᵛ π')
× (p₂ ≡ (α≡β i) ●ᵛ PSq)) eq eqβ
eq≡eqβ = ΣPathP ( isPropNatP1 (eq .fst) (eqβ .fst) α≡β
, isPropNatP2 (eq .snd) (eqβ .snd) α≡β)
where
isPropNatP1 : isOfHLevelDep 1 (λ γ → p₁ ≡ γ ●ᵛ π')
isPropNatP1 = isOfHLevel→isOfHLevelDep 1 (λ _ → isSetNat _ _)
isPropNatP2 : isOfHLevelDep 1 (λ γ → p₂ ≡ γ ●ᵛ PSq)
isPropNatP2 = isOfHLevel→isOfHLevelDep 1 (λ _ → isSetNat _ _)
-- putting everything together
isTypeCategoryPresheaf : isTypeCategory (PreShv C ℓ'')
isTypeCategoryPresheaf .Ty[_] Γ = PSTy[ Γ ]
isTypeCategoryPresheaf .cext = PSCext
isTypeCategoryPresheaf .reindex = PSReindex
isTypeCategoryPresheaf .q⟨_,_⟩ = PSq
isTypeCategoryPresheaf .isPB = PSIsPB
| {
"alphanum_fraction": 0.4504377295,
"avg_line_length": 37.670212766,
"ext": "agda",
"hexsha": "3b74ccb02d979699cd578502b7dd80183960ff01",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "5de11df25b79ee49d5c084fbbe6dfc66e4147a2e",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Edlyr/cubical",
"max_forks_repo_path": "Cubical/Categories/TypesOfCategories/TypeCategory.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "5de11df25b79ee49d5c084fbbe6dfc66e4147a2e",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Edlyr/cubical",
"max_issues_repo_path": "Cubical/Categories/TypesOfCategories/TypeCategory.agda",
"max_line_length": 128,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "5de11df25b79ee49d5c084fbbe6dfc66e4147a2e",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Edlyr/cubical",
"max_stars_repo_path": "Cubical/Categories/TypesOfCategories/TypeCategory.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 2716,
"size": 7082
} |
-- This bug was reported by Christian Sattler. (I modified his example
-- slightly.)
-- {-# OPTIONS -v tc.meta.assign:49 #-}
module Issue903 where
record T : Set where
constructor tt
postulate
Id : (A : Set) → A → Set
e : (B : Set) (f : T → B) → Id B (f tt) → Id (T → B) f
k : (P : Set → Set) (u : P T) → Id (P T) u → T
h : Id T tt
q : T
q = k {!!} {!!} (e {!!} _ {!h!})
-- WAS: If one tries to give h:
--
-- An internal error has occurred. Please report this as a bug.
-- Location of the error: src/full/Agda/TypeChecking/MetaVars.hs:654
| {
"alphanum_fraction": 0.5770609319,
"avg_line_length": 23.25,
"ext": "agda",
"hexsha": "48426ab2e6e3ca5c05dc5dd8a55941c1c4874e9e",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "cruhland/agda",
"max_forks_repo_path": "test/interaction/Issue903.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "cruhland/agda",
"max_issues_repo_path": "test/interaction/Issue903.agda",
"max_line_length": 70,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "7f58030124fa99dfbf8db376659416f3ad8384de",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "cruhland/agda",
"max_stars_repo_path": "test/interaction/Issue903.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 196,
"size": 558
} |
-- Andreas, 2017-06-14, issue #2603
-- reported by rfindler, shrunk test case by Ulf
-- {-# OPTIONS -v tc.conv:40 -v tc.conv.atom:50 -v tc:80 -v tc.meta.assign:70 #-}
{-# OPTIONS --allow-unsolved-metas #-}
open import Agda.Builtin.Equality
data List (A : Set) : Set where
[] : List A
postulate
Signal : Set
data Any (xs : List Signal) : Set where
no : Any xs
any : ∀ xs → Any xs
any [] = no
record Env : Set where
field sig : List Signal
open Env
Can : (θ : Env) → Any (sig θ) → Set
Can θ no = Signal
postulate
elephant : ∀ θ → Can θ (any (sig θ)) ≡ Signal
lemma2 : Set
lemma2 rewrite elephant _ = Signal
-- Should succeed.
-- This lead to an internal error when the conversion checker
-- tried to eta expand a meta variable but dontAssignMetas was on.
| {
"alphanum_fraction": 0.6619354839,
"avg_line_length": 20.3947368421,
"ext": "agda",
"hexsha": "a0175e3274dfe8203a003332c102357b0a3a4a87",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue2603.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue2603.agda",
"max_line_length": 81,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue2603.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 245,
"size": 775
} |
module Prelude.Fin where
open import Prelude.Eq
open import Prelude.Nat
data Fin : Nat -> Set where
fz : ∀{n} -> Fin (S n)
fs : ∀{n} -> Fin n -> Fin (S n)
forget : {n : Nat} -> Fin n -> Nat
forget fz = Z
forget (fs n) = S (forget n)
inject : (n : Nat) -> Fin (S n)
inject Z = fz
inject (S n) = fs (inject n)
inc : {n : Nat} -> Fin n -> Fin (S n)
inc fz = fz
inc (fs n) = fs (inc n)
| {
"alphanum_fraction": 0.5438596491,
"avg_line_length": 19,
"ext": "agda",
"hexsha": "bcd8ec4ffd940f44530bf16b6f04a0abd0600dd2",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_forks_event_min_datetime": "2022-03-12T11:35:18.000Z",
"max_forks_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "redfish64/autonomic-agda",
"max_forks_repo_path": "test/epic/Prelude/Fin.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "redfish64/autonomic-agda",
"max_issues_repo_path": "test/epic/Prelude/Fin.agda",
"max_line_length": 37,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "c0ae7d20728b15d7da4efff6ffadae6fe4590016",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "redfish64/autonomic-agda",
"max_stars_repo_path": "test/epic/Prelude/Fin.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 147,
"size": 399
} |
module Thesis.Lang where
open import Thesis.Syntax public
open import Thesis.Environments public
⟦_⟧Const : ∀ {τ} → Const τ → ⟦ τ ⟧Type
⟦ unit ⟧Const = tt
⟦ lit n ⟧Const = n
⟦ plus ⟧Const = _+_
⟦ minus ⟧Const = _-_
⟦ cons ⟧Const v1 v2 = v1 , v2
⟦ fst ⟧Const (v1 , v2) = v1
⟦ snd ⟧Const (v1 , v2) = v2
⟦ linj ⟧Const v1 = inj₁ v1
⟦ rinj ⟧Const v2 = inj₂ v2
⟦ match ⟧Const (inj₁ x) f g = f x
⟦ match ⟧Const (inj₂ y) f g = g y
⟦_⟧Term : ∀ {Γ τ} → Term Γ τ → ⟦ Γ ⟧Context → ⟦ τ ⟧Type
⟦ const c ⟧Term ρ = ⟦ c ⟧Const
⟦ var x ⟧Term ρ = ⟦ x ⟧Var ρ
⟦ app s t ⟧Term ρ = ⟦ s ⟧Term ρ (⟦ t ⟧Term ρ)
⟦ abs t ⟧Term ρ = λ v → ⟦ t ⟧Term (v • ρ)
open import Theorem.CongApp
open import Postulate.Extensionality
weaken-sound : ∀ {Γ₁ Γ₂ τ} {Γ₁≼Γ₂ : Γ₁ ≼ Γ₂}
(t : Term Γ₁ τ) (ρ : ⟦ Γ₂ ⟧Context) → ⟦ weaken Γ₁≼Γ₂ t ⟧Term ρ ≡ ⟦ t ⟧Term (⟦ Γ₁≼Γ₂ ⟧≼ ρ)
weaken-sound {Γ₁≼Γ₂ = Γ₁≼Γ₂} (var x) ρ = weaken-var-sound Γ₁≼Γ₂ x ρ
weaken-sound (app s t) ρ = weaken-sound s ρ ⟨$⟩ weaken-sound t ρ
weaken-sound (abs t) ρ = ext (λ v → weaken-sound t (v • ρ))
weaken-sound (const c) ρ = refl
| {
"alphanum_fraction": 0.5930122757,
"avg_line_length": 31.1470588235,
"ext": "agda",
"hexsha": "20f96b3bc3593229e09f75cce6df5153eea6e5fb",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2016-02-18T12:26:44.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-02-18T12:26:44.000Z",
"max_forks_repo_head_hexsha": "39bb081c6f192bdb87bd58b4a89291686d2d7d03",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "inc-lc/ilc-agda",
"max_forks_repo_path": "Thesis/Lang.agda",
"max_issues_count": 6,
"max_issues_repo_head_hexsha": "39bb081c6f192bdb87bd58b4a89291686d2d7d03",
"max_issues_repo_issues_event_max_datetime": "2017-05-04T13:53:59.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-07-01T18:09:31.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "inc-lc/ilc-agda",
"max_issues_repo_path": "Thesis/Lang.agda",
"max_line_length": 91,
"max_stars_count": 10,
"max_stars_repo_head_hexsha": "39bb081c6f192bdb87bd58b4a89291686d2d7d03",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "inc-lc/ilc-agda",
"max_stars_repo_path": "Thesis/Lang.agda",
"max_stars_repo_stars_event_max_datetime": "2019-07-19T07:06:59.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-03-04T06:09:20.000Z",
"num_tokens": 537,
"size": 1059
} |
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.Ints.HAEquivInt.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HAEquiv
data HAEquivInt : Type₀ where
zero : HAEquivInt
suc : HAEquivInt -> HAEquivInt
-- suc is a HAEquiv:
pred : HAEquivInt -> HAEquivInt
suc-pred : ∀ z -> suc (pred z) ≡ z
pred-suc : ∀ z -> pred (suc z) ≡ z
coh : ∀ z → (λ i → suc (pred-suc z i)) ≡ suc-pred (suc z)
suc-haequiv : HAEquiv HAEquivInt HAEquivInt
suc-haequiv = suc , record { g = pred ; sec = pred-suc ; ret = suc-pred ; com = coh }
-- OPEN: prove HAEquivInt ≃ Int! See Experiments/HInt.agda
| {
"alphanum_fraction": 0.6656101426,
"avg_line_length": 26.2916666667,
"ext": "agda",
"hexsha": "560ee5e8763625fcd32381e6d0cea8b373cf3b5e",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "df4ef7edffd1c1deb3d4ff342c7178e9901c44f1",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "limemloh/cubical",
"max_forks_repo_path": "Cubical/HITs/Ints/HAEquivInt/Base.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "df4ef7edffd1c1deb3d4ff342c7178e9901c44f1",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "limemloh/cubical",
"max_issues_repo_path": "Cubical/HITs/Ints/HAEquivInt/Base.agda",
"max_line_length": 85,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "df4ef7edffd1c1deb3d4ff342c7178e9901c44f1",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "limemloh/cubical",
"max_stars_repo_path": "Cubical/HITs/Ints/HAEquivInt/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 229,
"size": 631
} |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Strings: builtin type and basic operations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.String.Base where
open import Data.Nat.Base as Nat using (ℕ)
open import Data.List.Base as List using (List)
open import Data.List.NonEmpty as NE using (List⁺)
open import Agda.Builtin.Char using (Char)
open import Function
------------------------------------------------------------------------
-- From Agda.Builtin: type and renamed primitives
-- Note that we do not re-export primStringAppend because we want to
-- give it an infix definition and be able to assign it a level.
import Agda.Builtin.String as String
open String public using ( String )
renaming
( primStringToList to toList
; primStringFromList to fromList
; primShowString to show
)
------------------------------------------------------------------------
-- Operations
-- Additional conversion functions
fromList⁺ : List⁺ Char → String
fromList⁺ = fromList ∘ NE.toList
-- List-like functions
infixr 5 _++_
_++_ : String → String → String
_++_ = String.primStringAppend
length : String → ℕ
length = List.length ∘ toList
replicate : ℕ → Char → String
replicate n = fromList ∘ List.replicate n
concat : List String → String
concat = List.foldr _++_ ""
-- String-specific functions
unlines : List String → String
unlines = concat ∘ List.intersperse "\n"
| {
"alphanum_fraction": 0.5885826772,
"avg_line_length": 25.8305084746,
"ext": "agda",
"hexsha": "af017b2d8dbca2fb51a3ce1266f24561cd2ba34c",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "omega12345/agda-mode",
"max_forks_repo_path": "test/asset/agda-stdlib-1.0/Data/String/Base.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "omega12345/agda-mode",
"max_issues_repo_path": "test/asset/agda-stdlib-1.0/Data/String/Base.agda",
"max_line_length": 72,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "0debb886eb5dbcd38dbeebd04b34cf9d9c5e0e71",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "omega12345/agda-mode",
"max_stars_repo_path": "test/asset/agda-stdlib-1.0/Data/String/Base.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 329,
"size": 1524
} |
{-# OPTIONS --without-K --safe #-}
open import Algebra.Bundles using (Semiring)
-- Credit: This definition is taken from the stdlib issue #1175
-- As given by @MatthewDaggitt and @mechvel
module Definitions.Semiring {α α≈} (R : Semiring α α≈)
where
open Semiring R
record NonZero (x : Carrier) : Set α≈ where
constructor mkNonZero
field
nonZero : x ≉ 0#
| {
"alphanum_fraction": 0.6753926702,
"avg_line_length": 23.875,
"ext": "agda",
"hexsha": "7cd7654b58328c39d0085354770a0f64ed44ef57",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "72030f78934877ad67bf4e36e74e43845cabbf55",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Akshobhya1234/Agda-Algebra",
"max_forks_repo_path": "src/Definitions/Semiring.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "72030f78934877ad67bf4e36e74e43845cabbf55",
"max_issues_repo_issues_event_max_datetime": "2022-01-31T18:19:52.000Z",
"max_issues_repo_issues_event_min_datetime": "2022-01-02T20:50:34.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Akshobhya1234/Agda-Algebra",
"max_issues_repo_path": "src/Definitions/Semiring.agda",
"max_line_length": 63,
"max_stars_count": 2,
"max_stars_repo_head_hexsha": "72030f78934877ad67bf4e36e74e43845cabbf55",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Akshobhya1234/Agda-Algebra",
"max_stars_repo_path": "src/Definitions/Semiring.agda",
"max_stars_repo_stars_event_max_datetime": "2021-08-17T09:14:03.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-08-15T06:16:13.000Z",
"num_tokens": 114,
"size": 382
} |
{-# OPTIONS --without-K #-}
open import library.Basics hiding (Type ; Σ ; S)
open import library.types.Sigma
open import Sec2preliminaries
open import Sec3hedberg
open import Sec4hasConstToSplit
open import Sec5factorConst
open import Sec6hasConstToDecEq
open import Sec7populatedness
module Sec8taboos where
-- Subsection 8.1
all-hasConst : Type₁
all-hasConst = (X : Type) → hasConst X
-- Theorem 8.1
module functional-subrelation (ac : all-hasConst) (X : Type) (R : X × X → Type) where
all-sets : (Y : Type) → is-set Y
all-sets Y = pathHasConst→isSet (λ y₁ y₂ → ac _)
R₋ : (x : X) → Type
R₋ x = Σ X λ y → R(x , y)
k : (x : X) → (R₋ x) → (R₋ x)
k x = fst (ac _)
kc : (x : X) → const (k x)
kc x = snd (ac _)
S : X × X → Type
S (x , y) = Σ (R(x , y)) λ a →
(y , a) == k x (y , a)
-- the relation S
S₋ : (x : X) → Type
S₋ x = Σ X λ y → S(x , y)
-- fix kₓ is equivalent to Sₓ
-- This is just Σ-assoc. We try to make it more readable by adding some (trivial) steps.
fixk-S : (x : X) → (fix (k x)) ≃ S₋ x
fixk-S x =
(fix (k x)) ≃⟨ ide _ ⟩
(Σ (Σ X λ y → R(x , y)) λ a → a == k x a) ≃⟨ Σ-assoc ⟩
(Σ X λ y → Σ (R(x , y)) λ r → (y , r) == k x (y , r)) ≃⟨ ide _ ⟩
(S₋ x) ≃∎
-- claim (0)
subrelation : (x y : X) → S(x , y) → R(x , y)
subrelation x y (r , _) = r
-- claim (1)
prop-Sx : (x : X) → is-prop (S₋ x)
prop-Sx x = equiv-preserves-level {A = fix (k x)} {B = (S₋ x)} (fixk-S x) (fixed-point _ (kc x))
-- claim (2)
same-domain : (x : X) → (R₋ x) ↔ (S₋ x)
same-domain x = rs , sr where
rs : (R₋ x) → (S₋ x)
rs a = –> (fixk-S x) (to-fix (k x) (kc x) a)
sr : (S₋ x) → (R₋ x)
sr (y , r , _) = y , r
-- claim (3)
prop-S : (x y : X) → is-prop (S (x , y))
prop-S x y = all-paths-is-prop all-paths where
all-paths : (s₁ s₂ : S(x , y)) → s₁ == s₂
all-paths s₁ s₂ = ss where
yss : (y , s₁) == (y , s₂)
yss = prop-has-all-paths (prop-Sx x) _ _
ss : s₁ == s₂
ss = set-lemma (all-sets _) y s₁ s₂ yss
-- intermediate definition
-- see the caveat about the notion 'epimorphism' in the article
is-split-epimorphism : {U V : Type} → (U → V) → Type
is-split-epimorphism {U} {V} e = Σ (V → U) λ s → (v : V) → e (s v) == v
is-epimorphism : {U V : Type} → (U → V) → Type₁
is-epimorphism {U} {V} e = (W : Type) → (f g : V → W) → ((u : U) → f (e u) == g (e u)) → (v : V) → f v == g v
-- Lemma 8.2
path-trunc-epi→set : {Y : Type} → ((y₁ y₂ : Y) → is-epimorphism (∣_∣ {X = y₁ == y₂})) → is-set Y
path-trunc-epi→set {Y} path-epi = reminder special-case where
f : (y₁ y₂ : Y) → Trunc (y₁ == y₂) → Y
f y₁ _ _ = y₁
g : (y₁ y₂ : Y) → Trunc (y₁ == y₂) → Y
g _ y₂ _ = y₂
special-case : (y₁ y₂ : Y) → Trunc (y₁ == y₂) → y₁ == y₂
special-case y₁ y₂ = path-epi y₁ y₂ Y (f y₁ y₂) (g y₁ y₂) (idf _)
reminder : hseparated Y → is-set Y
reminder = fst set-characterizations ∘ snd (snd set-characterizations)
-- Theorem 8.3 (1)
all-split→all-deceq : ((X : Type) → is-split-epimorphism (∣_∣ {X = X})) → (X : Type) → has-dec-eq X
all-split→all-deceq all-split = all-hasConst→dec-eq ac where
ac : (X : Type) → hasConst X
ac X = snd hasConst↔splitSup (fst (all-split X))
-- Theorem 8.3 (2)
all-epi→all-set : ((X : Type) → is-epimorphism (∣_∣ {X = X})) → (X : Type) → is-set X
all-epi→all-set all-epi X = path-trunc-epi→set (λ y₁ y₂ → all-epi (y₁ == y₂))
-- Subsection 8.2
-- Lemma 8.4, first proof
pop-splitSup-1 : {X : Type} → Pop (splitSup X)
pop-splitSup-1 {X} f c = to-fix f c (hasConst→splitSup (g , gc)) where
g : X → X
g x = f (λ _ → x) ∣ x ∣
gc : const g
gc x₁ x₂ =
g x₁ =⟨ idp ⟩
f (λ _ → x₁) ∣ x₁ ∣ =⟨ ap (λ k → k ∣ x₁ ∣) (c (λ _ → x₁) (λ _ → x₂)) ⟩
f (λ _ → x₂) ∣ x₁ ∣ =⟨ ap (f (λ _ → x₂)) (prop-has-all-paths (h-tr X) ∣ x₁ ∣ ∣ x₂ ∣) ⟩
f (λ _ → x₂) ∣ x₂ ∣ =⟨ idp ⟩
g x₂ ∎
-- Lemma 8.4, second proof
pop-splitSup-2 : {X : Type} → Pop (splitSup X)
pop-splitSup-2 {X} = snd (pop-alt₂ {splitSup X}) get-P where
get-P : (P : Type) → is-prop P → splitSup X ↔ P → P
get-P P pp (hstp , phst) = hstp free-hst where
xp : X → P
xp x = hstp (λ _ → x)
zp : Trunc X → P
zp = rec pp xp
free-hst : splitSup X
free-hst z = phst (zp z) z
-- Lemma 8.5, third proof
pop-splitSup-3 : {X : Type} → Pop (splitSup X)
pop-splitSup-3 {X} = snd pop-alt translation where
translation-aux : splitSup (splitSup X) → splitSup X
translation-aux = λ hsthst z → hsthst (trunc-functorial {X = X} {Y = splitSup X} (λ x _ → x) z) z
translation : Trunc (splitSup (splitSup X)) → Trunc (splitSup X)
translation = trunc-functorial translation-aux
-- Theorem 8.5
module thm85 where
One = (X : Type) → Pop X → Trunc X
Two = (X : Type) → Trunc (splitSup X)
Three = (P : Type) → is-prop P → (Y : P → Type) → ((p : P) → Trunc (Y p)) → Trunc ((p : P) → Y p)
Four = (X Y : Type) → (X → Y) → (Pop X → Pop Y)
One→Two : One → Two
One→Two poptr X = poptr (splitSup X) pop-splitSup-1
Two→One : Two → One
Two→One trhst X pop = fst pop-alt pop (trhst X)
One→Four : One → Four
One→Four poptr X Y f = Trunc→Pop ∘ (trunc-functorial f) ∘ (poptr X)
Four→One : Four → One
Four→One funct X px = prop-pop (h-tr _) pz where
pz : Pop (Trunc X)
pz = funct X (Trunc X) ∣_∣ px
-- only very slightly different to the proof in the article
One→Three : One → Three
One→Three poptr P pp Y = λ py → poptr _ (snd pop-alt' (λ hst p₀ → hst (contr-trick p₀ py) p₀)) where
contr-trick : (p₀ : P) → ((p : P) → Trunc (Y p)) → Trunc ((p : P) → Y p)
contr-trick p₀ py = rec {X = Y p₀}
{P = Trunc ((p : P) → Y p)}
(h-tr _)
(λ y₀ → ∣ <– (thm55aux.neutral-contr-exp {P = P} {Y = Y} pp p₀) y₀ ∣) (py p₀)
Three→Two : Three → Two
Three→Two proj X = proj (Trunc X) (h-tr _) (λ _ → X) (idf _)
-- Subsection 8.3
-- Some very simple lemmata
-- If P is a proposition, so is P + ¬ P
dec-is-prop : {P : Type} → (Funext {X = P} {Y = Empty}) → is-prop P → is-prop (P + ¬ P)
dec-is-prop {P} fext pp = all-paths-is-prop (λ { (inl p₁) (inl p₂) → ap inl (prop-has-all-paths pp _ _) ;
(inl p₁) (inr np₂) → Empty-elim {A = λ _ → inl p₁ == inr np₂} (np₂ p₁) ;
(inr np₁) (inl p₂) → Empty-elim {A = λ _ → inr np₁ == inl p₂} (np₁ p₂) ;
(inr np₁) (inr np₂) → ap inr (fext np₁ np₂ (λ p → prop-has-all-paths (λ ()) _ _)) })
-- Theorem 8.7
nonempty-pop→lem : ((X : Type) → Funext {X} {Empty})
→ ((X : Type) → (¬(¬ X) → Pop X)) → LEM
nonempty-pop→lem fext nn-pop P pp = from-fix {X = dec} (idf _) (nn-pop dec nndec (idf _) idc) where
dec : Type
dec = P + ¬ P
idc : const (idf dec)
idc = λ _ _ → prop-has-all-paths (dec-is-prop {P} (fext P) pp) _ _
nndec : ¬(¬ dec)
nndec ndec = (λ np → ndec (inr np)) λ p → ndec (inl p)
-- Corollary 8.8
nonempty-pop↔lem : ((X : Type) → Funext {X} {Empty})
→ ((X : Type) → (¬(¬ X) → Pop X)) ↔₁₁ LEM
nonempty-pop↔lem fext = nonempty-pop→lem fext , other where
other : LEM → ((X : Type) → (¬(¬ X) → Pop X))
other lem X nnX = p where
pnp : Pop X + ¬ (Pop X)
pnp = lem (Pop X) pop-property₂
p : Pop X
p = match pnp withl idf _ withr (λ np → Empty-elim {A = λ _ → Pop X} (nnX (λ x → np (pop-property₁ x))))
| {
"alphanum_fraction": 0.516381483,
"avg_line_length": 32.0808510638,
"ext": "agda",
"hexsha": "68aa2f293d3b2ac5e047dceee4a7ad7c60a91604",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "nicolaikraus/HoTT-Agda",
"max_forks_repo_path": "nicolai/anonymousExistence/Sec8taboos.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "nicolaikraus/HoTT-Agda",
"max_issues_repo_path": "nicolai/anonymousExistence/Sec8taboos.agda",
"max_line_length": 116,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "939a2d83e090fcc924f69f7dfa5b65b3b79fe633",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "nicolaikraus/HoTT-Agda",
"max_stars_repo_path": "nicolai/anonymousExistence/Sec8taboos.agda",
"max_stars_repo_stars_event_max_datetime": "2021-06-30T00:17:55.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-06-30T00:17:55.000Z",
"num_tokens": 3094,
"size": 7539
} |
module Issue268 where
module Example₁ where
open import Common.Coinduction
module Record where
record Stream : Set where
constructor cons
field
tail : ∞ Stream
module Data where
data Stream : Set where
cons : ∞ Stream → Stream
-- open Data
open Record
id : Stream → Stream
id (cons xs) = cons (♯ id (♭ xs))
postulate
P : Stream → Set
f : ∀ xs → P (id xs) → Set
xs : Stream
p : P (id xs)
Foo : Set
Foo = f _ p
-- The code type checks when Data is opened, but not when Record is
-- opened:
--
-- Bug.agda:34,11-12
-- (Stream.tail (id xs)) != (.Bug.♯-0 _40) of type (∞ Stream)
-- when checking that the expression p has type P (id (cons _40))
module Example₂ where
data D : Set where
d : D
id : D → D
id d = d
module Record where
record E : Set where
constructor e
field
f : D
module Data where
data E : Set where
e : D → E
-- open Data
open Record
id′ : E → E
id′ (e xs) = e (id xs)
postulate
P : E → Set
f : (x : E) → P (id′ x) → Set
x : E
p : P (id′ x)
Foo : Set
Foo = f _ p
| {
"alphanum_fraction": 0.5470232959,
"avg_line_length": 15.6621621622,
"ext": "agda",
"hexsha": "7cb9e40f4b32a3f00e9c6d47feadce21d0f38bdf",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/agda-kanso",
"max_forks_repo_path": "test/succeed/Issue268.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/agda-kanso",
"max_issues_repo_path": "test/succeed/Issue268.agda",
"max_line_length": 69,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/agda-kanso",
"max_stars_repo_path": "test/succeed/Issue268.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 388,
"size": 1159
} |
{-# OPTIONS --safe #-}
module Cubical.Algebra.Group.DirProd where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Data.Sigma
open import Cubical.Algebra.Group.Base
open import Cubical.Algebra.Monoid
open import Cubical.Algebra.Semigroup
open GroupStr
open IsGroup hiding (·IdR ; ·IdL ; ·InvR ; ·InvL)
open IsMonoid hiding (·IdR ; ·IdL)
open IsSemigroup
DirProd : ∀ {ℓ ℓ'} → Group ℓ → Group ℓ' → Group (ℓ-max ℓ ℓ')
fst (DirProd G H) = (fst G) × (fst H)
1g (snd (DirProd G H)) = (1g (snd G)) , (1g (snd H))
_·_ (snd (DirProd G H)) (g , h) (g' , h') = _·_ (snd G) g g' , _·_ (snd H) h h'
inv (snd (DirProd G H)) (g , h) = (inv (snd G) g) , (inv (snd H) h)
isGroup (snd (DirProd G H)) = makeIsGroup
(isSet× (is-set (snd G)) (is-set (snd H)))
(λ x y z → ≡-× (·Assoc (snd G) _ _ _) (·Assoc (snd H) _ _ _))
(λ x → ≡-× (·IdR (snd G) _) (·IdR (snd H) _))
(λ x → ≡-× (·IdL (snd G) _) (·IdL (snd H) _))
(λ x → ≡-× (·InvR (snd G) _) (·InvR (snd H) _))
λ x → ≡-× (·InvL (snd G) _) (·InvL (snd H) _)
| {
"alphanum_fraction": 0.5110565111,
"avg_line_length": 43.6071428571,
"ext": "agda",
"hexsha": "ad3f0b4e5c67aa2a7318e913c5866110bda8a9c8",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "thomas-lamiaux/cubical",
"max_forks_repo_path": "Cubical/Algebra/Group/DirProd.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "thomas-lamiaux/cubical",
"max_issues_repo_path": "Cubical/Algebra/Group/DirProd.agda",
"max_line_length": 91,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "thomas-lamiaux/cubical",
"max_stars_repo_path": "Cubical/Algebra/Group/DirProd.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 441,
"size": 1221
} |
{-# OPTIONS --warning=error --allow-unsolved-metas #-}
-- This file contains everything that cannot be compiled in --safe mode.
--open import Lists.SortList
module Everything.Unsafe where
| {
"alphanum_fraction": 0.7486910995,
"avg_line_length": 23.875,
"ext": "agda",
"hexsha": "aac3ee53d172c3e479a5f5cd148a052535827562",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2021-11-29T13:23:07.000Z",
"max_forks_repo_forks_event_min_datetime": "2021-11-29T13:23:07.000Z",
"max_forks_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Smaug123/agdaproofs",
"max_forks_repo_path": "Everything/Unsafe.agda",
"max_issues_count": 14,
"max_issues_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_issues_repo_issues_event_max_datetime": "2020-04-11T11:03:39.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-06T21:11:59.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Smaug123/agdaproofs",
"max_issues_repo_path": "Everything/Unsafe.agda",
"max_line_length": 72,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "0f4230011039092f58f673abcad8fb0652e6b562",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Smaug123/agdaproofs",
"max_stars_repo_path": "Everything/Unsafe.agda",
"max_stars_repo_stars_event_max_datetime": "2022-01-28T06:04:15.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-08-08T12:44:19.000Z",
"num_tokens": 41,
"size": 191
} |
module StrongArrows where
open import Library
open import Categories
open import Functors
open import MonoidalCat
open import WeakArrows
record SArrow {l m}(J : Monoidal {l}{m}) : Set (lsuc (l ⊔ m)) where
constructor sarrow
open Monoidal J
open Cat C
open Fun
field A : Arrow C
open Arrow A
field fst' : ∀{X X' Y} -> R X' X -> R (OMap ⊗ (X' , Y)) (OMap ⊗ (X , Y))
-- laws later
| {
"alphanum_fraction": 0.6574307305,
"avg_line_length": 20.8947368421,
"ext": "agda",
"hexsha": "7ea81484f79d040154b5d1ad23b7fc399c3c5664",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-11-04T21:33:13.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-11-04T21:33:13.000Z",
"max_forks_repo_head_hexsha": "74707d3538bf494f4bd30263d2f5515a84733865",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "jmchapman/Relative-Monads",
"max_forks_repo_path": "StrongArrows.agda",
"max_issues_count": 3,
"max_issues_repo_head_hexsha": "74707d3538bf494f4bd30263d2f5515a84733865",
"max_issues_repo_issues_event_max_datetime": "2019-05-29T09:50:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-01-13T13:12:33.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "jmchapman/Relative-Monads",
"max_issues_repo_path": "StrongArrows.agda",
"max_line_length": 74,
"max_stars_count": 21,
"max_stars_repo_head_hexsha": "74707d3538bf494f4bd30263d2f5515a84733865",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "jmchapman/Relative-Monads",
"max_stars_repo_path": "StrongArrows.agda",
"max_stars_repo_stars_event_max_datetime": "2021-02-13T18:02:18.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-07-30T01:25:12.000Z",
"num_tokens": 137,
"size": 397
} |
{-
Functions between structures S and T: X ↦ S X → T X
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Structures.Function where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Function
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Path
open import Cubical.Foundations.SIP
open import Cubical.Foundations.Transport
open import Cubical.Foundations.Univalence
open import Cubical.Functions.FunExtEquiv
open import Cubical.Data.Nat
open import Cubical.Data.Vec
private
variable
ℓ ℓ₁ ℓ₁' ℓ₂ ℓ₂' : Level
-- General function structure
FunctionStructure : (S : Type ℓ → Type ℓ₁) (T : Type ℓ → Type ℓ₂)
→ Type ℓ → Type (ℓ-max ℓ₁ ℓ₂)
FunctionStructure S T X = S X → T X
FunctionEquivStr : {S : Type ℓ → Type ℓ₁} {T : Type ℓ → Type ℓ₂}
→ StrEquiv S ℓ₁' → StrEquiv T ℓ₂'
→ StrEquiv (FunctionStructure S T) (ℓ-max ℓ₁ (ℓ-max ℓ₁' ℓ₂'))
FunctionEquivStr {S = S} {T} ι₁ ι₂ (X , f) (Y , g) e =
{s : S X} {t : S Y} → ι₁ (X , s) (Y , t) e → ι₂ (X , f s) (Y , g t) e
functionUnivalentStr : {S : Type ℓ → Type ℓ₁} {T : Type ℓ → Type ℓ₂}
(ι₁ : StrEquiv S ℓ₁') (θ₁ : UnivalentStr S ι₁)
(ι₂ : StrEquiv T ℓ₂') (θ₂ : UnivalentStr T ι₂)
→ UnivalentStr (FunctionStructure S T) (FunctionEquivStr ι₁ ι₂)
functionUnivalentStr ι₁ θ₁ ι₂ θ₂ e =
compEquiv
(equivImplicitΠCod (equivImplicitΠCod (equiv→ (θ₁ e) (θ₂ e))))
funExtDepEquiv
functionEquivAction : {S : Type ℓ → Type ℓ₁} {T : Type ℓ → Type ℓ₂}
→ EquivAction S → EquivAction T
→ EquivAction (FunctionStructure S T)
functionEquivAction α₁ α₂ e = equiv→ (α₁ e) (α₂ e)
functionTransportStr : {S : Type ℓ → Type ℓ₁} {T : Type ℓ → Type ℓ₂}
(α₁ : EquivAction S) (τ₁ : TransportStr α₁)
(α₂ : EquivAction T) (τ₂ : TransportStr α₂)
→ TransportStr (functionEquivAction α₁ α₂)
functionTransportStr {S = S} α₁ τ₁ α₂ τ₂ e f =
funExt λ t →
cong (equivFun (α₂ e) ∘ f) (invTransportStr α₁ τ₁ e t)
∙ τ₂ e (f (subst⁻ S (ua e) t))
-- Definition of structured equivalence using an action in the domain
FunctionEquivStr+ : {S : Type ℓ → Type ℓ₁} {T : Type ℓ → Type ℓ₂}
→ EquivAction S → StrEquiv T ℓ₂'
→ StrEquiv (FunctionStructure S T) (ℓ-max ℓ₁ ℓ₂')
FunctionEquivStr+ {S = S} {T} α₁ ι₂ (X , f) (Y , g) e =
(s : S X) → ι₂ (X , f s) (Y , g (equivFun (α₁ e) s)) e
functionUnivalentStr+ : {S : Type ℓ → Type ℓ₁} {T : Type ℓ → Type ℓ₂}
(α₁ : EquivAction S) (τ₁ : TransportStr α₁)
(ι₂ : StrEquiv T ℓ₂') (θ₂ : UnivalentStr T ι₂)
→ UnivalentStr (FunctionStructure S T) (FunctionEquivStr+ α₁ ι₂)
functionUnivalentStr+ {S = S} {T} α₁ τ₁ ι₂ θ₂ {X , f} {Y , g} e =
compEquiv
(compEquiv
(equivΠCod λ s →
compEquiv
(θ₂ e)
(pathToEquiv (cong (PathP (λ i → T (ua e i)) (f s) ∘ g) (τ₁ e s))))
(invEquiv heteroHomotopy≃Homotopy))
funExtDepEquiv
| {
"alphanum_fraction": 0.6584089323,
"avg_line_length": 34.5301204819,
"ext": "agda",
"hexsha": "e0437624b8909a6a665f8a916d6bffdd67a16dd4",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "dan-iel-lee/cubical",
"max_forks_repo_path": "Cubical/Structures/Function.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_issues_repo_issues_event_max_datetime": "2022-01-27T02:07:48.000Z",
"max_issues_repo_issues_event_min_datetime": "2022-01-27T02:07:48.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "dan-iel-lee/cubical",
"max_issues_repo_path": "Cubical/Structures/Function.agda",
"max_line_length": 77,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "fd8059ec3eed03f8280b4233753d00ad123ffce8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "dan-iel-lee/cubical",
"max_stars_repo_path": "Cubical/Structures/Function.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 1136,
"size": 2866
} |
module examplesPaperJFP.triangleRightOperator where
_▹_ : ∀{A B : Set} → A → (A → B) → B
a ▹ f = f a
| {
"alphanum_fraction": 0.5833333333,
"avg_line_length": 21.6,
"ext": "agda",
"hexsha": "72428a32eda14aed249431bf99be5bcf7ca51afd",
"lang": "Agda",
"max_forks_count": 2,
"max_forks_repo_forks_event_max_datetime": "2022-03-12T11:41:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2018-09-01T15:02:37.000Z",
"max_forks_repo_head_hexsha": "7cc45e0148a4a508d20ed67e791544c30fecd795",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "agda/ooAgda",
"max_forks_repo_path": "examples/examplesPaperJFP/triangleRightOperator.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "7cc45e0148a4a508d20ed67e791544c30fecd795",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "agda/ooAgda",
"max_issues_repo_path": "examples/examplesPaperJFP/triangleRightOperator.agda",
"max_line_length": 51,
"max_stars_count": 23,
"max_stars_repo_head_hexsha": "7cc45e0148a4a508d20ed67e791544c30fecd795",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "agda/ooAgda",
"max_stars_repo_path": "examples/examplesPaperJFP/triangleRightOperator.agda",
"max_stars_repo_stars_event_max_datetime": "2020-10-12T23:15:25.000Z",
"max_stars_repo_stars_event_min_datetime": "2016-06-19T12:57:55.000Z",
"num_tokens": 46,
"size": 108
} |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2021 Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.Base.PKCS
open import LibraBFT.Base.Types
open import LibraBFT.Prelude
import LibraBFT.Yasm.Base as LYB
import LibraBFT.Yasm.System as LYS
-- This module provides a single import for all Yasm modules
module LibraBFT.Yasm.Yasm
(ℓ-PeerState : Level)
(ℓ-VSFP : Level)
(parms : LYB.SystemTypeParameters ℓ-PeerState)
(iiah : LYB.SystemInitAndHandlers ℓ-PeerState parms)
(ValidSenderForPK : LYS.WithInitAndHandlers.ValidSenderForPK-type ℓ-PeerState ℓ-VSFP parms iiah)
(ValidSenderForPK-stable : LYS.WithInitAndHandlers.ValidSenderForPK-stable-type ℓ-PeerState ℓ-VSFP parms iiah ValidSenderForPK)
where
open LYB.SystemTypeParameters parms
open LYB.SystemInitAndHandlers iiah
open import LibraBFT.Yasm.Base public
open import LibraBFT.Yasm.Types public
open import LibraBFT.Yasm.System ℓ-PeerState ℓ-VSFP parms public
open import LibraBFT.Yasm.Properties ℓ-PeerState ℓ-VSFP parms iiah ValidSenderForPK ValidSenderForPK-stable public
open WithInitAndHandlers iiah public
open import Util.FunctionOverride PeerId _≟PeerId_ public
| {
"alphanum_fraction": 0.626035503,
"avg_line_length": 54.5161290323,
"ext": "agda",
"hexsha": "535166f5e71e14e1ec8a6842bfbc0347ef0180db",
"lang": "Agda",
"max_forks_count": 6,
"max_forks_repo_forks_event_max_datetime": "2022-02-18T01:04:32.000Z",
"max_forks_repo_forks_event_min_datetime": "2020-12-16T19:43:52.000Z",
"max_forks_repo_head_hexsha": "49f8b1b70823be805d84ffc3157c3b880edb1e92",
"max_forks_repo_licenses": [
"UPL-1.0"
],
"max_forks_repo_name": "oracle/bft-consensus-agda",
"max_forks_repo_path": "LibraBFT/Yasm/Yasm.agda",
"max_issues_count": 72,
"max_issues_repo_head_hexsha": "49f8b1b70823be805d84ffc3157c3b880edb1e92",
"max_issues_repo_issues_event_max_datetime": "2022-03-25T05:36:11.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-02-04T05:04:33.000Z",
"max_issues_repo_licenses": [
"UPL-1.0"
],
"max_issues_repo_name": "oracle/bft-consensus-agda",
"max_issues_repo_path": "LibraBFT/Yasm/Yasm.agda",
"max_line_length": 130,
"max_stars_count": 4,
"max_stars_repo_head_hexsha": "49f8b1b70823be805d84ffc3157c3b880edb1e92",
"max_stars_repo_licenses": [
"UPL-1.0"
],
"max_stars_repo_name": "oracle/bft-consensus-agda",
"max_stars_repo_path": "LibraBFT/Yasm/Yasm.agda",
"max_stars_repo_stars_event_max_datetime": "2021-12-18T19:24:05.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-12-16T19:43:41.000Z",
"num_tokens": 402,
"size": 1690
} |
{-# OPTIONS --cubical-compatible #-}
postulate
A : Set
B : A → Set
@0 T : Set
T = (@0 x : A) → B x
_ : Set₁
_ = (@0 A : Set) → @0 A → (@0 x : A) → Set
data D : Set₁ where
@0 c : (@0 A : Set) → A → (x : A) → D
| {
"alphanum_fraction": 0.4449541284,
"avg_line_length": 15.5714285714,
"ext": "agda",
"hexsha": "05b090368ef840d82982606ef2fb8ff984d7e97c",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_forks_repo_licenses": [
"BSD-2-Clause"
],
"max_forks_repo_name": "KDr2/agda",
"max_forks_repo_path": "test/Succeed/Issue4784.agda",
"max_issues_count": 6,
"max_issues_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_issues_repo_issues_event_max_datetime": "2021-11-24T08:31:10.000Z",
"max_issues_repo_issues_event_min_datetime": "2021-10-18T08:12:24.000Z",
"max_issues_repo_licenses": [
"BSD-2-Clause"
],
"max_issues_repo_name": "KDr2/agda",
"max_issues_repo_path": "test/Succeed/Issue4784.agda",
"max_line_length": 42,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "98c9382a59f707c2c97d75919e389fc2a783ac75",
"max_stars_repo_licenses": [
"BSD-2-Clause"
],
"max_stars_repo_name": "KDr2/agda",
"max_stars_repo_path": "test/Succeed/Issue4784.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 97,
"size": 218
} |
------------------------------------------------------------------------------
-- Inductive Peano arithmetic base
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module PA.Inductive.Base where
infixl 7 _*_
infixl 6 _+_
------------------------------------------------------------------------------
-- PA universe
open import PA.Inductive.Base.Core public
-- First-order logic (without equality)
--
open import Common.FOL.FOL public hiding ( _,_ ; ∃ )
-- 2012-04-24. Agda bug? Why it is necessary to use the modifier
-- @using@ in the following importation?
open import PA.Inductive.Existential public using ( _,_ ; ∃ )
-- The induction principle on the PA universe
ℕ-ind : (A : ℕ → Set) → A zero → (∀ n → A n → A (succ n)) → ∀ n → A n
ℕ-ind A A0 h zero = A0
ℕ-ind A A0 h (succ n) = h n (ℕ-ind A A0 h n)
-- The identity type on the PA universe
open import PA.Inductive.Relation.Binary.PropositionalEquality public
-- PA primitive recursive functions
_+_ : ℕ → ℕ → ℕ
zero + n = n
succ m + n = succ (m + n)
_*_ : ℕ → ℕ → ℕ
zero * n = zero
succ m * n = n + m * n
------------------------------------------------------------------------------
-- ATPs helper
-- We don't traslate the body of functions, only the types. Therefore
-- we need to feed the ATPs with the functions' equations.
-- Addition axioms
+-0x : ∀ n → zero + n ≡ n
+-0x n = refl
-- {-# ATP hint +-0x #-}
+-Sx : ∀ m n → succ m + n ≡ succ (m + n)
+-Sx m n = refl
{-# ATP hint +-Sx #-}
-- Multiplication axioms
*-0x : ∀ n → zero * n ≡ zero
*-0x n = refl
-- {-# ATP hint *-0x #-}
*-Sx : ∀ m n → succ m * n ≡ n + m * n
*-Sx m n = refl
-- {-# ATP hint *-Sx #-}
| {
"alphanum_fraction": 0.493485342,
"avg_line_length": 28.3384615385,
"ext": "agda",
"hexsha": "e36be06e94c6b04021132f144c6d306e6b5ab382",
"lang": "Agda",
"max_forks_count": 3,
"max_forks_repo_forks_event_max_datetime": "2018-03-14T08:50:00.000Z",
"max_forks_repo_forks_event_min_datetime": "2016-09-19T14:18:30.000Z",
"max_forks_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "asr/fotc",
"max_forks_repo_path": "src/fot/PA/Inductive/Base.agda",
"max_issues_count": 2,
"max_issues_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_issues_repo_issues_event_max_datetime": "2017-01-01T14:34:26.000Z",
"max_issues_repo_issues_event_min_datetime": "2016-10-12T17:28:16.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "asr/fotc",
"max_issues_repo_path": "src/fot/PA/Inductive/Base.agda",
"max_line_length": 78,
"max_stars_count": 11,
"max_stars_repo_head_hexsha": "2fc9f2b81052a2e0822669f02036c5750371b72d",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "asr/fotc",
"max_stars_repo_path": "src/fot/PA/Inductive/Base.agda",
"max_stars_repo_stars_event_max_datetime": "2021-09-12T16:09:54.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-09-03T20:53:42.000Z",
"num_tokens": 506,
"size": 1842
} |
{-# OPTIONS --safe #-}
module Cubical.Algebra.MonoidSolver.Reflection where
open import Cubical.Foundations.Prelude hiding (Type)
open import Agda.Builtin.Reflection hiding (Type)
open import Agda.Builtin.String
open import Cubical.Reflection.Base
open import Cubical.Data.Maybe
open import Cubical.Data.Sigma
open import Cubical.Data.List
open import Cubical.Data.Nat
open import Cubical.Data.FinData using () renaming (zero to fzero; suc to fsuc)
open import Cubical.Data.Bool
open import Cubical.Data.Vec using (Vec) renaming ([] to emptyVec; _∷_ to _∷vec_) public
open import Cubical.Algebra.Monoid.Base
open import Cubical.Algebra.CommMonoid.Base
open import Cubical.Algebra.MonoidSolver.Solver renaming (solve to naiveSolve)
open import Cubical.Algebra.MonoidSolver.CommSolver renaming (solve to naiveCommSolve)
open import Cubical.Algebra.MonoidSolver.MonoidExpression
private
variable
ℓ : Level
module ReflectionSolver (op unit solver : Name) where
_==_ = primQNameEquality
{-# INLINE _==_ #-}
record VarInfo : Type ℓ-zero where
field
varName : String
varType : Arg Term
index : ℕ
{-
`getLastTwoArgsOf` maps a term 'def n (z₁ ∷ … ∷ zₙ ∷ x ∷ y ∷ [])' to the pair '(x,y)'
non-visible arguments are ignored.
-}
getLastTwoArgsOf : Name → Term → Maybe (Term × Term)
getLastTwoArgsOf n' (def n xs) =
if n == n'
then go xs
else nothing
where
go : List (Arg Term) → Maybe (Term × Term)
go (varg x ∷ varg y ∷ []) = just (x , y)
go (x ∷ xs) = go xs
go _ = nothing
getLastTwoArgsOf n' _ = nothing
{-
`getArgs` maps a term 'x ≡ y' to the pair '(x,y)'
-}
getArgs : Term → Maybe (Term × Term)
getArgs = getLastTwoArgsOf (quote PathP)
firstVisibleArg : List (Arg Term) → Maybe Term
firstVisibleArg [] = nothing
firstVisibleArg (varg x ∷ l) = just x
firstVisibleArg (x ∷ l) = firstVisibleArg l
{-
If the solver needs to be applied during equational reasoning,
the right hand side of the equation to solve cannot be given to
the solver directly. The following function extracts this term y
from a more complex expression as in:
x ≡⟨ solve ... ⟩ (y ≡⟨ ... ⟩ z ∎)
-}
getRhs : Term → Maybe Term
getRhs reasoningToTheRight@(def n xs) =
if n == (quote _∎)
then firstVisibleArg xs
else (if n == (quote _≡⟨_⟩_)
then firstVisibleArg xs
else nothing)
getRhs _ = nothing
private
solverCallAsTerm : Term → Arg Term → Term → Term → Term
solverCallAsTerm M varList lhs rhs =
def
solver
(varg M ∷ varg lhs ∷ varg rhs
∷ varList
∷ varg (def (quote refl) []) ∷ [])
solverCallWithLambdas : ℕ → List VarInfo → Term → Term → Term → Term
solverCallWithLambdas n varInfos M lhs rhs =
encloseWithIteratedLambda
(map VarInfo.varName varInfos)
(solverCallAsTerm M (variableList (rev varInfos)) lhs rhs)
where
encloseWithIteratedLambda : List String → Term → Term
encloseWithIteratedLambda (varName ∷ xs) t = lam visible (abs varName (encloseWithIteratedLambda xs t))
encloseWithIteratedLambda [] t = t
variableList : List VarInfo → Arg Term
variableList [] = varg (con (quote emptyVec) [])
variableList (varInfo ∷ varInfos)
= varg (con (quote _∷vec_) (varg (var (VarInfo.index varInfo) []) ∷ (variableList varInfos) ∷ []))
solverCallByVarIndices : ℕ → List ℕ → Term → Term → Term → Term
solverCallByVarIndices n varIndices R lhs rhs =
solverCallAsTerm R (variableList (rev varIndices)) lhs rhs
where
variableList : List ℕ → Arg Term
variableList [] = varg (con (quote emptyVec) [])
variableList (varIndex ∷ varIndices)
= varg (con (quote _∷vec_) (varg (var (varIndex) []) ∷ (variableList varIndices) ∷ []))
module _ (monoid : Term) where
`ε⊗` : Term
`ε⊗` = con (quote ε⊗) []
mutual
`_⊗_` : List (Arg Term) → Term
`_⊗_` (harg _ ∷ xs) = `_⊗_` xs
`_⊗_` (varg _ ∷ varg x ∷ varg y ∷ []) =
con
(quote _⊗_) (varg (buildExpression x) ∷ varg (buildExpression y) ∷ [])
`_⊗_` _ = unknown
finiteNumberAsTerm : ℕ → Term
finiteNumberAsTerm ℕ.zero = con (quote fzero) []
finiteNumberAsTerm (ℕ.suc n) = con (quote fsuc) (varg (finiteNumberAsTerm n) ∷ [])
buildExpression : Term → Term
buildExpression (var index _) = con (quote ∣) (varg (finiteNumberAsTerm index) ∷ [])
buildExpression t@(def n xs) =
if (n == op)
then `_⊗_` xs
else if (n == unit)
then `ε⊗`
else
unknown
buildExpression t = unknown
toMonoidExpression : Maybe (Term × Term) → Maybe (Term × Term)
toMonoidExpression nothing = nothing
toMonoidExpression (just (lhs , rhs)) = just (buildExpression lhs , buildExpression rhs)
adjustDeBruijnIndex : (n : ℕ) → Term → Term
adjustDeBruijnIndex n (var k args) = var (k + n) args
adjustDeBruijnIndex n _ = unknown
extractVarIndices : Maybe (List Term) → Maybe (List ℕ)
extractVarIndices (just ((var index _) ∷ l)) with extractVarIndices (just l)
... | just indices = just (index ∷ indices)
... | nothing = nothing
extractVarIndices (just []) = just []
extractVarIndices _ = nothing
getVarsAndEquation : Term → Maybe (List VarInfo × Term)
getVarsAndEquation t =
let
(rawVars , equationTerm) = extractVars t
maybeVars = addIndices (length rawVars) rawVars
in map-Maybe (_, equationTerm) maybeVars
where
extractVars : Term → List (String × Arg Term) × Term
extractVars (pi argType (abs varName t)) with extractVars t
... | xs , equation
= (varName , argType) ∷ xs , equation
extractVars equation = [] , equation
addIndices : ℕ → List (String × Arg Term) → Maybe (List VarInfo)
addIndices ℕ.zero [] = just []
addIndices (ℕ.suc countVar) ((varName , argType) ∷ list) =
map-Maybe (λ varList → record { varName = varName ; varType = argType ; index = countVar }
∷ varList)
(addIndices countVar list)
addIndices _ _ = nothing
toListOfTerms : Term → Maybe (List Term)
toListOfTerms (con c []) = if (c == (quote [])) then just [] else nothing
toListOfTerms (con c (varg t ∷ varg s ∷ args)) with toListOfTerms s
... | just terms = if (c == (quote _∷_)) then just (t ∷ terms) else nothing
... | nothing = nothing
toListOfTerms (con c (harg t ∷ args)) = toListOfTerms (con c args)
toListOfTerms _ = nothing
solve-macro : Term → Term → TC Unit
solve-macro monoid hole =
do
hole′ ← inferType hole >>= normalise
just (varInfos , equation) ← returnTC (getVarsAndEquation hole′)
where
nothing
→ typeError (strErr "Something went wrong when getting the variable names in "
∷ termErr hole′ ∷ [])
{-
The call to the monoid solver will be inside a lamba-expression.
That means, that we have to adjust the deBruijn-indices of the variables in 'monoid'
-}
adjustedMonoid ← returnTC (adjustDeBruijnIndex (length varInfos) monoid)
just (lhs , rhs) ← returnTC (toMonoidExpression adjustedMonoid (getArgs equation))
where
nothing
→ typeError(
strErr "Error while trying to build ASTs for the equation " ∷
termErr equation ∷ [])
let solution = solverCallWithLambdas (length varInfos) varInfos adjustedMonoid lhs rhs
unify hole solution
macro
solveMonoid : Term → Term → TC _
solveMonoid = ReflectionSolver.solve-macro (quote MonoidStr._·_) (quote MonoidStr.ε) (quote naiveSolve)
solveCommMonoid : Term → Term → TC _
solveCommMonoid = ReflectionSolver.solve-macro (quote CommMonoidStr._·_) (quote CommMonoidStr.ε) (quote naiveCommSolve)
| {
"alphanum_fraction": 0.627246808,
"avg_line_length": 36.3378378378,
"ext": "agda",
"hexsha": "3c33ed3fc9b9699d51420188043495d8fc98cbfd",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "thomas-lamiaux/cubical",
"max_forks_repo_path": "Cubical/Algebra/MonoidSolver/Reflection.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "thomas-lamiaux/cubical",
"max_issues_repo_path": "Cubical/Algebra/MonoidSolver/Reflection.agda",
"max_line_length": 121,
"max_stars_count": 1,
"max_stars_repo_head_hexsha": "58c0b83bb0fed0dc683f3d29b1709effe51c1689",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "thomas-lamiaux/cubical",
"max_stars_repo_path": "Cubical/Algebra/MonoidSolver/Reflection.agda",
"max_stars_repo_stars_event_max_datetime": "2021-10-31T17:32:49.000Z",
"max_stars_repo_stars_event_min_datetime": "2021-10-31T17:32:49.000Z",
"num_tokens": 2304,
"size": 8067
} |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category using (Category; module Commutation)
-- The "four middle interchange" for monoidal categories.
--
-- Aka the "interchange law" or "exchange law" (though those terms are
-- more comonly used in the more general context of composition in
-- 2-categories).
-- Section 5.3 of the PhD thesis of Geoff Cruttwell states most (all?)
-- the properties in the module, starting on p. 57 (starting with Prop. 5.3.4).
-- It also has nice string-diagrammatic proofs.
-- See also further comments in https://github.com/agda/agda-categories/pull/294#issuecomment-897697009
module Categories.Category.Monoidal.Interchange
{o ℓ e} {C : Category o ℓ e} where
open import Level using (_⊔_)
import Categories.Category.Monoidal.Construction.Product as MonoidalProduct
open import Categories.Category.Monoidal.Core using (Monoidal)
import Categories.Category.Monoidal.Utilities as MonoidalUtilities
open import Categories.Category.Product using (_⁂_)
open import Categories.Functor using (_∘F_)
open import Categories.NaturalTransformation.NaturalIsomorphism using (_≃_; niHelper)
open import Categories.Morphism C using (_≅_; module ≅)
open Category C using (Obj; id; _⇒_; _∘_; _≈_)
open Commutation C
private
variable
W W₁ W₂ X X₁ X₂ Y Y₁ Y₂ Z Z₁ Z₂ : Obj
f g h i : X ⇒ Y
-- An abstract definition of an interchange map with the minimal set
-- of coherence laws required to make the tensor product ⊗ of C a
-- monoidal functor. (See also Categories.Functor.Monoidal.Tensor.)
record HasInterchange (M : Monoidal C) : Set (o ⊔ ℓ ⊔ e) where
open Monoidal M using (_⊗₀_; _⊗₁_; unit; ⊗)
open MonoidalUtilities.Shorthands M using (α⇒; λ⇐; λ⇒; ρ⇒)
-- The "four middle interchange" for tensor products.
field swapInner : ∀ {W X Y Z} → (W ⊗₀ X) ⊗₀ (Y ⊗₀ Z) ≅ (W ⊗₀ Y) ⊗₀ (X ⊗₀ Z)
module swapInner {W X Y Z} = _≅_ (swapInner {W} {X} {Y} {Z})
private
i⇒ = swapInner.from
i⇐ = swapInner.to
-- Naturality and coherence laws of the interchange.
field
natural : i⇒ ∘ (f ⊗₁ g) ⊗₁ (h ⊗₁ i) ≈ (f ⊗₁ h) ⊗₁ (g ⊗₁ i) ∘ i⇒
assoc : [ ((X₁ ⊗₀ X₂) ⊗₀ (Y₁ ⊗₀ Y₂)) ⊗₀ (Z₁ ⊗₀ Z₂) ⇒
(X₁ ⊗₀ (Y₁ ⊗₀ Z₁)) ⊗₀ (X₂ ⊗₀ (Y₂ ⊗₀ Z₂)) ]⟨
i⇒ ⊗₁ id ⇒⟨ ((X₁ ⊗₀ Y₁) ⊗₀ (X₂ ⊗₀ Y₂)) ⊗₀ (Z₁ ⊗₀ Z₂) ⟩
i⇒ ⇒⟨ ((X₁ ⊗₀ Y₁) ⊗₀ Z₁) ⊗₀ ((X₂ ⊗₀ Y₂) ⊗₀ Z₂) ⟩
α⇒ ⊗₁ α⇒
≈ α⇒ ⇒⟨ (X₁ ⊗₀ X₂) ⊗₀ ((Y₁ ⊗₀ Y₂) ⊗₀ (Z₁ ⊗₀ Z₂)) ⟩
id ⊗₁ i⇒ ⇒⟨ (X₁ ⊗₀ X₂) ⊗₀ ((Y₁ ⊗₀ Z₁) ⊗₀ (Y₂ ⊗₀ Z₂)) ⟩
i⇒
⟩
unitˡ : [ unit ⊗₀ (X ⊗₀ Y) ⇒ (X ⊗₀ Y) ]⟨
λ⇐ ⊗₁ id ⇒⟨ (unit ⊗₀ unit) ⊗₀ (X ⊗₀ Y) ⟩
i⇒ ⇒⟨ (unit ⊗₀ X) ⊗₀ (unit ⊗₀ Y) ⟩
λ⇒ ⊗₁ λ⇒
≈ λ⇒
⟩
unitʳ : [ (X ⊗₀ Y) ⊗₀ unit ⇒ (X ⊗₀ Y) ]⟨
id ⊗₁ λ⇐ ⇒⟨ (X ⊗₀ Y) ⊗₀ (unit ⊗₀ unit) ⟩
i⇒ ⇒⟨ (X ⊗₀ unit) ⊗₀ (Y ⊗₀ unit) ⟩
ρ⇒ ⊗₁ ρ⇒
≈ ρ⇒
⟩
-- The interchange is a natural isomorphism.
naturalIso : ⊗ ∘F (⊗ ⁂ ⊗) ≃ ⊗ ∘F MonoidalProduct.⊗ M M
naturalIso = niHelper (record
{ η = λ _ → i⇒
; η⁻¹ = λ _ → i⇐
; commute = λ _ → natural
; iso = λ _ → swapInner.iso
})
| {
"alphanum_fraction": 0.567867036,
"avg_line_length": 35.3152173913,
"ext": "agda",
"hexsha": "ec71ea38969f7b53f30451d0f2b6da54e5fd7c2b",
"lang": "Agda",
"max_forks_count": 64,
"max_forks_repo_forks_event_max_datetime": "2022-03-14T02:00:59.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-06-02T16:58:15.000Z",
"max_forks_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Code-distancing/agda-categories",
"max_forks_repo_path": "src/Categories/Category/Monoidal/Interchange.agda",
"max_issues_count": 236,
"max_issues_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_issues_repo_issues_event_max_datetime": "2022-03-28T14:31:43.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-06-01T14:53:54.000Z",
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Code-distancing/agda-categories",
"max_issues_repo_path": "src/Categories/Category/Monoidal/Interchange.agda",
"max_line_length": 106,
"max_stars_count": 279,
"max_stars_repo_head_hexsha": "d9e4f578b126313058d105c61707d8c8ae987fa8",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Trebor-Huang/agda-categories",
"max_stars_repo_path": "src/Categories/Category/Monoidal/Interchange.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-22T00:40:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-06-01T14:36:40.000Z",
"num_tokens": 1290,
"size": 3249
} |
postulate A : Set
data D : Set where
c : A → D
data P : D → Set where
d : (x : A) → P (c x)
g : (x : D) → P x → D
g blargh (d y) with Set
g glurph (d y) | w = {!!}
-- Expected: glurph = c y : D, y : A, w : Set₁
h : D → D
h x@(c y) with Set
h (c z) | w = {!!}
-- Expected: z : A, w : Set₁
| {
"alphanum_fraction": 0.4584717608,
"avg_line_length": 15.8421052632,
"ext": "agda",
"hexsha": "4b57ce2608000113c7ca2e8e444729b5d3be0268",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_forks_event_min_datetime": "2019-03-05T20:02:38.000Z",
"max_forks_repo_head_hexsha": "aac88412199dd4cbcb041aab499d8a6b7e3f4a2e",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "hborum/agda",
"max_forks_repo_path": "test/interaction/Issue2303.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "aac88412199dd4cbcb041aab499d8a6b7e3f4a2e",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "hborum/agda",
"max_issues_repo_path": "test/interaction/Issue2303.agda",
"max_line_length": 48,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "aac88412199dd4cbcb041aab499d8a6b7e3f4a2e",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "hborum/agda",
"max_stars_repo_path": "test/interaction/Issue2303.agda",
"max_stars_repo_stars_event_max_datetime": "2015-12-07T20:14:00.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-03-28T14:51:03.000Z",
"num_tokens": 139,
"size": 301
} |
-- 2018-05-25, Reported by Sergei Meshveliani on the Agda list
open import Common.Prelude
record _×_ (A B : Set) : Set where
constructor _,_
field
fst : A
snd : B
f : List (Nat × Nat) → List (Nat × Nat)
f ps =
map (\p → let (x , y) = p in (x , suc y)) ps
| {
"alphanum_fraction": 0.5833333333,
"avg_line_length": 19.7142857143,
"ext": "agda",
"hexsha": "f1d6224feb9db865775ba94e28e0061e75983d8c",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue3085.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue3085.agda",
"max_line_length": 62,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue3085.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 99,
"size": 276
} |
module Esterel.CompletionCode where
open import Data.Nat
using (ℕ ; zero ; suc) renaming (_≟_ to _≟ℕ_ ; _⊔_ to _⊔ℕ_ ; _≤_ to _≤N_ ; _≤?_ to _≤?N_)
open import Data.Nat.Properties
using (⊔-⊓-isCommutativeSemiringWithoutOne)
open import Function
using (_∘_)
open import Relation.Nullary
using (Dec ; yes ; no)
open import Relation.Binary
using (Decidable)
open import Relation.Binary.PropositionalEquality
using (_≡_ ; refl ; cong)
import Level
import Relation.Binary
open import Data.List using (List ; _∷_ ; [] ; _++_)
open import Data.List.Any.Properties using (++⁻)
renaming (++⁺ˡ to ++ˡ ; ++⁺ʳ to ++ʳ)
open import Data.Sum using (_⊎_ ; inj₁ ; inj₂)
open import Data.Empty using (⊥-elim)
import Data.Bool
open import Algebra.Structures
using (IsCommutativeSemiringWithoutOne ; IsCommutativeMonoid)
open import utility
data CompletionCode : Set where
nothin : CompletionCode
pause : CompletionCode
exit : ℕ → CompletionCode
↓* : CompletionCode → CompletionCode
↓* nothin = nothin
↓* pause = pause
↓* (exit zero) = nothin
↓* (exit (suc n)) = exit n
exit-injective : ∀{n m} → exit n ≡ exit m → n ≡ m
exit-injective refl = refl
_≟_ : Decidable {A = CompletionCode} _≡_
nothin ≟ nothin = yes refl
nothin ≟ pause = no λ()
nothin ≟ exit _ = no λ()
pause ≟ nothin = no λ()
pause ≟ pause = yes refl
pause ≟ exit _ = no λ()
exit _ ≟ nothin = no λ()
exit _ ≟ pause = no λ()
exit n ≟ exit m with n ≟ℕ m
... | yes n≡m = yes (cong exit n≡m)
... | no ¬n≡m = no (¬n≡m ∘ exit-injective)
open ListSet _≟_
_⊔_ : CompletionCode → CompletionCode → CompletionCode
nothin ⊔ r = r
pause ⊔ nothin = pause
pause ⊔ r = r
exit n ⊔ nothin = exit n
exit n ⊔ pause = exit n
exit n ⊔ exit m = exit (n ⊔ℕ m)
⊔-comm : ∀ c₁ c₂ → c₁ ⊔ c₂ ≡ c₂ ⊔ c₁
⊔-comm nothin nothin = refl
⊔-comm nothin pause = refl
⊔-comm nothin (exit m) = refl
⊔-comm pause nothin = refl
⊔-comm pause pause = refl
⊔-comm pause (exit m) = refl
⊔-comm (exit n) nothin = refl
⊔-comm (exit n) pause = refl
⊔-comm (exit n) (exit m)
rewrite IsCommutativeMonoid.comm
(IsCommutativeSemiringWithoutOne.+-isCommutativeMonoid
⊔-⊓-isCommutativeSemiringWithoutOne) n m
= refl
data _≤_ : Relation.Binary.Rel CompletionCode Level.zero where
nothin≤c : ∀ {c} -> nothin ≤ c
pause≤pause : pause ≤ pause
pause≤exit : ∀ {n} -> pause ≤ exit n
exit≤exit : ∀ {n} {m} -> (n ≤N m) -> exit n ≤ exit m
_≤?_ : Decidable _≤_
nothin ≤? c2 = yes nothin≤c
pause ≤? nothin = no (λ ())
pause ≤? pause = yes pause≤pause
pause ≤? exit x = yes pause≤exit
exit n ≤? nothin = no (λ ())
exit n ≤? pause = no (λ ())
exit n ≤? exit m with n ≤?N m
exit n ≤? exit m | yes n≤m = yes (exit≤exit n≤m)
exit n ≤? exit m | no ¬n≤m = no ¬≤ where
¬≤ : Relation.Nullary.¬ (exit n ≤ exit m)
¬≤ (exit≤exit n) = ¬n≤m n
codessub : (List CompletionCode) → (List CompletionCode) → Set
codessub codes' codes = (∀ a → a ∈ codes' → a ∈ codes)
codesub++ll : ∀{a b c} → codessub a b → codessub a (b ++ c)
codesub++ll sub a a∈ = ++ˡ (sub a a∈)
codesub++both : ∀{a b c d} → codessub a c → codessub b d → codessub (a ++ b) (c ++ d)
codesub++both{a}{b}{c}{d} a⊂c b⊂d z z∈ with ++⁻ a z∈
... | inj₁ z∈1 = ++ˡ (a⊂c z z∈1)
... | inj₂ z∈2 = ++ʳ c (b⊂d z z∈2)
codesub- : ∀{a b} z → codessub a b → codessub (set-remove a z) (set-remove b z)
codesub-{a}{b} z a⊂b x x∈ with z ≟ x
... | yes refl = ⊥-elim (set-remove-removed{x}{a} x∈)
... | no ¬refl = set-remove-not-removed ¬refl (a⊂b x (set-remove-mono-∈ z x∈))
| {
"alphanum_fraction": 0.6054459572,
"avg_line_length": 31.8495575221,
"ext": "agda",
"hexsha": "2ef6db7f3ba8bf114042e351c32557504a4580b6",
"lang": "Agda",
"max_forks_count": 1,
"max_forks_repo_forks_event_max_datetime": "2020-04-15T20:02:49.000Z",
"max_forks_repo_forks_event_min_datetime": "2020-04-15T20:02:49.000Z",
"max_forks_repo_head_hexsha": "4340bef3f8df42ab8167735d35a4cf56243a45cd",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "florence/esterel-calculus",
"max_forks_repo_path": "agda/Esterel/CompletionCode.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "4340bef3f8df42ab8167735d35a4cf56243a45cd",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "florence/esterel-calculus",
"max_issues_repo_path": "agda/Esterel/CompletionCode.agda",
"max_line_length": 91,
"max_stars_count": 3,
"max_stars_repo_head_hexsha": "4340bef3f8df42ab8167735d35a4cf56243a45cd",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "florence/esterel-calculus",
"max_stars_repo_path": "agda/Esterel/CompletionCode.agda",
"max_stars_repo_stars_event_max_datetime": "2020-07-01T03:59:31.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-16T10:58:53.000Z",
"num_tokens": 1417,
"size": 3599
} |
mmodule silly1 where
| {
"alphanum_fraction": 0.8181818182,
"avg_line_length": 7.3333333333,
"ext": "agda",
"hexsha": "d0697094c3788eb2e791d40e7890efd8442ad9e8",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "alhassy/agda",
"max_forks_repo_path": "silly1.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "alhassy/agda",
"max_issues_repo_path": "silly1.agda",
"max_line_length": 20,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "6043e77e4a72518711f5f808fb4eb593cbf0bb7c",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "alhassy/agda",
"max_stars_repo_path": "silly1.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 6,
"size": 22
} |
module Values where
open import Data.Bool
open import Data.List
open import Data.List.All
open import Data.Nat
open import Data.Product
open import Data.Sum
open import Relation.Binary.PropositionalEquality
open import Typing
open import Syntax
open import Global
open import Channel
mutual
-- a value indexed by a *relevant* session context, which is "used up" by the value
data Val (G : SCtx) : Type → Set where
VUnit : (inaG : Inactive G)
→ Val G TUnit
VInt : (i : ℕ)
→ (inaG : Inactive G)
→ Val G TInt
VPair : ∀ {t₁ t₂ G₁ G₂}
→ (ss-GG₁G₂ : SSplit G G₁ G₂)
→ (v₁ : Val G₁ t₁)
→ (v₂ : Val G₂ t₂)
→ Val G (TPair t₁ t₂)
VChan : ∀ {s}
→ (ce : ChannelEnd)
→ (cr : ChannelRef G ce s)
→ Val G (TChan s)
VFun : ∀ {φ lu t₁ t₂}
→ (lu ≡ LL ⊎ All Unr φ)
→ (ϱ : VEnv G φ)
→ (e : Expr (t₁ ∷ φ) t₂)
→ Val G (TFun lu t₁ t₂)
-- type environment-indexed value environment
-- session context G describes the entire environment, it splits over all (channel) values
data VEnv (G : SCtx) : TCtx → Set where
vnil : (ina : Inactive G) → VEnv G []
vcons : ∀{t φ G₁ G₂} → (ssp : SSplit G G₁ G₂) → (v : Val G₁ t) → (ϱ : VEnv G₂ φ) → VEnv G (t ∷ φ)
unrestricted-val : ∀ {t G} → Unr t → Val G t → Inactive G
unrestricted-venv : ∀ {φ G} → All Unr φ → VEnv G φ → Inactive G
unrestricted-val UUnit (VUnit x) = x
unrestricted-val UInt (VInt i x) = x
unrestricted-val (UPair unrt unrt₁) (VPair x v v₁) =
ssplit-inactive x (unrestricted-val unrt v) (unrestricted-val unrt₁ v₁)
unrestricted-val {TFun UU t₁ t₂} UFun (VFun (inj₁ ()) ϱ e)
unrestricted-val {TFun UU t₁ t₂} UFun (VFun (inj₂ unr-φ) ϱ e) = unrestricted-venv unr-φ ϱ
unrestricted-venv unr-φ (vnil ina) = ina
unrestricted-venv (px ∷ unr-φ) (vcons ssp v ϱ) =
ssplit-inactive ssp (unrestricted-val px v) (unrestricted-venv unr-φ ϱ)
-- access a value in an indexed environment
access : ∀ {φ t} {G : SCtx} → VEnv G φ → t ∈ φ → ∃ λ G₁ → ∃ λ G₂ → Inactive G₂ × SSplit G G₁ G₂ × Val G₁ t
access (vcons ssp v ϱ) (here allUnr) = _ , _ , unrestricted-venv allUnr ϱ , ssp , v
access (vcons ssp x₀ ϱ) (there unrX₀ x) with access ϱ x
access (vcons ssp x₀ ϱ) (there unrX₀ x) | G₁ , G₂ , inaG₂ , ssp12 , v with ssplit-compose4 ssp ssp12
... | Gi , ssp1 , ssp2 = G₁ , Gi , ssplit-inactive ssp2 (unrestricted-val unrX₀ x₀) inaG₂ , ssp1 , v
-- coerce a value to a supertype
coerce : ∀ {G t t'} → Val G t → SubT t t' → Val G t'
coerce (VUnit inaG) sub-unit = VUnit inaG
coerce (VInt i inaG) sub-int = VInt i inaG
coerce (VPair ss-GG₁G₂ v v₁) (sub-pair t≤t' t≤t'') = VPair ss-GG₁G₂ (coerce v t≤t') (coerce v₁ t≤t'')
coerce (VChan b vcr) (sub-chan s≲s') = VChan b (vcr-coerce vcr s≲s')
coerce (VFun lu ϱ e) (sub-fun t≤t' t≤t'') = VFun lu ϱ (expr-coerce e t≤t'' t≤t')
rewrite-ssplit : ∀ {G G' G₁ G₂} → G ≡ G' → SSplit G G₁ G₂ → SSplit G' G₁ G₂
rewrite-ssplit p ssp rewrite p = ssp
rewrite-ssplit1 : ∀ {G G₁ G₁' G₂} → G₁ ≡ G₁' → SSplit G G₁ G₂ → SSplit G G₁' G₂
rewrite-ssplit1 p ssp rewrite p = ssp
-- split environment according to type context split
split-env : ∀ {Φ Φ₁ Φ₂} {G : SCtx}
→ Split Φ Φ₁ Φ₂
→ VEnv G Φ
→ Σ (SCtx × SCtx) λ { (G₁ , G₂) → SSplit G G₁ G₂ × VEnv G₁ Φ₁ × VEnv G₂ Φ₂ }
split-env{G = G} [] (vnil ina) = (G , G) , inactive-ssplit-trivial ina , vnil ina , vnil ina
split-env (dupl unrt sp) (vcons ssp v ϱ) with split-env sp ϱ | unrestricted-val unrt v
split-env (dupl unrt sp) (vcons ssp v ϱ) | (G₁' , G₂') , ssp12 , ϱ₁' , ϱ₂' | unr-v rewrite inactive-left-ssplit ssp unr-v with ssplit-compose4 ssp ssp12 | ssplit-compose3 ssp ssp12
... | Gi , ssp-GG1Gi , ssp-GiG1G2' | Gi-1 , ssp-GGiG2' , ssp-GiG1G1' =
let p₁ = (inactive-left-ssplit ssp-GiG1G1' unr-v) in
let p₂ = (inactive-left-ssplit ssp-GiG1G2' unr-v) in
(G₁' , G₂') , ssp12 , vcons (rewrite-ssplit p₁ ssp-GiG1G1') v ϱ₁' , vcons (rewrite-ssplit p₂ ssp-GiG1G2') v ϱ₂'
split-env (drop px sp) (vcons ssp v ϱ)
rewrite inactive-left-ssplit ssp (unrestricted-val px v)
= split-env sp ϱ
split-env (left sp) (vcons ssp v ϱ) with split-env sp ϱ
split-env{G = G} (left sp) (vcons ssp v ϱ) | (G₁' , G₂') , ssp12 , ϱ₁' , ϱ₂' with ssplit-compose3 ssp ssp12
... | Gi , ssp-GiG2' , ssp-GiG1G1' = (Gi , G₂') , ssp-GiG2' , vcons ssp-GiG1G1' v ϱ₁' , ϱ₂'
split-env (rght sp) (vcons ssp v ϱ) with split-env sp ϱ
split-env (rght sp) (vcons ssp v ϱ) | (G₁' , G₂') , ssp12 , ϱ₁' , ϱ₂' with ssplit-compose4 ssp ssp12
...| Gi , ssp-GG1'Gi , ssp-GiG1G2' = (G₁' , Gi) , ssp-GG1'Gi , ϱ₁' , vcons ssp-GiG1G2' v ϱ₂'
| {
"alphanum_fraction": 0.6305788776,
"avg_line_length": 44.3725490196,
"ext": "agda",
"hexsha": "65feba4ac439636d1e401845b14cb88dd436cb0d",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "c2213909c8a308fb1c1c1e4e789d65ba36f6042c",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "peterthiemann/definitional-session",
"max_forks_repo_path": "src/Values.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "c2213909c8a308fb1c1c1e4e789d65ba36f6042c",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "peterthiemann/definitional-session",
"max_issues_repo_path": "src/Values.agda",
"max_line_length": 180,
"max_stars_count": 9,
"max_stars_repo_head_hexsha": "c2213909c8a308fb1c1c1e4e789d65ba36f6042c",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "peterthiemann/definitional-session",
"max_stars_repo_path": "src/Values.agda",
"max_stars_repo_stars_event_max_datetime": "2021-01-18T08:10:14.000Z",
"max_stars_repo_stars_event_min_datetime": "2019-01-19T16:33:27.000Z",
"num_tokens": 1927,
"size": 4526
} |
open import Oscar.Prelude
open import Oscar.Class
open import Oscar.Class.IsEquivalence
open import Oscar.Data.𝟙
module Oscar.Class.HasEquivalence where
module _
{𝔬} (𝔒 : Ø 𝔬) ℓ
where
𝔥asEquivalence : Rℭlass 𝟙
𝔥asEquivalence = ∁ (𝔒 → 𝔒 → Ø ℓ) IsEquivalence
open Rℭlass 𝔥asEquivalence using () renaming (GET-CLASS to HasEquivalence) public
module _
{𝔬} (𝔒 : Ø 𝔬) {ℓ}
where
open Rℭlass (𝔥asEquivalence 𝔒 ℓ) using () renaming (GET-METHOD to Equivalence[_]) public
infix 4 ≈-syntax
≈-syntax = Equivalence[_]
syntax ≈-syntax 𝔒 x y = x ≈[ 𝔒 ] y
module _
{𝔬} {𝔒 : Ø 𝔬} {ℓ}
where
open Rℭlass (𝔥asEquivalence 𝔒 ℓ) using () renaming (GET-METHOD to Equivalence) public
infix 4 _≈_
_≈_ = Equivalence
| {
"alphanum_fraction": 0.7029288703,
"avg_line_length": 22.40625,
"ext": "agda",
"hexsha": "b702a24498b5c414347e73259f577180b2633cd8",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_forks_repo_licenses": [
"RSA-MD"
],
"max_forks_repo_name": "m0davis/oscar",
"max_forks_repo_path": "archive/agda-3/src/Oscar/Class/HasEquivalence.agda",
"max_issues_count": 1,
"max_issues_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_issues_repo_issues_event_max_datetime": "2019-05-11T23:33:04.000Z",
"max_issues_repo_issues_event_min_datetime": "2019-04-29T00:35:04.000Z",
"max_issues_repo_licenses": [
"RSA-MD"
],
"max_issues_repo_name": "m0davis/oscar",
"max_issues_repo_path": "archive/agda-3/src/Oscar/Class/HasEquivalence.agda",
"max_line_length": 90,
"max_stars_count": null,
"max_stars_repo_head_hexsha": "52e1cdbdee54d9a8eaee04ee518a0d7f61d25afb",
"max_stars_repo_licenses": [
"RSA-MD"
],
"max_stars_repo_name": "m0davis/oscar",
"max_stars_repo_path": "archive/agda-3/src/Oscar/Class/HasEquivalence.agda",
"max_stars_repo_stars_event_max_datetime": null,
"max_stars_repo_stars_event_min_datetime": null,
"num_tokens": 301,
"size": 717
} |
module _ where
module A where
postulate C : Set → Set → Set
syntax C X Y = X , Y
module B where
postulate C : Set
open A
open B
Foo : Set → Set
Foo X = X , X
| {
"alphanum_fraction": 0.5445026178,
"avg_line_length": 10.6111111111,
"ext": "agda",
"hexsha": "a88fb8976b99d42d015fb9ce06699c42a288ea0e",
"lang": "Agda",
"max_forks_count": 371,
"max_forks_repo_forks_event_max_datetime": "2022-03-30T19:00:30.000Z",
"max_forks_repo_forks_event_min_datetime": "2015-01-03T14:04:08.000Z",
"max_forks_repo_head_hexsha": "231d6ad8e77b67ff8c4b1cb35a6c31ccd988c3e9",
"max_forks_repo_licenses": [
"BSD-3-Clause"
],
"max_forks_repo_name": "Agda-zh/agda",
"max_forks_repo_path": "test/Succeed/Issue1194l.agda",
"max_issues_count": 4066,
"max_issues_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_issues_repo_issues_event_max_datetime": "2022-03-31T21:14:49.000Z",
"max_issues_repo_issues_event_min_datetime": "2015-01-10T11:24:51.000Z",
"max_issues_repo_licenses": [
"BSD-3-Clause"
],
"max_issues_repo_name": "shlevy/agda",
"max_issues_repo_path": "test/Succeed/Issue1194l.agda",
"max_line_length": 33,
"max_stars_count": 1989,
"max_stars_repo_head_hexsha": "ed8ac6f4062ea8a20fa0f62d5db82d4e68278338",
"max_stars_repo_licenses": [
"BSD-3-Clause"
],
"max_stars_repo_name": "shlevy/agda",
"max_stars_repo_path": "test/Succeed/Issue1194l.agda",
"max_stars_repo_stars_event_max_datetime": "2022-03-30T18:20:48.000Z",
"max_stars_repo_stars_event_min_datetime": "2015-01-09T23:51:16.000Z",
"num_tokens": 66,
"size": 191
} |
open import Type
open import Structure.Relator
open import Structure.Setoid renaming (_≡_ to _≡ₑ_)
module Structure.Sets.Quantifiers.Proofs {ℓₛ ℓₗ ℓₑ} {S : Type{ℓₛ}} ⦃ equiv : Equiv{ℓₑ}(S) ⦄ (_∈_ : S → S → Type{ℓₗ}) ⦃ [∈]-binaryRelator : BinaryRelator(_∈_) ⦄ where
import Lvl
open import Structure.Relator.Proofs renaming ([≡]-binaryRelator to [≡ₑ]-binaryRelator)
open import Structure.Sets.Quantifiers(_∈_)
open import Syntax.Function
private variable ℓ : Lvl.Level
private variable A : S
[∃ₛ]-unaryRelator : ∀{P : S → S → Type{ℓ}} → ⦃ rel-P : ∀{x} → UnaryRelator(P(x)) ⦄ → UnaryRelator(\y → ∃ₛ(A)(x ↦ P(x)(y)))
[∃ₛ]-unaryRelator = [∃]-unaryRelator ⦃ rel-P = [∧]-unaryRelator ⦄
[∀ₛ]-unaryRelator : ∀{P : S → S → Type{ℓ}} → ⦃ rel-P : ∀{x} → UnaryRelator(P(x)) ⦄ → UnaryRelator(\y → ∀ₛ(A)(x ↦ P(x)(y)))
[∀ₛ]-unaryRelator = [∀]-unaryRelator ⦃ rel-P = [→]-unaryRelator ⦄
[∃ₛ]-binaryRelator : ∀{P : S → S → S → Type{ℓ}} → ⦃ rel-P : ∀{x} → BinaryRelator(P(x)) ⦄ → BinaryRelator(\A y → ∃ₛ(A)(x ↦ P(x)(A)(y)))
[∃ₛ]-binaryRelator = binaryRelator-from-unaryRelator
⦃ relₗ = [∃]-unaryRelator ⦃ rel-P = [∧]-unaryRelator ⦃ rel-P = binary-unaryRelatorₗ ⦄ ⦃ rel-Q = binary-unaryRelatorᵣ ⦄ ⦄ ⦄
⦃ relᵣ = [∃]-unaryRelator ⦃ rel-P = [∧]-unaryRelator ⦃ rel-Q = binary-unaryRelatorₗ ⦄ ⦄ ⦄
[∀ₛ]-binaryRelator : ∀{P : S → S → S → Type{ℓ}} → ⦃ rel-P : ∀{x} → BinaryRelator(P(x)) ⦄ → BinaryRelator(\A y → ∀ₛ(A)(x ↦ P(x)(A)(y)))
[∀ₛ]-binaryRelator = binaryRelator-from-unaryRelator
⦃ relₗ = [∀]-unaryRelator ⦃ rel-P = [→]-unaryRelator ⦃ rel-P = binary-unaryRelatorₗ ⦄ ⦃ rel-Q = binary-unaryRelatorᵣ ⦄ ⦄ ⦄
⦃ relᵣ = [∀]-unaryRelator ⦃ rel-P = [→]-unaryRelator ⦃ rel-Q = binary-unaryRelatorₗ ⦄ ⦄ ⦄
| {
"alphanum_fraction": 0.6189349112,
"avg_line_length": 56.3333333333,
"ext": "agda",
"hexsha": "60c1ad1199b764ea6ea22a9e9d93db3307c03ea9",
"lang": "Agda",
"max_forks_count": null,
"max_forks_repo_forks_event_max_datetime": null,
"max_forks_repo_forks_event_min_datetime": null,
"max_forks_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_forks_repo_licenses": [
"MIT"
],
"max_forks_repo_name": "Lolirofle/stuff-in-agda",
"max_forks_repo_path": "Structure/Sets/Quantifiers/Proofs.agda",
"max_issues_count": null,
"max_issues_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_issues_repo_issues_event_max_datetime": null,
"max_issues_repo_issues_event_min_datetime": null,
"max_issues_repo_licenses": [
"MIT"
],
"max_issues_repo_name": "Lolirofle/stuff-in-agda",
"max_issues_repo_path": "Structure/Sets/Quantifiers/Proofs.agda",
"max_line_length": 165,
"max_stars_count": 6,
"max_stars_repo_head_hexsha": "70f4fba849f2fd779c5aaa5af122ccb6a5b271ba",
"max_stars_repo_licenses": [
"MIT"
],
"max_stars_repo_name": "Lolirofle/stuff-in-agda",
"max_stars_repo_path": "Structure/Sets/Quantifiers/Proofs.agda",
"max_stars_repo_stars_event_max_datetime": "2022-02-05T06:53:22.000Z",
"max_stars_repo_stars_event_min_datetime": "2020-04-07T17:58:13.000Z",
"num_tokens": 808,
"size": 1690
} |
Subsets and Splits