text stringlengths 4 690k |
|---|
-- Minimal implicational modal logic, vector-based de Bruijn approach, initial encoding
module Vi.BoxMp where
open import Lib using (Nat; suc; _+_; Fin; fin; Vec; []; _,_; proj; VMem; mem)
-- Types
infixr 0 _=>_
data Ty : Set where
UNIT : Ty
_=>_ : Ty -> Ty -> Ty
BOX : Ty -> Ty
-- Contex... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use the
-- Relation.Binary.Construct.Closure.ReflexiveTransitive module directly
------------------------------------------------------------------------
{-# OPTIONS --without-K... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.List.Relation.Binary.Lex.Core directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List... |
module Issue2487-1 where
postulate get-out-of-jail : {A : Set} -> A
|
{-# OPTIONS --without-K #-}
module overloading.level where
open import sum
open import equality.core
open import overloading.bundle
open import function.isomorphism
open import hott.level.core
open import sets.unit
open Bundle
bundle-structure-iso : ∀ {i j}{Base : Set i}
(Struct : Base → Set ... |
module Data.Fin.Subset.Properties.Cardinality where
open import Data.Nat as ℕ using (ℕ)
open import Data.Nat.Properties as NP
open import Data.Empty using (⊥-elim)
open import Data.Fin
open import Data.Fin.Subset
open import Data.Fin.Subset.Properties
open import Data.Vec using (_∷_; [])
open import Data.Vec.Any usi... |
module _ where
open import Agda.Builtin.Nat
open import Imports.ImportedDisplayForms
postulate
T : Nat → Set
foo : (a : Nat) → T (a + a)
foo a = {!!}
|
open import Oscar.Prelude
open import Oscar.Class.HasEquivalence
open import Oscar.Class.Smap
open import Oscar.Class.Surjextensionality
open import Oscar.Class.Symmetry
open import Oscar.Class.Symmetrical
open import Oscar.Class.Transitivity
open import Oscar.Data.ProductIndexEquivalence
open import Oscar.Data.Surjex... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.AbGroup.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cu... |
{-# OPTIONS --cubical #-}
module Type.Cubical.Path.Category{ℓ} where
open import Data.Tuple as Tuple using (_,_)
open import Data
open import Functional
open import Function.Axioms
open import Logic.Propositional
open import Structure.Category
open import Structure.Categorical.Properties
open import Structure.Operato... |
open import Agda.Builtin.Bool
f : Bool → Bool
f x = let y = x in {!!}
|
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.Ints.QuoInt where
open import Cubical.HITs.Ints.QuoInt.Base public
-- open import Cubical.HITs.Ints.QuoInt.Properties public
|
{-# OPTIONS --without-K --exact-split #-}
module dn-sheaves where
import rings
open rings public
{- We postulate a propositional resizing axiom -}
raise-UU-Prop :
(l : Level) → UU-Prop lzero → UU-Prop l
raise-UU-Prop l (pair P is-prop-P) =
pair ( raise l P)
( is-prop-is-equiv' P
( map-raise l P)... |
-- 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... |
module Algebra.Dioid.Bool where
open import Algebra.Dioid
data Bool : Set where
true : Bool
false : Bool
data _≡_ : (x y : Bool) -> Set where
reflexivity : ∀ {x : Bool} -> x ≡ x
symmetry : ∀ {x y : Bool} -> x ≡ y -> y ≡ x
transitivity : ∀ {x y z : Bool} -> x ≡ y -> y ... |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020, 2021, Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.Prelude
open import LibraBFT.Lemmas
open import Lib... |
module Identity where
data _==_ {A : Set}(x : A) : A -> Set where
refl : x == x
elim== : {A : Set}(x : A)(C : (y : A) -> x == y -> Set) ->
C x refl -> (y : A) -> (p : x == y) -> C y p
elim== x C Cx .x refl = Cx
elim==₁ : {A : Set}(x : A)(C : (y : A) -> x == y -> Set1) ->
C x refl -> (y : A) -> (p : x ... |
{-# OPTIONS --no-auto-inline #-}
module Haskell.Prim.Num where
open import Agda.Builtin.Nat as Nat hiding (_+_; _-_; _*_; _<_; _==_)
open import Agda.Builtin.Int using (pos; negsuc)
open import Agda.Builtin.FromNat
open import Agda.Builtin.FromNeg
open import Agda.Builtin.Unit
open import Haskell.Prim
open import Ha... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Some derivable properties
------------------------------------------------------------------------
open import Algebra
module Algebra.Properties.Lattice {l₁ l₂} (L : Lattice l₁ l₂) where
open Lattice L
open im... |
{-# OPTIONS --without-K --safe #-}
-- Some of the obvious properties of cartesian functors
module Categories.Functor.Cartesian.Properties where
open import Level
open import Data.Product using (Σ ; _,_)
open import Categories.Category
open import Categories.Category.Cartesian.Structure
open import Categories.Functor... |
-- Andreas, 2012-05-24, issue reported by Nisse
{-# OPTIONS --allow-unsolved-metas #-}
-- {-# OPTIONS -v tc.meta:50 #-}
module Issue658 where
import Common.Level
postulate
A : Set
P : A → Set
Q : (x : A) → P x → Set
p : (x : A) → P x
record R : Set where
field
a : A
r : R
r = {!!}
postulate
q : Q (... |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020 Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.Prelude
open import LibraBFT.Hash
open import LibraBFT.Ab... |
{-# OPTIONS --without-K --safe #-}
-- Pi combinators inspired by duals and traced monoidal categories
module PiPointedFracTrace where
open import Data.Unit
open import Data.Sum
open import Data.Product
open import Relation.Binary.PropositionalEquality
open import PiPointedFrac
-------------------------------------... |
module McK-B where
open import CS410-Prelude
open import CS410-Nat
open import CS410-Vec
data Bit : Set where O I : Bit
exp2 : Nat -> Nat
exp2 zero = 1
exp2 (suc n) = exp2 n +N exp2 n
WordNZ : Nat -> Set
data Word (n : Nat) : Set where
O : Word n
[_] : WordNZ n -> Word n
WordNZ zero = One
WordNZ (suc n) ... |
module IdentP where
data Bool
: Set
where
false
: Bool
true
: Bool
f
: {A : Set}
→ A
→ A
→ A
f x y
= x
g
: Bool
→ Bool
g false
= true
g true
= true
|
-- Andreas, 2018-09-03, issue #3207
--
-- Error message for disabled Prop.
{-# OPTIONS --no-prop #-}
test = Prop
|
module Fin where
open import Prelude
open import Star
open import Modal
open import Nat
Fin : Nat -> Set
Fin = Any (\_ -> True)
fzero : {n : Nat} -> Fin (suc n)
fzero = done _ • ε
fsuc : {n : Nat} -> Fin n -> Fin (suc n)
fsuc i = step • i
|
module HasDecidableSalvation where
open import OscarPrelude
open import HasSalvation
record HasDecidableSalvation (A : Set) : Set₁
where
field
⦃ hasSalvation ⦄ : HasSalvation A
▷?_ : (x : A) → Dec $ ▷ x
open HasDecidableSalvation ⦃ … ⦄ public
{-# DISPLAY HasDecidableSalvation.▷?_ _ = ▷?_ #-}
|
{-
A couple of general facts about equivalences:
- if f is an equivalence then (cong f) is an equivalence ([equivCong])
- if f is an equivalence then pre- and postcomposition with f are equivalences ([preCompEquiv], [postCompEquiv])
- if f is an equivalence then (Σ[ g ] section f g) and (Σ[ g ] retract f g) are contr... |
module List where
import Prelude
import Equiv
import Datoid
import Nat
open Prelude
open Equiv
open Datoid
open Nat
data List (a : Set) : Set where
nil : List a
_::_ : a -> List a -> List a
map : {a b : Set} -> (a -> b) -> List a -> List b
map f nil = nil
map f (x :: xs) = f ... |
interleaved mutual
data CoNat : Set
record ∞CoNat : Set
constructor
zero : CoNat
record ∞CoNat where
coinductive
field force : CoNat
constructor
suc : ∞CoNat → ?
|
------------------------------------------------------------------------------
-- Inductive PA properties using the induction principle
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-u... |
-- Andreas, 2014-03-27 fixed issue
{-# OPTIONS --copatterns --sized-types #-}
open import Common.Size
record R (i : Size) : Set where
inductive
constructor c
field
j : Size< i
r : R j
data ⊥ : Set where
elim : (i : Size) → R i → ⊥
elim i (c j r) = elim j r
-- elim should be rejected by termination c... |
module Rationals.Properties where
open import Nats renaming (_*_ to _:*:_)
open import Rationals
open import Data.Empty
open import Data.Product
open import Equality
------------------------------------------------------------------------
-- internal stuffs
private
a*b÷b=a : ∀ a b → a :*: b ÷ b →ℕ ≡ (a , refl)
... |
module RandomAccessList.Standard.Core where
open import BuildingBlock.BinaryLeafTree using (BinaryLeafTree; Node; Leaf)
open import Data.Nat
open import Data.Nat.Etc
-- parameterized by the level of the least significant digit
data 0-1-RAL (A : Set) : ℕ → Set where
[] : ∀ {n} → ... |
------------------------------------------------------------------------------
-- Test the consistency of PA.Axiomatic.Standard.Base
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-univ... |
-- Box modality: cofree presheaf on a family
module SOAS.Abstract.Box {T : Set} where
open import SOAS.Common
open import SOAS.Context
open import SOAS.Sorting
open import SOAS.Variable
open import SOAS.Families.Core {T}
open import SOAS.Families.Isomorphism
open import SOAS.Families.BCCC using (_×ₘ_; _+ₘ_; _⇨_; _⇨̣_... |
-- 2011-10-04 Andreas
{-# OPTIONS --experimental-irrelevance #-}
module TerminationOnIrrelevant where
data ⊥ : Set where
data Empty : Set where
c : Empty → Empty
d : Empty → Empty
d (c x) = x
f : .Empty → ⊥
f (c x) = f x
g : .Empty → ⊥
g (c x) = g x
data _≡_ {A : Set}(a : A) : A → Set where
refl : a ≡ a
-- t... |
module RepeatedVariableInPattern where
K : Set -> Set
K A A = A
|
module Categories.Functor.CartesianClosed where
open import Categories.Category using (Category; _[_∘_]; _[_,_])
open import Categories.Category.Cartesian using (Cartesian)
open import Categories.Category.Cartesian.Bundle using (CartesianCategory)
open import Categories.Category.CartesianClosed using (CartesianClosed)... |
module Issue2937.WithUnicode where
foo : _ → _ → Set
foo bar x = λ x → foo (bar x {!!}) x
|
-- Left ℤ-multiplication on groups and some of its properties
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.Group.ZAction where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Data.Sigma
open... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Monad syntax for the TC monad
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Reflection.TypeChecking.MonadSyntax where
open import Agda.Built... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.HSpace
open import homotopy.EM1HSpace
open import homotopy.EilenbergMacLane1 using (EM₁-level₁)
open import lib.types.TwoSemiCategory
open import lib.two-semi-categories.FundamentalCategory
module homotopy.EM1HSpaceAssoc where
module EM₁HS... |
module Vec where
open import Basics
open import Ix
open import All
open import Cutting
open import Tensor
data Vec (X : Set) : Nat -> Set where
[] : Vec X zero
_,-_ : forall {n} -> X -> Vec X n -> Vec X (suc n)
_+V_ : forall {X n m} -> Vec X n -> Vec X m -> Vec X (n +N m)
[] +V ys = ys
(x ,- xs) +V ys = x... |
------------------------------------------------------------------------------
-- Test the consistency of FOTC.Relation.Binary.Bisimilarity.Type
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIO... |
{-# OPTIONS --without-K --safe #-}
module Math.NumberTheory.Product.Nat where
-- agda-stdlib
open import Data.Nat.Properties
-- agda-misc
open import Math.NumberTheory.Product.Generic
open MonoidProduct *-1-monoid public
|
open import Prelude
module Implicits.Syntax.Context where
open import Implicits.Syntax.Type
open import Data.List.All
open import Data.Vec
open import Data.List
Ctx : ℕ → ℕ → Set
Ctx ν n = Vec (Type ν) n
ICtx : ℕ → Set
ICtx ν = List (Type ν)
-- wellformed implicit contexts
_⊢OK : ∀ {ν} → ICtx ν → Set
Δ ⊢OK = All (... |
------------------------------------------------------------------------------
-- Distributive laws on a binary operation (Stanovský example)
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS ... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Sets.EquivalenceRelations
open import LogicalFormulae
open import Setoids.Setoids
open import Rings.Definition
open import Modules.Definition
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Order
open import Lists.Lists
open import Vecto... |
{-# OPTIONS --rewriting #-}
-- 2014-05-27 Jesper and Andreas
postulate
A B : Set
R : A → B → Set
{-# BUILTIN REWRITE R #-}
|
{-# OPTIONS --without-K --exact-split --rewriting --overlapping-instances #-}
open import lib.Basics
open import lib.NConnected
open import lib.NType2
open import lib.types.Truncation
open import Coequalizers.Definition
open import Coequalizers.Misc
open import Graphs.Definition
open import Util.Misc
module Groups... |
module CTL.Proof where
open import CTL.Proof.AG public
open import CTL.Proof.EG public
|
module ReflectionExposeConstraints where
open import Agda.Builtin.Reflection
open import Agda.Builtin.List
open import Agda.Builtin.Nat
open import Agda.Builtin.Unit
open import Agda.Builtin.Equality
_>>=_ : ∀ {a b} {A : Set a} {B : Set b} → TC A → (A → TC B) → TC B
_>>=_ = bindTC
_ifMeta_ : {A : Set} → Term → (Meta... |
open import Relation.Unary
open import Relation.Ternary.Separation
module Relation.Ternary.Separation.Monad.Free {ℓ} {A : Set ℓ}
{{r : RawSep A}}
(Cmd : Pred A ℓ)
(δ : ∀ {Φ} → Cmd Φ → Pred A ℓ)
where
open import Level
open import Function
open import Data.Unit
open import Data.Product
open import Relation.U... |
module PLRTree.Complete.Correctness.Alternative {A : Set} where
open import BTree.Complete.Alternative {A}
open import BTree.Complete.Alternative.Properties {A}
open import BTree.Equality {A}
open import PLRTree {A}
open import PLRTree.Complete {A} renaming (Complete to Complete' ; _⋗_ to _⋗'_ ; _⋘_ to _⋘'_ ; _⋙_ to ... |
-- Andreas, 2012-02-13: polarity info must be correct
{-# OPTIONS --sized-types --show-implicit #-}
-- {-# OPTIONS -v tc.size.solve:20 -v tc.conv.size:20 #-}
-- {-# OPTIONS -v tc.polarity.set:10 -v tc.conv.term.shortcut:20 #-}
module WrongPolarity where
open import Common.Size
data ⊥ : Set where
data Sink (A : Set... |
module DescStrat where
open import StratSigma
data Desc42 : Set43 where
id42 : Desc42
const42 : Set42 -> Desc42
prod42 : Desc42 -> Desc42 -> Desc42
sigma42 : (S : Set42) -> (S -> Desc42) -> Desc42
pi42 : (S : Set42) -> (S -> Desc42) -> Desc42
[|_|]42_ : Desc42 -> Set42 -> Set42
[| id42 |]42 Z ... |
module CombinatoryLogic.Semantics where
open import Relation.Binary using (Rel)
open import CombinatoryLogic.Syntax
-- Kapitel 1, Abschnitt C, §5 (Axiome)
data Axiom : Combinator → Set where
Q : Axiom (Π ∙ (W ∙ (C ∙ Q)))
B : Axiom (C ∙ (B ∙ B ∙ (B ∙ B ∙ B)) ∙ B == B ∙ (B ∙ B) ∙ B)
C : Axiom (C ∙ (B ∙ B ∙ (B ∙ ... |
open import Prelude
open import dynamics-core
open import progress-checks
module finality where
finality : Σ[ d ∈ ihexp ] (d final × (Σ[ d' ∈ ihexp ] (d ↦ d'))) → ⊥
finality (π1 , π2 , π3 , π4) = final-not-step π2 (π3 , π4)
-- a slight restatement of the above, generalizing it to the
-- multistep judgement
... |
postulate A : Set
record R : Set where
constructor c
field f : A
open R {{...}}
works : {{_ : R}} → A
works = f
works' : {{_ : R}} → Set → A
works' B = f
test : {{_ : R}} → A
test {{_}} = f
-- No variable of type R was found in scope.
-- when checking that the expression f has type A
test1 : {{_ : R}} → Set... |
module monad where
open import eq
record Monad (M : Set → Set) : Set₁ where
field
return : ∀{A : Set} → A → M A
bind : ∀{A B : Set} → M A → (A → M B) → M B
monad-left-id : ∀{A B : Set}{a : A}{f : A → M B}
→ bind (return a) f ≡ f a
monad-right-id : ∀{A : Set}{c : M A}
→ bind c... |
------------------------------------------------------------------------
-- Higher lenses with erased proofs
------------------------------------------------------------------------
-- At the time of writing there are counterparts in this file of more
-- or less everything in Lens.Non-dependent.Higher, except for part... |
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.Cylinder.Base where
open import Cubical.Core.Everything
open import Cubical.Foundations.Everything
open import Cubical.HITs.PropositionalTruncation
import Cubical.Data.Everything as Data
open Data hiding (inl; inr)
open import Cubical.HITs.Interval
-- Cylinder... |
module Editor where
open import Agda.Builtin.FromNat
open import BasicIO
open import Data.Bool
open import Data.Char
open import Data.List hiding (_++_)
open import Data.String
open import Data.Unit
open import Function
open import Int
open import Terminal
readTimeout : Int
readTimeout = 0
readMinChars : Int
readMin... |
{-# OPTIONS --cubical --safe #-}
module Cubical.Foundations.UnivalenceId where
open import Cubical.Core.Glue
renaming ( isEquiv to isEquivPath
; _≃_ to EquivPath
; equivFun to equivFunPath )
open import Cubical.Core.Id
open import Cubical.Foundations.Prelude public
hiding (... |
module Ual.Void where
data ⊥ : Set where
¬ : Set → Set
¬ p = p → ⊥
|
module Arity where
open import OscarPrelude
record Arity : Set
where
constructor ⟨_⟩
field
arity : Nat
open Arity public
instance EqArity : Eq Arity
Eq._==_ EqArity _ = decEq₁ (cong arity) ∘ (_≟_ on arity $ _)
|
open import Common.Reflect
open import Common.Prelude
data Z : Set where
zero : Z
foo : QName → Bool → Bool
foo (quote Nat.zero) b = {!b!}
foo _ _ = false
|
open import Oscar.Prelude
open import Oscar.Class
open import Oscar.Class.Leftunit
open import Oscar.Class.Reflexivity
open import Oscar.Class.Transitivity
open import Oscar.Class.Transleftidentity
module Oscar.Class.Transleftidentity.ToLeftunit where
module _
{𝔬} {𝔒 : Ø 𝔬}
{𝔯} {_∼_ : 𝔒 → 𝔒 → Ø 𝔯}
{ℓ} {... |
------------------------------------------------------------------------
-- A map function for the substitutions
------------------------------------------------------------------------
open import Data.Universe.Indexed
module deBruijn.Substitution.Function.Map
{i u e} {Uni : IndexedUniverse i u e} where
import Ax... |
{-# OPTIONS --sized-types #-}
module SList.Properties (A : Set) where
open import Data.List
open import List.Permutation.Base A
open import SList
lemma-unsize-size : (xs : List A) → xs ∼ unsize A (size A xs)
lemma-unsize-size [] = ∼[]
lemma-unsize-size (x ∷ xs) = ∼x /head /head (lemma-unsize-size xs)
|
open import Relation.Unary using ( ∅ ; _∪_ )
open import Web.Semantic.DL.Concept using ( Concept )
open import Web.Semantic.DL.Role using ( Role )
open import Web.Semantic.DL.Signature using ( Signature )
open import Web.Semantic.Util using ( Subset ; ⁅_⁆ )
module Web.Semantic.DL.TBox where
infixl 5 _⊑₁_ _⊑₂_
infixr ... |
module GUIgeneric.GUIFeatures where
open import GUIgeneric.Prelude
open import GUIgeneric.GUIDefinitions renaming (add to add'; add' to add)
open import GUIgeneric.GUI
open import GUIgeneric.GUIExampleLib
open import StateSizedIO.GUI.WxGraphicsLibLevel3
open Interfaceˢ public
-- Components
--
frameAndOKButton : ... |
{-# OPTIONS --allow-unsolved-metas #-}
{- 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 Haskell.Modules.RWS
open i... |
------------------------------------------------------------------------
-- From the Agda standard library
--
-- Sizes for Agda's sized types
------------------------------------------------------------------------
module Common.Size where
open import Agda.Builtin.Size public renaming (ω to ∞; SizeU to SizeUniv)
|
module cfg1 where
open import Level renaming ( suc to succ ; zero to Zero )
open import Data.Nat hiding ( _≟_ )
-- open import Data.Fin
-- open import Data.Product
open import Data.List
open import Data.Maybe
-- open import Data.Bool using ( Bool ; true ; false ; _∧_ ; _∨_ )
open import Relation.Binary.Propositional... |
open import Agda.Builtin.Equality
variable
A B : Set
f g : A
postulate
F : Set → Set
map : (A → B) → F A → F B
lemma : (x : F A) → map (λ x → f (g x)) x ≡ map f (map g x) → F A
lemma {A = A} {f = f} {g = g} x _ = x
|
------------------------------------------------------------------------
-- Coinductive higher lenses with erased "proofs"
------------------------------------------------------------------------
{-# OPTIONS --guardedness #-}
import Equality.Path as P
module Lens.Non-dependent.Higher.Coinductive.Erased
{e⁺} (eq : ... |
{-# OPTIONS --warning=error --without-K --safe #-}
open import LogicalFormulae
open import Categories.Definition
open import Categories.Functor.Definition
module Categories.Functor.Lemmas where
functorCompose : {a b c d e f : _} {B : Category {a} {b}} {C : Category {c} {d}} {D : Category {e} {f}} → (Functor C D) → (... |
{-# OPTIONS --without-K #-}
module Pi0Examples where
open import PiU using (U; ZERO; ONE; PLUS; TIMES)
open import PiLevel0
using (_⟷_;
unite₊l; uniti₊l; unite₊r; uniti₊r; swap₊; assocl₊; assocr₊;
unite⋆l; uniti⋆l; unite⋆r; uniti⋆r; swap⋆; assocl⋆; assocr⋆;
absorbr; absorbl; factorzr; fac... |
import Lvl
open import Data.Boolean
open import Type
module Data.List.Sorting.MergeSort {ℓ} {T : Type{ℓ}} (_≤?_ : T → T → Bool) where
open import Data.List
open import Data.List.Functions as List
open import Data.List.Relation.Membership as Membership using (_∈_ ; use ; skip)
open import Data.List.Relation.Membe... |
{-
This file contains basic theory about subgroups.
The definition is the same as the first definition of subgroups in:
https://www.cs.bham.ac.uk/~mhe/HoTT-UF-in-Agda-Lecture-Notes/HoTT-UF-Agda.html#subgroups-sip
-}
{-# OPTIONS --safe #-}
module Cubical.Algebra.Group.Subgroup where
open import Cubical.Foundations.... |
module CompleteSemantics.Iemhoff where
open import Syntax public
-- Introspective brilliant Kripke models.
record Model : Set₁ where
infix 3 _⊩ᵅ_
field
World : Set
_≤_ : World → World → Set
refl≤ : ∀ {w} → w ≤ w
trans≤ : ∀ {w w′ w″} → w ≤ w′ → w′ ≤ w″ → w ≤ w″
_R_ : World → Worl... |
module sum-thms where
open import eq
open import sum
open import list
open import product
inj₁-inj : ∀{ℓ ℓ'}{A : Set ℓ}{B : Set ℓ'}{x : A}{x'} → inj₁{ℓ}{ℓ'}{A}{B} x ≡ inj₁ x' → x ≡ x'
inj₁-inj refl = refl
|
module MultiSorted.Context {s} (Sort : Set s) where
-- An attempt to define more structured context
-- that directly support the cartesian structure
data Context : Set s where
ctx-empty : Context
ctx-slot : Sort → Context
ctx-concat : Context → Context → Context
-- the variables in a context
data var : Contex... |
{-# OPTIONS --prop #-}
open import Agda.Primitive
record LiftP {ℓ ℓ'}(A : Prop ℓ) : Prop (ℓ ⊔ ℓ') where
constructor liftP
field
unliftP : A
open LiftP public
unliftP' : {ℓ ℓ' ℓ'' : Level} {A : Prop ℓ}{B : Set ℓ''}(f : A → B) → LiftP {ℓ}{ℓ'} A → B
unliftP' f (liftP x) = f x
|
{-# OPTIONS --cubical --no-import-sorts #-}
module Cubical.Codata.Everything where
open import Cubical.Codata.EverythingSafe public
--- Modules making assumptions that might be incompatible with other
-- flags or make use of potentially unsafe features.
-- Assumes --guardedness
open import Cubical.Codata.Stream pub... |
module Automaton.Pushdown where
|
module Naturals where
open import Library
open import Categories
open import Functors
open Fun
record NatT {a b c d}{C : Cat {a}{b}}{D : Cat {c}{d}}(F G : Fun C D) :
Set (a ⊔ b ⊔ c ⊔ d) where
constructor natural
open Cat
field cmp : ∀ {X} → Hom D (OMap F X) (OMap G X)
nat : ∀{X Y}{f : Hom C X Y} → ... |
module PushProdPull where
open import Categories.Category
open import Categories.Category.Cartesian.Bundle
open import Categories.Category.CartesianClosed.Canonical
open import Categories.Category.Core
open import Categories.Category.Product
open import Categories.Diagram.Pullback
open import Categories.Diagram.Pushou... |
module Esterel.Lang.Properties where
open import Esterel.Lang
open import Relation.Binary.PropositionalEquality
open import Relation.Unary
open import Relation.Nullary using (¬_ ; Dec ; yes ; no)
open import Esterel.Environment
open import Esterel.Variable.Signal as Signal
open import Esterel.Variable.Shared as Shared... |
------------------------------------------------------------------------
-- Safe modules that use --erased-cubical and --guardedness
------------------------------------------------------------------------
{-# OPTIONS --safe --erased-cubical --guardedness #-}
module README.Safe.Cubical.Erased.Guardedness where
-- M-... |
module OpenModule where
module A where
postulate X : Set
-- Both open import and open module applies the directives
-- to the "open" rather than to the module.
open import Nat hiding (zero) renaming (Nat to N)
open module B = A renaming (X to Y)
Test : Set
Test = Y → B.X → N → Nat.Nat
zero : N
zero = Nat.zero
... |
-- The category of contexts and renamings
module SOAS.ContextMaps.CategoryOfRenamings {T : Set} where
open import SOAS.Common
open import SOAS.Context {T}
open import SOAS.Variable
open import SOAS.ContextMaps.Combinators (ℐ {T})
open import Categories.Functor.Bifunctor
open import Categories.Object.Initial
open imp... |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Support.SetoidPi where
open import Level
open import Function as Fun using (_on_)
open import Relation.Binary as B using () renaming (_=[_]⇒_ to _=[_]⇒₀_; _⇒_ to _⊆_)
open import Relation.Binary.PropositionalEquality as PE using (_≡_)
open import Relation.Bina... |
{-# OPTIONS --without-K --safe #-}
-- This module provides the basic expression type for polynomials.
module Polynomial.Expr where
open import Data.Nat using (ℕ)
open import Data.Fin using (Fin)
infixl 6 _⊕_
infixl 7 _⊗_
infixr 8 _⊛_
data Expr {ℓ} (A : Set ℓ) (n : ℕ) : Set ℓ where
Κ : A → Expr A n
Ι : Fin ... |
-- 2012-09-25 Andreas, reported by Nicolas Pouillard
{-# OPTIONS --sized-types #-}
module Issue700 where
import Common.Level
open import Common.Size
postulate
Size< : Size → Set
{-# BUILTIN SIZELT Size< #-}
postulate
A : Set
data T (i : Size) : Set where
c : (j : Size< i) → T j → T _
bug : ∀ i → T i → A
bug ... |
-- {-# OPTIONS -v term:30 #-}
{-# OPTIONS --copatterns #-}
module ColistMutual where
mutual
data CoList (A : Set) : Set where
[] : CoList A
_∷_ : (x : A)(xs : ∞CoList A) → CoList A
record ∞CoList (A : Set) : Set where
coinductive
field out : CoList A
open ∞CoList
mutual
repeat : {A : Set}(a... |
-- Saturated sets.
module SAT3 where
open import Library
open import Terms
open import Substitution
open import Reduction
open import SN
open import SN.AntiRename
-- Kripke predicates on well-typed terms.
TmSet : (a : Ty) → Set₁
TmSet a = {Γ : Cxt} (t : Tm Γ a) → Set
_⊆_ : ∀{a} (𝑨 𝑨′ : TmSet a) → Set
𝑨 ⊆ 𝑨′ = ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.