text stringlengths 4 690k |
|---|
{-# OPTIONS --cubical-compatible #-}
-- Issue raised by Martin Escardo 2012-12-13
-- on the Agda list "no longer type checks"
module WithoutKDisjointSum where
open import Common.Equality
data ⊥ : Set where
data _⊎_ (A B : Set) : Set where
inl : A → A ⊎ B
inr : B → A ⊎ B
distinct : {A B : Set} (a : A) (b : B) → ... |
{-# OPTIONS --without-K --rewriting #-}
open import PathInduction using (Type; _==_; idp; Square; !; _∙_; Coh; path-induction)
module ExPathInduction {i} where
{-<excoh>-}
coh : {A : Type i} {a : A} →
Coh ({b : A} (p : a == b)
{d : A} {s : d == b}
{c : A} {r : b == c}
{f ... |
module exec-tc.empty where
|
open import Prelude hiding (subst; module Fin)
module Implicits.Substitutions.Lemmas.MetaType where
open import Implicits.Syntax.Type
open import Implicits.Syntax.Term hiding (var)
open import Implicits.Syntax.Context
open import Implicits.WellTyped
open import Implicits.Substitutions
open import Data.Vec hiding ([_... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Setoids.Setoids
open import Setoids.Functions.Definition
open import Sets.EquivalenceRelations
module Setoids.Functions.Extension where
ExtensionallyEqual : {a b c d : _} {A : Set a} {B : Set b} ... |
{-# OPTIONS --without-K --safe #-}
open import Level using (Level)
open import Data.Nat using (ℕ) renaming (_+_ to _+ᴺ_)
open import Data.Vec using (Vec; _++_; take; drop; replicate; map; foldr)
open import Data.Vec.Properties
open import Relation.Binary.PropositionalEquality
open ≡-Reasoning
open import Function u... |
{-# OPTIONS --without-K --safe #-}
-- Any category can be made into a trivial restriction category
module Categories.Category.Restriction.Construction.Trivial where
open import Level using (Level)
open import Categories.Category.Core using (Category)
open import Categories.Category.Restriction using (Restriction)
o... |
-- basic stuff: core definitions, etc
open import statics-core
open import statics-checks
open import judgemental-erase
open import moveerase
open import examples
-- first wave theorems
open import sensibility
open import aasubsume-min
open import determinism
-- second wave theorems (checksums)
open import reachabili... |
{-# OPTIONS --cubical #-}
module Multidimensional.Data.Dir.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Data.Empty
open import Cubical.Relation.Nullary
open import Multidimensional.Data.Dir.Base
¬↓≡↑ : ¬ ↓ ≡ ↑
¬↓≡↑ eq = subst (caseDir Dir ⊥) eq ... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Construction.Coproduct where
-- Coproduct of categories. Need to pull out some of the combinators.
-- Coproduct of Groupoid as well.
open import Level
open import Data.Sum
open import Data.Empty
open import Relation.Binary using (Rel)
open import Function... |
{-# OPTIONS --without-K #-}
open import HoTT
open import homotopy.EilenbergMacLane
open import cohomology.Theory
open import cohomology.SpectrumModel
open import cohomology.WithCoefficients
module cohomology.EMModel where
module _ {i} (G : Group i) (G-abelian : is-abelian G) where
open EMExplicit G G-abelian usin... |
import Lvl
open import Type
module Structure.Logic.Constructive.NaturalDeduction {ℓₗ} {Formula : Type{ℓₗ}} {ℓₘₗ} (Proof : Formula → Type{ℓₘₗ}) where
open import Functional
module Propositional where
-- Rules of bottom
record Bottom(⊥ : Formula) : Type{ℓₘₗ Lvl.⊔ ℓₗ} where
field
elim : ∀{X} → Proof... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.Equivalence2
open import lib.Function2
open import lib.NType2
open import lib.types.Coproduct
open import lib.types.Fin
open import lib.types.Group
open import lib.types.Int
open import lib.types.Nat
open import lib.types.Pi
open import lib... |
module Formalization where
module Introduction where
open import Data.Product using (Σ; Σ-syntax; _×_; _,_; proj₁; proj₂)
open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong)
data Iso (A B : Set): Set where
iso : (f : A → B) → (g : B → A) → (((x : A) → (g (f x)) ≡ x) × ((y : B) → (f (g y)) ≡ y... |
------------------------------------------------------------------------
-- Properties of homogeneous binary relations
------------------------------------------------------------------------
-- This file contains some core definitions which are reexported by
-- Relation.Binary or Relation.Binary.PropositionalEquality... |
{-# OPTIONS --safe #-}
{-
This is inspired by/copied from:
https://github.com/agda/agda-stdlib/blob/master/src/Tactic/MonoidSolver.agda
Boilerplate code for calling the ring solver is constructed automatically
with agda's reflection features.
-}
module Cubical.Algebra.NatSolver.Reflection where
open import Cu... |
{-# OPTIONS --exact-split #-}
module Issue1383 where
data Bool : Set where
true false : Bool
xor : Bool → Bool → Bool
xor = \ { true true -> false ;
false false -> false ;
{-# CATCHALL #-}
_ _ -> true }
|
open import Function using (id) renaming (_∘′_ to _∘_)
open import Relation.Binary.PropositionalEquality
open ≡-Reasoning
open import Control.Monad
module Control.Monad.Error (E : Set) where
-- The Error monad.
data Error (A : Set) : Set where
fail : (e : E) → Error A
return : (a : A) → Error A
-- The follow... |
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.Ints.QuoInt.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.GroupoidLaws
open import Cubical.HITs.Ints.QuoInt.Base
renaming (_+ℤ_ to _+_)
open import Cubical.Data.Nat
hiding (+-comm; +... |
------------------------------------------------------------------------------
-- Totality properties for Forest
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-... |
{-# OPTIONS --safe --no-qualified-instances #-}
module CF.Contexts.Lexical where
open import Level
open import Data.Unit
open import Data.Product
open import Data.String using (String)
open import Data.List
open import Data.List.Properties as LP
open import Data.List.Relation.Binary.Sublist.Propositional.Properties
o... |
------------------------------------------------------------------------
-- The Maybe type
------------------------------------------------------------------------
-- The definitions in this file are reexported by Data.Maybe.
module Data.Maybe.Core where
data Maybe (A : Set) : Set where
just : (x : A) → Maybe A... |
module Structure.Categorical.Proofs where
open import Data
open import Functional
open import Logic.Propositional
import Lvl
open import Structure.Setoid
open import Structure.Categorical.Properties
import Structure.Relator.Names as Names
open import Structure.Relator.Properties
open import Type
private var... |
module Lvl.Proofs where
open import Data.Tuple as Tuple using ()
open import Logic.Predicate
open import Lvl
open import Structure.Setoid
open import Structure.Function.Domain
open import Structure.Relator.Equivalence
open import Structure.Relator.Properties
open import Type
private variable ℓ ℓ₁ ℓ₂ ℓₑ : Lvl.Level
pr... |
------------------------------------------------------------------------
-- Simple kinding of Fω with interval kinds
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module FOmegaInt.Kinding.Simple where
open import Data.Context.WellFormed
open import Data.F... |
module UselessPrivatePragma where
postulate Char : Set
private
{-# BUILTIN CHAR Char #-}
|
-- Andreas, 2016-09-22, issue #2183, issue reported by Ulf
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
module _ (n : Nat) where
foo : (m : Nat) → n ≡ m → Nat
foo m refl = {!m!}
-- Splitting on m fails currently, as it internally is .n
-- We may be doing something about this in the future.
|
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.MaybeEmbed {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.LogicalRelation
open import Definition.LogicalRelation.Irrelevance
open import Definition.LogicalRelation.... |
F : Set → Set
F A = A → A
{-# POLARITY F ++ #-}
|
module Common.SumProperties where
open import Function as Fun
open import Data.Sum as Sum
open import Relation.Binary.PropositionalEquality as PE hiding ([_])
open ≡-Reasoning
copair-elimˡ : {A B C : Set} {f : A → C} {g : B → C} (x : A) →
([ f , g ]′ ) (inj₁ x) ≡ f x
copair-elimˡ x = refl
copair-elimʳ... |
module bags where
open import Data.PropFormula.Syntax 4
open import Data.PropFormula.SyntaxExperiment 4 public
open import Data.Fin using (suc; zero; #_)
open import Relation.Binary.PropositionalEquality using (_≡_)
p : PropFormula
p = Var (# 0)
q : PropFormula
q = Var (# 1)
pq : PropFormula
pq = p ∧ q
qp : PropFo... |
module seven where
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
open import Naturals using (ℕ; zero; suc)
seven : ℕ
seven = suc (suc (suc (suc (suc (suc (suc zero))))))
_ : seven ≡ 7
_ = refl
|
{-# OPTIONS --safe #-}
module Definition.Conversion.Universe where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.RedSteps
open import Definition.Conversion
open import Definition.Conversion.Reduction
open import Definition.Conversion.L... |
module SizedIO.IOGraphicsLib where
{-# FOREIGN GHC import qualified Graphics.SOE #-}
{-# FOREIGN GHC import qualified Graphics.Rendering.OpenGL #-}
{-# FOREIGN GHC import qualified GHC.Int #-}
{-# FOREIGN GHC import qualified Foreign.C.Types #-}
open import Data.Bool.Base
open import Data.Char.Base
open import Data.N... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use the
-- Relation.Binary.Reasoning.PartialOrder module directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
o... |
module Category.Profunctor.Star where
open import Agda.Primitive using (_⊔_)
open import Category.Functor using (RawFunctor ; module RawFunctor)
open import Category.Functor.Lawful
open import Category.Applicative using (RawApplicative; module RawApplicative)
open import Data.Product using (_,_)
open import Data... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.cubical.Square
open import lib.types.Bool
open import lib.types.Cofiber
open import lib.types.Lift
open import lib.types.Paths
open import lib.types.Pointed
open import lib.types.PushoutFmap
open import lib.types.Sigma
open import lib.types... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Indexed containers aka interaction structures aka polynomial
-- functors. The notation and presentation here is closest to that of
-- Hancock and Hyvernat in "Programming interfaces and basic topology"
-- (2006/9... |
-- Andreas, 2017-02-13, issue #2456 reported by identicalsnowflake
-- Introduced by fix for #1698
record Class (t : Set) : Set where
postulate
t : Set
instance Class t
-- Should give error, but not internal error.
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Indexed containers core
------------------------------------------------------------------------
module Data.Container.Indexed.Core where
open import Level
open import Data.Product
open import Relation.Unary
i... |
-- Andreas, 2018-10-15, issue #3264 reported by Guillaume Brunerie
-- Refine should not say "cannot refine" just because of a termination error.
f : Set → Set
f A = {!f!} -- C-c C-r
-- EXPECTED ANSWER:
--
-- ?1 : Set
-- ———— Errors ————————————————————————————————————————————————
-- Termination checking failed for ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Conversion of < to ≤, along with a number of properties
------------------------------------------------------------------------
-- Possible TODO: Prove that a conversion ≤ → < → ≤ returns a
-- relation equivale... |
module Prelude.Fin where
open import Prelude.Nat
open import Prelude.Equality
open import Prelude.Decidable
open import Prelude.Ord
open import Prelude.Bool
open import Prelude.Function
open import Prelude.Number
open import Prelude.Nat.Properties using (suc-inj)
data Fin : Nat → Set where
zero : ∀ {n} → Fin (suc ... |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Limit where
open import Level
open import Data.Product using (Σ; _,_; Σ-syntax; uncurry; proj₂)
open import Categories.Support.PropositionalEquality
open import Categories.Category
open import Categories.Functor using (Functor; module Functor)
open import Cat... |
open import Data.Maybe
open import Data.Product hiding (Σ)
open import Axiom.Extensionality.Propositional
open import Relation.Binary.PropositionalEquality hiding ([_])
open import Relation.Nullary
open import Relation.Nullary.Negation
open import EffectAnnotations
open import Types
module AEff where
-- ARITY ASSIG... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.HSpace
module homotopy.EM1HSpace where
module EM₁HSpace {i} (G : AbGroup i) where
private
module G = AbGroup G
mult-loop : (g : G.El) (x : EM₁ G.grp) → x == x
mult-loop g = EM₁-elim
{P = λ x → x == x}
(emloop g)
... |
module Sigma.Renaming.Vec where
open import Data.Nat using (ℕ; zero; suc; _+_)
open import Data.Fin as Fin using (Fin; zero; suc)
open import Data.Product using (_×_; proj₁; proj₂) renaming (_,_ to ⟨_,_⟩)
open import Data.Vec as V using (Vec; []; _∷_; map; _[_]≔_)
renaming (head to headᵥ; tail to tailᵥ; lookup to ... |
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module Issue3a where
module A where
postulate
D : Set
_≡_ : D → D → Set
a b : D
postulate p : a ≡ b
open A
{-# ATP axiom p ... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Magma.MorphismProperties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Foundations.HLevels
op... |
{-# OPTIONS --without-K #-}
open import Base
open import Homotopy.TruncatedHIT
open import Sets.Quotient
module Sets.QuotientUP {i j} (A : Set i) ⦃ A-set : is-set A ⦄
(R : A → A → Set j) ⦃ R-prop : (x y : A) → is-prop (R x y) ⦄ where
-- [X →→ Y ~ R] is the set of functions [X → Y] respecting the relation [R]
_→→_~... |
module Issue1168 where
id : {A : Set} → A → A
id {A = A} a = a
|
module Compilation.Encode.Core where
open import Context
open import Type.Core
open import Compilation.Data
open import Function
open import Data.List.Base as List
{- Note [Compilation]
We compile data descriptions to System Fωμ in two steps:
1. Lambda-bind
a) a tag to distinguish between the data types from t... |
module Issue1760e where
-- Skipping a single record definition in a private block.
private
{-# NO_POSITIVITY_CHECK #-}
record U : Set where
field ap : U → U
|
{-# OPTIONS --safe #-}
module STLC.Typing where
open import STLC.Syntax
open import Data.Nat using (ℕ)
open import Data.Fin using (Fin) renaming (zero to fzero; suc to fsuc)
open import Data.Product using (∃-syntax; _,_)
open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong; subst)
open import Relat... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommMonoid.CommMonoidProd where
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Prelude
open import Cubical.Data.Sigma
open import Cubical.Algebra.Monoid
open import Cubical.Algebra.Semigroup
open import Cubical.Algebra.CommMonoid.Base
open Comm... |
-- Andreas, 2014-10-05, code by Jesper Cockx
{-# OPTIONS --cubical-compatible --guardedness #-}
open import Common.Coinduction
open import Common.Equality
data False : Set where
data Pandora : Set where
C : ∞ False → Pandora
postulate
ext : (False → Pandora) → (Pandora → False) → False ≡ Pandora
f : False → P... |
{-# OPTIONS --without-K #-}
module Truncation_Level_Criteria where
open import lib.Basics hiding (_⊔_)
open import lib.NType2
open import lib.types.Nat hiding (_+_)
open import lib.types.Pi
open import lib.types.Sigma
open import lib.types.Unit
open import lib.types.Empty
open import lib.types.TLevel
open import Pre... |
open import MJ.Types
import MJ.Classtable.Core as Core
module MJ.Syntax.Typed {c}(Ct : Core.Classtable c) where
open import Prelude
open import Data.Maybe as Maybe using (Maybe; just; nothing)
open import Data.Vec as Vec
open import Data.Star as Star
open import Data.List hiding (null)
open import Data.List.Relation.... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Data.FinData.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Data.Nat
open import Cubical.Data.Bool.Base
open import Cubical.Relation.Nullary
private
variable
ℓ : Level
A B : Typ... |
------------------------------------------------------------------------------
-- Propositional logic theorems
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
... |
{-# OPTIONS --without-K #-}
-- I've been spinning my wheels quite a bit on this proof.
-- I've chatted with several people and feel confident my
-- functions are properly defined, but I'm really struggling
-- to see how to prove they are quasi-inverses (it has been a little
-- reassuring, no one I have talked to has ... |
{-# OPTIONS --safe #-}
module Definition.Typed.Weakening where
open import Definition.Untyped as U hiding (wk)
open import Definition.Untyped.Properties
open import Definition.Typed
import Tools.PropositionalEquality as PE
-- Weakening type
data _∷_⊆_ : Wk → Con Term → Con Term → Set where
id : ∀ {Γ} → ... |
{-# OPTIONS --safe #-}
module Tools.Function where
-- Identity function
idᶠ : {A : Set} → A → A
idᶠ x = x
-- Function composition (simply typed variant)
_∘ᶠ_ : {A B C : Set} → (B → C) → (A → B) → A → C
_∘ᶠ_ f g a = f (g a)
|
{-# OPTIONS --without-K --safe #-}
module Function.Reasoning where
open import Level
infixr 2 _⟨⟩⇒_ ⟨∙⟩⇒-syntax
⟨∙⟩⇒-syntax : ∀ (A : Type a) → (B → C) → (A → B) → A → C
⟨∙⟩⇒-syntax _ f g x = f (g x)
syntax ⟨∙⟩⇒-syntax A f g = A ⟨ g ⟩⇒ f
_⟨⟩⇒_ : ∀ (A : Type a) → (A → B) → A → B
_ ⟨⟩⇒ f = f
infix 2.5 _⇒∎
_⇒∎ : (A ... |
-- Andreas, 2016-04-13 display forms do not work for projection patterns
-- {-# OPTIONS -v tc.display:100 #-}
postulate B : Set
module M (A : Set) where
record R : Set where
field f : A
open M B
test : R
test = {!!} -- C-c C-c RET split on result here
-- Is:
-- M.R.f test = ?
--
-- Expected:
-- R.f test =... |
module Arithmetic where
data ℕ : Set where
zero : ℕ
succ : ℕ → ℕ
_+_ : ℕ → ℕ → ℕ
zero + b = b
(succ a) + b = succ (a + b)
-- ℕ + ℕ = succ (succ ℕ))
_*_ : ℕ → ℕ → ℕ
zero * b = zero
(succ a) * b = a + b * a
|
{-# OPTIONS --without-K #-}
open import HoTT
open import cohomology.CofiberSequence
open import cohomology.Exactness
open import cohomology.FunctionOver
open import cohomology.Theory
open import cohomology.ProductRepr
open import cohomology.WedgeCofiber
{- Finite additivity is provable (and in a stronger form) withou... |
module Model where
open import Data.Product
open import Data.Char
open import Data.String
open import Data.Container.Indexed
open import IO.Primitive
open import Signature
postulate
Model : Set
initialModel : Model
moveModel : Dir → Model → Model
setMode : Mode → Model → Model
g... |
{-# OPTIONS --without-K #-}
module sets.fin where
open import sets.fin.core public
-- open import sets.fin.properties public
-- open import sets.fin.ordering public
-- open import sets.fin.universe public
|
import Lvl
open import Structure.Category
open import Structure.Setoid
open import Type
-- TODO: Deprecate this file and use Relator.Equals.Category instead
module Structure.Category.Morphism.IdTransport where
import Functional.Dependent as Fn
import Function.Equals
open Function.Equals.Dependen... |
{-# OPTIONS --rewriting --confluence-check #-}
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
open import Agda.Builtin.Equality.Rewrite
module _ where
data Unit : Set where
unit : Unit
sym : {A : Set} {x y : A} → x ≡ y → y ≡ x
sym refl = refl
subst : {A : Set} (P : A → Set) {x y : A} → x ≡ y → P... |
module Lemmachine.Default.Proofs where
open import Lemmachine
import Lemmachine.Default
import Lemmachine.Lemmas
open import Lemmachine.Default.Lemmas
open Lemmachine.Lemmas Lemmachine.Default.resource
open import Relation.Binary.PropositionalEquality
open import Data.Empty
open import Data.Maybe
open import Data.Produ... |
open import Common.Prelude
⟨_⟩_ : Bool → Bool → Bool
⟨ _ ⟩_ = λ b → b
|
-- Andreas, 2017-12-16, issue #2870
-- Nicer error for non-printable character in lexer.
postulate
beforeHyphenafterHyphen : Set
-- Expected something like:
-- Lexical error (unprintable character)
|
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Setoids.Setoids
open import Rings.Definition
open import Sets.EquivalenceRelations
open import Rings.IntegralDomains.Definition
module Rings.Primes.Lemmas {a b : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ _*_ : A → A → A} {R :... |
{-# OPTIONS --without-K --safe #-}
open import Level
open import Categories.Category
open import Categories.Monad
module Categories.Monad.Morphism {o ℓ e} {C D : Category o ℓ e} where
open import Categories.NaturalTransformation
open import Categories.Functor
open NaturalTransformation
-- monad morphism in the sen... |
module Issue679a where
data ty : Set where
_`→_ : ty → ty → ty
⟦_⟧ : ty → Set
⟦ A `→ B ⟧ = ⟦ A ⟧ → ⟦ B ⟧
eq : ∀ (σ : ty) (a b : ⟦ σ ⟧) → Set
eq (A `→ B) f g = ∀ {a : ⟦ A ⟧} → eq B (f a) (g a)
eq-sym : ∀ σ {f g} (h : eq σ f g) → eq σ g f
eq-sym (A `→ B) h with B
... | B' = {!!}
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Coinductive vectors
------------------------------------------------------------------------
{-# OPTIONS --without-K --guardedness --sized-types #-}
module Codata.Musical.Covec where
open import Codata.Musical... |
open import FRP.JS.Behaviour using ( Beh ; map ; [_] )
open import FRP.JS.DOM using ( DOM ; text ; _++_ )
open import FRP.JS.RSet using ( ⟦_⟧ )
open import FRP.JS.Maybe using ( Maybe ; just ; nothing )
open import FRP.JS.String using ( String )
open import FRP.JS.Geolocation using ( geolocation )
open import FRP.JS.Geo... |
{-# OPTIONS --rewriting #-}
module _ where
open import Agda.Builtin.Equality
open import Agda.Builtin.Equality.Rewrite
open import Agda.Builtin.Bool
data D (A : Set) : Set where
con : (a : A) → D A
pr : ∀ {A} → D A → A
pr (con a) = a
postulate
f : D Bool → Bool
prf : pr ≡ f
{-# REWRITE prf #-}
|
{-
This file proves the monotonicity of potential function over reductions.
CorrectBinding is required in order to guarantee that SI and SC introduced
by the loop never accidentally capture signals in the loop body.
canₖ-monotonic : ∀ {BV FV} θ r r' →
CorrectBinding r BV FV →
r sn⟶₁ r' →
∀ k →
k ∈ Canₖ r' θ... |
module Lib.Eq where
open import Lib.Prelude as P hiding (String)
open import Lib.Nat renaming (_==_ to _=Nat=_)
open import Lib.Fin
open import Lib.List
open import Lib.Bool
-- Wrapper type, used to ensure that El is constructor-headed.
record String : Set where
constructor string
field unString : P.String
-- ... |
------------------------------------------------------------------------
-- Strict ω-continuous functions
------------------------------------------------------------------------
{-# OPTIONS --erased-cubical --safe #-}
module Partiality-algebra.Strict-omega-continuous where
open import Equality.Propositional.Cubical... |
open import FRP.LTL.Time using ( Time ; _,_ )
open import FRP.LTL.Time.Bound using
( Time∞ ; _≼_ ; _≺_ ; fin ; +∞ ; +∞-top ; t≺+∞ ; ≼-refl ; _≼-trans_
; ≡-impl-≼ ; ≺-impl-≼ ; _≺-trans_ ; _≺-transʳ_ ; ≺-impl-⋡ ; t≺t+1 )
open import FRP.LTL.Util using ( irrelevant ; ⊥-elim )
open import Relation.Unary using ( _∈_ ... |
------------------------------------------------------------------------
-- Laws related to _>>=_
------------------------------------------------------------------------
module TotalParserCombinators.Laws.Monad where
open import Algebra
open import Category.Monad
open import Codata.Musical.Notation
open import Data.... |
{-# OPTIONS --cubical --no-import-sorts #-}
module MoreAlgebra where
open import Agda.Primitive renaming (_⊔_ to ℓ-max; lsuc to ℓ-suc; lzero to ℓ-zero)
private
variable
ℓ ℓ' ℓ'' : Level
open import Cubical.Foundations.Everything renaming (_⁻¹ to _⁻¹ᵖ; assoc to ∙-assoc)
open import Cubical.Relation.Nullary.Ba... |
open import Coinduction using ( ♯_ )
open import Data.Maybe using ( Maybe ; just ; nothing ; maybe )
open import Data.Nat using ( ℕ ; _+_ )
open import Data.Integer using ( ℤ ; +_ ; _⊖_ )
open import System.IO.Transducers using ( inp ; out ; done ; _⇒_ ; Inp_⇒_ ; C⟦_⟧ ; _⟨¿⟩_ )
open import System.IO.Transducers.Trace u... |
module Structure.Operator.Field where
import Lvl
open import Logic
open import Logic.Propositional
open import Structure.Setoid
open import Structure.Operator.Properties
open import Structure.Operator.Ring
open import Type
record Field {ℓ ℓₑ} {T : Type{ℓ}} ⦃ _ : Equiv{ℓₑ}(T) ⦄ (_+_ : T → T → T) (_⋅_ : T → T → ... |
{-# OPTIONS --without-K --safe #-}
-- Bundled version of a Cartesian Category
module Categories.Category.Cartesian.Bundle where
open import Level
open import Categories.Category.Core using (Category)
open import Categories.Category.Cartesian using (Cartesian)
open import Categories.Category.Cartesian.Monoidal using ... |
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Weakening {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped as U hiding (wk)
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.T... |
module FlexInterpreter where
data Ty : Set where
nat : Ty
arr : Ty -> Ty -> Ty
data Exp : Ty -> Set where
zero : Exp nat
suc : Exp (arr nat nat)
pred : Exp (arr nat nat)
app : {a b : Ty} -> Exp (arr a b) -> Exp a -> Exp b
data Nat : Set where
zero : Nat
suc : Nat -> Nat
Sem : Ty -> Set
Sem nat = ... |
-- Ordinals as defined in the HoTT book.
{-# OPTIONS --without-K --safe #-}
module Ordinal.HoTT where
open import Data.Empty using (⊥)
open import Data.Unit using (⊤)
open import Induction.WellFounded using (Acc ; acc ; WellFounded)
open import Level using (Level ; _⊔_ ; 0ℓ) renaming (suc to lsuc)
open import Relatio... |
module Part2_Agda_in_a_Nutshell where
{-
https://serokell.io/blog/agda-in-nutshell
Danya Rogozin
Monday, November 26th, 2018
Theorem proving in Agda based on a constructive logical framework.
Dependently typed programming and theorem proving in Agda.
Example use of Agda in the formalisation of algebra.
------------... |
open import Agda.Primitive
variable
ℓ : Level
A : Set ℓ
postulate
w/e : ∀ {a} {A : Set a} → A
Sub : {a : Level} (A : Set a) → (Set → A) → Set
hcomp-equivFillerSub : Sub A (λ { _ → w/e {_} {_} })
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Sn where
open import Cubical.HITs.Sn.Base public
open import Cubical.HITs.Sn.Properties public
|
module Luau.Run where
open import Agda.Builtin.Equality using (_≡_; refl)
open import Luau.Heap using (Heap; ∅)
open import Luau.Syntax using (Block; return; _∙_; done)
open import Luau.OpSem using (_⊢_⟶*_⊣_; refl; step)
open import Luau.Value using (val)
open import Properties.Step using (stepᴮ; step; return; done; e... |
{-# OPTIONS --without-K #-}
-- Definition of Pi with fractionals
module PiFrac2 where
-- From the standard library:
open import Data.Empty using (⊥)
open import Data.Unit using (⊤; tt)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Data.Product using (_×_; _,_; proj₁; proj₂)
open import Relation.Binary.Pro... |
{-# OPTIONS --cubical --safe #-}
module Analysis where
open import Data.List using (List; []; _∷_; map)
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
open import Harmony
open import Music
open import Note
open import Pitch
-- test of analysis
accompF : List Pitch
accompF = f 4 ∷ a 4 ∷ ... |
open import Everything
{-
open import Oscar.Prelude
open import Oscar.Class.HasEquivalence
open import Oscar.Class.Symmetrical
open import Oscar.Data.Term
open import Oscar.Data.Substitunction
open import Oscar.Data.Surjcollation
open import Oscar.Data.Surjextenscollation
open import Oscar.Data.Proposequality
import ... |
{-# OPTIONS --no-universe-polymorphism #-}
open import Data.Product hiding (map)
open import Relation.Binary.Core
open import Function
open import Data.List
open import Data.Unit using (⊤)
open import Data.Empty
open import Equivalence
module BagEquality where
infixr 5 _⊕_
data _⊕_ (A B : Set) : Set where
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.