text stringlengths 4 690k |
|---|
------------------------------------------------------------------------
-- Properties satisfied by posets
------------------------------------------------------------------------
open import Relation.Binary
module Relation.Binary.Props.Poset (p : Poset) where
open Relation.Binary.Poset p hiding (trans)
import Relat... |
{-# OPTIONS --without-K #-}
module container.fixpoint where
open import sum
open import level
open import container.core
open import function.core
open import function.isomorphism
open import function.overloading
record Fixpoint {li la lb}
(c : Container li la lb)
(lx : Level) : Set (... |
module plfa.part2.Properties-peer where
open import Relation.Binary.PropositionalEquality
using (_≡_; _≢_; refl; sym; cong; cong₂)
open import Data.String using (String; _≟_)
open import Data.Nat using (ℕ; zero; suc)
open import Data.Empty using (⊥; ⊥-elim)
open import Data.Product
using (_×_; proj₁; proj₂; ∃; ∃... |
{-# OPTIONS --without-K --rewriting #-}
module lib.two-semi-categories.TwoSemiCategories where
open import lib.two-semi-categories.FunCategory public
open import lib.two-semi-categories.Functor public
open import lib.two-semi-categories.FunctorInverse public
open import lib.two-semi-categories.FundamentalCategory pub... |
open import Function using (_∘_)
open import Category.Monad using (module RawMonad)
open import Data.Fin using (Fin; suc; zero)
open import Data.Fin.Properties renaming (_≟_ to _≟-Fin_)
open import Data.List as List ... |
module Oscar.Data.Term.internal.SubstituteAndSubstitution1 {𝔣} (FunctionName : Set 𝔣) where
open import Oscar.Data.Equality
open import Oscar.Data.Equality.properties
open import Oscar.Data.Fin
open import Oscar.Data.Nat
open import Oscar.Data.Term FunctionName
open import Oscar.Data.Vec
open import Oscar.Function
... |
------------------------------------------------------------------------
-- A parser for PBM images; illustrates essential use of bind
------------------------------------------------------------------------
-- Note that I am using the simple "Plain PBM" format, and I try to
-- adhere to the following statement from t... |
{-# OPTIONS --no-qualified-instances #-}
module CF.Compile where
open import Data.Product
open import Data.List hiding (null; [_])
open import Relation.Binary.PropositionalEquality hiding ([_])
open import Relation.Unary
open import Relation.Unary.PredicateTransformer using (Pt)
open import Relation.Ternary.Core
open ... |
open import Agda.Primitive
open import Agda.Builtin.Sigma
open import Agda.Builtin.Equality
record R {A : Set} {B : A → Set} (p) : Set where
field
prf : p ≡ p
|
{-# OPTIONS --without-K #-}
module level where
open import Agda.Primitive public
using (Level; _⊔_; lzero; lsuc)
record ↑ {a} ℓ (A : Set a) : Set (a ⊔ ℓ) where
constructor lift
field lower : A
open ↑ public
|
{-
Type quotients:
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.TypeQuotients.Properties where
open import Cubical.HITs.TypeQuotients.Base
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundatio... |
module OldBasicILP.UntypedSyntax.Translation where
open import OldBasicILP.UntypedSyntax.Common public
import OldBasicILP.UntypedSyntax.ClosedHilbertSequential as CHS
import OldBasicILP.UntypedSyntax.ClosedHilbert as CH
-- Translation of types parametrised by a closed, untyped representation of syntax.
_↦ᵀ_ : ∀ {R... |
open import Nat
open import Prelude
open import dynamics-core
open import contexts
open import typed-elaboration
open import lemmas-gcomplete
open import lemmas-complete
open import progress-checks
open import finality
module cast-inert where
-- if a term is compelete and well typed, then the casts inside are all
... |
module PatternMatchingLambda where
data Bool : Set where
true false : Bool
data Void : Set where
data _≡_ {A : Set}(x : A) : A -> Set where
refl : x ≡ x
and : Bool -> Bool -> Bool
and = λ { true x → x ; false _ → false }
or : Bool -> Bool -> Bool
or x y = not (and (not x) (not y))
where not : Bool -> Bool
... |
{-# OPTIONS --safe #-}
open import Generics.Prelude
open import Generics.Telescope
open import Generics.Desc
open import Generics.Mu
open import Generics.Mu.All
module Generics.Mu.Elim
{P I n} {D : DataDesc P I n}
{p c} (Pr : ∀ {i} → μ D (p , i) → Set c)
(f : ∀ {i} (x : μ D (p , i)) → All D Pr x → Pr x) where
... |
------------------------------------------------------------------------
-- The two big-step semantics given by Leroy and Grall in "Coinductive
-- big-step operational semantics"
------------------------------------------------------------------------
module Lambda.Substitution.TwoSemantics where
open import Codata.M... |
------------------------------------------------------------------------
-- Inversion of canonical subtyping in Fω with interval kinds
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module FOmegaInt.Kinding.Canonical.Inversion where
open import Data.Produc... |
------------------------------------------------------------------------------
-- Properties of the alter list
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
... |
{-# OPTIONS --without-K #-}
module sets.nat.ordering.properties where
open import function.isomorphism
open import sets.nat.core
open import sets.nat.ordering.lt
open import sets.nat.ordering.leq
open import hott.level.core
<-≤-iso : ∀ {n m} → (n < m) ≅ (suc n ≤ m)
<-≤-iso = record
{ to = f
; from = g
; iso₁ = ... |
open import Prelude hiding (lift; Fin′; subst; id)
module Implicits.Substitutions.LNMetaType where
open import Implicits.Syntax.LNMetaType
open import Data.Fin.Substitution
open import Data.Star as Star hiding (map)
open import Data.Star.Properties
module MetaTypeApp {T} (l : Lift T MetaType) where
open Lift l hid... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.CommRing.Instances.MultivariatePoly-notationZ where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat
open import Cubical.Data.FinData
open import Cubical.Relation.Nullary
open import Cubical.Algebra.Ring
open import C... |
-- Andreas, 2015-03-12
-- Sizes should be irrelevant in terms, while they are relevant in types!
{-# OPTIONS --experimental-irrelevance #-}
open import Common.Size
open import Common.Equality
module IrrelevantSizes where
-- Nat i is shape-irrelevant in i.
data Nat ..(i : Size) : Set where
zero : .(j : Size... |
{-# OPTIONS --cubical --safe #-}
module Cardinality.Finite.ManifestBishop.Isomorphism where
open import Prelude
open import Data.Fin
open import Data.Fin.Properties
open import Container.List.Isomorphism
import Cardinality.Finite.ManifestBishop.Inductive as 𝕃
import Cardinality.Finite.ManifestBishop.Container as ℒ... |
-- Andreas, 2013-02-26
module Issue799a where
data D (A : Set1) : Set where
d : D A
x : D Set
x = d {A = _} -- correct parameter name
y : D Set
y = d {B = _} -- wrong parameter name, should give error
|
module Acc where
data Acc ( A : Set ) ( Lt : A -> A -> Set) : A -> Set where
acc : ( b : A )
-> ( ( a : A ) -> Lt a b -> Acc A Lt a )
-> ( Acc A Lt b )
data Nat : Set where
zero : Nat
succ : Nat -> Nat
data Lt : Nat -> Nat -> Set where
ltzero : ( x : Nat ) -> Lt zero (succ x)
ltsucc... |
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Properties.Symmetry {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Properties
import Definition.Typed.Weakening... |
module Lib where
open import Data.Nat public hiding (_<_)
open import Function public using (_∘_)
open import Data.List public
open import Data.Product public using (_×_ ; _,_ ; proj₁ ; proj₂ ; Σ ; ∃)
open import Data.Sum public using (_⊎_ ; [_,_]′ ; inj₁ ; inj₂)
open import Relation.Nullary public
open import Relat... |
module Debug where
open import Data.String using (String) public
open import Level public
{-# FOREIGN GHC import qualified Data.Text #-}
{-# FOREIGN GHC import qualified Debug.Trace as Trace #-}
{-# FOREIGN GHC
debug' :: Data.Text.Text -> c -> c
debug' txt c = Trace.trace (Data.Text.unpack txt) c
#-}
postulate debug... |
{-
This second-order term syntax was created from the following second-order syntax description:
syntax Lens | L
type
S : 0-ary
A : 0-ary
term
get : S -> A
put : S A -> S
theory
(PG) s : S a : A |> get (put (s, a)) = a
(GP) s : S |> put (s, get(s)) = s
(PP) s : S a b : A |> put ... |
open import Oscar.Prelude
open import Oscar.Class.IsCategory
open import Oscar.Class.IsPrefunctor
open import Oscar.Class.Reflexivity
open import Oscar.Class.Smap
open import Oscar.Class.Surjection
open import Oscar.Class.Surjidentity
open import Oscar.Class.Transitivity
module Oscar.Class.IsFunctor where
module _
... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Groups.Definition
open import Rings.Definition
open import Rings.Orders.Partial.Definition
open import Rings.Orders.Total.Definition
open import Rings.Orders.Total.Lemmas
open import Rings.IntegralDomains.Definition
open import ... |
-- 2010-10-02, see issue 334
module TerminationInfiniteRecord where
record Empty : Set where
inductive
constructor empty
field
fromEmpty : Empty
elimEmpty : Empty -> Set
elimEmpty (empty e) = elimEmpty e
-- this no longer termination checks
-- and it should not, since it is translated to
-- elimEmpty e' =... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Implications of nullary relations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Relation.Nullary.Implication where
open import Relation.Null... |
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module LogicalFramework.UniversalQuantifier where
postulate D : Set
-- The universal quantifier type on D.
data ForAll (A : D → Set) : Set where
... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- An alternative definition of mutually-defined lists and non-empty
-- lists, using the Kleene star and plus.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe... |
{-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.IdRefl {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed... |
{-
This file contains:
- the coequalizer of sets as a HIT as performed in https://1lab.dev/Data.Set.Coequaliser.html
-}
{-# OPTIONS --safe #-}
module Cubical.HITs.SetCoequalizer.Properties where
open import Cubical.HITs.SetCoequalizer.Base
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLe... |
-- Qualified imported constructors
module Issue262 where
open import Common.Prelude
z = Nat.zero
|
-- Andreas, 2016-10-09, issue #2223
-- The level constraint solver needs to combine constraints
-- from different contexts and modules.
-- The parameter refinement broke this test case.
-- {-# OPTIONS -v tc.with.top:25 #-}
-- {-# OPTIONS -v tc.conv.nat:40 #-}
-- {-# OPTIONS -v tc.constr.add:45 #-}
open import Common... |
{-# OPTIONS --without-K #-}
module PiLevel0 where
-- We refine the trivial relation used in level-(-2). We do not
-- identify all types: only those of the same "size". So between any
-- two types, there could be zero, one, or many identifications. If
-- there is more than one idenfication we force them to be the same... |
module BabyAgda where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
stuff : Nat
nonDependent : Nat -> Nat -> Nat
nonDependent a b = a
dependent : {A : Set} -> A -> A
dependent a = a
asdf : {A : Set} -> {B : Nat} -> {renameMe0 : Nat} -> Nat
asdf {_} {_} {zero} = zero
asdf {_} {_} {suc c} = dependent c
|
-- Andreas, 2016-06-01, issue 1999
-- Bug in TypeChecking.Signature.applySection
-- If that function was not such horrible spaghetti code,
-- there would be less bugs like this.
-- Bug was: code for applying projection used ts instead of ts'
-- {-# OPTIONS -v tc.mod.apply:80 #-}
module Issue1999 where
import Common... |
module DTGP.Rand where
open import Data.Nat
open import Relation.Nullary.Decidable
open import Data.Nat.DivMod renaming (_mod_ to _nmod_)
open import Data.Fin
open import Data.Product
open import DTGP.State public
postulate Int : Set
{-# BUILTIN INTEGER Int #-}
primitive
primIntegerPlus : Int → Int → Int
prim... |
open import Agda.Builtin.Equality
postulate
A : Set
Phantom : A → Set
Phantom _ = A
postulate
rigid : A → A
mutual
X : A → A → A → A
X = _
Y : (x y : A) → Phantom x
Y = _
-- This constraint triggers pruning of X in an attempt to remove the non-linearity.
-- It doesn't get rid of the non-linearit... |
{-# OPTIONS --cubical --safe #-}
module Data.Empty where
open import Data.Empty.Base public
|
-- Andreas, 2021-04-14, #1154
-- Andreas, 2021-04-10, BNFC/bnfc#354
-- Make sure we do not "resurrect" superseded layout columns.
private private private
A : Set -- OK, stacking
B : Set -- Bad, should fail
-- Expected: Parse error after B
|
------------------------------------------------------------------------
-- Lemmas related to expansion and CCS
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
open import Prelude hiding (module W; step-→)
module Expansion.CCS {ℓ} {Name : Type ℓ} where
open imp... |
module BTree.Complete.Base {A : Set} where
open import BTree {A}
open import BTree.Equality {A}
data Perfect : BTree → Set where
plf : Perfect leaf
p≃ : {l r : BTree}
(x : A)
→ l ≃ r
→ Perfect (node x l r)
data _⋗_ : BTree → BTree → Set where
⋗lf : (x :... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Relation.Binary.Construct.Always where
open import Cubical.Core.Everything
open import Cubical.Relation.Binary
open import Cubical.Relation.Binary.Construct.Constant using (Const)
open import Cubical.Data.Unit.Polymorphic
-----------------------------... |
module Prelude where
open import Data.Nat
open import Data.Unit
open import Data.Product
_^_ : Set → ℕ → Set
A ^ zero = ⊤
-- A ^ 1 = A
A ^ suc n = A × (A ^ n)
ℜⁿ : {A B : Set} → (A → B → Set) → (n : ℕ) → (A ^ n → B ^ n → Set)
ℜⁿ r zero = λ tt tt → ⊤
ℜⁿ r (suc n) = λ { (a , aⁿ) (b , bⁿ) → r a b × (ℜⁿ r n) aⁿ bⁿ }
𝔉... |
data _≡_ {ℓ} {A : Set ℓ} (x : A) : A → Set ℓ where
refl : x ≡ x
data ℕ : Set where
zero : ℕ
succ : ℕ → ℕ
record Stream (A : Set) : Set where
constructor stream
field
start : A
next : A → A
open Stream
ℕ-stream : Stream ℕ
start ℕ-stream = zero
next ℕ-stream n = succ n
0th : {A : Set} → Stream A → ... |
-- Andreas, 2017-12-04, Re: issue #2862, reported by m0davis,
-- Make sure there is similar problem with functions.
open import Agda.Builtin.Equality
data Bool : Set where
true false : Bool
val : Bool
module M where
val = true -- Should fail
val≡true : val ≡ true
val≡true = refl
val = false
data ⊥ : Set... |
------------------------------------------------------------------------------
-- Testing the η-expansion
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# O... |
module Day1 where
open import Data.String as String
open import Data.Maybe
open import Foreign.Haskell using (Unit)
open import Data.List as List
open import Data.Nat
import Data.Nat.Show as ℕs
open import Data.Char
open import Data.Vec as Vec renaming (_>>=_ to _VV=_ ; toList to VecToList)
open import D... |
module UnifyFin where
open import Data.Fin using (Fin; suc; zero)
open import Data.Nat using (ℕ; suc; zero)
open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong₂; cong; sym; trans)
open import Function using (_∘_)
open import Relation.Nullary using (¬_; Dec; yes; no)
open import Data.Product using... |
module SET where
----------------------------------------------------------------------------
-- Auxiliary.
----------------------------------------------------------------------------
data Fun (X Y : Set) : Set where
fun : (X -> Y) -> Fun X Y
{-
Unop : Set -> Set
Unop X = Fun X X
Binop : Set -> S... |
module Membership where
open import OscarPrelude
open import Successor
record Membership {ℓ} (m : Set ℓ) (M : Set ℓ) : Set (⊹ ℓ)
where
field
_∈_ : m → M → Set ℓ
_∉_ : m → M → Set ℓ
xor-membership : ∀ {x : m} {X : M} → x ∈ X ←⊗→ x ∉ X
open Membership ⦃ … ⦄ public
data _∈List_ {ℓ} {A : Set ℓ} (a : A) ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Intersection of two binary relations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Relation.Binary.Construct.Intersection where
open import ... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NType2
open import lib.types.Pi
open import lib.types.Group
{-
The definition of G-sets. Thanks to Daniel Grayson.
-}
module lib.types.GroupSet {i} where
-- The right group action with respect to the group [grp].
record GroupSet... |
module Sets.BoolSet.Proofs{ℓ₁} where
open import Data.Boolean
open import Data.Boolean.Proofs
open import Functional
open import Logic.Propositional
open import Sets.BoolSet{ℓ₁}
open import Type
module _ {ℓ₂}{T : Type{ℓ₂}} where
[∈]-in-[∪] : ∀{a : T}{S₁ S₂ : BoolSet(T)} → (a ∈ S₁) → (a ∈ (S₁ ∪ S₂))
[∈]-in-[∪] pro... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Pointwise lifting of relations to lists
------------------------------------------------------------------------
module Relation.Binary.List.Pointwise where
open import Function
open import Function.Inverse usi... |
data ℕ : Set where
ze : ℕ
su : ℕ → ℕ
f : (ℕ → ℕ) → ℕ → ℕ
f g n = g n
syntax f g n = n , g
h : ℕ
h = ?
|
-- if curious: https://agda.readthedocs.io/en/v2.6.0.1/language/without-k.html
{-# OPTIONS --without-K --allow-unsolved-metas #-}
{-
CS 598 TLR
Artifact 1: Proof Objects
Student Copy
READ ME FIRST: You will absolutely not be graded on your ability to finish
these proofs. It's OK to be confused and find this... |
------------------------------------------------------------------------
-- The semantics given in OneSemantics and TwoSemantics are equivalent
------------------------------------------------------------------------
module Lambda.Substitution.Equivalence where
open import Codata.Musical.Notation
open import Lambda.... |
open import Coinduction using ( ∞ ; ♯_ ; ♭ )
open import Data.Product using ( ∃ ; _×_ ; _,_ ; proj₂ )
open import Data.Nat using ( ℕ ; zero ; suc )
open import Data.Empty using ( ⊥ )
open import FRP.LTL.ISet.Core using ( ISet ; M⟦_⟧ ; ⟦_⟧ ; ⌈_⌉ ; _,_ ; splitM⟦_⟧ ) renaming ( [_] to ⟪_⟫ )
open import FRP.LTL.ISet.Global... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Helper reflection functions
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Tactic.RingSolver.Core.ReflectionHelp where
open import Agda.Built... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties related to All
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Maybe.Relation.Unary.All.Properties where
open import Data.Mayb... |
open import Prelude
open import RW.Language.RTerm
open import RW.Language.RTermUtils
open import RW.Language.RTermIdx
open import RW.Data.RTrie
open import RW.Strategy using (Trs; Symmetry; UData; u-data)
module RW.Language.RTermTrie where
open import RW.Utils.Monads
open Monad {{...}}
add-action : Name → ℕ ×... |
module _ where
open import Agda.Builtin.Reflection renaming (bindTC to _>>=_)
open import Agda.Builtin.Equality
open import Agda.Builtin.String
macro
m : Name → Term → TC _
m f hole = do
ty ← getType f
ty ← normalise ty
quoteTC ty >>= unify hole
open import Agda.Builtin.Nat
import Agda.Builtin.N... |
module Base.Free.Properties where
open import Relation.Binary.PropositionalEquality using (_≢_)
open import Base.Free using (Free; pure; impure)
discriminate : ∀ {S P A} {s : S} {pf : P s → Free S P A} {a : A} → impure s pf ≢ pure a
discriminate = λ ()
|
{-# OPTIONS --cubical --safe #-}
module Algebra where
open import Prelude
module _ {a} {A : Type a} (_∙_ : A → A → A) where
Associative : Type a
Associative = ∀ x y z → (x ∙ y) ∙ z ≡ x ∙ (y ∙ z)
Commutative : Type _
Commutative = ∀ x y → x ∙ y ≡ y ∙ x
Idempotent : Type _
Idempotent = ∀ x → x ∙ x ≡ x
Id... |
module Monads where
open import Library
open import Categories
record Monad {a}{b}(C : Cat {a}{b}) : Set (a ⊔ b) where
constructor monad
open Cat C
field T : Obj → Obj
η : ∀ {X} → Hom X (T X)
bind : ∀{X Y} → Hom X (T Y) → Hom (T X) (T Y)
law1 : ∀{X} → bind (η {X}) ≅ iden {T X}
... |
module CS410-Prelude where
------------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Standard Equipment for use in Exercises
------------------------------------------------------------------------------
-----------... |
------------------------------------------------------------------------
-- Traditional non-dependent lenses
------------------------------------------------------------------------
{-# OPTIONS --cubical #-}
import Equality.Path as P
module Lens.Non-dependent.Traditional
{e⁺} (eq : ∀ {a p} → P.Equality-with-paths ... |
{-# OPTIONS --without-K --safe #-}
-- The category of Cats is Monoidal
module Categories.Category.Monoidal.Instance.Cats where
open import Level
open import Categories.Category.BinaryProducts using (BinaryProducts)
open import Categories.Category.Cartesian using (Cartesian)
open import Categories.Category.Cartesian... |
{-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Definition
open import Numbers.Naturals.Addition
open import Numbers.Naturals.Multiplication
open import Semirings.Definition
open import Monoids.Definition
module Numbers.Naturals.Semiring where
open Numbers.... |
-- Type-checker for the simply-typed lambda calculus
--
-- Where we make sure that failing to typecheck a term is justified by
-- an "ill-typing judgment", which erases to the original term.
open import Data.Empty
open import Data.Unit hiding (_≟_)
open import Data.List hiding ([_])
open import Data.Nat hiding (_*_ ; ... |
-- Andreas 2015-01-07 fixing polarity of projection-like functions
-- {-# OPTIONS -v tc.polarity:20 -v tc.proj.like:10 #-}
-- {-# OPTIONS -v tc.conv.elim:25 --show-implicit #-}
open import Common.Size
-- List covariant covariant
data List (i : Size) (A : Set) : Set where
[] : List i A
cons : ∀{j : Size< i} → A →... |
module DualTail where
open import Data.Nat
open import Data.Fin using (Fin; zero; suc)
open import Data.Product
open import Function using (id; _∘_)
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
open import Types.Direction
open import Types.Tail
private
variable
n : ℕ
-- instead of unr... |
------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Terms that operate on changes (Fig. 3).
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.... |
{-# OPTIONS --cubical --safe #-}
module Data.List.Sugar where
open import Data.List.Base
open import Prelude
[_] : A → List A
[ x ] = x ∷ []
pure : A → List A
pure = [_]
_>>=_ : List A → (A → List B) → List B
_>>=_ = flip concatMap
_>>_ : List A → List B → List B
xs >> ys = xs >>= const ys
_<*>_ : List (A → B) →... |
module DCBSets where
open import prelude
open import relations
-- The objects:
Obj : Set₁
Obj = Σ[ U ∈ Set ] (Σ[ X ∈ Set ] (Σ[ x ∈ (⊤ → X) ] (Σ[ d ∈ (X × X → X) ](Σ[ α ∈ (U → X → Set) ](
(∀{u : U}{x₁ x₂ : X} → α u (d (x₁ , x₂)) → ((α u x₁) × (α u x₂))) ×
( ∀{Y : Set}{x' : X}{F : Y → X}{y : ⊤ → Y} → d (x' , F (y t... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Some derivable properties
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Algebra
module Algebra.Properties.Semilattice {c ℓ} (L : Semila... |
open import Nat
open import Prelude
open import core
open import contexts
open import preservation
module complete-preservation where
-- if you substitute a complete term into a complete term, the result is
-- still complete.
cp-subst : ∀ {x d1 d2} →
d1 dcomplete →
d2 dcomplete →
... |
module Structure.Sets.Names where
open import Data.Boolean
open import Data.Boolean.Stmt
open import Functional
import Lvl
open import Logic
open import Logic.Propositional
open import Logic.Predicate
open import Structure.Function
open import Structure.Relator
open import Structure.Setoid using (Equiv) renaming ... |
data Nat : Set where
Zero : Nat
Suc : Nat → Nat
{-# COMPILE AGDA2HS Nat #-}
Nat' = Nat
{-# COMPILE AGDA2HS Nat' #-}
myNat : Nat'
myNat = Suc (Suc Zero)
{-# COMPILE AGDA2HS myNat #-}
data List (a : Set) : Set where
Nil : List a
Cons : a → List a → List a
{-# COMPILE AGDA2HS List #-}
List' : Set → Set
List'... |
open import Data.Empty
open import AEff
open import EffectAnnotations
open import Renamings
open import Types hiding (``)
open import Relation.Binary.PropositionalEquality hiding ([_])
module Substitutions where
-- PARALLEL SUBSTITUTIONS
data Sub : Ctx → Ctx → Set where
⟨_,_⟩ : {Γ Γ' : Ctx} {X : VType} →
... |
-- Andreas, 2014-10-08, issue reported by Andrea Vezzosi
{-# OPTIONS --copatterns #-}
import Common.Level
open import Common.Product
postulate Nat : Set
record Cxt : Set₁ where
constructor Con -- essential
field
CSet : Set
CRel : (e0 e1 : CSet) → Set
record Type (Γ : Cxt) : Set₁ where
open Cxt
fi... |
open import Data.Nat
open import Data.Fin
open import Data.List
open import Data.List.Membership.Propositional
open import Data.List.Relation.Unary.All as All
open import Data.List.All.Properties.Extra
open import Data.Vec hiding (_∷ʳ_ ; _>>=_ ; init)
open import Data.Product
open import Relation.Binary.PropositionalEq... |
{-# OPTIONS --safe #-}
module Cubical.Data.FinSet where
open import Cubical.Data.FinSet.Base public
open import Cubical.Data.FinSet.Properties public
|
module Impure.LFRef.Properties.Decidable where
open import Prelude
open import Relation.Unary
open import Relation.Nullary.Decidable as DecM
open import Data.Fin.Properties as FinP using ()
open import Data.List
open import Data.Vec
open import Data.Vec.Properties
open import Function.Inverse hiding (_∘_; sym)
open im... |
-- {-# OPTIONS -v tc.term.con:100 #-}
module Issue799 where
data D : Set where
d : D
x : D
x = d {_} {_} {interesting-argument = _} {_} {_} {_}
-- should fail
|
module STLC.Term where
open import Data.Fin using (Fin)
open import Data.Fin.Substitution
open import Data.Nat using (ℕ; _+_)
open import Relation.Binary.Construct.Closure.ReflexiveTransitive
using (Star; ε; _◅_)
open import Data.Vec using (Vec; []; _∷_; lookup)
open import Relation.Binary.PropositionalEquality
... |
{-# OPTIONS --without-K #-}
module sets.empty where
open import level using ()
data ⊥ : Set where
⊥-elim : ∀ {i}{A : Set i} → ⊥ → A
⊥-elim ()
¬_ : ∀ {i} → Set i → Set i
¬ X = X → ⊥
infix 3 ¬_
|
{-# OPTIONS --without-K --safe #-}
module Categories.Functor.Continuous where
open import Level
open import Data.Product using (Σ)
open import Categories.Category
open import Categories.Functor
import Categories.Category.Construction.Cones as Con
import Categories.Diagram.Cone.Properties as Conₚ
import Categories.Di... |
{-# OPTIONS --without-K #-}
module UnivalenceFiniteTypes where
open import Data.Empty
open import Data.Unit
open import Data.Unit.Core
open import Data.Nat renaming (_⊔_ to _⊔ℕ_)
open import Data.Sum renaming (map to _⊎→_)
open import Data.Product renaming (map to _×→_)
open import Function renaming (_∘_ to _○_)
open... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module collects the property definitions for left-scaling
-- (LeftDefs), right-scaling (RightDefs), and both (BiDefs).
------------------------------------------------------------------------
{-# OPTIONS --... |
open import Relation.Binary.PropositionalEquality
open import Data.Nat
open import Data.Nat.Properties using (+-suc)
open import Data.Product renaming (_×_ to _∧_)
open import Data.Sum renaming (_⊎_ to _∨_ ; inj₁ to left ; inj₂ to right)
{- 5.1 Extrinsic approach -}
div2 : ℕ → ℕ
div2 zero = zero
div2 (suc zero) = z... |
------------------------------------------------------------------------
-- Some results about various forms of coinductively defined weak
-- bisimilarity for the delay monad
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
open import Prelude
module Bisimilarity... |
module Signature where
open import Function renaming (const to K)
open import Category.Monad.Predicate
open import Data.Sum
open import Data.Product
open import Data.Container.Indexed hiding (_∈_)
open import Data.Container.Indexed.Combinator
renaming (_⊎_ to _⊎^C_; _×_ to _×^C_)
open import Data.Container.Indexed.F... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.